Mercurial > libavcodec.hg
comparison dv.c @ 2979:bfabfdf9ce55 libavcodec
COSMETICS: tabs --> spaces, some prettyprinting
author | diego |
---|---|
date | Thu, 22 Dec 2005 01:10:11 +0000 |
parents | ef2149182f1c |
children | d377b0788381 |
comparison
equal
deleted
inserted
replaced
2978:403183bbb505 | 2979:bfabfdf9ce55 |
---|---|
82 for(i = 1; i < 64; i++) { | 82 for(i = 1; i < 64; i++) { |
83 /* 88 table */ | 83 /* 88 table */ |
84 j = perm[i]; | 84 j = perm[i]; |
85 s->dv_idct_shift[0][0][q][j] = | 85 s->dv_idct_shift[0][0][q][j] = |
86 dv_quant_shifts[q][dv_88_areas[i]] + 1; | 86 dv_quant_shifts[q][dv_88_areas[i]] + 1; |
87 s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1; | 87 s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1; |
88 } | 88 } |
89 | 89 |
90 /* 248DCT */ | 90 /* 248DCT */ |
91 for(i = 1; i < 64; i++) { | 91 for(i = 1; i < 64; i++) { |
92 /* 248 table */ | 92 /* 248 table */ |
93 s->dv_idct_shift[0][1][q][i] = | 93 s->dv_idct_shift[0][1][q][i] = |
94 dv_quant_shifts[q][dv_248_areas[i]] + 1; | 94 dv_quant_shifts[q][dv_248_areas[i]] + 1; |
95 s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1; | 95 s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1; |
96 } | 96 } |
97 } | 97 } |
98 } | 98 } |
99 | 99 |
100 static int dvvideo_init(AVCodecContext *avctx) | 100 static int dvvideo_init(AVCodecContext *avctx) |
112 int16_t new_dv_vlc_level[NB_DV_VLC*2]; | 112 int16_t new_dv_vlc_level[NB_DV_VLC*2]; |
113 | 113 |
114 done = 1; | 114 done = 1; |
115 | 115 |
116 dv_vlc_map = av_mallocz_static(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair)); | 116 dv_vlc_map = av_mallocz_static(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair)); |
117 if (!dv_vlc_map) | 117 if (!dv_vlc_map) |
118 return -ENOMEM; | 118 return -ENOMEM; |
119 | 119 |
120 /* dv_anchor lets each thread know its Id */ | 120 /* dv_anchor lets each thread know its Id */ |
121 dv_anchor = av_malloc(12*27*sizeof(void*)); | 121 dv_anchor = av_malloc(12*27*sizeof(void*)); |
122 if (!dv_anchor) { | 122 if (!dv_anchor) { |
123 return -ENOMEM; | 123 return -ENOMEM; |
124 } | 124 } |
125 for (i=0; i<12*27; i++) | 125 for (i=0; i<12*27; i++) |
126 dv_anchor[i] = (void*)(size_t)i; | 126 dv_anchor[i] = (void*)(size_t)i; |
127 | 127 |
128 /* it's faster to include sign bit in a generic VLC parsing scheme */ | 128 /* it's faster to include sign bit in a generic VLC parsing scheme */ |
129 for (i=0, j=0; i<NB_DV_VLC; i++, j++) { | 129 for (i=0, j=0; i<NB_DV_VLC; i++, j++) { |
130 new_dv_vlc_bits[j] = dv_vlc_bits[i]; | 130 new_dv_vlc_bits[j] = dv_vlc_bits[i]; |
131 new_dv_vlc_len[j] = dv_vlc_len[i]; | 131 new_dv_vlc_len[j] = dv_vlc_len[i]; |
132 new_dv_vlc_run[j] = dv_vlc_run[i]; | 132 new_dv_vlc_run[j] = dv_vlc_run[i]; |
133 new_dv_vlc_level[j] = dv_vlc_level[i]; | 133 new_dv_vlc_level[j] = dv_vlc_level[i]; |
134 | 134 |
135 if (dv_vlc_level[i]) { | 135 if (dv_vlc_level[i]) { |
136 new_dv_vlc_bits[j] <<= 1; | 136 new_dv_vlc_bits[j] <<= 1; |
137 new_dv_vlc_len[j]++; | 137 new_dv_vlc_len[j]++; |
138 | 138 |
139 j++; | 139 j++; |
140 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1; | 140 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1; |
141 new_dv_vlc_len[j] = dv_vlc_len[i] + 1; | 141 new_dv_vlc_len[j] = dv_vlc_len[i] + 1; |
142 new_dv_vlc_run[j] = dv_vlc_run[i]; | 142 new_dv_vlc_run[j] = dv_vlc_run[i]; |
143 new_dv_vlc_level[j] = -dv_vlc_level[i]; | 143 new_dv_vlc_level[j] = -dv_vlc_level[i]; |
144 } | 144 } |
145 } | 145 } |
146 | 146 |
147 /* NOTE: as a trick, we use the fact the no codes are unused | 147 /* NOTE: as a trick, we use the fact the no codes are unused |
148 to accelerate the parsing of partial codes */ | 148 to accelerate the parsing of partial codes */ |
149 init_vlc(&dv_vlc, TEX_VLC_BITS, j, | 149 init_vlc(&dv_vlc, TEX_VLC_BITS, j, |
150 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0); | 150 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0); |
151 | 151 |
152 dv_rl_vlc = av_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM)); | 152 dv_rl_vlc = av_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM)); |
153 if (!dv_rl_vlc) { | 153 if (!dv_rl_vlc) { |
154 av_free(dv_anchor); | 154 av_free(dv_anchor); |
155 return -ENOMEM; | 155 return -ENOMEM; |
156 } | 156 } |
157 for(i = 0; i < dv_vlc.table_size; i++){ | 157 for(i = 0; i < dv_vlc.table_size; i++){ |
158 int code= dv_vlc.table[i][0]; | 158 int code= dv_vlc.table[i][0]; |
159 int len = dv_vlc.table[i][1]; | 159 int len = dv_vlc.table[i][1]; |
160 int level, run; | 160 int level, run; |
161 | 161 |
168 } | 168 } |
169 dv_rl_vlc[i].len = len; | 169 dv_rl_vlc[i].len = len; |
170 dv_rl_vlc[i].level = level; | 170 dv_rl_vlc[i].level = level; |
171 dv_rl_vlc[i].run = run; | 171 dv_rl_vlc[i].run = run; |
172 } | 172 } |
173 free_vlc(&dv_vlc); | 173 free_vlc(&dv_vlc); |
174 | 174 |
175 for (i = 0; i < NB_DV_VLC - 1; i++) { | 175 for (i = 0; i < NB_DV_VLC - 1; i++) { |
176 if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE) | 176 if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE) |
177 continue; | 177 continue; |
178 #ifdef DV_CODEC_TINY_TARGET | 178 #ifdef DV_CODEC_TINY_TARGET |
179 if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE) | 179 if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE) |
180 continue; | 180 continue; |
181 #endif | 181 #endif |
182 | 182 |
183 if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0) | 183 if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0) |
184 continue; | 184 continue; |
185 | 185 |
186 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] << | 186 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] << |
187 (!!dv_vlc_level[i]); | 187 (!!dv_vlc_level[i]); |
188 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] + | 188 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] + |
189 (!!dv_vlc_level[i]); | 189 (!!dv_vlc_level[i]); |
190 } | 190 } |
191 for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) { | 191 for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) { |
192 #ifdef DV_CODEC_TINY_TARGET | 192 #ifdef DV_CODEC_TINY_TARGET |
193 for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) { | 193 for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) { |
194 if (dv_vlc_map[i][j].size == 0) { | 194 if (dv_vlc_map[i][j].size == 0) { |
195 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc | | 195 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc | |
196 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size)); | 196 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size)); |
197 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + | 197 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + |
198 dv_vlc_map[0][j].size; | 198 dv_vlc_map[0][j].size; |
199 } | 199 } |
200 } | 200 } |
201 #else | 201 #else |
202 for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) { | 202 for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) { |
203 if (dv_vlc_map[i][j].size == 0) { | 203 if (dv_vlc_map[i][j].size == 0) { |
204 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc | | 204 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc | |
205 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size)); | 205 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size)); |
206 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + | 206 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + |
207 dv_vlc_map[0][j].size; | 207 dv_vlc_map[0][j].size; |
208 } | 208 } |
209 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc = | 209 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc = |
210 dv_vlc_map[i][j].vlc | 1; | 210 dv_vlc_map[i][j].vlc | 1; |
211 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size = | 211 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size = |
212 dv_vlc_map[i][j].size; | 212 dv_vlc_map[i][j].size; |
213 } | 213 } |
214 #endif | 214 #endif |
215 } | 215 } |
216 } | 216 } |
217 | 217 |
218 /* Generic DSP setup */ | 218 /* Generic DSP setup */ |
219 dsputil_init(&dsp, avctx); | 219 dsputil_init(&dsp, avctx); |
220 s->get_pixels = dsp.get_pixels; | 220 s->get_pixels = dsp.get_pixels; |
239 /* XXX: do it only for constant case */ | 239 /* XXX: do it only for constant case */ |
240 dv_build_unquantize_tables(s, dsp.idct_permutation); | 240 dv_build_unquantize_tables(s, dsp.idct_permutation); |
241 | 241 |
242 /* FIXME: I really don't think this should be here */ | 242 /* FIXME: I really don't think this should be here */ |
243 if (dv_codec_profile(avctx)) | 243 if (dv_codec_profile(avctx)) |
244 avctx->pix_fmt = dv_codec_profile(avctx)->pix_fmt; | 244 avctx->pix_fmt = dv_codec_profile(avctx)->pix_fmt; |
245 avctx->coded_frame = &s->picture; | 245 avctx->coded_frame = &s->picture; |
246 s->avctx= avctx; | 246 s->avctx= avctx; |
247 | 247 |
248 return 0; | 248 return 0; |
249 } | 249 } |
304 UPDATE_CACHE(re, gb); | 304 UPDATE_CACHE(re, gb); |
305 | 305 |
306 /* if we must parse a partial vlc, we do it here */ | 306 /* if we must parse a partial vlc, we do it here */ |
307 if (partial_bit_count > 0) { | 307 if (partial_bit_count > 0) { |
308 re_cache = ((unsigned)re_cache >> partial_bit_count) | | 308 re_cache = ((unsigned)re_cache >> partial_bit_count) | |
309 (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count)); | 309 (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count)); |
310 re_index -= partial_bit_count; | 310 re_index -= partial_bit_count; |
311 mb->partial_bit_count = 0; | 311 mb->partial_bit_count = 0; |
312 } | 312 } |
313 | 313 |
314 /* get the AC coefficients until last_index is reached */ | 314 /* get the AC coefficients until last_index is reached */ |
315 for(;;) { | 315 for(;;) { |
316 #ifdef VLC_DEBUG | 316 #ifdef VLC_DEBUG |
317 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index); | 317 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index); |
318 #endif | 318 #endif |
319 /* our own optimized GET_RL_VLC */ | 319 /* our own optimized GET_RL_VLC */ |
320 index = NEG_USR32(re_cache, TEX_VLC_BITS); | 320 index = NEG_USR32(re_cache, TEX_VLC_BITS); |
321 vlc_len = dv_rl_vlc[index].len; | 321 vlc_len = dv_rl_vlc[index].len; |
322 if (vlc_len < 0) { | 322 if (vlc_len < 0) { |
323 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level; | 323 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level; |
324 vlc_len = TEX_VLC_BITS - vlc_len; | 324 vlc_len = TEX_VLC_BITS - vlc_len; |
325 } | 325 } |
326 level = dv_rl_vlc[index].level; | 326 level = dv_rl_vlc[index].level; |
327 run = dv_rl_vlc[index].run; | 327 run = dv_rl_vlc[index].run; |
328 | 328 |
329 /* gotta check if we're still within gb boundaries */ | 329 /* gotta check if we're still within gb boundaries */ |
330 if (re_index + vlc_len > last_index) { | 330 if (re_index + vlc_len > last_index) { |
331 /* should be < 16 bits otherwise a codeword could have been parsed */ | 331 /* should be < 16 bits otherwise a codeword could have been parsed */ |
332 mb->partial_bit_count = last_index - re_index; | 332 mb->partial_bit_count = last_index - re_index; |
333 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count); | 333 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count); |
334 re_index = last_index; | 334 re_index = last_index; |
335 break; | 335 break; |
336 } | 336 } |
337 re_index += vlc_len; | 337 re_index += vlc_len; |
338 | 338 |
339 #ifdef VLC_DEBUG | 339 #ifdef VLC_DEBUG |
340 printf("run=%d level=%d\n", run, level); | 340 printf("run=%d level=%d\n", run, level); |
341 #endif | 341 #endif |
342 pos += run; | 342 pos += run; |
343 if (pos >= 64) | 343 if (pos >= 64) |
344 break; | 344 break; |
345 | 345 |
346 assert(level); | 346 assert(level); |
347 pos1 = scan_table[pos]; | 347 pos1 = scan_table[pos]; |
348 block[pos1] = level << shift_table[pos1]; | 348 block[pos1] = level << shift_table[pos1]; |
349 | 349 |
402 init_put_bits(&pb, mb_bit_buffer, 80); | 402 init_put_bits(&pb, mb_bit_buffer, 80); |
403 mb = mb1; | 403 mb = mb1; |
404 block = block1; | 404 block = block1; |
405 for(j = 0;j < 6; j++) { | 405 for(j = 0;j < 6; j++) { |
406 last_index = block_sizes[j]; | 406 last_index = block_sizes[j]; |
407 init_get_bits(&gb, buf_ptr, last_index); | 407 init_get_bits(&gb, buf_ptr, last_index); |
408 | 408 |
409 /* get the dc */ | 409 /* get the dc */ |
410 dc = get_sbits(&gb, 9); | 410 dc = get_sbits(&gb, 9); |
411 dct_mode = get_bits1(&gb); | 411 dct_mode = get_bits1(&gb); |
412 mb->dct_mode = dct_mode; | 412 mb->dct_mode = dct_mode; |
442 printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index); | 442 printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index); |
443 #endif | 443 #endif |
444 block = block1; | 444 block = block1; |
445 mb = mb1; | 445 mb = mb1; |
446 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb)); | 446 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb)); |
447 flush_put_bits(&pb); | 447 flush_put_bits(&pb); |
448 for(j = 0;j < 6; j++, block += 64, mb++) { | 448 for(j = 0;j < 6; j++, block += 64, mb++) { |
449 if (mb->pos < 64 && get_bits_left(&gb) > 0) { | 449 if (mb->pos < 64 && get_bits_left(&gb) > 0) { |
450 dv_decode_ac(&gb, mb, block); | 450 dv_decode_ac(&gb, mb, block); |
451 /* if still not finished, no need to parse other blocks */ | 451 /* if still not finished, no need to parse other blocks */ |
452 if (mb->pos < 64) | 452 if (mb->pos < 64) |
454 } | 454 } |
455 } | 455 } |
456 /* all blocks are finished, so the extra bytes can be used at | 456 /* all blocks are finished, so the extra bytes can be used at |
457 the video segment level */ | 457 the video segment level */ |
458 if (j >= 6) | 458 if (j >= 6) |
459 bit_copy(&vs_pb, &gb); | 459 bit_copy(&vs_pb, &gb); |
460 } | 460 } |
461 | 461 |
462 /* we need a pass other the whole video segment */ | 462 /* we need a pass other the whole video segment */ |
463 #ifdef VLC_DEBUG | 463 #ifdef VLC_DEBUG |
464 printf("***pass 3 size=%d\n", put_bits_count(&vs_pb)); | 464 printf("***pass 3 size=%d\n", put_bits_count(&vs_pb)); |
473 #ifdef VLC_DEBUG | 473 #ifdef VLC_DEBUG |
474 printf("start %d:%d\n", mb_index, j); | 474 printf("start %d:%d\n", mb_index, j); |
475 #endif | 475 #endif |
476 dv_decode_ac(&gb, mb, block); | 476 dv_decode_ac(&gb, mb, block); |
477 } | 477 } |
478 if (mb->pos >= 64 && mb->pos < 127) | 478 if (mb->pos >= 64 && mb->pos < 127) |
479 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos); | 479 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos); |
480 block += 64; | 480 block += 64; |
481 mb++; | 481 mb++; |
482 } | 482 } |
483 } | 483 } |
484 | 484 |
506 } | 506 } |
507 } else { | 507 } else { |
508 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) { | 508 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) { |
509 uint64_t aligned_pixels[64/8]; | 509 uint64_t aligned_pixels[64/8]; |
510 uint8_t *pixels= (uint8_t*)aligned_pixels; | 510 uint8_t *pixels= (uint8_t*)aligned_pixels; |
511 uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1; | 511 uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1; |
512 int x, y, linesize; | 512 int x, y, linesize; |
513 /* NOTE: at end of line, the macroblock is handled as 420 */ | 513 /* NOTE: at end of line, the macroblock is handled as 420 */ |
514 idct_put(pixels, 8, block); | 514 idct_put(pixels, 8, block); |
515 linesize = s->picture.linesize[6 - j]; | 515 linesize = s->picture.linesize[6 - j]; |
516 c_ptr = s->picture.data[6 - j] + c_offset; | 516 c_ptr = s->picture.data[6 - j] + c_offset; |
541 static always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc) | 541 static always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc) |
542 { | 542 { |
543 int size; | 543 int size; |
544 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { | 544 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { |
545 *vlc = dv_vlc_map[run][level].vlc | sign; | 545 *vlc = dv_vlc_map[run][level].vlc | sign; |
546 size = dv_vlc_map[run][level].size; | 546 size = dv_vlc_map[run][level].size; |
547 } | 547 } |
548 else { | 548 else { |
549 if (level < DV_VLC_MAP_LEV_SIZE) { | 549 if (level < DV_VLC_MAP_LEV_SIZE) { |
550 *vlc = dv_vlc_map[0][level].vlc | sign; | 550 *vlc = dv_vlc_map[0][level].vlc | sign; |
551 size = dv_vlc_map[0][level].size; | 551 size = dv_vlc_map[0][level].size; |
552 } else { | 552 } else { |
553 *vlc = 0xfe00 | (level << 1) | sign; | 553 *vlc = 0xfe00 | (level << 1) | sign; |
554 size = 16; | 554 size = 16; |
555 } | 555 } |
556 if (run) { | 556 if (run) { |
557 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc : | 557 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc : |
558 (0x1f80 | (run - 1))) << size; | 558 (0x1f80 | (run - 1))) << size; |
559 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; | 559 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; |
560 } | 560 } |
561 } | 561 } |
562 | 562 |
563 return size; | 563 return size; |
564 } | 564 } |
565 | 565 |
566 static always_inline int dv_rl2vlc_size(int run, int level) | 566 static always_inline int dv_rl2vlc_size(int run, int level) |
567 { | 567 { |
568 int size; | 568 int size; |
569 | 569 |
570 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { | 570 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) { |
571 size = dv_vlc_map[run][level].size; | 571 size = dv_vlc_map[run][level].size; |
572 } | 572 } |
573 else { | 573 else { |
574 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16; | 574 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16; |
575 if (run) { | 575 if (run) { |
576 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; | 576 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13; |
577 } | 577 } |
578 } | 578 } |
579 return size; | 579 return size; |
580 } | 580 } |
581 #else | 581 #else |
582 static always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc) | 582 static always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc) |
618 for(;;){ | 618 for(;;){ |
619 /* Find suitable storage space */ | 619 /* Find suitable storage space */ |
620 for (; size > (bits_left = put_bits_left(pb)); pb++) { | 620 for (; size > (bits_left = put_bits_left(pb)); pb++) { |
621 if (bits_left) { | 621 if (bits_left) { |
622 size -= bits_left; | 622 size -= bits_left; |
623 put_bits(pb, bits_left, vlc >> size); | 623 put_bits(pb, bits_left, vlc >> size); |
624 vlc = vlc & ((1<<size)-1); | 624 vlc = vlc & ((1<<size)-1); |
625 } | 625 } |
626 if (pb + 1 >= pb_end) { | 626 if (pb + 1 >= pb_end) { |
627 bi->partial_bit_count = size; | 627 bi->partial_bit_count = size; |
628 bi->partial_bit_buffer = vlc; | 628 bi->partial_bit_buffer = vlc; |
629 return pb; | 629 return pb; |
630 } | 630 } |
631 } | 631 } |
632 | 632 |
633 /* Store VLC */ | 633 /* Store VLC */ |
634 put_bits(pb, size, vlc); | 634 put_bits(pb, size, vlc); |
635 | 635 |
710 | 710 |
711 /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */ | 711 /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */ |
712 s = blk; | 712 s = blk; |
713 for(i=0; i<7; i++) { | 713 for(i=0; i<7; i++) { |
714 score88 += SC(0, 8) + SC(1, 9) + SC(2, 10) + SC(3, 11) + | 714 score88 += SC(0, 8) + SC(1, 9) + SC(2, 10) + SC(3, 11) + |
715 SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15); | 715 SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15); |
716 s += 8; | 716 s += 8; |
717 } | 717 } |
718 /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */ | 718 /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */ |
719 s = blk; | 719 s = blk; |
720 for(i=0; i<6; i++) { | 720 for(i=0; i<6; i++) { |
721 score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) + | 721 score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) + |
722 SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23); | 722 SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23); |
723 s += 8; | 723 s += 8; |
724 } | 724 } |
725 | 725 |
726 return (score88 - score248 > -10); | 726 return (score88 - score248 > -10); |
727 } | 727 } |
734 | 734 |
735 do { | 735 do { |
736 b = blks; | 736 b = blks; |
737 for (i=0; i<5; i++) { | 737 for (i=0; i<5; i++) { |
738 if (!qnos[i]) | 738 if (!qnos[i]) |
739 continue; | 739 continue; |
740 | 740 |
741 qnos[i]--; | 741 qnos[i]--; |
742 size[i] = 0; | 742 size[i] = 0; |
743 for (j=0; j<6; j++, b++) { | 743 for (j=0; j<6; j++, b++) { |
744 for (a=0; a<4; a++) { | 744 for (a=0; a<4; a++) { |
745 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) { | 745 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) { |
746 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :) | 746 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :) |
747 b->area_q[a]++; | 747 b->area_q[a]++; |
748 prev= b->prev[a]; | 748 prev= b->prev[a]; |
749 for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) { | 749 for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) { |
750 b->mb[k] >>= 1; | 750 b->mb[k] >>= 1; |
751 if (b->mb[k]) { | 751 if (b->mb[k]) { |
752 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); | 752 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]); |
753 prev= k; | 753 prev= k; |
754 } else { | 754 } else { |
755 b->next[prev] = b->next[k]; | 755 b->next[prev] = b->next[k]; |
756 } | 756 } |
757 } | 757 } |
758 b->prev[a+1]= prev; | 758 b->prev[a+1]= prev; |
759 } | 759 } |
760 size[i] += b->bit_size[a]; | 760 size[i] += b->bit_size[a]; |
761 } | 761 } |
762 } | 762 } |
763 } | 763 } |
764 } while ((vs_total_ac_bits < size[0] + size[1] + size[2] + size[3] + size[4]) && | 764 } while ((vs_total_ac_bits < size[0] + size[1] + size[2] + size[3] + size[4]) && |
765 (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4])); | 765 (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4])); |
766 } | 766 } |
767 | 767 |
795 for(mb_index = 0; mb_index < 5; mb_index++) { | 795 for(mb_index = 0; mb_index < 5; mb_index++) { |
796 v = *mb_pos_ptr++; | 796 v = *mb_pos_ptr++; |
797 mb_x = v & 0xff; | 797 mb_x = v & 0xff; |
798 mb_y = v >> 8; | 798 mb_y = v >> 8; |
799 y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8); | 799 y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8); |
800 c_offset = (s->sys->pix_fmt == PIX_FMT_YUV411P) ? | 800 c_offset = (s->sys->pix_fmt == PIX_FMT_YUV411P) ? |
801 ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8)) : | 801 ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8)) : |
802 (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8)); | 802 (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8)); |
803 do_edge_wrap = 0; | 803 do_edge_wrap = 0; |
804 qnos[mb_index] = 15; /* No quantization */ | 804 qnos[mb_index] = 15; /* No quantization */ |
805 ptr = dif + mb_index*80 + 4; | 805 ptr = dif + mb_index*80 + 4; |
806 for(j = 0;j < 6; j++) { | 806 for(j = 0;j < 6; j++) { |
807 if (j < 4) { /* Four Y blocks */ | 807 if (j < 4) { /* Four Y blocks */ |
808 /* NOTE: at end of line, the macroblock is handled as 420 */ | 808 /* NOTE: at end of line, the macroblock is handled as 420 */ |
809 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) { | 809 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) { |
810 data = y_ptr + (j * 8); | 810 data = y_ptr + (j * 8); |
811 } else { | 811 } else { |
812 data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]); | 812 data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]); |
813 } | 813 } |
814 linesize = s->picture.linesize[0]; | 814 linesize = s->picture.linesize[0]; |
815 } else { /* Cr and Cb blocks */ | 815 } else { /* Cr and Cb blocks */ |
816 /* don't ask Fabrice why they inverted Cb and Cr ! */ | 816 /* don't ask Fabrice why they inverted Cb and Cr ! */ |
817 data = s->picture.data[6 - j] + c_offset; | 817 data = s->picture.data[6 - j] + c_offset; |
818 linesize = s->picture.linesize[6 - j]; | 818 linesize = s->picture.linesize[6 - j]; |
819 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) | 819 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) |
820 do_edge_wrap = 1; | 820 do_edge_wrap = 1; |
821 } | 821 } |
822 | 822 |
823 /* Everything is set up -- now just copy data -> DCT block */ | 823 /* Everything is set up -- now just copy data -> DCT block */ |
824 if (do_edge_wrap) { /* Edge wrap copy: 4x16 -> 8x8 */ | 824 if (do_edge_wrap) { /* Edge wrap copy: 4x16 -> 8x8 */ |
825 uint8_t* d; | 825 uint8_t* d; |
826 DCTELEM *b = block; | 826 DCTELEM *b = block; |
827 for (i=0;i<8;i++) { | 827 for (i=0;i<8;i++) { |
828 d = data + 8 * linesize; | 828 d = data + 8 * linesize; |
829 b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3]; | 829 b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3]; |
830 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3]; | 830 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3]; |
831 data += linesize; | 831 data += linesize; |
832 b += 8; | 832 b += 8; |
833 } | 833 } |
834 } else { /* Simple copy: 8x8 -> 8x8 */ | 834 } else { /* Simple copy: 8x8 -> 8x8 */ |
835 s->get_pixels(block, data, linesize); | 835 s->get_pixels(block, data, linesize); |
836 } | 836 } |
837 | 837 |
838 if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) | 838 if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) |
839 enc_blk->dct_mode = dv_guess_dct_mode(block); | 839 enc_blk->dct_mode = dv_guess_dct_mode(block); |
840 else | 840 else |
841 enc_blk->dct_mode = 0; | 841 enc_blk->dct_mode = 0; |
842 enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0; | 842 enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0; |
843 enc_blk->partial_bit_count = 0; | 843 enc_blk->partial_bit_count = 0; |
844 enc_blk->partial_bit_buffer = 0; | 844 enc_blk->partial_bit_buffer = 0; |
845 enc_blk->cur_ac = 0; | 845 enc_blk->cur_ac = 0; |
846 | 846 |
847 s->fdct[enc_blk->dct_mode](block); | 847 s->fdct[enc_blk->dct_mode](block); |
848 | 848 |
849 dv_set_class_number(block, enc_blk, | 849 dv_set_class_number(block, enc_blk, |
850 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct, j/4); | 850 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct, j/4); |
851 | 851 |
852 init_put_bits(pb, ptr, block_sizes[j]/8); | 852 init_put_bits(pb, ptr, block_sizes[j]/8); |
853 put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2)); | 853 put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2)); |
854 put_bits(pb, 1, enc_blk->dct_mode); | 854 put_bits(pb, 1, enc_blk->dct_mode); |
855 put_bits(pb, 2, enc_blk->cno); | 855 put_bits(pb, 2, enc_blk->cno); |
856 | 856 |
857 vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] + | 857 vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] + |
858 enc_blk->bit_size[2] + enc_blk->bit_size[3]; | 858 enc_blk->bit_size[2] + enc_blk->bit_size[3]; |
859 ++enc_blk; | 859 ++enc_blk; |
860 ++pb; | 860 ++pb; |
861 ptr += block_sizes[j]/8; | 861 ptr += block_sizes[j]/8; |
862 } | 862 } |
863 } | 863 } |
864 | 864 |
865 if (vs_total_ac_bits < vs_bit_size) | 865 if (vs_total_ac_bits < vs_bit_size) |
866 dv_guess_qnos(&enc_blks[0], &qnos[0]); | 866 dv_guess_qnos(&enc_blks[0], &qnos[0]); |
896 static int dv_decode_mt(AVCodecContext *avctx, void* sl) | 896 static int dv_decode_mt(AVCodecContext *avctx, void* sl) |
897 { | 897 { |
898 DVVideoContext *s = avctx->priv_data; | 898 DVVideoContext *s = avctx->priv_data; |
899 int slice = (size_t)sl; | 899 int slice = (size_t)sl; |
900 dv_decode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80], | 900 dv_decode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80], |
901 &s->sys->video_place[slice*5]); | 901 &s->sys->video_place[slice*5]); |
902 return 0; | 902 return 0; |
903 } | 903 } |
904 | 904 |
905 static int dv_encode_mt(AVCodecContext *avctx, void* sl) | 905 static int dv_encode_mt(AVCodecContext *avctx, void* sl) |
906 { | 906 { |
907 DVVideoContext *s = avctx->priv_data; | 907 DVVideoContext *s = avctx->priv_data; |
908 int slice = (size_t)sl; | 908 int slice = (size_t)sl; |
909 dv_encode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80], | 909 dv_encode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80], |
910 &s->sys->video_place[slice*5]); | 910 &s->sys->video_place[slice*5]); |
911 return 0; | 911 return 0; |
912 } | 912 } |
913 | 913 |
914 /* NOTE: exactly one frame must be given (120000 bytes for NTSC, | 914 /* NOTE: exactly one frame must be given (120000 bytes for NTSC, |
915 144000 bytes for PAL) */ | 915 144000 bytes for PAL) */ |
938 s->picture.interlaced_frame = 1; | 938 s->picture.interlaced_frame = 1; |
939 s->picture.top_field_first = 0; | 939 s->picture.top_field_first = 0; |
940 | 940 |
941 s->buf = buf; | 941 s->buf = buf; |
942 avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL, | 942 avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL, |
943 s->sys->difseg_size * 27); | 943 s->sys->difseg_size * 27); |
944 | 944 |
945 emms_c(); | 945 emms_c(); |
946 | 946 |
947 /* return image */ | 947 /* return image */ |
948 *data_size = sizeof(AVFrame); | 948 *data_size = sizeof(AVFrame); |
956 { | 956 { |
957 DVVideoContext *s = c->priv_data; | 957 DVVideoContext *s = c->priv_data; |
958 | 958 |
959 s->sys = dv_codec_profile(c); | 959 s->sys = dv_codec_profile(c); |
960 if (!s->sys) | 960 if (!s->sys) |
961 return -1; | 961 return -1; |
962 if(buf_size < s->sys->frame_size) | 962 if(buf_size < s->sys->frame_size) |
963 return -1; | 963 return -1; |
964 | 964 |
965 c->pix_fmt = s->sys->pix_fmt; | 965 c->pix_fmt = s->sys->pix_fmt; |
966 s->picture = *((AVFrame *)data); | 966 s->picture = *((AVFrame *)data); |
967 s->picture.key_frame = 1; | 967 s->picture.key_frame = 1; |
968 s->picture.pict_type = FF_I_TYPE; | 968 s->picture.pict_type = FF_I_TYPE; |
969 | 969 |
970 s->buf = buf; | 970 s->buf = buf; |
971 c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL, | 971 c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL, |
972 s->sys->difseg_size * 27); | 972 s->sys->difseg_size * 27); |
973 | 973 |
974 emms_c(); | 974 emms_c(); |
975 return s->sys->frame_size; | 975 return s->sys->frame_size; |
976 } | 976 } |
977 | 977 |