Mercurial > libavcodec.hg

comparison dnxhdenc.c @ 6981:e897f60e5048 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
cosmetics, remove table_ prefix
author bcoudurier
date Mon, 02 Jun 2008 03:12:43 +0000
parents 9774d160f014
children e943e1409077
comparison
equal deleted inserted replaced
6980:ddbc1767b7cd 6981:e897f60e5048
65 uint16_t (*qmatrix_c16)[2][64]; 65 uint16_t (*qmatrix_c16)[2][64];
66 66
67 unsigned frame_bits; 67 unsigned frame_bits;
68 uint8_t *src[3]; 68 uint8_t *src[3];
69 69
70 uint32_t *table_vlc_codes; 70 uint32_t *vlc_codes;
71 uint8_t *table_vlc_bits; 71 uint8_t *vlc_bits;
72 uint16_t *table_run_codes; 72 uint16_t *run_codes;
73 uint8_t *table_run_bits; 73 uint8_t *run_bits;
74 74
75 /** Rate control */ 75 /** Rate control */
76 unsigned slice_bits; 76 unsigned slice_bits;
77 unsigned qscale; 77 unsigned qscale;
78 unsigned lambda; 78 unsigned lambda;
91 static int dnxhd_init_vlc(DNXHDEncContext *ctx) 91 static int dnxhd_init_vlc(DNXHDEncContext *ctx)
92 { 92 {
93 int i, j, level, run; 93 int i, j, level, run;
94 int max_level = 1<<(ctx->cid_table->bit_depth+2); 94 int max_level = 1<<(ctx->cid_table->bit_depth+2);
95 95
96 CHECKED_ALLOCZ(ctx->table_vlc_codes, max_level*4*sizeof(*ctx->table_vlc_codes)); 96 CHECKED_ALLOCZ(ctx->vlc_codes, max_level*4*sizeof(*ctx->vlc_codes));
97 CHECKED_ALLOCZ(ctx->table_vlc_bits, max_level*4*sizeof(*ctx->table_vlc_bits)); 97 CHECKED_ALLOCZ(ctx->vlc_bits, max_level*4*sizeof(*ctx->vlc_bits));
98 CHECKED_ALLOCZ(ctx->table_run_codes, 63*2); 98 CHECKED_ALLOCZ(ctx->run_codes, 63*2);
99 CHECKED_ALLOCZ(ctx->table_run_bits, 63); 99 CHECKED_ALLOCZ(ctx->run_bits, 63);
100 100
101 ctx->table_vlc_codes += max_level*2; 101 ctx->vlc_codes += max_level*2;
102 ctx->table_vlc_bits += max_level*2; 102 ctx->vlc_bits += max_level*2;
103 for (level = -max_level; level < max_level; level++) { 103 for (level = -max_level; level < max_level; level++) {
104 for (run = 0; run < 2; run++) { 104 for (run = 0; run < 2; run++) {
105 int index = (level<<1)|run; 105 int index = (level<<1)|run;
106 int sign, offset = 0, alevel = level; 106 int sign, offset = 0, alevel = level;
107 107
112 } 112 }
113 for (j = 0; j < 257; j++) { 113 for (j = 0; j < 257; j++) {
114 if (ctx->cid_table->ac_level[j] == alevel && 114 if (ctx->cid_table->ac_level[j] == alevel &&
115 (!offset || (ctx->cid_table->ac_index_flag[j] && offset)) && 115 (!offset || (ctx->cid_table->ac_index_flag[j] && offset)) &&
116 (!run || (ctx->cid_table->ac_run_flag [j] && run))) { 116 (!run || (ctx->cid_table->ac_run_flag [j] && run))) {
117 assert(!ctx->table_vlc_codes[index]); 117 assert(!ctx->vlc_codes[index]);
118 if (alevel) { 118 if (alevel) {
119 ctx->table_vlc_codes[index] = (ctx->cid_table->ac_codes[j]<<1)|(sign&1); 119 ctx->vlc_codes[index] = (ctx->cid_table->ac_codes[j]<<1)|(sign&1);
120 ctx->table_vlc_bits [index] = ctx->cid_table->ac_bits[j]+1; 120 ctx->vlc_bits [index] = ctx->cid_table->ac_bits[j]+1;
121 } else { 121 } else {
122 ctx->table_vlc_codes[index] = ctx->cid_table->ac_codes[j]; 122 ctx->vlc_codes[index] = ctx->cid_table->ac_codes[j];
123 ctx->table_vlc_bits [index] = ctx->cid_table->ac_bits [j]; 123 ctx->vlc_bits [index] = ctx->cid_table->ac_bits [j];
124 } 124 }
125 break; 125 break;
126 } 126 }
127 } 127 }
128 assert(!alevel || j < 257); 128 assert(!alevel || j < 257);
129 if (offset) { 129 if (offset) {
130 ctx->table_vlc_codes[index] = (ctx->table_vlc_codes[index]<<ctx->cid_table->index_bits)|offset; 130 ctx->vlc_codes[index] = (ctx->vlc_codes[index]<<ctx->cid_table->index_bits)|offset;
131 ctx->table_vlc_bits [index]+= ctx->cid_table->index_bits; 131 ctx->vlc_bits [index]+= ctx->cid_table->index_bits;
132 } 132 }
133 } 133 }
134 } 134 }
135 for (i = 0; i < 62; i++) { 135 for (i = 0; i < 62; i++) {
136 int run = ctx->cid_table->run[i]; 136 int run = ctx->cid_table->run[i];
137 assert(run < 63); 137 assert(run < 63);
138 ctx->table_run_codes[run] = ctx->cid_table->run_codes[i]; 138 ctx->run_codes[run] = ctx->cid_table->run_codes[i];
139 ctx->table_run_bits [run] = ctx->cid_table->run_bits[i]; 139 ctx->run_bits [run] = ctx->cid_table->run_bits[i];
140 } 140 }
141 return 0; 141 return 0;
142 fail: 142 fail:
143 return -1; 143 return -1;
144 } 144 }
319 j = ctx->m.intra_scantable.permutated[i]; 319 j = ctx->m.intra_scantable.permutated[i];
320 slevel = block[j]; 320 slevel = block[j];
321 if (slevel) { 321 if (slevel) {
322 int run_level = i - last_non_zero - 1; 322 int run_level = i - last_non_zero - 1;
323 int rlevel = (slevel<<1)|!!run_level; 323 int rlevel = (slevel<<1)|!!run_level;
324 put_bits(&ctx->m.pb, ctx->table_vlc_bits[rlevel], ctx->table_vlc_codes[rlevel]); 324 put_bits(&ctx->m.pb, ctx->vlc_bits[rlevel], ctx->vlc_codes[rlevel]);
325 if (run_level) 325 if (run_level)
326 put_bits(&ctx->m.pb, ctx->table_run_bits[run_level], ctx->table_run_codes[run_level]); 326 put_bits(&ctx->m.pb, ctx->run_bits[run_level], ctx->run_codes[run_level]);
327 last_non_zero = i; 327 last_non_zero = i;
328 } 328 }
329 } 329 }
330 put_bits(&ctx->m.pb, ctx->table_vlc_bits[0], ctx->table_vlc_codes[0]); // EOB 330 put_bits(&ctx->m.pb, ctx->vlc_bits[0], ctx->vlc_codes[0]); // EOB
331 } 331 }
332 332
333 static av_always_inline void dnxhd_unquantize_c(DNXHDEncContext *ctx, DCTELEM *block, int n, int qscale, int last_index) 333 static av_always_inline void dnxhd_unquantize_c(DNXHDEncContext *ctx, DCTELEM *block, int n, int qscale, int last_index)
334 { 334 {
335 const uint8_t *weight_matrix; 335 const uint8_t *weight_matrix;
376 for (i = 1; i <= last_index; i++) { 376 for (i = 1; i <= last_index; i++) {
377 j = ctx->m.intra_scantable.permutated[i]; 377 j = ctx->m.intra_scantable.permutated[i];
378 level = block[j]; 378 level = block[j];
379 if (level) { 379 if (level) {
380 int run_level = i - last_non_zero - 1; 380 int run_level = i - last_non_zero - 1;
381 bits += ctx->table_vlc_bits[(level<<1)|!!run_level]+ctx->table_run_bits[run_level]; 381 bits += ctx->vlc_bits[(level<<1)|!!run_level]+ctx->run_bits[run_level];
382 last_non_zero = i; 382 last_non_zero = i;
383 } 383 }
384 } 384 }
385 return bits; 385 return bits;
386 } 386 }
489 ctx->m.dsp.idct(block); 489 ctx->m.dsp.idct(block);
490 ssd += dnxhd_ssd_block(block, src_block); 490 ssd += dnxhd_ssd_block(block, src_block);
491 } 491 }
492 } 492 }
493 ctx->mb_rc[qscale][mb].ssd = ssd; 493 ctx->mb_rc[qscale][mb].ssd = ssd;
494 ctx->mb_rc[qscale][mb].bits = ac_bits+dc_bits+12+8*ctx->table_vlc_bits[0]; 494 ctx->mb_rc[qscale][mb].bits = ac_bits+dc_bits+12+8*ctx->vlc_bits[0];
495 } 495 }
496 } 496 }
497 return 0; 497 return 0;
498 } 498 }
499 499
824 { 824 {
825 DNXHDEncContext *ctx = avctx->priv_data; 825 DNXHDEncContext *ctx = avctx->priv_data;
826 int max_level = 1<<(ctx->cid_table->bit_depth+2); 826 int max_level = 1<<(ctx->cid_table->bit_depth+2);
827 int i; 827 int i;
828 828
829 av_free(ctx->table_vlc_codes-max_level*2); 829 av_free(ctx->vlc_codes-max_level*2);
830 av_free(ctx->table_vlc_bits -max_level*2); 830 av_free(ctx->vlc_bits -max_level*2);
831 av_freep(&ctx->table_run_codes); 831 av_freep(&ctx->run_codes);
832 av_freep(&ctx->table_run_bits); 832 av_freep(&ctx->run_bits);
833 833
834 av_freep(&ctx->mb_bits); 834 av_freep(&ctx->mb_bits);
835 av_freep(&ctx->mb_qscale); 835 av_freep(&ctx->mb_qscale);
836 av_freep(&ctx->mb_rc); 836 av_freep(&ctx->mb_rc);
837 av_freep(&ctx->mb_cmp); 837 av_freep(&ctx->mb_cmp);