Mercurial > libavcodec.hg
comparison dv.c @ 3149:2679184e8be0 libavcodec
AC coefficient weighing (per SMPTE 314M) for the DV encoder and decoder. The
performance impact is less than 1%.
Patch by Dan Maas (dmaas at maasdigital dot com)
author | romansh |
---|---|
date | Mon, 27 Feb 2006 04:50:06 +0000 |
parents | d4d8e5436be7 |
children | c4b6411b4b53 |
comparison
equal
deleted
inserted
replaced
3148:d4d8e5436be7 | 3149:2679184e8be0 |
---|---|
251 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__) | 251 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__) |
252 | 252 |
253 typedef struct BlockInfo { | 253 typedef struct BlockInfo { |
254 const uint8_t *shift_table; | 254 const uint8_t *shift_table; |
255 const uint8_t *scan_table; | 255 const uint8_t *scan_table; |
256 const int *iweight_table; | |
256 uint8_t pos; /* position in block */ | 257 uint8_t pos; /* position in block */ |
257 uint8_t dct_mode; | 258 uint8_t dct_mode; |
258 uint8_t partial_bit_count; | 259 uint8_t partial_bit_count; |
259 uint16_t partial_bit_buffer; | 260 uint16_t partial_bit_buffer; |
260 int shift_offset; | 261 int shift_offset; |
293 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block) | 294 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block) |
294 { | 295 { |
295 int last_index = get_bits_size(gb); | 296 int last_index = get_bits_size(gb); |
296 const uint8_t *scan_table = mb->scan_table; | 297 const uint8_t *scan_table = mb->scan_table; |
297 const uint8_t *shift_table = mb->shift_table; | 298 const uint8_t *shift_table = mb->shift_table; |
299 const int *iweight_table = mb->iweight_table; | |
298 int pos = mb->pos; | 300 int pos = mb->pos; |
299 int partial_bit_count = mb->partial_bit_count; | 301 int partial_bit_count = mb->partial_bit_count; |
300 int level, pos1, run, vlc_len, index; | 302 int level, pos1, run, vlc_len, index; |
301 | 303 |
302 OPEN_READER(re, gb); | 304 OPEN_READER(re, gb); |
341 pos += run; | 343 pos += run; |
342 if (pos >= 64) | 344 if (pos >= 64) |
343 break; | 345 break; |
344 | 346 |
345 pos1 = scan_table[pos]; | 347 pos1 = scan_table[pos]; |
346 block[pos1] = level << shift_table[pos1]; | 348 level <<= shift_table[pos1]; |
349 | |
350 /* unweigh, round, and shift down */ | |
351 level = (level*iweight_table[pos] + (1 << (dv_iweight_bits-1))) >> dv_iweight_bits; | |
352 | |
353 block[pos1] = level; | |
347 | 354 |
348 UPDATE_CACHE(re, gb); | 355 UPDATE_CACHE(re, gb); |
349 } | 356 } |
350 CLOSE_READER(re, gb); | 357 CLOSE_READER(re, gb); |
351 mb->pos = pos; | 358 mb->pos = pos; |
407 /* get the dc */ | 414 /* get the dc */ |
408 dc = get_sbits(&gb, 9); | 415 dc = get_sbits(&gb, 9); |
409 dct_mode = get_bits1(&gb); | 416 dct_mode = get_bits1(&gb); |
410 mb->dct_mode = dct_mode; | 417 mb->dct_mode = dct_mode; |
411 mb->scan_table = s->dv_zigzag[dct_mode]; | 418 mb->scan_table = s->dv_zigzag[dct_mode]; |
419 mb->iweight_table = dct_mode ? dv_iweight_248 : dv_iweight_88; | |
412 class1 = get_bits(&gb, 2); | 420 class1 = get_bits(&gb, 2); |
413 mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode] | 421 mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode] |
414 [quant + dv_quant_offset[class1]]; | 422 [quant + dv_quant_offset[class1]]; |
415 dc = dc << 2; | 423 dc = dc << 2; |
416 /* convert to unsigned because 128 is not added in the | 424 /* convert to unsigned because 128 is not added in the |
645 } | 653 } |
646 return pb; | 654 return pb; |
647 } | 655 } |
648 | 656 |
649 static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi, | 657 static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi, |
650 const uint8_t* zigzag_scan, int bias) | 658 const uint8_t* zigzag_scan, const int *weight, int bias) |
651 { | 659 { |
652 int i, area; | 660 int i, area; |
653 static const int classes[] = {12, 24, 36, 0xffff}; | 661 static const int classes[] = {12, 24, 36, 0xffff}; |
654 int max=12; | 662 int max=12; |
655 int prev=0; | 663 int prev=0; |
662 for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) { | 670 for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) { |
663 int level = blk[zigzag_scan[i]]; | 671 int level = blk[zigzag_scan[i]]; |
664 | 672 |
665 if (level+15 > 30U) { | 673 if (level+15 > 30U) { |
666 bi->sign[i] = (level>>31)&1; | 674 bi->sign[i] = (level>>31)&1; |
667 bi->mb[i] = level= ABS(level)>>4; | 675 /* weigh it and and shift down into range, adding for rounding */ |
676 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT | |
677 AND the 2x doubling of the weights */ | |
678 level = (ABS(level) * weight[i] + (1<<(dv_weight_bits+3))) >> (dv_weight_bits+4); | |
679 bi->mb[i] = level; | |
668 if(level>max) max= level; | 680 if(level>max) max= level; |
669 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level); | 681 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level); |
670 bi->next[prev]= i; | 682 bi->next[prev]= i; |
671 prev= i; | 683 prev= i; |
672 } | 684 } |
873 enc_blk->cur_ac = 0; | 885 enc_blk->cur_ac = 0; |
874 | 886 |
875 s->fdct[enc_blk->dct_mode](block); | 887 s->fdct[enc_blk->dct_mode](block); |
876 | 888 |
877 dv_set_class_number(block, enc_blk, | 889 dv_set_class_number(block, enc_blk, |
878 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct, j/4); | 890 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct, |
891 enc_blk->dct_mode ? dv_weight_248 : dv_weight_88, | |
892 j/4); | |
879 | 893 |
880 init_put_bits(pb, ptr, block_sizes[j]/8); | 894 init_put_bits(pb, ptr, block_sizes[j]/8); |
881 put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2)); | 895 put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2)); |
882 put_bits(pb, 1, enc_blk->dct_mode); | 896 put_bits(pb, 1, enc_blk->dct_mode); |
883 put_bits(pb, 2, enc_blk->cno); | 897 put_bits(pb, 2, enc_blk->cno); |