removing unused encoding code
Originally committed as revision 3133 to svn://svn.ffmpeg.org/ffmpeg/trunk
This commit is contained in:
Michael Niedermayer
parent
22f7a0601e
commit
cc77b9435b
@ -85,8 +85,6 @@ typedef struct SVQ1Context {
|
||||
int c_block_width;
|
||||
int c_block_height;
|
||||
|
||||
unsigned char *c_plane;
|
||||
|
||||
uint16_t *mb_type;
|
||||
uint32_t *dummy;
|
||||
int16_t (*motion_val8[3])[2];
|
||||
@ -914,419 +912,10 @@ static void svq1_write_header(SVQ1Context *s, int frame_type)
|
||||
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 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){
|
||||
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
|
||||
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)
|
||||
{
|
||||
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 i, j;
|
||||
int i;
|
||||
int block_width, block_height;
|
||||
int left_edge;
|
||||
int level;
|
||||
int threshold[6];
|
||||
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 */
|
||||
threshold[5] = QUALITY_THRESHOLD;
|
||||
for (level = 4; level >= 0; level--)
|
||||
@ -1537,9 +1112,9 @@ av_log(s->avctx, AV_LOG_INFO, "********* frame #%d\n", frame++);
|
||||
s->m.mb_type= s->mb_type;
|
||||
|
||||
//dummies, to avoid segfaults
|
||||
s->m.current_picture.mb_mean= s->dummy;
|
||||
s->m.current_picture.mb_var= s->dummy;
|
||||
s->m.current_picture.mc_mb_var= s->dummy;
|
||||
s->m.current_picture.mb_mean= (uint8_t *)s->dummy;
|
||||
s->m.current_picture.mb_var= (uint16_t*)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.motion_val[0]= s->motion_val8[plane];
|
||||
@ -1602,9 +1177,6 @@ av_log(s->avctx, AV_LOG_INFO, "********* frame #%d\n", frame++);
|
||||
s->m.mb_x= x;
|
||||
ff_init_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)){
|
||||
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);
|
||||
if(best==0){
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
/* 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)
|
||||
{
|
||||
SVQ1Context * const s = avctx->priv_data;
|
||||
int i;
|
||||
unsigned char least_bits_value = 0;
|
||||
int least_bits;
|
||||
|
||||
dsputil_init(&s->dsp, avctx);
|
||||
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",
|
||||
s->y_block_width, s->y_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;
|
||||
}
|
||||
|
||||
@ -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_freep(&s->c_plane);
|
||||
av_freep(&s->m.me.scratchpad);
|
||||
av_freep(&s->m.me.map);
|
||||
av_freep(&s->m.me.score_map);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user