Mercurial > libavcodec.hg

comparison dv.c @ 8175:0d1c9c936a52 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Making idct factor tables dynamically allocated
author romansh
date Thu, 20 Nov 2008 01:40:40 +0000
parents 471b16105266
children 7a463923ecd1
comparison
equal deleted inserted replaced
8174:f11197441364 8175:0d1c9c936a52
52 AVFrame picture; 52 AVFrame picture;
53 AVCodecContext *avctx; 53 AVCodecContext *avctx;
54 uint8_t *buf; 54 uint8_t *buf;
55 55
56 uint8_t dv_zigzag[2][64]; 56 uint8_t dv_zigzag[2][64];
57 uint32_t dv_idct_factor[2][2][22][64];
58 uint32_t dv100_idct_factor[4][4][16][64];
59 57
60 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size); 58 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
61 void (*fdct[2])(DCTELEM *block); 59 void (*fdct[2])(DCTELEM *block);
62 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block); 60 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
63 } DVVideoContext; 61 } DVVideoContext;
206 } 204 }
207 205
208 static int dv_init_dynamic_tables(const DVprofile *d) 206 static int dv_init_dynamic_tables(const DVprofile *d)
209 { 207 {
210 int j,i,c,s,p; 208 int j,i,c,s,p;
209 uint32_t *factor1, *factor2;
210 const int *iweight1, *iweight2;
211 211
212 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) { 212 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
213 p = i = 0; 213 p = i = 0;
214 for (c=0; c<d->n_difchan; c++) { 214 for (c=0; c<d->n_difchan; c++) {
215 for (s=0; s<d->difseg_size; s++) { 215 for (s=0; s<d->difseg_size; s++) {
224 p += 5; 224 p += 5;
225 } 225 }
226 } 226 }
227 } 227 }
228 } 228 }
229
230 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
231 factor1 = &d->idct_factor[0];
232 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
233 if (d->height == 720) {
234 iweight1 = &dv_iweight_720_y[0];
235 iweight2 = &dv_iweight_720_c[0];
236 } else {
237 iweight1 = &dv_iweight_1080_y[0];
238 iweight2 = &dv_iweight_1080_c[0];
239 }
240 if (DV_PROFILE_IS_HD(d)) {
241 for (c = 0; c < 4; c++) {
242 for (s = 0; s < 16; s++) {
243 for (i = 0; i < 64; i++) {
244 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
245 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
246 }
247 }
248 }
249 } else {
250 iweight1 = &dv_iweight_88[0];
251 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
252 for (s = 0; s < 22; s++) {
253 for (i = c = 0; c < 4; c++) {
254 for (; i < dv_quant_areas[c]; i++) {
255 *factor1 = iweight1[i] << (dv_quant_shifts[s][c] + 1);
256 *factor2++ = (*factor1++) << 1;
257 }
258 }
259 }
260 }
261 }
262 }
263
229 return 0; 264 return 0;
230 }
231
232 static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
233 {
234 int i, q, a;
235
236 /* NOTE: max left shift is 6 */
237 for (q = 0; q < 22; q++) {
238 /* 88DCT */
239 i = 1;
240 for (a = 0; a < 4; a++) {
241 for (; i < dv_quant_areas[a]; i++) {
242 /* 88 table */
243 s->dv_idct_factor[0][0][q][i] = dv_iweight_88[i] << (dv_quant_shifts[q][a] + 1);
244 s->dv_idct_factor[1][0][q][i] = s->dv_idct_factor[0][0][q][i] << 1;
245
246 /* 248 table */
247 s->dv_idct_factor[0][1][q][i] = dv_iweight_248[i] << (dv_quant_shifts[q][a] + 1);
248 s->dv_idct_factor[1][1][q][i] = s->dv_idct_factor[0][1][q][i] << 1;
249 }
250 }
251 }
252
253 for (a = 0; a < 4; a++) {
254 for (q = 0; q < 16; q++) {
255 for (i = 1; i < 64; i++) {
256 s->dv100_idct_factor[0][a][q][i] = (dv100_qstep[q] << (a + 9)) * dv_iweight_1080_y[i];
257 s->dv100_idct_factor[1][a][q][i] = (dv100_qstep[q] << (a + 9)) * dv_iweight_1080_c[i];
258 s->dv100_idct_factor[2][a][q][i] = (dv100_qstep[q] << (a + 9)) * dv_iweight_720_y[i];
259 s->dv100_idct_factor[3][a][q][i] = (dv100_qstep[q] << (a + 9)) * dv_iweight_720_c[i];
260 }
261 }
262 }
263 } 265 }
264 266
265 static av_cold int dvvideo_init(AVCodecContext *avctx) 267 static av_cold int dvvideo_init(AVCodecContext *avctx)
266 { 268 {
267 DVVideoContext *s = avctx->priv_data; 269 DVVideoContext *s = avctx->priv_data;
383 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2]; 385 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
384 } 386 }
385 }else 387 }else
386 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64); 388 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
387 389
388 /* XXX: do it only for constant case */
389 dv_build_unquantize_tables(s, dsp.idct_permutation);
390
391 avctx->coded_frame = &s->picture; 390 avctx->coded_frame = &s->picture;
392 s->avctx = avctx; 391 s->avctx = avctx;
393 392
394 return 0; 393 return 0;
395 } 394 }
554 dct_mode = get_bits1(&gb); 553 dct_mode = get_bits1(&gb);
555 class1 = get_bits(&gb, 2); 554 class1 = get_bits(&gb, 2);
556 if (DV_PROFILE_IS_HD(s->sys)) { 555 if (DV_PROFILE_IS_HD(s->sys)) {
557 mb->idct_put = s->idct_put[0]; 556 mb->idct_put = s->idct_put[0];
558 mb->scan_table = s->dv_zigzag[0]; 557 mb->scan_table = s->dv_zigzag[0];
559 mb->factor_table = s->dv100_idct_factor[((s->sys->height == 720) << 1) | (j >= 4)][class1][quant]; 558 mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64];
560 is_field_mode[mb_index] |= !j && dct_mode; 559 is_field_mode[mb_index] |= !j && dct_mode;
561 } else { 560 } else {
562 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3]; 561 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
563 mb->scan_table = s->dv_zigzag[dct_mode]; 562 mb->scan_table = s->dv_zigzag[dct_mode];
564 mb->factor_table = s->dv_idct_factor[class1 == 3][dct_mode] 563 mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 +
565 [quant + dv_quant_offset[class1]]; 564 (quant + dv_quant_offset[class1])*64];
566 } 565 }
567 dc = dc << 2; 566 dc = dc << 2;
568 /* convert to unsigned because 128 is not added in the 567 /* convert to unsigned because 128 is not added in the
569 standard IDCT */ 568 standard IDCT */
570 dc += 1024; 569 dc += 1024;