3 * Copyright (c) 2002 Fabrice Bellard.
4 * Copyright (c) 2004 Roman Shaposhnik.
7 * Copyright (c) 2003 Roman Shaposhnik.
9 * 50 Mbps (DVCPRO50) support
10 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
12 * 100 Mbps (DVCPRO HD) support
13 * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)
14 * Final code by Roman Shaposhnik
16 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
17 * of DV technical info.
19 * This file is part of FFmpeg.
21 * FFmpeg is free software; you can redistribute it and/or
22 * modify it under the terms of the GNU Lesser General Public
23 * License as published by the Free Software Foundation; either
24 * version 2.1 of the License, or (at your option) any later version.
26 * FFmpeg is distributed in the hope that it will be useful,
27 * but WITHOUT ANY WARRANTY; without even the implied warranty of
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
29 * Lesser General Public License for more details.
31 * You should have received a copy of the GNU Lesser General Public
32 * License along with FFmpeg; if not, write to the Free Software
33 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
40 #define ALT_BITSTREAM_READER
43 #include "bitstream.h"
44 #include "simple_idct.h"
50 typedef struct DVVideoContext {
53 AVCodecContext *avctx;
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];
60 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
61 void (*fdct[2])(DCTELEM *block);
62 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
65 #define TEX_VLC_BITS 9
68 #define DV_VLC_MAP_RUN_SIZE 15
69 #define DV_VLC_MAP_LEV_SIZE 23
71 #define DV_VLC_MAP_RUN_SIZE 64
72 #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
75 /* XXX: also include quantization */
76 static RL_VLC_ELEM dv_rl_vlc[1184];
77 /* VLC encoding lookup table */
78 static struct dv_vlc_pair {
81 } dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE];
83 static inline int dv_work_pool_size(const DVprofile *d)
85 int size = d->n_difchan*d->difseg_size*27;
86 if (DV_PROFILE_IS_1080i50(d))
88 if (DV_PROFILE_IS_720p50(d))
93 static int dv_init_dynamic_tables(const DVprofile *d)
97 if (d->work_chunks[dv_work_pool_size(d)-1])
101 for (c=0; c<d->n_difchan; c++) {
102 for (s=0; s<d->difseg_size; s++) {
104 for (j=0; j<27; j++) {
106 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
107 !(DV_PROFILE_IS_720p50(d) && s > 9)) {
108 d->work_chunks[i++] = (void*)(size_t)((p<<18)|(c << 16)|(s << 8)|j);
117 static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
121 /* NOTE: max left shift is 6 */
122 for (q = 0; q < 22; q++) {
125 for (a = 0; a < 4; a++) {
126 for (; i < dv_quant_areas[a]; i++) {
128 s->dv_idct_factor[0][0][q][i] = dv_iweight_88[i] << (dv_quant_shifts[q][a] + 1);
129 s->dv_idct_factor[1][0][q][i] = s->dv_idct_factor[0][0][q][i] << 1;
132 s->dv_idct_factor[0][1][q][i] = dv_iweight_248[i] << (dv_quant_shifts[q][a] + 1);
133 s->dv_idct_factor[1][1][q][i] = s->dv_idct_factor[0][1][q][i] << 1;
138 for (a = 0; a < 4; a++) {
139 for (q = 0; q < 16; q++) {
140 for (i = 1; i < 64; i++) {
141 s->dv100_idct_factor[0][a][q][i] = (dv100_qstep[q] << (a + 9)) * dv_iweight_1080_y[i];
142 s->dv100_idct_factor[1][a][q][i] = (dv100_qstep[q] << (a + 9)) * dv_iweight_1080_c[i];
143 s->dv100_idct_factor[2][a][q][i] = (dv100_qstep[q] << (a + 9)) * dv_iweight_720_y[i];
144 s->dv100_idct_factor[3][a][q][i] = (dv100_qstep[q] << (a + 9)) * dv_iweight_720_c[i];
150 static av_cold int dvvideo_init(AVCodecContext *avctx)
152 DVVideoContext *s = avctx->priv_data;
159 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
160 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
161 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
162 int16_t new_dv_vlc_level[NB_DV_VLC*2];
166 /* it's faster to include sign bit in a generic VLC parsing scheme */
167 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
168 new_dv_vlc_bits[j] = dv_vlc_bits[i];
169 new_dv_vlc_len[j] = dv_vlc_len[i];
170 new_dv_vlc_run[j] = dv_vlc_run[i];
171 new_dv_vlc_level[j] = dv_vlc_level[i];
173 if (dv_vlc_level[i]) {
174 new_dv_vlc_bits[j] <<= 1;
178 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
179 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
180 new_dv_vlc_run[j] = dv_vlc_run[i];
181 new_dv_vlc_level[j] = -dv_vlc_level[i];
185 /* NOTE: as a trick, we use the fact the no codes are unused
186 to accelerate the parsing of partial codes */
187 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
188 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
189 assert(dv_vlc.table_size == 1184);
191 for (i = 0; i < dv_vlc.table_size; i++){
192 int code = dv_vlc.table[i][0];
193 int len = dv_vlc.table[i][1];
196 if (len < 0){ //more bits needed
200 run = new_dv_vlc_run [code] + 1;
201 level = new_dv_vlc_level[code];
203 dv_rl_vlc[i].len = len;
204 dv_rl_vlc[i].level = level;
205 dv_rl_vlc[i].run = run;
209 for (i = 0; i < NB_DV_VLC - 1; i++) {
210 if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
213 if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
217 if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
220 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc =
221 dv_vlc_bits[i] << (!!dv_vlc_level[i]);
222 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size =
223 dv_vlc_len[i] + (!!dv_vlc_level[i]);
225 for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
227 for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
228 if (dv_vlc_map[i][j].size == 0) {
229 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
230 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
231 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
232 dv_vlc_map[0][j].size;
236 for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
237 if (dv_vlc_map[i][j].size == 0) {
238 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
239 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
240 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
241 dv_vlc_map[0][j].size;
243 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
244 dv_vlc_map[i][j].vlc | 1;
245 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
246 dv_vlc_map[i][j].size;
252 /* Generic DSP setup */
253 dsputil_init(&dsp, avctx);
254 s->get_pixels = dsp.get_pixels;
257 s->fdct[0] = dsp.fdct;
258 s->idct_put[0] = dsp.idct_put;
259 for (i = 0; i < 64; i++)
260 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
263 s->fdct[1] = dsp.fdct248;
264 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
266 for (i = 0; i < 64; i++){
267 int j = ff_zigzag248_direct[i];
268 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
271 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
273 /* XXX: do it only for constant case */
274 dv_build_unquantize_tables(s, dsp.idct_permutation);
276 avctx->coded_frame = &s->picture;
283 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
285 typedef struct BlockInfo {
286 const uint32_t *factor_table;
287 const uint8_t *scan_table;
288 uint8_t pos; /* position in block */
289 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
290 uint8_t partial_bit_count;
291 uint16_t partial_bit_buffer;
295 /* bit budget for AC only in 5 MBs */
296 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
297 /* see dv_88_areas and dv_248_areas for details */
298 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
300 static inline int get_bits_left(GetBitContext *s)
302 return s->size_in_bits - get_bits_count(s);
305 static inline int put_bits_left(PutBitContext* s)
307 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
310 /* decode ac coefficients */
311 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
313 int last_index = gb->size_in_bits;
314 const uint8_t *scan_table = mb->scan_table;
315 const uint32_t *factor_table = mb->factor_table;
317 int partial_bit_count = mb->partial_bit_count;
318 int level, run, vlc_len, index;
321 UPDATE_CACHE(re, gb);
323 /* if we must parse a partial vlc, we do it here */
324 if (partial_bit_count > 0) {
325 re_cache = ((unsigned)re_cache >> partial_bit_count) |
326 (mb->partial_bit_buffer << (sizeof(re_cache) * 8 - partial_bit_count));
327 re_index -= partial_bit_count;
328 mb->partial_bit_count = 0;
331 /* get the AC coefficients until last_index is reached */
334 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
336 /* our own optimized GET_RL_VLC */
337 index = NEG_USR32(re_cache, TEX_VLC_BITS);
338 vlc_len = dv_rl_vlc[index].len;
340 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
341 vlc_len = TEX_VLC_BITS - vlc_len;
343 level = dv_rl_vlc[index].level;
344 run = dv_rl_vlc[index].run;
346 /* gotta check if we're still within gb boundaries */
347 if (re_index + vlc_len > last_index) {
348 /* should be < 16 bits otherwise a codeword could have been parsed */
349 mb->partial_bit_count = last_index - re_index;
350 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
351 re_index = last_index;
357 printf("run=%d level=%d\n", run, level);
363 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;
364 block[scan_table[pos]] = level;
366 UPDATE_CACHE(re, gb);
368 CLOSE_READER(re, gb);
372 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
374 int bits_left = get_bits_left(gb);
375 while (bits_left >= MIN_CACHE_BITS) {
376 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
377 bits_left -= MIN_CACHE_BITS;
380 put_bits(pb, bits_left, get_bits(gb, bits_left));
384 static inline void dv_calculate_mb_xy(DVVideoContext *s, int work_chunk, int m, int *mb_x, int *mb_y)
386 int i, chan, seg, slot;
388 chan = (work_chunk>>16)&0x03;
389 seg = (work_chunk>>8)&0xff;
390 slot = (work_chunk)&0xff;
392 i = (chan*s->sys->difseg_size+seg)*27*5 + slot*5 + m;
393 *mb_x = s->sys->video_place[i] & 0xff;
394 *mb_y = s->sys->video_place[i] >> 8;
396 /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
397 if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
398 *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */
402 /* mb_x and mb_y are in units of 8 pixels */
403 static inline void dv_decode_video_segment(DVVideoContext *s, int work_chunk)
405 int quant, dc, dct_mode, class1, j;
406 int mb_index, mb_x, mb_y, last_index;
407 int y_stride, linesize;
408 DCTELEM *block, *block1;
411 const uint8_t *buf_ptr;
412 PutBitContext pb, vs_pb;
414 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
415 DECLARE_ALIGNED_16(DCTELEM, sblock[5*DV_MAX_BPM][64]);
416 DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
417 DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
418 const int log2_blocksize = 3-s->avctx->lowres;
419 int is_field_mode[5];
421 assert((((int)mb_bit_buffer) & 7) == 0);
422 assert((((int)vs_bit_buffer) & 7) == 0);
424 memset(sblock, 0, sizeof(sblock));
426 /* pass 1 : read DC and AC coefficients in blocks */
427 buf_ptr = &s->buf[(work_chunk>>18)*80];
428 block1 = &sblock[0][0];
430 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
431 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
433 quant = buf_ptr[3] & 0x0f;
435 init_put_bits(&pb, mb_bit_buffer, 80);
438 is_field_mode[mb_index] = 0;
439 for (j = 0; j < s->sys->bpm; j++) {
440 last_index = s->sys->block_sizes[j];
441 init_get_bits(&gb, buf_ptr, last_index);
444 dc = get_sbits(&gb, 9);
445 dct_mode = get_bits1(&gb);
446 class1 = get_bits(&gb, 2);
447 if (DV_PROFILE_IS_HD(s->sys)) {
448 mb->idct_put = s->idct_put[0];
449 mb->scan_table = s->dv_zigzag[0];
450 mb->factor_table = s->dv100_idct_factor[((s->sys->height == 720) << 1) | (j >= 4)][class1][quant];
451 is_field_mode[mb_index] |= !j && dct_mode;
453 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
454 mb->scan_table = s->dv_zigzag[dct_mode];
455 mb->factor_table = s->dv_idct_factor[class1 == 3][dct_mode]
456 [quant + dv_quant_offset[class1]];
459 /* convert to unsigned because 128 is not added in the
463 buf_ptr += last_index >> 3;
465 mb->partial_bit_count = 0;
468 printf("MB block: %d, %d ", mb_index, j);
470 dv_decode_ac(&gb, mb, block);
472 /* write the remaining bits in a new buffer only if the
481 /* pass 2 : we can do it just after */
483 printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
487 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
489 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
490 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
491 dv_decode_ac(&gb, mb, block);
492 /* if still not finished, no need to parse other blocks */
497 /* all blocks are finished, so the extra bytes can be used at
498 the video segment level */
499 if (j >= s->sys->bpm)
500 bit_copy(&vs_pb, &gb);
503 /* we need a pass other the whole video segment */
505 printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
507 block = &sblock[0][0];
509 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
510 flush_put_bits(&vs_pb);
511 for (mb_index = 0; mb_index < 5; mb_index++) {
512 for (j = 0; j < s->sys->bpm; j++) {
515 printf("start %d:%d\n", mb_index, j);
517 dv_decode_ac(&gb, mb, block);
519 if (mb->pos >= 64 && mb->pos < 127)
520 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
526 /* compute idct and place blocks */
527 block = &sblock[0][0];
529 for (mb_index = 0; mb_index < 5; mb_index++) {
530 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
532 /* idct_put'ting luminance */
533 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
534 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
535 (s->sys->height >= 720 && mb_y != 134)) {
536 y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
538 y_stride = (2 << log2_blocksize);
540 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize);
541 linesize = s->picture.linesize[0] << is_field_mode[mb_index];
542 mb[0] .idct_put(y_ptr , linesize, block + 0*64);
543 if (s->sys->video_stype == 4) { /* SD 422 */
544 mb[2].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 2*64);
546 mb[1].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 1*64);
547 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2*64);
548 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
553 /* idct_put'ting chrominance */
554 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
555 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
556 for (j = 2; j; j--) {
557 uint8_t *c_ptr = s->picture.data[j] + c_offset;
558 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
559 uint64_t aligned_pixels[64/8];
560 uint8_t *pixels = (uint8_t*)aligned_pixels;
561 uint8_t *c_ptr1, *ptr1;
563 mb->idct_put(pixels, 8, block);
564 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
565 ptr1 = pixels + (1 << (log2_blocksize - 1));
566 c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
567 for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
568 c_ptr[x] = pixels[x];
574 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
575 s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
576 linesize = s->picture.linesize[j] << is_field_mode[mb_index];
577 (mb++)-> idct_put(c_ptr , linesize, block); block += 64;
578 if (s->sys->bpm == 8) {
579 (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
587 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
588 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
591 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
592 *vlc = dv_vlc_map[run][level].vlc | sign;
593 size = dv_vlc_map[run][level].size;
596 if (level < DV_VLC_MAP_LEV_SIZE) {
597 *vlc = dv_vlc_map[0][level].vlc | sign;
598 size = dv_vlc_map[0][level].size;
600 *vlc = 0xfe00 | (level << 1) | sign;
604 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
605 (0x1f80 | (run - 1))) << size;
606 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
613 static av_always_inline int dv_rl2vlc_size(int run, int level)
617 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
618 size = dv_vlc_map[run][level].size;
621 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
623 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
629 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
631 *vlc = dv_vlc_map[run][l].vlc | sign;
632 return dv_vlc_map[run][l].size;
635 static av_always_inline int dv_rl2vlc_size(int run, int l)
637 return dv_vlc_map[run][l].size;
641 typedef struct EncBlockInfo {
651 uint8_t partial_bit_count;
652 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
655 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
656 PutBitContext* pb_pool,
657 PutBitContext* pb_end)
660 PutBitContext* pb = pb_pool;
661 int size = bi->partial_bit_count;
662 uint32_t vlc = bi->partial_bit_buffer;
664 bi->partial_bit_count = bi->partial_bit_buffer = 0;
666 /* Find suitable storage space */
667 for (; size > (bits_left = put_bits_left(pb)); pb++) {
670 put_bits(pb, bits_left, vlc >> size);
671 vlc = vlc & ((1 << size) - 1);
673 if (pb + 1 >= pb_end) {
674 bi->partial_bit_count = size;
675 bi->partial_bit_buffer = vlc;
681 put_bits(pb, size, vlc);
683 if (bi->cur_ac >= 64)
686 /* Construct the next VLC */
688 bi->cur_ac = bi->next[prev];
689 if (bi->cur_ac < 64){
690 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
692 size = 4; vlc = 6; /* End Of Block stamp */
698 static av_always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
699 const uint8_t* zigzag_scan,
700 const int *weight, int bias)
703 /* We offer two different methods for class number assignment: the
704 method suggested in SMPTE 314M Table 22, and an improved
705 method. The SMPTE method is very conservative; it assigns class
706 3 (i.e. severe quantization) to any block where the largest AC
707 component is greater than 36. FFmpeg's DV encoder tracks AC bit
708 consumption precisely, so there is no need to bias most blocks
709 towards strongly lossy compression. Instead, we assign class 2
710 to most blocks, and use class 3 only when strictly necessary
711 (for blocks whose largest AC component exceeds 255). */
713 #if 0 /* SMPTE spec method */
714 static const int classes[] = {12, 24, 36, 0xffff};
715 #else /* improved FFmpeg method */
716 static const int classes[] = {-1, -1, 255, 0xffff};
718 int max = classes[0];
723 for (area = 0; area < 4; area++) {
724 bi->prev[area] = prev;
725 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
726 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
727 int level = blk[zigzag_scan[i]];
729 if (level + 15 > 30U) {
730 bi->sign[i] = (level >> 31) & 1;
731 /* weigh it and and shift down into range, adding for rounding */
732 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
733 AND the 2x doubling of the weights */
734 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
738 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
745 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
753 for (area = 0; area < 4; area++) {
754 bi->prev[area] = prev;
755 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
756 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
760 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
770 //FIXME replace this by dsputil
771 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
772 static av_always_inline int dv_guess_dct_mode(DCTELEM *blk) {
778 /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
780 for (i = 0; i < 7; i++) {
781 score88 += SC(0, 8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
782 SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
785 /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
787 for (i = 0; i < 6; i++) {
788 score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
789 SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
793 return (score88 - score248 > -10);
796 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
799 int i, j, k, a, prev, a2;
802 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
805 for (i = 0; i < 5; i++) {
811 for (j = 0; j < 6; j++, b++) {
812 for (a = 0; a < 4; a++) {
813 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
814 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
817 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
818 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
821 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
824 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
825 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
828 assert(b->mb[b->next[k]]);
829 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
830 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
831 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
834 b->next[prev] = b->next[k];
839 size[i] += b->bit_size[a];
842 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
845 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
848 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
850 size[0] = 5 * 6 * 4; //EOB
851 for (j = 0; j < 6 *5; j++, b++) {
853 for (k = b->next[prev]; k < 64; k = b->next[k]) {
854 if (b->mb[k] < a && b->mb[k] > -a){
855 b->next[prev] = b->next[k];
857 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
865 static inline void dv_encode_video_segment(DVVideoContext *s, int work_chunk)
868 int mb_x, mb_y, c_offset, linesize;
874 DECLARE_ALIGNED_16(DCTELEM, block[64]);
875 EncBlockInfo enc_blks[5*6];
876 PutBitContext pbs[5*6];
878 EncBlockInfo* enc_blk;
882 assert((((int)block) & 15) == 0);
884 dif = &s->buf[(work_chunk>>18)*80];
885 enc_blk = &enc_blks[0];
887 for (mb_index = 0; mb_index < 5; mb_index++) {
888 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
889 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
890 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
891 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
893 qnos[mb_index] = 15; /* No quantization */
894 ptr = dif + mb_index*80 + 4;
895 for (j = 0; j < 6; j++) {
897 if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
898 if (j == 0 || j == 2) {
900 data = y_ptr + ((j >> 1) * 8);
901 linesize = s->picture.linesize[0];
904 data = s->picture.data[6 - j] + c_offset;
905 linesize = s->picture.linesize[6 - j];
907 /* j=1 and j=3 are "dummy" blocks, used for AC data only */
912 } else { /* 4:1:1 or 4:2:0 */
913 if (j < 4) { /* Four Y blocks */
914 /* NOTE: at end of line, the macroblock is handled as 420 */
915 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
916 data = y_ptr + (j * 8);
918 data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
920 linesize = s->picture.linesize[0];
921 } else { /* Cr and Cb blocks */
922 /* don't ask Fabrice why they inverted Cb and Cr ! */
923 data = s->picture.data [6 - j] + c_offset;
924 linesize = s->picture.linesize[6 - j];
925 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
930 /* Everything is set up -- now just copy data -> DCT block */
931 if (do_edge_wrap) { /* Edge wrap copy: 4x16 -> 8x8 */
934 for (i = 0; i < 8; i++) {
935 d = data + 8 * linesize;
936 b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
937 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
941 } else { /* Simple copy: 8x8 -> 8x8 */
943 s->get_pixels(block, data, linesize);
946 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
947 enc_blk->dct_mode = dv_guess_dct_mode(block);
949 enc_blk->dct_mode = 0;
950 enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
951 enc_blk->partial_bit_count = 0;
952 enc_blk->partial_bit_buffer = 0;
956 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
957 which is precisely what the spec calls for in the "dummy" blocks. */
958 memset(block, 0, sizeof(block));
960 s->fdct[enc_blk->dct_mode](block);
963 dv_set_class_number(block, enc_blk,
964 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct,
965 enc_blk->dct_mode ? dv_weight_248 : dv_weight_88,
968 init_put_bits(pb, ptr, s->sys->block_sizes[j]/8);
969 put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
970 put_bits(pb, 1, enc_blk->dct_mode);
971 put_bits(pb, 2, enc_blk->cno);
973 vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
974 enc_blk->bit_size[2] + enc_blk->bit_size[3];
977 ptr += s->sys->block_sizes[j]/8;
981 if (vs_total_ac_bits < vs_bit_size)
982 dv_guess_qnos(&enc_blks[0], &qnos[0]);
984 for (i = 0; i < 5; i++) {
985 dif[i*80 + 3] = qnos[i];
988 /* First pass over individual cells only */
989 for (j = 0; j < 5 * 6; j++)
990 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
992 /* Second pass over each MB space */
993 for (j = 0; j < 5 * 6; j += 6) {
995 for (i = 0; i < 6; i++) {
996 if (enc_blks[i+j].partial_bit_count)
997 pb = dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
1001 /* Third and final pass over the whole video segment space */
1003 for (j = 0; j < 5 * 6; j++) {
1004 if (enc_blks[j].partial_bit_count)
1005 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
1006 if (enc_blks[j].partial_bit_count)
1007 av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
1010 for (j = 0; j < 5 * 6; j++)
1011 flush_put_bits(&pbs[j]);
1014 static int dv_decode_mt(AVCodecContext *avctx, void* sl)
1016 dv_decode_video_segment((DVVideoContext *)avctx->priv_data, *(size_t*)sl);
1020 #ifdef CONFIG_DVVIDEO_ENCODER
1021 static int dv_encode_mt(AVCodecContext *avctx, void* sl)
1023 dv_encode_video_segment((DVVideoContext *)avctx->priv_data, *(size_t*)sl);
1028 #ifdef CONFIG_DVVIDEO_DECODER
1029 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1030 144000 bytes for PAL - or twice those for 50Mbps) */
1031 static int dvvideo_decode_frame(AVCodecContext *avctx,
1032 void *data, int *data_size,
1033 const uint8_t *buf, int buf_size)
1035 DVVideoContext *s = avctx->priv_data;
1037 s->sys = dv_frame_profile(buf);
1038 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1039 return -1; /* NOTE: we only accept several full frames */
1041 if (s->picture.data[0])
1042 avctx->release_buffer(avctx, &s->picture);
1044 s->picture.reference = 0;
1045 s->picture.key_frame = 1;
1046 s->picture.pict_type = FF_I_TYPE;
1047 avctx->pix_fmt = s->sys->pix_fmt;
1048 avctx->time_base = s->sys->time_base;
1049 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1050 if (avctx->get_buffer(avctx, &s->picture) < 0) {
1051 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1054 s->picture.interlaced_frame = 1;
1055 s->picture.top_field_first = 0;
1058 avctx->execute(avctx, dv_decode_mt, s->sys->work_chunks, NULL,
1059 dv_work_pool_size(s->sys), sizeof(void*));
1064 *data_size = sizeof(AVFrame);
1065 *(AVFrame*)data = s->picture;
1067 return s->sys->frame_size;
1069 #endif /* CONFIG_DVVIDEO_DECODER */
1072 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1076 * Here's what SMPTE314M says about these two:
1077 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1078 * as track application IDs (APTn = 001, AP1n =
1079 * 001, AP2n = 001, AP3n = 001), if the source signal
1080 * comes from a digital VCR. If the signal source is
1081 * unknown, all bits for these data shall be set to 1.
1082 * (page 12) STYPE: STYPE defines a signal type of video signal
1083 * 00000b = 4:1:1 compression
1084 * 00100b = 4:2:2 compression
1086 * Now, I've got two problems with these statements:
1087 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1088 * It seems that for PAL as defined in IEC 61834 we have to set
1089 * APT to 000 and for SMPTE314M to 001.
1090 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1091 * compression scheme (if any).
1093 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1094 int stype = (c->sys->pix_fmt == PIX_FMT_YUV422P ? 4 : 0);
1097 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) == 17) /* 16:9 */
1100 buf[0] = (uint8_t)pack_id;
1102 case dv_header525: /* I can't imagine why these two weren't defined as real */
1103 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1104 buf[1] = 0xf8 | /* reserved -- always 1 */
1105 (apt & 0x07); /* APT: Track application ID */
1106 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1107 (0x0f << 3) | /* reserved -- always 1 */
1108 (apt & 0x07); /* AP1: Audio application ID */
1109 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1110 (0x0f << 3) | /* reserved -- always 1 */
1111 (apt & 0x07); /* AP2: Video application ID */
1112 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1113 (0x0f << 3) | /* reserved -- always 1 */
1114 (apt & 0x07); /* AP3: Subcode application ID */
1116 case dv_video_source:
1117 buf[1] = 0xff; /* reserved -- always 1 */
1118 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1119 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1120 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1121 0xf; /* reserved -- always 1 */
1122 buf[3] = (3 << 6) | /* reserved -- always 1 */
1123 (c->sys->dsf << 5) | /* system: 60fields/50fields */
1124 stype; /* signal type video compression */
1125 buf[4] = 0xff; /* VISC: 0xff -- no information */
1127 case dv_video_control:
1128 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1129 0x3f; /* reserved -- always 1 */
1130 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1132 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1133 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1134 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1135 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1136 0xc; /* reserved -- always b1100 */
1137 buf[4] = 0xff; /* reserved -- always 1 */
1140 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1145 #ifdef CONFIG_DVVIDEO_ENCODER
1146 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1150 for (chan = 0; chan < c->sys->n_difchan; chan++) {
1151 for (i = 0; i < c->sys->difseg_size; i++) {
1152 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1154 /* DV header: 1DIF */
1155 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1156 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1157 buf += 72; /* unused bytes */
1159 /* DV subcode: 2DIFs */
1160 for (j = 0; j < 2; j++) {
1161 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1162 for (k = 0; k < 6; k++)
1163 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1164 buf += 29; /* unused bytes */
1167 /* DV VAUX: 3DIFS */
1168 for (j = 0; j < 3; j++) {
1169 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1170 buf += dv_write_pack(dv_video_source, c, buf);
1171 buf += dv_write_pack(dv_video_control, c, buf);
1173 buf += dv_write_pack(dv_video_source, c, buf);
1174 buf += dv_write_pack(dv_video_control, c, buf);
1175 buf += 4*5 + 2; /* unused bytes */
1178 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1179 for (j = 0; j < 135; j++) {
1181 memset(buf, 0xff, 80);
1182 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1183 buf += 77; /* audio control & shuffled PCM audio */
1185 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1186 buf += 77; /* 1 video macroblock: 1 bytes control
1187 4 * 14 bytes Y 8x8 data
1188 10 bytes Cr 8x8 data
1189 10 bytes Cb 8x8 data */
1196 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1199 DVVideoContext *s = c->priv_data;
1201 s->sys = dv_codec_profile(c);
1202 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1205 c->pix_fmt = s->sys->pix_fmt;
1206 s->picture = *((AVFrame *)data);
1207 s->picture.key_frame = 1;
1208 s->picture.pict_type = FF_I_TYPE;
1211 c->execute(c, dv_encode_mt, s->sys->work_chunks, NULL,
1212 dv_work_pool_size(s->sys), sizeof(void*));
1216 dv_format_frame(s, buf);
1218 return s->sys->frame_size;
1222 static int dvvideo_close(AVCodecContext *c)
1224 DVVideoContext *s = c->priv_data;
1226 if (s->picture.data[0])
1227 c->release_buffer(c, &s->picture);
1233 #ifdef CONFIG_DVVIDEO_ENCODER
1234 AVCodec dvvideo_encoder = {
1238 sizeof(DVVideoContext),
1240 dvvideo_encode_frame,
1241 .pix_fmts = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1242 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1244 #endif // CONFIG_DVVIDEO_ENCODER
1246 #ifdef CONFIG_DVVIDEO_DECODER
1247 AVCodec dvvideo_decoder = {
1251 sizeof(DVVideoContext),
1255 dvvideo_decode_frame,
1258 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),