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 /* MultiThreading - dv_anchor applies to entire DV codec, not just the avcontext */
66 /* one element is needed for each video segment in a DV frame */
67 /* at most there are 4 DIF channels * 12 DIF sequences * 27 video segments (1080i50) */
68 #define DV_ANCHOR_SIZE (4*12*27)
70 static void* dv_anchor[DV_ANCHOR_SIZE];
72 #define TEX_VLC_BITS 9
74 #ifdef DV_CODEC_TINY_TARGET
75 #define DV_VLC_MAP_RUN_SIZE 15
76 #define DV_VLC_MAP_LEV_SIZE 23
78 #define DV_VLC_MAP_RUN_SIZE 64
79 #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
82 /* XXX: also include quantization */
83 static RL_VLC_ELEM dv_rl_vlc[1184];
84 /* VLC encoding lookup table */
85 static struct dv_vlc_pair {
88 } dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE];
90 static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
94 /* NOTE: max left shift is 6 */
95 for(q = 0; q < 22; q++) {
98 for(a = 0; a<4; a++) {
99 for(; i < dv_quant_areas[a]; i++) {
101 s->dv_idct_factor[0][0][q][i] = dv_iweight_88[i]<<(dv_quant_shifts[q][a] + 1);
102 s->dv_idct_factor[1][0][q][i] = s->dv_idct_factor[0][0][q][i]<<1;
105 s->dv_idct_factor[0][1][q][i] = dv_iweight_248[i]<<(dv_quant_shifts[q][a] + 1);
106 s->dv_idct_factor[1][1][q][i] = s->dv_idct_factor[0][1][q][i]<<1;
111 for(a = 0; a < 4; a++) {
112 for(q = 0; q < 16; q++) {
113 for(i = 1; i < 64; i++) {
114 s->dv100_idct_factor[0][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_1080_y[i];
115 s->dv100_idct_factor[1][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_1080_c[i];
116 s->dv100_idct_factor[2][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_720_y[i];
117 s->dv100_idct_factor[3][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_720_c[i];
123 static av_cold int dvvideo_init(AVCodecContext *avctx)
125 DVVideoContext *s = avctx->priv_data;
132 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
133 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
134 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
135 int16_t new_dv_vlc_level[NB_DV_VLC*2];
139 /* dv_anchor lets each thread know its Id */
140 for (i=0; i<DV_ANCHOR_SIZE; i++)
141 dv_anchor[i] = (void*)(size_t)i;
143 /* it's faster to include sign bit in a generic VLC parsing scheme */
144 for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
145 new_dv_vlc_bits[j] = dv_vlc_bits[i];
146 new_dv_vlc_len[j] = dv_vlc_len[i];
147 new_dv_vlc_run[j] = dv_vlc_run[i];
148 new_dv_vlc_level[j] = dv_vlc_level[i];
150 if (dv_vlc_level[i]) {
151 new_dv_vlc_bits[j] <<= 1;
155 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
156 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
157 new_dv_vlc_run[j] = dv_vlc_run[i];
158 new_dv_vlc_level[j] = -dv_vlc_level[i];
162 /* NOTE: as a trick, we use the fact the no codes are unused
163 to accelerate the parsing of partial codes */
164 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
165 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
166 assert(dv_vlc.table_size == 1184);
168 for(i = 0; i < dv_vlc.table_size; i++){
169 int code= dv_vlc.table[i][0];
170 int len = dv_vlc.table[i][1];
173 if(len<0){ //more bits needed
177 run= new_dv_vlc_run[code] + 1;
178 level= new_dv_vlc_level[code];
180 dv_rl_vlc[i].len = len;
181 dv_rl_vlc[i].level = level;
182 dv_rl_vlc[i].run = run;
186 for (i = 0; i < NB_DV_VLC - 1; i++) {
187 if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
189 #ifdef DV_CODEC_TINY_TARGET
190 if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
194 if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
197 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] <<
199 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] +
202 for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
203 #ifdef DV_CODEC_TINY_TARGET
204 for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
205 if (dv_vlc_map[i][j].size == 0) {
206 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
207 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
208 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
209 dv_vlc_map[0][j].size;
213 for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
214 if (dv_vlc_map[i][j].size == 0) {
215 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
216 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
217 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
218 dv_vlc_map[0][j].size;
220 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
221 dv_vlc_map[i][j].vlc | 1;
222 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
223 dv_vlc_map[i][j].size;
229 /* Generic DSP setup */
230 dsputil_init(&dsp, avctx);
231 s->get_pixels = dsp.get_pixels;
234 s->fdct[0] = dsp.fdct;
235 s->idct_put[0] = dsp.idct_put;
237 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
240 s->fdct[1] = dsp.fdct248;
241 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
243 for (i=0; i<64; i++){
244 int j= ff_zigzag248_direct[i];
245 s->dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2];
248 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
250 /* XXX: do it only for constant case */
251 dv_build_unquantize_tables(s, dsp.idct_permutation);
253 avctx->coded_frame = &s->picture;
260 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
262 typedef struct BlockInfo {
263 const uint32_t *factor_table;
264 const uint8_t *scan_table;
265 uint8_t pos; /* position in block */
266 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
267 uint8_t partial_bit_count;
268 uint16_t partial_bit_buffer;
272 /* bit budget for AC only in 5 MBs */
273 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
274 /* see dv_88_areas and dv_248_areas for details */
275 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
277 static inline int get_bits_left(GetBitContext *s)
279 return s->size_in_bits - get_bits_count(s);
282 static inline int put_bits_left(PutBitContext* s)
284 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
287 /* decode ac coefficients */
288 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
290 int last_index = gb->size_in_bits;
291 const uint8_t *scan_table = mb->scan_table;
292 const uint32_t *factor_table = mb->factor_table;
294 int partial_bit_count = mb->partial_bit_count;
295 int level, run, vlc_len, index;
298 UPDATE_CACHE(re, gb);
300 /* if we must parse a partial vlc, we do it here */
301 if (partial_bit_count > 0) {
302 re_cache = ((unsigned)re_cache >> partial_bit_count) |
303 (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
304 re_index -= partial_bit_count;
305 mb->partial_bit_count = 0;
308 /* get the AC coefficients until last_index is reached */
311 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
313 /* our own optimized GET_RL_VLC */
314 index = NEG_USR32(re_cache, TEX_VLC_BITS);
315 vlc_len = dv_rl_vlc[index].len;
317 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
318 vlc_len = TEX_VLC_BITS - vlc_len;
320 level = dv_rl_vlc[index].level;
321 run = dv_rl_vlc[index].run;
323 /* gotta check if we're still within gb boundaries */
324 if (re_index + vlc_len > last_index) {
325 /* should be < 16 bits otherwise a codeword could have been parsed */
326 mb->partial_bit_count = last_index - re_index;
327 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
328 re_index = last_index;
334 printf("run=%d level=%d\n", run, level);
340 level = (level*factor_table[pos] + (1 << (dv_iweight_bits-1))) >> dv_iweight_bits;
341 block[scan_table[pos]] = level;
343 UPDATE_CACHE(re, gb);
345 CLOSE_READER(re, gb);
349 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
351 int bits_left = get_bits_left(gb);
352 while (bits_left >= MIN_CACHE_BITS) {
353 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
354 bits_left -= MIN_CACHE_BITS;
357 put_bits(pb, bits_left, get_bits(gb, bits_left));
361 /* mb_x and mb_y are in units of 8 pixels */
362 static inline void dv_decode_video_segment(DVVideoContext *s,
363 const uint8_t *buf_ptr1,
364 const uint16_t *mb_pos_ptr)
366 int quant, dc, dct_mode, class1, j;
367 int mb_index, mb_x, mb_y, v, last_index;
369 DCTELEM *block, *block1;
372 const uint8_t *buf_ptr;
373 PutBitContext pb, vs_pb;
375 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
376 DECLARE_ALIGNED_16(DCTELEM, sblock[5*DV_MAX_BPM][64]);
377 DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
378 DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
379 const int log2_blocksize= 3-s->avctx->lowres;
380 int is_field_mode[5];
382 assert((((int)mb_bit_buffer)&7)==0);
383 assert((((int)vs_bit_buffer)&7)==0);
385 memset(sblock, 0, sizeof(sblock));
387 /* pass 1 : read DC and AC coefficients in blocks */
389 block1 = &sblock[0][0];
391 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
392 for(mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
394 quant = buf_ptr[3] & 0x0f;
396 init_put_bits(&pb, mb_bit_buffer, 80);
399 is_field_mode[mb_index] = 0;
400 for(j = 0;j < s->sys->bpm; j++) {
401 last_index = s->sys->block_sizes[j];
402 init_get_bits(&gb, buf_ptr, last_index);
405 dc = get_sbits(&gb, 9);
406 dct_mode = get_bits1(&gb);
407 class1 = get_bits(&gb, 2);
408 if (DV_PROFILE_IS_HD(s->sys)) {
409 mb->idct_put = s->idct_put[0];
410 mb->scan_table = s->dv_zigzag[0];
411 mb->factor_table = s->dv100_idct_factor[((s->sys->height == 720)<<1)&(j < 4)][class1][quant];
412 is_field_mode[mb_index] |= !j && dct_mode;
414 mb->idct_put = s->idct_put[dct_mode && log2_blocksize==3];
415 mb->scan_table = s->dv_zigzag[dct_mode];
416 mb->factor_table = s->dv_idct_factor[class1 == 3][dct_mode]
417 [quant + dv_quant_offset[class1]];
420 /* convert to unsigned because 128 is not added in the
424 buf_ptr += last_index >> 3;
426 mb->partial_bit_count = 0;
429 printf("MB block: %d, %d ", mb_index, j);
431 dv_decode_ac(&gb, mb, block);
433 /* write the remaining bits in a new buffer only if the
442 /* pass 2 : we can do it just after */
444 printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
448 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
450 for(j = 0;j < s->sys->bpm; j++, block += 64, mb++) {
451 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
452 dv_decode_ac(&gb, mb, block);
453 /* if still not finished, no need to parse other blocks */
458 /* all blocks are finished, so the extra bytes can be used at
459 the video segment level */
460 if (j >= s->sys->bpm)
461 bit_copy(&vs_pb, &gb);
464 /* we need a pass other the whole video segment */
466 printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
468 block = &sblock[0][0];
470 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
471 flush_put_bits(&vs_pb);
472 for(mb_index = 0; mb_index < 5; mb_index++) {
473 for(j = 0;j < s->sys->bpm; j++) {
476 printf("start %d:%d\n", mb_index, j);
478 dv_decode_ac(&gb, mb, block);
480 if (mb->pos >= 64 && mb->pos < 127)
481 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
487 /* compute idct and place blocks */
488 block = &sblock[0][0];
490 for(mb_index = 0; mb_index < 5; mb_index++) {
494 /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
495 if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
496 mb_y -= (mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macroblocks */
499 /* idct_put'ting luminance */
500 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
501 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
502 (s->sys->height >= 720 && mb_y != 134)) {
503 y_stride = (s->picture.linesize[0]<<((!is_field_mode[mb_index])*log2_blocksize)) - (2<<log2_blocksize);
507 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize);
508 for(j = 0; j < 2; j++, y_ptr += y_stride) {
509 for (i=0; i<2; i++, block += 64, mb++, y_ptr += (1<<log2_blocksize))
510 if (s->sys->pix_fmt == PIX_FMT_YUV422P && s->sys->width == 720 && i)
511 y_ptr -= (1<<log2_blocksize);
513 mb->idct_put(y_ptr, s->picture.linesize[0]<<is_field_mode[mb_index], block);
516 /* idct_put'ting chrominance */
517 c_offset = (((mb_y>>(s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
518 (mb_x>>((s->sys->pix_fmt == PIX_FMT_YUV411P)?2:1)))<<log2_blocksize);
520 uint8_t *c_ptr = s->picture.data[j] + c_offset;
521 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
522 uint64_t aligned_pixels[64/8];
523 uint8_t *pixels = (uint8_t*)aligned_pixels;
524 uint8_t *c_ptr1, *ptr1;
526 mb->idct_put(pixels, 8, block);
527 for(y = 0; y < (1<<log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
528 ptr1= pixels + (1<<(log2_blocksize-1));
529 c_ptr1 = c_ptr + (s->picture.linesize[j]<<log2_blocksize);
530 for(x=0; x < (1<<(log2_blocksize-1)); x++) {
537 y_stride = (mb_y == 134) ? (1<<log2_blocksize) :
538 s->picture.linesize[j]<<((!is_field_mode[mb_index])*log2_blocksize);
539 for (i=0; i<(1<<(s->sys->bpm==8)); i++, block += 64, mb++, c_ptr += y_stride)
540 mb->idct_put(c_ptr, s->picture.linesize[j]<<is_field_mode[mb_index], block);
546 #ifdef DV_CODEC_TINY_TARGET
547 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
548 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
551 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
552 *vlc = dv_vlc_map[run][level].vlc | sign;
553 size = dv_vlc_map[run][level].size;
556 if (level < DV_VLC_MAP_LEV_SIZE) {
557 *vlc = dv_vlc_map[0][level].vlc | sign;
558 size = dv_vlc_map[0][level].size;
560 *vlc = 0xfe00 | (level << 1) | sign;
564 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
565 (0x1f80 | (run - 1))) << size;
566 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
573 static av_always_inline int dv_rl2vlc_size(int run, int level)
577 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
578 size = dv_vlc_map[run][level].size;
581 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
583 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
589 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
591 *vlc = dv_vlc_map[run][l].vlc | sign;
592 return dv_vlc_map[run][l].size;
595 static av_always_inline int dv_rl2vlc_size(int run, int l)
597 return dv_vlc_map[run][l].size;
601 typedef struct EncBlockInfo {
611 uint8_t partial_bit_count;
612 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
615 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,
616 PutBitContext* pb_end)
620 PutBitContext* pb = pb_pool;
621 int size = bi->partial_bit_count;
622 uint32_t vlc = bi->partial_bit_buffer;
624 bi->partial_bit_count = bi->partial_bit_buffer = 0;
626 /* Find suitable storage space */
627 for (; size > (bits_left = put_bits_left(pb)); pb++) {
630 put_bits(pb, bits_left, vlc >> size);
631 vlc = vlc & ((1<<size)-1);
633 if (pb + 1 >= pb_end) {
634 bi->partial_bit_count = size;
635 bi->partial_bit_buffer = vlc;
641 put_bits(pb, size, vlc);
646 /* Construct the next VLC */
648 bi->cur_ac = bi->next[prev];
650 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
652 size = 4; vlc = 6; /* End Of Block stamp */
658 static av_always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
659 const uint8_t* zigzag_scan, const int *weight, int bias)
662 /* We offer two different methods for class number assignment: the
663 method suggested in SMPTE 314M Table 22, and an improved
664 method. The SMPTE method is very conservative; it assigns class
665 3 (i.e. severe quantization) to any block where the largest AC
666 component is greater than 36. FFmpeg's DV encoder tracks AC bit
667 consumption precisely, so there is no need to bias most blocks
668 towards strongly lossy compression. Instead, we assign class 2
669 to most blocks, and use class 3 only when strictly necessary
670 (for blocks whose largest AC component exceeds 255). */
672 #if 0 /* SMPTE spec method */
673 static const int classes[] = {12, 24, 36, 0xffff};
674 #else /* improved FFmpeg method */
675 static const int classes[] = {-1, -1, 255, 0xffff};
682 for (area = 0; area < 4; area++) {
683 bi->prev[area] = prev;
684 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
685 for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
686 int level = blk[zigzag_scan[i]];
688 if (level+15 > 30U) {
689 bi->sign[i] = (level>>31)&1;
690 /* weigh it and and shift down into range, adding for rounding */
691 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
692 AND the 2x doubling of the weights */
693 level = (FFABS(level) * weight[i] + (1<<(dv_weight_bits+3))) >> (dv_weight_bits+4);
695 if(level>max) max= level;
696 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
703 for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);
711 for (area = 0; area < 4; area++) {
712 bi->prev[area] = prev;
713 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
714 for (; i<mb_area_start[area+1]; i= bi->next[i]) {
718 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
728 //FIXME replace this by dsputil
729 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
730 static av_always_inline int dv_guess_dct_mode(DCTELEM *blk) {
736 /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
739 score88 += SC(0, 8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
740 SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
743 /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
746 score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
747 SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
751 return (score88 - score248 > -10);
754 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
757 int i, j, k, a, prev, a2;
760 size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24;
763 for (i=0; i<5; i++) {
769 for (j=0; j<6; j++, b++) {
770 for (a=0; a<4; a++) {
771 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
772 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
775 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
776 for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
779 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
782 if(b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
783 for(a2=a+1; b->next[k] >= mb_area_start[a2+1]; a2++)
786 assert(b->mb[b->next[k]]);
787 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
788 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
789 assert(b->prev[a2]==k && (a2+1 >= 4 || b->prev[a2+1]!=k));
792 b->next[prev] = b->next[k];
797 size[i] += b->bit_size[a];
800 if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
803 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
806 for(a=2; a==2 || vs_total_ac_bits < size[0]; a+=a){
808 size[0] = 5*6*4; //EOB
809 for (j=0; j<6*5; j++, b++) {
811 for (k= b->next[prev]; k<64; k= b->next[k]) {
812 if(b->mb[k] < a && b->mb[k] > -a){
813 b->next[prev] = b->next[k];
815 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
823 static inline void dv_encode_video_segment(DVVideoContext *s,
825 const uint16_t *mb_pos_ptr)
827 int mb_index, i, j, v;
828 int mb_x, mb_y, c_offset, linesize;
833 DECLARE_ALIGNED_16(DCTELEM, block[64]);
834 EncBlockInfo enc_blks[5*6];
835 PutBitContext pbs[5*6];
837 EncBlockInfo* enc_blk;
841 assert((((int)block) & 15) == 0);
843 enc_blk = &enc_blks[0];
845 for(mb_index = 0; mb_index < 5; mb_index++) {
849 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<3);
850 c_offset = (((mb_y>>(s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
851 (mb_x>>((s->sys->pix_fmt == PIX_FMT_YUV411P)?2:1)))<<3);
853 qnos[mb_index] = 15; /* No quantization */
854 ptr = dif + mb_index*80 + 4;
855 for(j = 0;j < 6; j++) {
857 if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
858 if (j == 0 || j == 2) {
860 data = y_ptr + ((j>>1) * 8);
861 linesize = s->picture.linesize[0];
864 data = s->picture.data[6 - j] + c_offset;
865 linesize = s->picture.linesize[6 - j];
867 /* j=1 and j=3 are "dummy" blocks, used for AC data only */
872 } else { /* 4:1:1 or 4:2:0 */
873 if (j < 4) { /* Four Y blocks */
874 /* NOTE: at end of line, the macroblock is handled as 420 */
875 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
876 data = y_ptr + (j * 8);
878 data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
880 linesize = s->picture.linesize[0];
881 } else { /* Cr and Cb blocks */
882 /* don't ask Fabrice why they inverted Cb and Cr ! */
883 data = s->picture.data[6 - j] + c_offset;
884 linesize = s->picture.linesize[6 - j];
885 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
890 /* Everything is set up -- now just copy data -> DCT block */
891 if (do_edge_wrap) { /* Edge wrap copy: 4x16 -> 8x8 */
895 d = data + 8 * linesize;
896 b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
897 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
901 } else { /* Simple copy: 8x8 -> 8x8 */
903 s->get_pixels(block, data, linesize);
906 if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
907 enc_blk->dct_mode = dv_guess_dct_mode(block);
909 enc_blk->dct_mode = 0;
910 enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
911 enc_blk->partial_bit_count = 0;
912 enc_blk->partial_bit_buffer = 0;
916 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
917 which is precisely what the spec calls for in the "dummy" blocks. */
918 memset(block, 0, sizeof(block));
920 s->fdct[enc_blk->dct_mode](block);
923 dv_set_class_number(block, enc_blk,
924 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct,
925 enc_blk->dct_mode ? dv_weight_248 : dv_weight_88,
928 init_put_bits(pb, ptr, s->sys->block_sizes[j]/8);
929 put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
930 put_bits(pb, 1, enc_blk->dct_mode);
931 put_bits(pb, 2, enc_blk->cno);
933 vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
934 enc_blk->bit_size[2] + enc_blk->bit_size[3];
937 ptr += s->sys->block_sizes[j]/8;
941 if (vs_total_ac_bits < vs_bit_size)
942 dv_guess_qnos(&enc_blks[0], &qnos[0]);
944 for (i=0; i<5; i++) {
945 dif[i*80 + 3] = qnos[i];
948 /* First pass over individual cells only */
949 for (j=0; j<5*6; j++)
950 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
952 /* Second pass over each MB space */
953 for (j=0; j<5*6; j+=6) {
955 for (i=0; i<6; i++) {
956 if (enc_blks[i+j].partial_bit_count)
957 pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
961 /* Third and final pass over the whole vides segment space */
963 for (j=0; j<5*6; j++) {
964 if (enc_blks[j].partial_bit_count)
965 pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
966 if (enc_blks[j].partial_bit_count)
967 av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
970 for (j=0; j<5*6; j++)
971 flush_put_bits(&pbs[j]);
974 static int dv_decode_mt(AVCodecContext *avctx, void* sl)
976 DVVideoContext *s = avctx->priv_data;
977 int slice = (size_t)sl;
979 /* which DIF channel is this? */
980 int chan = slice / (s->sys->difseg_size * 27);
982 /* slice within the DIF channel */
983 int chan_slice = slice % (s->sys->difseg_size * 27);
985 /* byte offset of this channel's data */
986 int chan_offset = chan * s->sys->difseg_size * 150 * 80;
989 int seq = chan_slice / 27;
991 /* in 1080i50 and 720p50 some seq are unused */
992 if ((DV_PROFILE_IS_1080i50(s->sys) && chan != 0 && seq == 11) ||
993 (DV_PROFILE_IS_720p50(s->sys) && seq > 9))
996 dv_decode_video_segment(s, &s->buf[(seq*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
997 &s->sys->video_place[slice*5]);
1001 #ifdef CONFIG_DVVIDEO_ENCODER
1002 static int dv_encode_mt(AVCodecContext *avctx, void* sl)
1004 DVVideoContext *s = avctx->priv_data;
1005 int slice = (size_t)sl;
1007 /* which DIF channel is this? */
1008 int chan = slice / (s->sys->difseg_size * 27);
1010 /* slice within the DIF channel */
1011 int chan_slice = slice % (s->sys->difseg_size * 27);
1013 /* byte offset of this channel's data */
1014 int chan_offset = chan * s->sys->difseg_size * 150 * 80;
1016 dv_encode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
1017 &s->sys->video_place[slice*5]);
1022 #ifdef CONFIG_DVVIDEO_DECODER
1023 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1024 144000 bytes for PAL - or twice those for 50Mbps) */
1025 static int dvvideo_decode_frame(AVCodecContext *avctx,
1026 void *data, int *data_size,
1027 const uint8_t *buf, int buf_size)
1029 DVVideoContext *s = avctx->priv_data;
1031 s->sys = dv_frame_profile(buf);
1032 if (!s->sys || buf_size < s->sys->frame_size)
1033 return -1; /* NOTE: we only accept several full frames */
1035 if(s->picture.data[0])
1036 avctx->release_buffer(avctx, &s->picture);
1038 s->picture.reference = 0;
1039 s->picture.key_frame = 1;
1040 s->picture.pict_type = FF_I_TYPE;
1041 avctx->pix_fmt = s->sys->pix_fmt;
1042 avctx->time_base = (AVRational){s->sys->frame_rate_base, s->sys->frame_rate};
1043 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1044 if(avctx->get_buffer(avctx, &s->picture) < 0) {
1045 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1048 s->picture.interlaced_frame = 1;
1049 s->picture.top_field_first = 0;
1052 avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
1053 s->sys->n_difchan * s->sys->difseg_size * 27);
1058 *data_size = sizeof(AVFrame);
1059 *(AVFrame*)data= s->picture;
1061 return s->sys->frame_size;
1063 #endif /* CONFIG_DVVIDEO_DECODER */
1066 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, uint8_t* buf)
1069 * Here's what SMPTE314M says about these two:
1070 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1071 * as track application IDs (APTn = 001, AP1n =
1072 * 001, AP2n = 001, AP3n = 001), if the source signal
1073 * comes from a digital VCR. If the signal source is
1074 * unknown, all bits for these data shall be set to 1.
1075 * (page 12) STYPE: STYPE defines a signal type of video signal
1076 * 00000b = 4:1:1 compression
1077 * 00100b = 4:2:2 compression
1079 * Now, I've got two problems with these statements:
1080 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1081 * It seems that for PAL as defined in IEC 61834 we have to set
1082 * APT to 000 and for SMPTE314M to 001.
1083 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1084 * compression scheme (if any).
1086 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1087 int stype = (c->sys->pix_fmt == PIX_FMT_YUV422P ? 4 : 0);
1090 if((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) == 17) /* 16:9 */
1093 buf[0] = (uint8_t)pack_id;
1095 case dv_header525: /* I can't imagine why these two weren't defined as real */
1096 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1097 buf[1] = 0xf8 | /* reserved -- always 1 */
1098 (apt & 0x07); /* APT: Track application ID */
1099 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1100 (0x0f << 3) | /* reserved -- always 1 */
1101 (apt & 0x07); /* AP1: Audio application ID */
1102 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1103 (0x0f << 3) | /* reserved -- always 1 */
1104 (apt & 0x07); /* AP2: Video application ID */
1105 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1106 (0x0f << 3) | /* reserved -- always 1 */
1107 (apt & 0x07); /* AP3: Subcode application ID */
1109 case dv_video_source:
1110 buf[1] = 0xff; /* reserved -- always 1 */
1111 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1112 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1113 (3 << 4) | /* CLF: color frames id (see ITU-R BT.470-4) */
1114 0xf; /* reserved -- always 1 */
1115 buf[3] = (3 << 6) | /* reserved -- always 1 */
1116 (c->sys->dsf << 5) | /* system: 60fields/50fields */
1117 stype; /* signal type video compression */
1118 buf[4] = 0xff; /* VISC: 0xff -- no information */
1120 case dv_video_control:
1121 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1122 0x3f; /* reserved -- always 1 */
1123 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1125 buf[3] = (1 << 7) | /* Frame/field flag 1 -- frame, 0 -- field */
1126 (1 << 6) | /* First/second field flag 0 -- field 2, 1 -- field 1 */
1127 (1 << 5) | /* Frame change flag 0 -- same picture as before, 1 -- different */
1128 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1129 0xc; /* reserved -- always b1100 */
1130 buf[4] = 0xff; /* reserved -- always 1 */
1133 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1138 #ifdef CONFIG_DVVIDEO_ENCODER
1139 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1143 for (chan = 0; chan < c->sys->n_difchan; chan++) {
1144 for (i = 0; i < c->sys->difseg_size; i++) {
1145 memset(buf, 0xff, 80 * 6); /* First 6 DIF blocks are for control data */
1147 /* DV header: 1DIF */
1148 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1149 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1150 buf += 72; /* unused bytes */
1152 /* DV subcode: 2DIFs */
1153 for (j = 0; j < 2; j++) {
1154 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1155 for (k = 0; k < 6; k++)
1156 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1157 buf += 29; /* unused bytes */
1160 /* DV VAUX: 3DIFS */
1161 for (j = 0; j < 3; j++) {
1162 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1163 buf += dv_write_pack(dv_video_source, c, buf);
1164 buf += dv_write_pack(dv_video_control, c, buf);
1166 buf += dv_write_pack(dv_video_source, c, buf);
1167 buf += dv_write_pack(dv_video_control, c, buf);
1168 buf += 4*5 + 2; /* unused bytes */
1171 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1172 for (j = 0; j < 135; j++) {
1174 memset(buf, 0xff, 80);
1175 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1176 buf += 77; /* audio control & shuffled PCM audio */
1178 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1179 buf += 77; /* 1 video macroblock: 1 bytes control
1180 4 * 14 bytes Y 8x8 data
1181 10 bytes Cr 8x8 data
1182 10 bytes Cb 8x8 data */
1189 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1192 DVVideoContext *s = c->priv_data;
1194 s->sys = dv_codec_profile(c);
1197 if(buf_size < s->sys->frame_size)
1200 c->pix_fmt = s->sys->pix_fmt;
1201 s->picture = *((AVFrame *)data);
1202 s->picture.key_frame = 1;
1203 s->picture.pict_type = FF_I_TYPE;
1206 c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
1207 s->sys->n_difchan * s->sys->difseg_size * 27);
1211 dv_format_frame(s, buf);
1213 return s->sys->frame_size;
1217 static int dvvideo_close(AVCodecContext *c)
1219 DVVideoContext *s = c->priv_data;
1221 if(s->picture.data[0])
1222 c->release_buffer(c, &s->picture);
1228 #ifdef CONFIG_DVVIDEO_ENCODER
1229 AVCodec dvvideo_encoder = {
1233 sizeof(DVVideoContext),
1235 dvvideo_encode_frame,
1236 .pix_fmts = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1237 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1239 #endif // CONFIG_DVVIDEO_ENCODER
1241 #ifdef CONFIG_DVVIDEO_DECODER
1242 AVCodec dvvideo_decoder = {
1246 sizeof(DVVideoContext),
1250 dvvideo_decode_frame,
1253 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),