Skip to content

F
ffmpeg.wasm-core
Commit cc77b943 authored by Michael Niedermayer's avatar Michael Niedermayer
Browse files
Options

removing unused encoding code 

Originally committed as revision 3133 to svn://svn.ffmpeg.org/ffmpeg/trunk
parent 22f7a060
Hide whitespace changes
Inline Side-by-side
Showing with 4 additions and 560 deletions
libavcodec/svq1.c
View file @ cc77b943
...@@ -84,8 +84,6 @@ typedef struct SVQ1Context { ...@@ -84,8 +84,6 @@ typedef struct SVQ1Context {
/* U & V plane (C planes) block dimensions */ /* U & V plane (C planes) block dimensions */
int c_block_width; int c_block_width;
int c_block_height; int c_block_height;
unsigned char *c_plane;
uint16_t *mb_type; uint16_t *mb_type;
uint32_t *dummy; uint32_t *dummy;
...@@ -914,419 +912,10 @@ static void svq1_write_header(SVQ1Context *s, int frame_type) ...@@ -914,419 +912,10 @@ static void svq1_write_header(SVQ1Context *s, int frame_type)
put_bits(&s->pb, 2, 0); put_bits(&s->pb, 2, 0);
} }
int level_sizes[6] = { 8, 16, 32, 64, 128, 256 };
int level_log2_sizes[6] = { 3, 4, 5, 6, 7, 8 };
#define IABS(x) ((x < 0) ? (-(x)) : x)
//#define USE_MAD_ALGORITHM
#ifdef USE_MAD_ALGORITHM
#define QUALITY_THRESHOLD 100 #define QUALITY_THRESHOLD 100
#define THRESHOLD_MULTIPLIER 0.6 #define THRESHOLD_MULTIPLIER 0.6
/* This function calculates vector differences using mean absolute
* difference (MAD). */
static int encode_vector(SVQ1Context *s, unsigned char *vector,
unsigned int level, int threshold)
{
int i, j, k;
int mean;
signed short work_vector[256];
int best_codebook;
int best_score;
int multistage_codebooks[6];
int number_of_stages = 0;
int8_t *current_codebook;
int total_deviation;
int ret;
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " ** recursive entry point: encoding level %d vector at threshold %d\n",
level, threshold);
#endif
if (level > 5) {
av_log(s->avctx, AV_LOG_INFO, " help! level %d > 5\n", level);
return 0;
}
#ifdef DEBUG_SVQ1
for (i = 0; i < level_sizes[level]; i++)
av_log(s->avctx, AV_LOG_INFO, " %02X", vector[i]);
av_log(s->avctx, AV_LOG_INFO, "\n");
#endif
/* calculate the mean */
mean = 0;
for (i = 0; i < level_sizes[level]; i++)
mean += vector[i];
mean >>= level_log2_sizes[level];
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " vector mean = 0x%02X\n", mean);
#endif
/* remove the mean from the vector */
total_deviation = 0;
for (i = 0; i < level_sizes[level]; i++) {
work_vector[i] = (signed short)vector[i] - mean;
total_deviation += IABS(work_vector[i]);
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " %d", work_vector[i]);
#endif
}
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, "\n total deviation = %d\n", total_deviation);
#endif
if (total_deviation < threshold) {
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " mean-only encoding found for level %d vector, mean = %d\n",
level, mean);
#endif
/* indicate that this is the end of the subdivisions */
if (level > 0)
put_bits(&s->pb, 1, 0);
/* index 1 in the table indicates mean-only encoding */
put_bits(&s->pb, svq1_intra_multistage_vlc[level][1][1],
svq1_intra_multistage_vlc[level][1][0]);
put_bits(&s->pb, svq1_intra_mean_vlc[mean][1],
svq1_intra_mean_vlc[mean][0]);
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " mean-only L%d, VLC = (0x%X, %d), mean = %d (0x%X, %d)\n",
level,
svq1_intra_multistage_vlc[level][1 + number_of_stages][0],
svq1_intra_multistage_vlc[level][1 + number_of_stages][1],
mean,
svq1_intra_mean_vlc[mean][0],
svq1_intra_mean_vlc[mean][1]);
#endif
ret = 0;
} else {
if (level <= 3) {
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " multistage VQ search...\n");
#endif
/* conduct multistage VQ search, for each stage... */
for (i = 0; i < 6; i++) {
best_codebook = 0;
best_score = 0x7FFFFFFF;
/* for each codebook in stage */
for (j = 0; j < 16; j++) {
total_deviation = 0;
current_codebook =
&svq1_intra_codebooks[level]
[i * level_sizes[level] * 16 + j * level_sizes[level]];
/* calculate the total deviation for the vector */
for (k = 0; k < level_sizes[level]; k++) {
total_deviation +=
IABS(work_vector[k] - current_codebook[k]);
}
/* lowest score so far? */
if (total_deviation < best_score) {
best_score = total_deviation;
best_codebook = j;
}
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " after %d, %d, best codebook is %d with a score of %d (score was %d)\n",
i, j, best_codebook, best_score, total_deviation);
#endif
}
/* apply the winning codebook to the work vector and check if
* the vector meets the quality threshold */
total_deviation = 0;
current_codebook =
&svq1_intra_codebooks[level]
[i * level_sizes[level] * 16 + j * level_sizes[level]];
multistage_codebooks[number_of_stages++] = best_codebook;
for (j = 0; j < level_sizes[level]; j++) {
work_vector[j] = work_vector[j] - current_codebook[j];
total_deviation += IABS(work_vector[j]);
}
/* do not go forward with the rest of the search if an acceptable
* codebook combination has been found */
if (total_deviation < threshold)
break;
}
}
if ((total_deviation < threshold) || (level == 0)) {
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " level %d VQ encoding found using mean %d and codebooks", level, mean);
for (i = 0; i < number_of_stages; i++)
av_log(s->avctx, AV_LOG_INFO, " %d", multistage_codebooks[i]);
av_log(s->avctx, AV_LOG_INFO, "\n");
#endif
/* indicate that this is the end of the subdivisions */
if (level > 0)
put_bits(&s->pb, 1, 0);
/* output the encoding */
put_bits(&s->pb,
svq1_intra_multistage_vlc[level][1 + number_of_stages][1],
svq1_intra_multistage_vlc[level][1 + number_of_stages][0]);
put_bits(&s->pb, svq1_intra_mean_vlc[mean][1],
svq1_intra_mean_vlc[mean][0]);
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " L%d: multistage = %d (0x%X, %d), mean = %d (0x%X, %d), codebooks = ",
level,
number_of_stages,
svq1_intra_multistage_vlc[level][1 + number_of_stages][0],
svq1_intra_multistage_vlc[level][1 + number_of_stages][1],
mean,
svq1_intra_mean_vlc[mean][0],
svq1_intra_mean_vlc[mean][1]);
#endif
for (i = 0; i < number_of_stages; i++)
{
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, "%d ", multistage_codebooks[i]);
#endif
put_bits(&s->pb, 4, multistage_codebooks[i]);
}
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, "\n");
#endif
ret = 0;
} else {
/* output a subdivision bit to the encoded stream and signal to
* the calling function that this vector could not be
* coded at the requested threshold and needs to be subdivided */
put_bits(&s->pb, 1, 1);
ret = 1;
}
}
return ret;
}
#else
#define QUALITY_THRESHOLD 100
#define THRESHOLD_MULTIPLIER 0.6
/* This function calculates vector differences using mean square
* error (MSE). */
static int encode_vector(SVQ1Context *s, unsigned char *vector,
unsigned int level, int threshold)
{
int i, j, k;
int mean;
signed short work_vector[256];
int best_codebook;
int best_score;
int multistage_codebooks[6];
int number_of_stages = 0;
int8_t *current_codebook;
int mse;
int diff;
int ret;
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " ** recursive entry point: encoding level %d vector at threshold %d\n",
level, threshold);
#endif
if (level > 5) {
av_log(s->avctx, AV_LOG_INFO, " help! level %d > 5\n", level);
return 0;
}
#ifdef DEBUG_SVQ1
for (i = 0; i < level_sizes[level]; i++)
av_log(s->avctx, AV_LOG_INFO, " %02X", vector[i]);
av_log(s->avctx, AV_LOG_INFO, "\n");
#endif
/* calculate the mean */
mean = 0;
for (i = 0; i < level_sizes[level]; i++)
mean += vector[i];
mean >>= level_log2_sizes[level];
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " vector mean = 0x%02X\n", mean);
#endif
/* remove the mean from the vector and compute the resulting MSE */
mse = 0;
for (i = 0; i < level_sizes[level]; i++) {
work_vector[i] = (signed short)vector[i] - mean;
mse += (work_vector[i] * work_vector[i]);
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " %d", work_vector[i]);
#endif
}
mse >>= level_log2_sizes[level];
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, "\n MSE = %d\n", mse);
#endif
if (mse < threshold) {
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " mean-only encoding found for level %d vector, mean = %d\n",
level, mean);
#endif
/* indicate that this is the end of the subdivisions */
if (level > 0)
put_bits(&s->pb, 1, 0);
/* index 1 in the table indicates mean-only encoding */
put_bits(&s->pb, svq1_intra_multistage_vlc[level][1][1],
svq1_intra_multistage_vlc[level][1][0]);
put_bits(&s->pb, svq1_intra_mean_vlc[mean][1],
svq1_intra_mean_vlc[mean][0]);
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " mean-only L%d, VLC = (0x%X, %d), mean = %d (0x%X, %d)\n",
level,
svq1_intra_multistage_vlc[level][1 + number_of_stages][0],
svq1_intra_multistage_vlc[level][1 + number_of_stages][1],
mean,
svq1_intra_mean_vlc[mean][0],
svq1_intra_mean_vlc[mean][1]);
#endif
ret = 0;
} else {
if (level <= 3) {
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " multistage VQ search...\n");
#endif
/* conduct multistage VQ search, for each stage... */
for (i = 0; i < 6; i++) {
best_codebook = 0;
best_score = 0x7FFFFFFF;
/* for each codebook in stage */
for (j = 0; j < 16; j++) {
mse = 0;
current_codebook =
&svq1_intra_codebooks[level]
[i * level_sizes[level] * 16 + j * level_sizes[level]];
/* calculate the MSE for this vector */
for (k = 0; k < level_sizes[level]; k++) {
diff = work_vector[k] - current_codebook[k];
mse += (diff * diff);
}
mse >>= level_log2_sizes[level];
/* lowest score so far? */
if (mse < best_score) {
best_score = mse;
best_codebook = j;
}
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " after %d, %d, best codebook is %d with a score of %d (score was %d)\n",
i, j, best_codebook, best_score, mse);
#endif
}
/* apply the winning codebook to the work vector and check if
* the vector meets the quality threshold */
mse = 0;
current_codebook =
&svq1_intra_codebooks[level]
[i * level_sizes[level] * 16 + j * level_sizes[level]];
multistage_codebooks[number_of_stages++] = best_codebook;
for (j = 0; j < level_sizes[level]; j++) {
work_vector[j] = work_vector[j] - current_codebook[j];
mse += (work_vector[j] * work_vector[j]);
}
mse >>= level_log2_sizes[level];
/* do not go forward with the rest of the search if an acceptable
* codebook combination has been found */
if (mse < threshold)
break;
}
}
if ((mse < threshold) || (level == 0)) {
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " level %d VQ encoding found using mean %d and codebooks", level, mean);
for (i = 0; i < number_of_stages; i++)
av_log(s->avctx, AV_LOG_INFO, " %d", multistage_codebooks[i]);
av_log(s->avctx, AV_LOG_INFO, "\n");
#endif
/* indicate that this is the end of the subdivisions */
if (level > 0)
put_bits(&s->pb, 1, 0);
/* output the encoding */
put_bits(&s->pb,
svq1_intra_multistage_vlc[level][1 + number_of_stages][1],
svq1_intra_multistage_vlc[level][1 + number_of_stages][0]);
put_bits(&s->pb, svq1_intra_mean_vlc[mean][1],
svq1_intra_mean_vlc[mean][0]);
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " L%d: multistage = %d (0x%X, %d), mean = %d (0x%X, %d), codebooks = ",
level,
number_of_stages,
svq1_intra_multistage_vlc[level][1 + number_of_stages][0],
svq1_intra_multistage_vlc[level][1 + number_of_stages][1],
mean,
svq1_intra_mean_vlc[mean][0],
svq1_intra_mean_vlc[mean][1]);
#endif
for (i = 0; i < number_of_stages; i++)
{
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, "%d ", multistage_codebooks[i]);
#endif
put_bits(&s->pb, 4, multistage_codebooks[i]);
}
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, "\n");
#endif
ret = 0;
} else {
/* output a subdivision bit to the encoded stream and signal to
* the calling function that this vector could not be
* coded at the requested threshold and needs to be subdivided */
put_bits(&s->pb, 1, 1);
ret = 1;
}
}
return ret;
}
#endif
static int encode_block(SVQ1Context *s, uint8_t *src, uint8_t *ref, uint8_t *decoded, int stride, int level, int threshold, int lambda, int intra){ static int encode_block(SVQ1Context *s, uint8_t *src, uint8_t *ref, uint8_t *decoded, int stride, int level, int threshold, int lambda, int intra){
int count, y, x, i, j, split, best_mean, best_score, best_count; int count, y, x, i, j, split, best_mean, best_score, best_count;
...@@ -1480,27 +1069,13 @@ static int encode_block(SVQ1Context *s, uint8_t *src, uint8_t *ref, uint8_t *dec ...@@ -1480,27 +1069,13 @@ static int encode_block(SVQ1Context *s, uint8_t *src, uint8_t *ref, uint8_t *dec
static void svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane, static void svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane,
int width, int height, int src_stride, int stride) int width, int height, int src_stride, int stride)
{ {
unsigned char buffer0[256];
unsigned char buffer1[256];
int current_buffer;
unsigned char *vector;
unsigned char *subvectors;
int vector_count;
int subvector_count;
int x, y; int x, y;
int i, j; int i;
int block_width, block_height; int block_width, block_height;
int left_edge;
int level; int level;
int threshold[6]; int threshold[6];
const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT); const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT);
static int frame = 0;
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, "********* frame #%d\n", frame++);
#endif
/* figure out the acceptable level thresholds in advance */ /* figure out the acceptable level thresholds in advance */
threshold[5] = QUALITY_THRESHOLD; threshold[5] = QUALITY_THRESHOLD;
for (level = 4; level >= 0; level--) for (level = 4; level >= 0; level--)
...@@ -1537,9 +1112,9 @@ av_log(s->avctx, AV_LOG_INFO, "********* frame #%d\n", frame++); ...@@ -1537,9 +1112,9 @@ av_log(s->avctx, AV_LOG_INFO, "********* frame #%d\n", frame++);
s->m.mb_type= s->mb_type; s->m.mb_type= s->mb_type;
//dummies, to avoid segfaults //dummies, to avoid segfaults
s->m.current_picture.mb_mean= s->dummy; s->m.current_picture.mb_mean= (uint8_t *)s->dummy;
s->m.current_picture.mb_var= s->dummy; s->m.current_picture.mb_var= (uint16_t*)s->dummy;
s->m.current_picture.mc_mb_var= s->dummy; s->m.current_picture.mc_mb_var= (uint16_t*)s->dummy;
s->m.current_picture.mb_type= s->dummy; s->m.current_picture.mb_type= s->dummy;
s->m.current_picture.motion_val[0]= s->motion_val8[plane]; s->m.current_picture.motion_val[0]= s->motion_val8[plane];
...@@ -1602,9 +1177,6 @@ av_log(s->avctx, AV_LOG_INFO, "********* frame #%d\n", frame++); ...@@ -1602,9 +1177,6 @@ av_log(s->avctx, AV_LOG_INFO, "********* frame #%d\n", frame++);
s->m.mb_x= x; s->m.mb_x= x;
ff_init_block_index(&s->m); ff_init_block_index(&s->m);
ff_update_block_index(&s->m); ff_update_block_index(&s->m);
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, "* level 5 vector @ %d, %d:\n", x * 16, y * 16);
#endif
if(s->picture.pict_type == I_TYPE || (s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTRA)){ if(s->picture.pict_type == I_TYPE || (s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTRA)){
for(i=0; i<6; i++){ for(i=0; i<6; i++){
...@@ -1690,125 +1262,14 @@ av_log(s->avctx, AV_LOG_INFO, "* level 5 vector @ %d, %d:\n", x * 16, y * 16); ...@@ -1690,125 +1262,14 @@ av_log(s->avctx, AV_LOG_INFO, "* level 5 vector @ %d, %d:\n", x * 16, y * 16);
if(best==0){ if(best==0){
s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16); s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
} }
#if 0
for (i = 0; i < 256; i += 16) {
memcpy(&buffer0[i], &plane[left_edge], 16);
left_edge += stride;
}
current_buffer = 1; /* this will toggle to 0 immediately */
/* perform a breadth-first tree encoding for each vector level */
subvector_count = 1; /* one subvector at level 5 */
for (level = 5; level >= 0; level--) {
vector_count = subvector_count;
subvector_count = 0;
if (current_buffer == 0) {
current_buffer = 1;
vector = buffer1;
subvectors = buffer0;
} else {
current_buffer = 0;
vector = buffer0;
subvectors = buffer1;
}
/* iterate through each vector in the list */
for (i = 0; i < vector_count; i++) {
if (encode_vector(s, vector, level, threshold[level])) {
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " split to level %d\n", level - 1);
#endif
/* subdivide into 2 subvectors for later processing */
subvector_count += 2;
if (level - 1 == 3) {
/* subdivide 16x8 -> 2 8x8 */
for (j = 0; j < 8; j++) {
/* left half */
memcpy(subvectors + j * 8, vector + j * 16, 8);
/* right half */
memcpy(subvectors + 64 + j * 8,
vector + 8 + j * 16, 8);
}
subvectors += 128;
} else if (level - 1 == 1) {
/* subdivide 8x4 -> 2 4x4 */
for (j = 0; j < 4; j++) {
/* left half */
memcpy(subvectors + j * 4, vector + j * 8, 4);
/* right half */
memcpy(subvectors + 16 + j * 4,
vector + 4 + j * 8, 4);
}
subvectors += 32;
} else {
/* first half */
memcpy(subvectors, vector, level_sizes[level - 1]);
subvectors += level_sizes[level - 1];
/* second half */
memcpy(subvectors, vector + level_sizes[level - 1],
level_sizes[level - 1]);
subvectors += level_sizes[level - 1];
}
}
vector += level_sizes[level];
}
/* if there are no more subvectors, break early */
if (!subvector_count)
break;
}
#endif
} }
s->m.first_slice_line=0; s->m.first_slice_line=0;
} }
} }
/* output a plane with a constant mean value; good for debugging and for
* greyscale encoding but only valid for intra frames */
static void svq1_output_intra_constant_mean(SVQ1Context *s, int block_width,
int block_height, unsigned char mean)
{
int i;
/* for each level 5 vector, output the specified mean value */
for (i = 0; i < block_width * block_height; i++) {
/* output a 0 before each vector indicating no subdivision */
put_bits(&s->pb, 1, 0);
/* output a 0 indicating mean-only encoding; use index 1 as that
* maps to code 0 */
put_bits(&s->pb, svq1_intra_multistage_vlc[5][1][1],
svq1_intra_multistage_vlc[5][1][0]);
/* output a constant mean */
put_bits(&s->pb, svq1_intra_mean_vlc[mean][1],
svq1_intra_mean_vlc[mean][0]);
#ifdef DEBUG_SVQ1
av_log(s->avctx, AV_LOG_INFO, " const L5 %d/%d: multistage = 0 (0x%X, %d), mean = %d (0x%X, %d)\n",
i, block_width * block_height,
svq1_intra_multistage_vlc[5][1][0],
svq1_intra_multistage_vlc[5][1][1],
mean,
svq1_intra_mean_vlc[mean][0],
svq1_intra_mean_vlc[mean][1]);
#endif
}
}
static int svq1_encode_init(AVCodecContext *avctx) static int svq1_encode_init(AVCodecContext *avctx)
{ {
SVQ1Context * const s = avctx->priv_data; SVQ1Context * const s = avctx->priv_data;
int i;
unsigned char least_bits_value = 0;
int least_bits;
dsputil_init(&s->dsp, avctx); dsputil_init(&s->dsp, avctx);
avctx->coded_frame= (AVFrame*)&s->picture; avctx->coded_frame= (AVFrame*)&s->picture;
...@@ -1835,22 +1296,6 @@ av_log(s->avctx, AV_LOG_INFO, " Hey: %d x %d, %d x %d, %d x %d\n", ...@@ -1835,22 +1296,6 @@ av_log(s->avctx, AV_LOG_INFO, " Hey: %d x %d, %d x %d, %d x %d\n",
s->y_block_width, s->y_block_height, s->y_block_width, s->y_block_height,
s->c_block_width, s->c_block_height); s->c_block_width, s->c_block_height);
/* allocate a plane for the U & V planes (color, or C, planes) and
* initialize them to the value that is represented by the fewest bits
* in the mean table; the reasoning behind this is that when the border
* vectors are operated upon and possibly subdivided, the mean will be
* removed resulting in a perfect deviation score of 0 and encoded with
* the minimal possible bits */
s->c_plane = av_malloc(s->c_block_width * s->c_block_height * 16 * 16);
least_bits = 10000;
for (i = 0; i < 256; i++)
if (svq1_intra_mean_vlc[i][1] < least_bits) {
least_bits = svq1_intra_mean_vlc[i][1];
least_bits_value = i;
}
memset(s->c_plane, least_bits_value,
s->c_block_width * s->c_block_height * 16 * 16);
return 0; return 0;
} }
...@@ -1907,7 +1352,6 @@ static int svq1_encode_end(AVCodecContext *avctx) ...@@ -1907,7 +1352,6 @@ static int svq1_encode_end(AVCodecContext *avctx)
av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", s->rd_total/(double)(avctx->width*avctx->height*avctx->frame_number)); av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", s->rd_total/(double)(avctx->width*avctx->height*avctx->frame_number));
av_freep(&s->c_plane);
av_freep(&s->m.me.scratchpad); av_freep(&s->m.me.scratchpad);
av_freep(&s->m.me.map); av_freep(&s->m.me.map);
av_freep(&s->m.me.score_map); av_freep(&s->m.me.score_map);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment