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);
66 * MultiThreading - dv_anchor applies to entire DV codec, not just the avcontext
67 * one element is needed for each video segment in a DV frame
68 * at most there are 4 DIF channels * 12 DIF sequences * 27 video segments (1080i50)
70 #define DV_ANCHOR_SIZE (4*12*27)
72 static void* dv_anchor[DV_ANCHOR_SIZE];
74 #define TEX_VLC_BITS 9
76 #ifdef DV_CODEC_TINY_TARGET
77 #define DV_VLC_MAP_RUN_SIZE 15
78 #define DV_VLC_MAP_LEV_SIZE 23
80 #define DV_VLC_MAP_RUN_SIZE 64
81 #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
84 /* XXX: also include quantization */
85 static RL_VLC_ELEM dv_rl_vlc[1184];
86 /* VLC encoding lookup table */
87 static struct dv_vlc_pair {
90 } dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE];
92 static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
96 /* NOTE: max left shift is 6 */
97 for(q = 0; q < 22; q++) {
100 for(a = 0; a<4; a++) {
101 for(; i < dv_quant_areas[a]; i++) {
103 s->dv_idct_factor[0][0][q][i] = dv_iweight_88[i]<<(dv_quant_shifts[q][a] + 1);
104 s->dv_idct_factor[1][0][q][i] = s->dv_idct_factor[0][0][q][i]<<1;
107 s->dv_idct_factor[0][1][q][i] = dv_iweight_248[i]<<(dv_quant_shifts[q][a] + 1);
108 s->dv_idct_factor[1][1][q][i] = s->dv_idct_factor[0][1][q][i]<<1;
113 for(a = 0; a < 4; a++) {
114 for(q = 0; q < 16; q++) {
115 for(i = 1; i < 64; i++) {
116 s->dv100_idct_factor[0][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_1080_y[i];
117 s->dv100_idct_factor[1][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_1080_c[i];
118 s->dv100_idct_factor[2][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_720_y[i];
119 s->dv100_idct_factor[3][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_720_c[i];
125 static av_cold int dvvideo_init(AVCodecContext *avctx)
127 DVVideoContext *s = avctx->priv_data;
134 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
135 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
136 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
137 int16_t new_dv_vlc_level[NB_DV_VLC*2];
141 /* dv_anchor lets each thread know its Id */
142 for (i=0; i<DV_ANCHOR_SIZE; i++)
143 dv_anchor[i] = (void*)(size_t)i;
145 /* it's faster to include sign bit in a generic VLC parsing scheme */
146 for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
147 new_dv_vlc_bits[j] = dv_vlc_bits[i];
148 new_dv_vlc_len[j] = dv_vlc_len[i];
149 new_dv_vlc_run[j] = dv_vlc_run[i];
150 new_dv_vlc_level[j] = dv_vlc_level[i];
152 if (dv_vlc_level[i]) {
153 new_dv_vlc_bits[j] <<= 1;
157 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
158 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
159 new_dv_vlc_run[j] = dv_vlc_run[i];
160 new_dv_vlc_level[j] = -dv_vlc_level[i];
164 /* NOTE: as a trick, we use the fact the no codes are unused
165 to accelerate the parsing of partial codes */
166 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
167 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
168 assert(dv_vlc.table_size == 1184);
170 for(i = 0; i < dv_vlc.table_size; i++){
171 int code= dv_vlc.table[i][0];
172 int len = dv_vlc.table[i][1];
175 if(len<0){ //more bits needed
179 run= new_dv_vlc_run[code] + 1;
180 level= new_dv_vlc_level[code];
182 dv_rl_vlc[i].len = len;
183 dv_rl_vlc[i].level = level;
184 dv_rl_vlc[i].run = run;
188 for (i = 0; i < NB_DV_VLC - 1; i++) {
189 if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
191 #ifdef DV_CODEC_TINY_TARGET
192 if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
196 if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
199 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] <<
201 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] +
204 for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
205 #ifdef DV_CODEC_TINY_TARGET
206 for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
207 if (dv_vlc_map[i][j].size == 0) {
208 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
209 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
210 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
211 dv_vlc_map[0][j].size;
215 for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
216 if (dv_vlc_map[i][j].size == 0) {
217 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
218 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
219 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
220 dv_vlc_map[0][j].size;
222 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
223 dv_vlc_map[i][j].vlc | 1;
224 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
225 dv_vlc_map[i][j].size;
231 /* Generic DSP setup */
232 dsputil_init(&dsp, avctx);
233 s->get_pixels = dsp.get_pixels;
236 s->fdct[0] = dsp.fdct;
237 s->idct_put[0] = dsp.idct_put;
239 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
242 s->fdct[1] = dsp.fdct248;
243 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
245 for (i=0; i<64; i++){
246 int j= ff_zigzag248_direct[i];
247 s->dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2];
250 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
252 /* XXX: do it only for constant case */
253 dv_build_unquantize_tables(s, dsp.idct_permutation);
255 avctx->coded_frame = &s->picture;
262 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
264 typedef struct BlockInfo {
265 const uint32_t *factor_table;
266 const uint8_t *scan_table;
267 uint8_t pos; /* position in block */
268 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
269 uint8_t partial_bit_count;
270 uint16_t partial_bit_buffer;
274 /* bit budget for AC only in 5 MBs */
275 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
276 /* see dv_88_areas and dv_248_areas for details */
277 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
279 static inline int get_bits_left(GetBitContext *s)
281 return s->size_in_bits - get_bits_count(s);
284 static inline int put_bits_left(PutBitContext* s)
286 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
289 /* decode ac coefficients */
290 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
292 int last_index = gb->size_in_bits;
293 const uint8_t *scan_table = mb->scan_table;
294 const uint32_t *factor_table = mb->factor_table;
296 int partial_bit_count = mb->partial_bit_count;
297 int level, run, vlc_len, index;
300 UPDATE_CACHE(re, gb);
302 /* if we must parse a partial vlc, we do it here */
303 if (partial_bit_count > 0) {
304 re_cache = ((unsigned)re_cache >> partial_bit_count) |
305 (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
306 re_index -= partial_bit_count;
307 mb->partial_bit_count = 0;
310 /* get the AC coefficients until last_index is reached */
313 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
315 /* our own optimized GET_RL_VLC */
316 index = NEG_USR32(re_cache, TEX_VLC_BITS);
317 vlc_len = dv_rl_vlc[index].len;
319 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
320 vlc_len = TEX_VLC_BITS - vlc_len;
322 level = dv_rl_vlc[index].level;
323 run = dv_rl_vlc[index].run;
325 /* gotta check if we're still within gb boundaries */
326 if (re_index + vlc_len > last_index) {
327 /* should be < 16 bits otherwise a codeword could have been parsed */
328 mb->partial_bit_count = last_index - re_index;
329 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
330 re_index = last_index;
336 printf("run=%d level=%d\n", run, level);
342 level = (level*factor_table[pos] + (1 << (dv_iweight_bits-1))) >> dv_iweight_bits;
343 block[scan_table[pos]] = level;
345 UPDATE_CACHE(re, gb);
347 CLOSE_READER(re, gb);
351 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
353 int bits_left = get_bits_left(gb);
354 while (bits_left >= MIN_CACHE_BITS) {
355 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
356 bits_left -= MIN_CACHE_BITS;
359 put_bits(pb, bits_left, get_bits(gb, bits_left));
363 /* mb_x and mb_y are in units of 8 pixels */
364 static inline void dv_decode_video_segment(DVVideoContext *s,
365 const uint8_t *buf_ptr1,
366 const uint16_t *mb_pos_ptr)
368 int quant, dc, dct_mode, class1, j;
369 int mb_index, mb_x, mb_y, v, last_index;
370 int y_stride, linesize;
371 DCTELEM *block, *block1;
374 const uint8_t *buf_ptr;
375 PutBitContext pb, vs_pb;
377 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
378 DECLARE_ALIGNED_16(DCTELEM, sblock[5*DV_MAX_BPM][64]);
379 DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
380 DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
381 const int log2_blocksize= 3-s->avctx->lowres;
382 int is_field_mode[5];
384 assert((((int)mb_bit_buffer)&7)==0);
385 assert((((int)vs_bit_buffer)&7)==0);
387 memset(sblock, 0, sizeof(sblock));
389 /* pass 1 : read DC and AC coefficients in blocks */
391 block1 = &sblock[0][0];
393 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
394 for(mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
396 quant = buf_ptr[3] & 0x0f;
398 init_put_bits(&pb, mb_bit_buffer, 80);
401 is_field_mode[mb_index] = 0;
402 for(j = 0;j < s->sys->bpm; j++) {
403 last_index = s->sys->block_sizes[j];
404 init_get_bits(&gb, buf_ptr, last_index);
407 dc = get_sbits(&gb, 9);
408 dct_mode = get_bits1(&gb);
409 class1 = get_bits(&gb, 2);
410 if (DV_PROFILE_IS_HD(s->sys)) {
411 mb->idct_put = s->idct_put[0];
412 mb->scan_table = s->dv_zigzag[0];
413 mb->factor_table = s->dv100_idct_factor[((s->sys->height == 720)<<1)|(j >= 4)][class1][quant];
414 is_field_mode[mb_index] |= !j && dct_mode;
416 mb->idct_put = s->idct_put[dct_mode && log2_blocksize==3];
417 mb->scan_table = s->dv_zigzag[dct_mode];
418 mb->factor_table = s->dv_idct_factor[class1 == 3][dct_mode]
419 [quant + dv_quant_offset[class1]];
422 /* convert to unsigned because 128 is not added in the
426 buf_ptr += last_index >> 3;
428 mb->partial_bit_count = 0;
431 printf("MB block: %d, %d ", mb_index, j);
433 dv_decode_ac(&gb, mb, block);
435 /* write the remaining bits in a new buffer only if the
444 /* pass 2 : we can do it just after */
446 printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
450 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
452 for(j = 0;j < s->sys->bpm; j++, block += 64, mb++) {
453 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
454 dv_decode_ac(&gb, mb, block);
455 /* if still not finished, no need to parse other blocks */
460 /* all blocks are finished, so the extra bytes can be used at
461 the video segment level */
462 if (j >= s->sys->bpm)
463 bit_copy(&vs_pb, &gb);
466 /* we need a pass other the whole video segment */
468 printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
470 block = &sblock[0][0];
472 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
473 flush_put_bits(&vs_pb);
474 for(mb_index = 0; mb_index < 5; mb_index++) {
475 for(j = 0;j < s->sys->bpm; j++) {
478 printf("start %d:%d\n", mb_index, j);
480 dv_decode_ac(&gb, mb, block);
482 if (mb->pos >= 64 && mb->pos < 127)
483 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
489 /* compute idct and place blocks */
490 block = &sblock[0][0];
492 for(mb_index = 0; mb_index < 5; mb_index++) {
496 /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
497 if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
498 mb_y -= (mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macroblocks */
501 /* idct_put'ting luminance */
502 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
503 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
504 (s->sys->height >= 720 && mb_y != 134)) {
505 y_stride = (s->picture.linesize[0]<<((!is_field_mode[mb_index])*log2_blocksize));
507 y_stride = (2<<log2_blocksize);
509 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize);
510 linesize = s->picture.linesize[0]<<is_field_mode[mb_index];
511 mb[0] .idct_put(y_ptr , linesize, block + 0*64);
512 if (s->sys->video_stype == 4) { /* SD 422 */
513 mb[2].idct_put(y_ptr + (1<<log2_blocksize) , linesize, block + 2*64);
515 mb[1].idct_put(y_ptr + (1<<log2_blocksize) , linesize, block + 1*64);
516 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2*64);
517 mb[3].idct_put(y_ptr + (1<<log2_blocksize) + y_stride, linesize, block + 3*64);
522 /* idct_put'ting chrominance */
523 c_offset = (((mb_y>>(s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
524 (mb_x>>((s->sys->pix_fmt == PIX_FMT_YUV411P)?2:1)))<<log2_blocksize);
526 uint8_t *c_ptr = s->picture.data[j] + c_offset;
527 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
528 uint64_t aligned_pixels[64/8];
529 uint8_t *pixels = (uint8_t*)aligned_pixels;
530 uint8_t *c_ptr1, *ptr1;
532 mb->idct_put(pixels, 8, block);
533 for(y = 0; y < (1<<log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
534 ptr1= pixels + (1<<(log2_blocksize-1));
535 c_ptr1 = c_ptr + (s->picture.linesize[j]<<log2_blocksize);
536 for(x=0; x < (1<<(log2_blocksize-1)); x++) {
543 y_stride = (mb_y == 134) ? (1<<log2_blocksize) :
544 s->picture.linesize[j]<<((!is_field_mode[mb_index])*log2_blocksize);
545 linesize = s->picture.linesize[j]<<is_field_mode[mb_index];
546 (mb++)-> idct_put(c_ptr , linesize, block); block+=64;
547 if (s->sys->bpm == 8) {
548 (mb++)->idct_put(c_ptr + y_stride, linesize, block); block+=64;
555 #ifdef DV_CODEC_TINY_TARGET
556 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
557 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
560 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
561 *vlc = dv_vlc_map[run][level].vlc | sign;
562 size = dv_vlc_map[run][level].size;
565 if (level < DV_VLC_MAP_LEV_SIZE) {
566 *vlc = dv_vlc_map[0][level].vlc | sign;
567 size = dv_vlc_map[0][level].size;
569 *vlc = 0xfe00 | (level << 1) | sign;
573 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
574 (0x1f80 | (run - 1))) << size;
575 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
582 static av_always_inline int dv_rl2vlc_size(int run, int level)
586 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
587 size = dv_vlc_map[run][level].size;
590 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
592 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
598 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
600 *vlc = dv_vlc_map[run][l].vlc | sign;
601 return dv_vlc_map[run][l].size;
604 static av_always_inline int dv_rl2vlc_size(int run, int l)
606 return dv_vlc_map[run][l].size;
610 typedef struct EncBlockInfo {
620 uint8_t partial_bit_count;
621 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
624 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,
625 PutBitContext* pb_end)
629 PutBitContext* pb = pb_pool;
630 int size = bi->partial_bit_count;
631 uint32_t vlc = bi->partial_bit_buffer;
633 bi->partial_bit_count = bi->partial_bit_buffer = 0;
635 /* Find suitable storage space */
636 for (; size > (bits_left = put_bits_left(pb)); pb++) {
639 put_bits(pb, bits_left, vlc >> size);
640 vlc = vlc & ((1<<size)-1);
642 if (pb + 1 >= pb_end) {
643 bi->partial_bit_count = size;
644 bi->partial_bit_buffer = vlc;
650 put_bits(pb, size, vlc);
655 /* Construct the next VLC */
657 bi->cur_ac = bi->next[prev];
659 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
661 size = 4; vlc = 6; /* End Of Block stamp */
667 static av_always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
668 const uint8_t* zigzag_scan, const int *weight, int bias)
671 /* We offer two different methods for class number assignment: the
672 method suggested in SMPTE 314M Table 22, and an improved
673 method. The SMPTE method is very conservative; it assigns class
674 3 (i.e. severe quantization) to any block where the largest AC
675 component is greater than 36. FFmpeg's DV encoder tracks AC bit
676 consumption precisely, so there is no need to bias most blocks
677 towards strongly lossy compression. Instead, we assign class 2
678 to most blocks, and use class 3 only when strictly necessary
679 (for blocks whose largest AC component exceeds 255). */
681 #if 0 /* SMPTE spec method */
682 static const int classes[] = {12, 24, 36, 0xffff};
683 #else /* improved FFmpeg method */
684 static const int classes[] = {-1, -1, 255, 0xffff};
691 for (area = 0; area < 4; area++) {
692 bi->prev[area] = prev;
693 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
694 for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
695 int level = blk[zigzag_scan[i]];
697 if (level+15 > 30U) {
698 bi->sign[i] = (level>>31)&1;
699 /* weigh it and and shift down into range, adding for rounding */
700 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
701 AND the 2x doubling of the weights */
702 level = (FFABS(level) * weight[i] + (1<<(dv_weight_bits+3))) >> (dv_weight_bits+4);
704 if(level>max) max= level;
705 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
712 for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);
720 for (area = 0; area < 4; area++) {
721 bi->prev[area] = prev;
722 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
723 for (; i<mb_area_start[area+1]; i= bi->next[i]) {
727 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
737 //FIXME replace this by dsputil
738 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
739 static av_always_inline int dv_guess_dct_mode(DCTELEM *blk) {
745 /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
748 score88 += SC(0, 8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
749 SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
752 /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
755 score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
756 SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
760 return (score88 - score248 > -10);
763 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
766 int i, j, k, a, prev, a2;
769 size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24;
772 for (i=0; i<5; i++) {
778 for (j=0; j<6; j++, b++) {
779 for (a=0; a<4; a++) {
780 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
781 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
784 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
785 for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
788 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
791 if(b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
792 for(a2=a+1; b->next[k] >= mb_area_start[a2+1]; a2++)
795 assert(b->mb[b->next[k]]);
796 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
797 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
798 assert(b->prev[a2]==k && (a2+1 >= 4 || b->prev[a2+1]!=k));
801 b->next[prev] = b->next[k];
806 size[i] += b->bit_size[a];
809 if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
812 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
815 for(a=2; a==2 || vs_total_ac_bits < size[0]; a+=a){
817 size[0] = 5*6*4; //EOB
818 for (j=0; j<6*5; j++, b++) {
820 for (k= b->next[prev]; k<64; k= b->next[k]) {
821 if(b->mb[k] < a && b->mb[k] > -a){
822 b->next[prev] = b->next[k];
824 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
832 static inline void dv_encode_video_segment(DVVideoContext *s,
834 const uint16_t *mb_pos_ptr)
836 int mb_index, i, j, v;
837 int mb_x, mb_y, c_offset, linesize;
842 DECLARE_ALIGNED_16(DCTELEM, block[64]);
843 EncBlockInfo enc_blks[5*6];
844 PutBitContext pbs[5*6];
846 EncBlockInfo* enc_blk;
850 assert((((int)block) & 15) == 0);
852 enc_blk = &enc_blks[0];
854 for(mb_index = 0; mb_index < 5; mb_index++) {
858 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<3);
859 c_offset = (((mb_y>>(s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
860 (mb_x>>((s->sys->pix_fmt == PIX_FMT_YUV411P)?2:1)))<<3);
862 qnos[mb_index] = 15; /* No quantization */
863 ptr = dif + mb_index*80 + 4;
864 for(j = 0;j < 6; j++) {
866 if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
867 if (j == 0 || j == 2) {
869 data = y_ptr + ((j>>1) * 8);
870 linesize = s->picture.linesize[0];
873 data = s->picture.data[6 - j] + c_offset;
874 linesize = s->picture.linesize[6 - j];
876 /* j=1 and j=3 are "dummy" blocks, used for AC data only */
881 } else { /* 4:1:1 or 4:2:0 */
882 if (j < 4) { /* Four Y blocks */
883 /* NOTE: at end of line, the macroblock is handled as 420 */
884 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
885 data = y_ptr + (j * 8);
887 data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
889 linesize = s->picture.linesize[0];
890 } else { /* Cr and Cb blocks */
891 /* don't ask Fabrice why they inverted Cb and Cr ! */
892 data = s->picture.data[6 - j] + c_offset;
893 linesize = s->picture.linesize[6 - j];
894 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
899 /* Everything is set up -- now just copy data -> DCT block */
900 if (do_edge_wrap) { /* Edge wrap copy: 4x16 -> 8x8 */
904 d = data + 8 * linesize;
905 b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
906 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
910 } else { /* Simple copy: 8x8 -> 8x8 */
912 s->get_pixels(block, data, linesize);
915 if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
916 enc_blk->dct_mode = dv_guess_dct_mode(block);
918 enc_blk->dct_mode = 0;
919 enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
920 enc_blk->partial_bit_count = 0;
921 enc_blk->partial_bit_buffer = 0;
925 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
926 which is precisely what the spec calls for in the "dummy" blocks. */
927 memset(block, 0, sizeof(block));
929 s->fdct[enc_blk->dct_mode](block);
932 dv_set_class_number(block, enc_blk,
933 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct,
934 enc_blk->dct_mode ? dv_weight_248 : dv_weight_88,
937 init_put_bits(pb, ptr, s->sys->block_sizes[j]/8);
938 put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
939 put_bits(pb, 1, enc_blk->dct_mode);
940 put_bits(pb, 2, enc_blk->cno);
942 vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
943 enc_blk->bit_size[2] + enc_blk->bit_size[3];
946 ptr += s->sys->block_sizes[j]/8;
950 if (vs_total_ac_bits < vs_bit_size)
951 dv_guess_qnos(&enc_blks[0], &qnos[0]);
953 for (i=0; i<5; i++) {
954 dif[i*80 + 3] = qnos[i];
957 /* First pass over individual cells only */
958 for (j=0; j<5*6; j++)
959 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
961 /* Second pass over each MB space */
962 for (j=0; j<5*6; j+=6) {
964 for (i=0; i<6; i++) {
965 if (enc_blks[i+j].partial_bit_count)
966 pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
970 /* Third and final pass over the whole vides segment space */
972 for (j=0; j<5*6; j++) {
973 if (enc_blks[j].partial_bit_count)
974 pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
975 if (enc_blks[j].partial_bit_count)
976 av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
979 for (j=0; j<5*6; j++)
980 flush_put_bits(&pbs[j]);
983 static int dv_decode_mt(AVCodecContext *avctx, void* sl)
985 DVVideoContext *s = avctx->priv_data;
986 int slice = (size_t)sl;
988 /* which DIF channel is this? */
989 int chan = slice / (s->sys->difseg_size * 27);
991 /* slice within the DIF channel */
992 int chan_slice = slice % (s->sys->difseg_size * 27);
994 /* byte offset of this channel's data */
995 int chan_offset = chan * s->sys->difseg_size * 150 * 80;
998 int seq = chan_slice / 27;
1000 /* in 1080i50 and 720p50 some seq are unused */
1001 if ((DV_PROFILE_IS_1080i50(s->sys) && chan != 0 && seq == 11) ||
1002 (DV_PROFILE_IS_720p50(s->sys) && seq > 9))
1005 dv_decode_video_segment(s, &s->buf[(seq*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
1006 &s->sys->video_place[slice*5]);
1010 #ifdef CONFIG_DVVIDEO_ENCODER
1011 static int dv_encode_mt(AVCodecContext *avctx, void* sl)
1013 DVVideoContext *s = avctx->priv_data;
1014 int slice = (size_t)sl;
1016 /* which DIF channel is this? */
1017 int chan = slice / (s->sys->difseg_size * 27);
1019 /* slice within the DIF channel */
1020 int chan_slice = slice % (s->sys->difseg_size * 27);
1022 /* byte offset of this channel's data */
1023 int chan_offset = chan * s->sys->difseg_size * 150 * 80;
1025 dv_encode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
1026 &s->sys->video_place[slice*5]);
1031 #ifdef CONFIG_DVVIDEO_DECODER
1032 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1033 144000 bytes for PAL - or twice those for 50Mbps) */
1034 static int dvvideo_decode_frame(AVCodecContext *avctx,
1035 void *data, int *data_size,
1036 const uint8_t *buf, int buf_size)
1038 DVVideoContext *s = avctx->priv_data;
1040 s->sys = dv_frame_profile(buf);
1041 if (!s->sys || buf_size < s->sys->frame_size)
1042 return -1; /* NOTE: we only accept several full frames */
1044 if(s->picture.data[0])
1045 avctx->release_buffer(avctx, &s->picture);
1047 s->picture.reference = 0;
1048 s->picture.key_frame = 1;
1049 s->picture.pict_type = FF_I_TYPE;
1050 avctx->pix_fmt = s->sys->pix_fmt;
1051 avctx->time_base = (AVRational){s->sys->frame_rate_base, s->sys->frame_rate};
1052 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1053 if(avctx->get_buffer(avctx, &s->picture) < 0) {
1054 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1057 s->picture.interlaced_frame = 1;
1058 s->picture.top_field_first = 0;
1061 avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
1062 s->sys->n_difchan * s->sys->difseg_size * 27);
1067 *data_size = sizeof(AVFrame);
1068 *(AVFrame*)data= s->picture;
1070 return s->sys->frame_size;
1072 #endif /* CONFIG_DVVIDEO_DECODER */
1075 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, uint8_t* buf)
1078 * Here's what SMPTE314M says about these two:
1079 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1080 * as track application IDs (APTn = 001, AP1n =
1081 * 001, AP2n = 001, AP3n = 001), if the source signal
1082 * comes from a digital VCR. If the signal source is
1083 * unknown, all bits for these data shall be set to 1.
1084 * (page 12) STYPE: STYPE defines a signal type of video signal
1085 * 00000b = 4:1:1 compression
1086 * 00100b = 4:2:2 compression
1088 * Now, I've got two problems with these statements:
1089 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1090 * It seems that for PAL as defined in IEC 61834 we have to set
1091 * APT to 000 and for SMPTE314M to 001.
1092 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1093 * compression scheme (if any).
1095 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1096 int stype = (c->sys->pix_fmt == PIX_FMT_YUV422P ? 4 : 0);
1099 if((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) == 17) /* 16:9 */
1102 buf[0] = (uint8_t)pack_id;
1104 case dv_header525: /* I can't imagine why these two weren't defined as real */
1105 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1106 buf[1] = 0xf8 | /* reserved -- always 1 */
1107 (apt & 0x07); /* APT: Track application ID */
1108 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1109 (0x0f << 3) | /* reserved -- always 1 */
1110 (apt & 0x07); /* AP1: Audio application ID */
1111 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1112 (0x0f << 3) | /* reserved -- always 1 */
1113 (apt & 0x07); /* AP2: Video application ID */
1114 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1115 (0x0f << 3) | /* reserved -- always 1 */
1116 (apt & 0x07); /* AP3: Subcode application ID */
1118 case dv_video_source:
1119 buf[1] = 0xff; /* reserved -- always 1 */
1120 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1121 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1122 (3 << 4) | /* CLF: color frames id (see ITU-R BT.470-4) */
1123 0xf; /* reserved -- always 1 */
1124 buf[3] = (3 << 6) | /* reserved -- always 1 */
1125 (c->sys->dsf << 5) | /* system: 60fields/50fields */
1126 stype; /* signal type video compression */
1127 buf[4] = 0xff; /* VISC: 0xff -- no information */
1129 case dv_video_control:
1130 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1131 0x3f; /* reserved -- always 1 */
1132 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1134 buf[3] = (1 << 7) | /* Frame/field flag 1 -- frame, 0 -- field */
1135 (1 << 6) | /* First/second field flag 0 -- field 2, 1 -- field 1 */
1136 (1 << 5) | /* Frame change flag 0 -- same picture as before, 1 -- different */
1137 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1138 0xc; /* reserved -- always b1100 */
1139 buf[4] = 0xff; /* reserved -- always 1 */
1142 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1147 #ifdef CONFIG_DVVIDEO_ENCODER
1148 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1152 for (chan = 0; chan < c->sys->n_difchan; chan++) {
1153 for (i = 0; i < c->sys->difseg_size; i++) {
1154 memset(buf, 0xff, 80 * 6); /* First 6 DIF blocks are for control data */
1156 /* DV header: 1DIF */
1157 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1158 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1159 buf += 72; /* unused bytes */
1161 /* DV subcode: 2DIFs */
1162 for (j = 0; j < 2; j++) {
1163 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1164 for (k = 0; k < 6; k++)
1165 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1166 buf += 29; /* unused bytes */
1169 /* DV VAUX: 3DIFS */
1170 for (j = 0; j < 3; j++) {
1171 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1172 buf += dv_write_pack(dv_video_source, c, buf);
1173 buf += dv_write_pack(dv_video_control, c, buf);
1175 buf += dv_write_pack(dv_video_source, c, buf);
1176 buf += dv_write_pack(dv_video_control, c, buf);
1177 buf += 4*5 + 2; /* unused bytes */
1180 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1181 for (j = 0; j < 135; j++) {
1183 memset(buf, 0xff, 80);
1184 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1185 buf += 77; /* audio control & shuffled PCM audio */
1187 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1188 buf += 77; /* 1 video macroblock: 1 bytes control
1189 4 * 14 bytes Y 8x8 data
1190 10 bytes Cr 8x8 data
1191 10 bytes Cb 8x8 data */
1198 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1201 DVVideoContext *s = c->priv_data;
1203 s->sys = dv_codec_profile(c);
1206 if(buf_size < s->sys->frame_size)
1209 c->pix_fmt = s->sys->pix_fmt;
1210 s->picture = *((AVFrame *)data);
1211 s->picture.key_frame = 1;
1212 s->picture.pict_type = FF_I_TYPE;
1215 c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
1216 s->sys->n_difchan * s->sys->difseg_size * 27);
1220 dv_format_frame(s, buf);
1222 return s->sys->frame_size;
1226 static int dvvideo_close(AVCodecContext *c)
1228 DVVideoContext *s = c->priv_data;
1230 if(s->picture.data[0])
1231 c->release_buffer(c, &s->picture);
1237 #ifdef CONFIG_DVVIDEO_ENCODER
1238 AVCodec dvvideo_encoder = {
1242 sizeof(DVVideoContext),
1244 dvvideo_encode_frame,
1245 .pix_fmts = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1246 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1248 #endif // CONFIG_DVVIDEO_ENCODER
1250 #ifdef CONFIG_DVVIDEO_DECODER
1251 AVCodec dvvideo_decoder = {
1255 sizeof(DVVideoContext),
1259 dvvideo_decode_frame,
1262 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),