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 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
13 * of DV technical info.
15 * This file is part of FFmpeg.
17 * FFmpeg is free software; you can redistribute it and/or
18 * modify it under the terms of the GNU Lesser General Public
19 * License as published by the Free Software Foundation; either
20 * version 2.1 of the License, or (at your option) any later version.
22 * FFmpeg is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25 * Lesser General Public License for more details.
27 * You should have received a copy of the GNU Lesser General Public
28 * License along with FFmpeg; if not, write to the Free Software
29 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
36 #define ALT_BITSTREAM_READER
39 #include "mpegvideo.h"
40 #include "simple_idct.h"
46 typedef struct DVVideoContext {
49 AVCodecContext *avctx;
52 uint8_t dv_zigzag[2][64];
53 uint8_t dv_idct_shift[2][2][22][64];
55 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
56 void (*fdct[2])(DCTELEM *block);
57 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
60 /* MultiThreading - dv_anchor applies to entire DV codec, not just the avcontext */
61 /* one element is needed for each video segment in a DV frame */
62 /* at most there are 2 DIF channels * 12 DIF sequences * 27 video segments (PAL 50Mbps) */
63 #define DV_ANCHOR_SIZE (2*12*27)
65 static void* dv_anchor[DV_ANCHOR_SIZE];
67 #define TEX_VLC_BITS 9
69 #ifdef DV_CODEC_TINY_TARGET
70 #define DV_VLC_MAP_RUN_SIZE 15
71 #define DV_VLC_MAP_LEV_SIZE 23
73 #define DV_VLC_MAP_RUN_SIZE 64
74 #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
77 /* XXX: also include quantization */
78 static RL_VLC_ELEM *dv_rl_vlc;
79 /* VLC encoding lookup table */
80 static struct dv_vlc_pair {
83 } (*dv_vlc_map)[DV_VLC_MAP_LEV_SIZE] = NULL;
85 static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
89 /* NOTE: max left shift is 6 */
90 for(q = 0; q < 22; q++) {
92 for(i = 1; i < 64; i++) {
95 s->dv_idct_shift[0][0][q][j] =
96 dv_quant_shifts[q][dv_88_areas[i]] + 1;
97 s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1;
101 for(i = 1; i < 64; i++) {
103 s->dv_idct_shift[0][1][q][i] =
104 dv_quant_shifts[q][dv_248_areas[i]] + 1;
105 s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1;
110 static int dvvideo_init(AVCodecContext *avctx)
112 DVVideoContext *s = avctx->priv_data;
119 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
120 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
121 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
122 int16_t new_dv_vlc_level[NB_DV_VLC*2];
126 dv_vlc_map = av_mallocz_static(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair));
128 return AVERROR(ENOMEM);
130 /* dv_anchor lets each thread know its Id */
131 for (i=0; i<DV_ANCHOR_SIZE; i++)
132 dv_anchor[i] = (void*)(size_t)i;
134 /* it's faster to include sign bit in a generic VLC parsing scheme */
135 for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
136 new_dv_vlc_bits[j] = dv_vlc_bits[i];
137 new_dv_vlc_len[j] = dv_vlc_len[i];
138 new_dv_vlc_run[j] = dv_vlc_run[i];
139 new_dv_vlc_level[j] = dv_vlc_level[i];
141 if (dv_vlc_level[i]) {
142 new_dv_vlc_bits[j] <<= 1;
146 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
147 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
148 new_dv_vlc_run[j] = dv_vlc_run[i];
149 new_dv_vlc_level[j] = -dv_vlc_level[i];
153 /* NOTE: as a trick, we use the fact the no codes are unused
154 to accelerate the parsing of partial codes */
155 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
156 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
158 dv_rl_vlc = av_mallocz_static(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
160 return AVERROR(ENOMEM);
162 for(i = 0; i < dv_vlc.table_size; i++){
163 int code= dv_vlc.table[i][0];
164 int len = dv_vlc.table[i][1];
167 if(len<0){ //more bits needed
171 run= new_dv_vlc_run[code] + 1;
172 level= new_dv_vlc_level[code];
174 dv_rl_vlc[i].len = len;
175 dv_rl_vlc[i].level = level;
176 dv_rl_vlc[i].run = run;
180 for (i = 0; i < NB_DV_VLC - 1; i++) {
181 if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
183 #ifdef DV_CODEC_TINY_TARGET
184 if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
188 if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
191 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] <<
193 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] +
196 for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
197 #ifdef DV_CODEC_TINY_TARGET
198 for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
199 if (dv_vlc_map[i][j].size == 0) {
200 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
201 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
202 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
203 dv_vlc_map[0][j].size;
207 for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
208 if (dv_vlc_map[i][j].size == 0) {
209 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
210 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
211 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
212 dv_vlc_map[0][j].size;
214 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
215 dv_vlc_map[i][j].vlc | 1;
216 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
217 dv_vlc_map[i][j].size;
223 /* Generic DSP setup */
224 dsputil_init(&dsp, avctx);
225 s->get_pixels = dsp.get_pixels;
228 s->fdct[0] = dsp.fdct;
229 s->idct_put[0] = dsp.idct_put;
231 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
234 s->fdct[1] = dsp.fdct248;
235 s->idct_put[1] = simple_idct248_put; // FIXME: need to add it to DSP
237 for (i=0; i<64; i++){
238 int j= ff_zigzag248_direct[i];
239 s->dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2];
242 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
244 /* XXX: do it only for constant case */
245 dv_build_unquantize_tables(s, dsp.idct_permutation);
247 avctx->coded_frame = &s->picture;
254 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
256 typedef struct BlockInfo {
257 const uint8_t *shift_table;
258 const uint8_t *scan_table;
259 const int *iweight_table;
260 uint8_t pos; /* position in block */
262 uint8_t partial_bit_count;
263 uint16_t partial_bit_buffer;
267 /* block size in bits */
268 static const uint16_t block_sizes[6] = {
269 112, 112, 112, 112, 80, 80
271 /* bit budget for AC only in 5 MBs */
272 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
273 /* see dv_88_areas and dv_248_areas for details */
274 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
276 static inline int get_bits_left(GetBitContext *s)
278 return s->size_in_bits - get_bits_count(s);
281 static inline int get_bits_size(GetBitContext *s)
283 return s->size_in_bits;
286 static inline int put_bits_left(PutBitContext* s)
288 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
291 /* decode ac coefs */
292 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
294 int last_index = get_bits_size(gb);
295 const uint8_t *scan_table = mb->scan_table;
296 const uint8_t *shift_table = mb->shift_table;
297 const int *iweight_table = mb->iweight_table;
299 int partial_bit_count = mb->partial_bit_count;
300 int level, pos1, run, vlc_len, index;
303 UPDATE_CACHE(re, gb);
305 /* if we must parse a partial vlc, we do it here */
306 if (partial_bit_count > 0) {
307 re_cache = ((unsigned)re_cache >> partial_bit_count) |
308 (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
309 re_index -= partial_bit_count;
310 mb->partial_bit_count = 0;
313 /* get the AC coefficients until last_index is reached */
316 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
318 /* our own optimized GET_RL_VLC */
319 index = NEG_USR32(re_cache, TEX_VLC_BITS);
320 vlc_len = dv_rl_vlc[index].len;
322 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
323 vlc_len = TEX_VLC_BITS - vlc_len;
325 level = dv_rl_vlc[index].level;
326 run = dv_rl_vlc[index].run;
328 /* gotta check if we're still within gb boundaries */
329 if (re_index + vlc_len > last_index) {
330 /* should be < 16 bits otherwise a codeword could have been parsed */
331 mb->partial_bit_count = last_index - re_index;
332 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
333 re_index = last_index;
339 printf("run=%d level=%d\n", run, level);
345 pos1 = scan_table[pos];
346 level <<= shift_table[pos1];
348 /* unweigh, round, and shift down */
349 level = (level*iweight_table[pos] + (1 << (dv_iweight_bits-1))) >> dv_iweight_bits;
353 UPDATE_CACHE(re, gb);
355 CLOSE_READER(re, gb);
359 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
361 int bits_left = get_bits_left(gb);
362 while (bits_left >= MIN_CACHE_BITS) {
363 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
364 bits_left -= MIN_CACHE_BITS;
367 put_bits(pb, bits_left, get_bits(gb, bits_left));
371 /* mb_x and mb_y are in units of 8 pixels */
372 static inline void dv_decode_video_segment(DVVideoContext *s,
374 const uint16_t *mb_pos_ptr)
376 int quant, dc, dct_mode, class1, j;
377 int mb_index, mb_x, mb_y, v, last_index;
378 DCTELEM *block, *block1;
381 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
383 PutBitContext pb, vs_pb;
385 BlockInfo mb_data[5 * 6], *mb, *mb1;
386 DECLARE_ALIGNED_8(DCTELEM, sblock[5*6][64]);
387 DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
388 DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
389 const int log2_blocksize= 3-s->avctx->lowres;
391 assert((((int)mb_bit_buffer)&7)==0);
392 assert((((int)vs_bit_buffer)&7)==0);
394 memset(sblock, 0, sizeof(sblock));
396 /* pass 1 : read DC and AC coefficients in blocks */
398 block1 = &sblock[0][0];
400 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
401 for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) {
403 quant = buf_ptr[3] & 0x0f;
405 init_put_bits(&pb, mb_bit_buffer, 80);
408 for(j = 0;j < 6; j++) {
409 last_index = block_sizes[j];
410 init_get_bits(&gb, buf_ptr, last_index);
413 dc = get_sbits(&gb, 9);
414 dct_mode = get_bits1(&gb);
415 mb->dct_mode = dct_mode;
416 mb->scan_table = s->dv_zigzag[dct_mode];
417 mb->iweight_table = dct_mode ? dv_iweight_248 : dv_iweight_88;
418 class1 = get_bits(&gb, 2);
419 mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode]
420 [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 < 6; 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 */
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 < 6; 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 if (s->sys->pix_fmt == PIX_FMT_YUV422P) {
497 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + (mb_x>>1))<<log2_blocksize);
498 c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);
499 } else { /* 4:1:1 or 4:2:0 */
500 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize);
501 if (s->sys->pix_fmt == PIX_FMT_YUV411P)
502 c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);
504 c_offset = (((mb_y >> 1) * s->picture.linesize[1] + (mb_x >> 1))<<log2_blocksize);
506 for(j = 0;j < 6; j++) {
507 idct_put = s->idct_put[mb->dct_mode && log2_blocksize==3];
508 if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
509 if (j == 0 || j == 2) {
511 idct_put(y_ptr + ((j >> 1)<<log2_blocksize),
512 s->picture.linesize[0], block);
515 idct_put(s->picture.data[6 - j] + c_offset,
516 s->picture.linesize[6 - j], block);
518 /* note: j=1 and j=3 are "dummy" blocks in 4:2:2 */
519 } else { /* 4:1:1 or 4:2:0 */
521 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
522 /* NOTE: at end of line, the macroblock is handled as 420 */
523 idct_put(y_ptr + (j<<log2_blocksize), s->picture.linesize[0], block);
525 idct_put(y_ptr + (((j & 1) + (j >> 1) * s->picture.linesize[0])<<log2_blocksize),
526 s->picture.linesize[0], block);
529 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
530 uint64_t aligned_pixels[64/8];
531 uint8_t *pixels= (uint8_t*)aligned_pixels;
532 uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1;
534 /* NOTE: at end of line, the macroblock is handled as 420 */
535 idct_put(pixels, 8, block);
536 linesize = s->picture.linesize[6 - j];
537 c_ptr = s->picture.data[6 - j] + c_offset;
539 for(y = 0;y < (1<<log2_blocksize); y++) {
540 ptr1= ptr + (1<<(log2_blocksize-1));
541 c_ptr1 = c_ptr + (linesize<<log2_blocksize);
542 for(x=0; x < (1<<(log2_blocksize-1)); x++){
543 c_ptr[x]= ptr[x]; c_ptr1[x]= ptr1[x];
549 /* don't ask me why they inverted Cb and Cr ! */
550 idct_put(s->picture.data[6 - j] + c_offset,
551 s->picture.linesize[6 - j], block);
561 #ifdef DV_CODEC_TINY_TARGET
562 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
563 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
566 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
567 *vlc = dv_vlc_map[run][level].vlc | sign;
568 size = dv_vlc_map[run][level].size;
571 if (level < DV_VLC_MAP_LEV_SIZE) {
572 *vlc = dv_vlc_map[0][level].vlc | sign;
573 size = dv_vlc_map[0][level].size;
575 *vlc = 0xfe00 | (level << 1) | sign;
579 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
580 (0x1f80 | (run - 1))) << size;
581 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
588 static av_always_inline int dv_rl2vlc_size(int run, int level)
592 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
593 size = dv_vlc_map[run][level].size;
596 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
598 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
604 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
606 *vlc = dv_vlc_map[run][l].vlc | sign;
607 return dv_vlc_map[run][l].size;
610 static av_always_inline int dv_rl2vlc_size(int run, int l)
612 return dv_vlc_map[run][l].size;
616 typedef struct EncBlockInfo {
626 uint8_t partial_bit_count;
627 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
630 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,
631 PutBitContext* pb_end)
635 PutBitContext* pb = pb_pool;
636 int size = bi->partial_bit_count;
637 uint32_t vlc = bi->partial_bit_buffer;
639 bi->partial_bit_count = bi->partial_bit_buffer = 0;
641 /* Find suitable storage space */
642 for (; size > (bits_left = put_bits_left(pb)); pb++) {
645 put_bits(pb, bits_left, vlc >> size);
646 vlc = vlc & ((1<<size)-1);
648 if (pb + 1 >= pb_end) {
649 bi->partial_bit_count = size;
650 bi->partial_bit_buffer = vlc;
656 put_bits(pb, size, vlc);
661 /* Construct the next VLC */
663 bi->cur_ac = bi->next[prev];
665 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
667 size = 4; vlc = 6; /* End Of Block stamp */
673 static av_always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
674 const uint8_t* zigzag_scan, const int *weight, int bias)
677 /* We offer two different methods for class number assignment: the
678 method suggested in SMPTE 314M Table 22, and an improved
679 method. The SMPTE method is very conservative; it assigns class
680 3 (i.e. severe quantization) to any block where the largest AC
681 component is greater than 36. ffmpeg's DV encoder tracks AC bit
682 consumption precisely, so there is no need to bias most blocks
683 towards strongly lossy compression. Instead, we assign class 2
684 to most blocks, and use class 3 only when strictly necessary
685 (for blocks whose largest AC component exceeds 255). */
687 #if 0 /* SMPTE spec method */
688 static const int classes[] = {12, 24, 36, 0xffff};
689 #else /* improved ffmpeg method */
690 static const int classes[] = {-1, -1, 255, 0xffff};
697 for (area = 0; area < 4; area++) {
698 bi->prev[area] = prev;
699 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
700 for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
701 int level = blk[zigzag_scan[i]];
703 if (level+15 > 30U) {
704 bi->sign[i] = (level>>31)&1;
705 /* weigh it and and shift down into range, adding for rounding */
706 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
707 AND the 2x doubling of the weights */
708 level = (FFABS(level) * weight[i] + (1<<(dv_weight_bits+3))) >> (dv_weight_bits+4);
710 if(level>max) max= level;
711 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
718 for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);
726 for (area = 0; area < 4; area++) {
727 bi->prev[area] = prev;
728 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
729 for (; i<mb_area_start[area+1]; i= bi->next[i]) {
733 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
743 //FIXME replace this by dsputil
744 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
745 static av_always_inline int dv_guess_dct_mode(DCTELEM *blk) {
751 /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
754 score88 += SC(0, 8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
755 SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
758 /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
761 score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
762 SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
766 return (score88 - score248 > -10);
769 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
772 int i, j, k, a, prev, a2;
775 size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24;
778 for (i=0; i<5; i++) {
784 for (j=0; j<6; j++, b++) {
785 for (a=0; a<4; a++) {
786 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
787 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
790 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
791 for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
794 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
797 if(b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
798 for(a2=a+1; b->next[k] >= mb_area_start[a2+1]; a2++)
801 assert(b->mb[b->next[k]]);
802 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
803 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
804 assert(b->prev[a2]==k && (a2+1 >= 4 || b->prev[a2+1]!=k));
807 b->next[prev] = b->next[k];
812 size[i] += b->bit_size[a];
815 if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
818 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
821 for(a=2; a==2 || vs_total_ac_bits < size[0]; a+=a){
823 size[0] = 5*6*4; //EOB
824 for (j=0; j<6*5; j++, b++) {
826 for (k= b->next[prev]; k<64; k= b->next[k]) {
827 if(b->mb[k] < a && b->mb[k] > -a){
828 b->next[prev] = b->next[k];
830 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
838 static inline void dv_encode_video_segment(DVVideoContext *s,
840 const uint16_t *mb_pos_ptr)
842 int mb_index, i, j, v;
843 int mb_x, mb_y, c_offset, linesize;
848 DECLARE_ALIGNED_8(DCTELEM, block[64]);
849 EncBlockInfo enc_blks[5*6];
850 PutBitContext pbs[5*6];
852 EncBlockInfo* enc_blk;
856 assert((((int)block) & 7) == 0);
858 enc_blk = &enc_blks[0];
860 for(mb_index = 0; mb_index < 5; mb_index++) {
864 if (s->sys->pix_fmt == PIX_FMT_YUV422P) {
865 y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 4);
867 y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);
869 if (s->sys->pix_fmt == PIX_FMT_YUV420P) {
870 c_offset = (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8));
871 } else { /* 4:2:2 or 4:1:1 */
872 c_offset = ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8));
875 qnos[mb_index] = 15; /* No quantization */
876 ptr = dif + mb_index*80 + 4;
877 for(j = 0;j < 6; j++) {
879 if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
880 if (j == 0 || j == 2) {
882 data = y_ptr + ((j>>1) * 8);
883 linesize = s->picture.linesize[0];
886 data = s->picture.data[6 - j] + c_offset;
887 linesize = s->picture.linesize[6 - j];
889 /* j=1 and j=3 are "dummy" blocks, used for AC data only */
894 } else { /* 4:1:1 or 4:2:0 */
895 if (j < 4) { /* Four Y blocks */
896 /* NOTE: at end of line, the macroblock is handled as 420 */
897 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
898 data = y_ptr + (j * 8);
900 data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
902 linesize = s->picture.linesize[0];
903 } else { /* Cr and Cb blocks */
904 /* don't ask Fabrice why they inverted Cb and Cr ! */
905 data = s->picture.data[6 - j] + c_offset;
906 linesize = s->picture.linesize[6 - j];
907 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
912 /* Everything is set up -- now just copy data -> DCT block */
913 if (do_edge_wrap) { /* Edge wrap copy: 4x16 -> 8x8 */
917 d = data + 8 * linesize;
918 b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
919 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
923 } else { /* Simple copy: 8x8 -> 8x8 */
925 s->get_pixels(block, data, linesize);
928 if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
929 enc_blk->dct_mode = dv_guess_dct_mode(block);
931 enc_blk->dct_mode = 0;
932 enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
933 enc_blk->partial_bit_count = 0;
934 enc_blk->partial_bit_buffer = 0;
938 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
939 which is precisely what the spec calls for in the "dummy" blocks. */
940 memset(block, 0, sizeof(block));
942 s->fdct[enc_blk->dct_mode](block);
945 dv_set_class_number(block, enc_blk,
946 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct,
947 enc_blk->dct_mode ? dv_weight_248 : dv_weight_88,
950 init_put_bits(pb, ptr, block_sizes[j]/8);
951 put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
952 put_bits(pb, 1, enc_blk->dct_mode);
953 put_bits(pb, 2, enc_blk->cno);
955 vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
956 enc_blk->bit_size[2] + enc_blk->bit_size[3];
959 ptr += block_sizes[j]/8;
963 if (vs_total_ac_bits < vs_bit_size)
964 dv_guess_qnos(&enc_blks[0], &qnos[0]);
966 for (i=0; i<5; i++) {
967 dif[i*80 + 3] = qnos[i];
970 /* First pass over individual cells only */
971 for (j=0; j<5*6; j++)
972 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
974 /* Second pass over each MB space */
975 for (j=0; j<5*6; j+=6) {
977 for (i=0; i<6; i++) {
978 if (enc_blks[i+j].partial_bit_count)
979 pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
983 /* Third and final pass over the whole vides segment space */
985 for (j=0; j<5*6; j++) {
986 if (enc_blks[j].partial_bit_count)
987 pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
988 if (enc_blks[j].partial_bit_count)
989 av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
992 for (j=0; j<5*6; j++)
993 flush_put_bits(&pbs[j]);
996 static int dv_decode_mt(AVCodecContext *avctx, void* sl)
998 DVVideoContext *s = avctx->priv_data;
999 int slice = (size_t)sl;
1001 /* which DIF channel is this? */
1002 int chan = slice / (s->sys->difseg_size * 27);
1004 /* slice within the DIF channel */
1005 int chan_slice = slice % (s->sys->difseg_size * 27);
1007 /* byte offset of this channel's data */
1008 int chan_offset = chan * s->sys->difseg_size * 150 * 80;
1010 dv_decode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
1011 &s->sys->video_place[slice*5]);
1015 #ifdef CONFIG_ENCODERS
1016 static int dv_encode_mt(AVCodecContext *avctx, void* sl)
1018 DVVideoContext *s = avctx->priv_data;
1019 int slice = (size_t)sl;
1021 /* which DIF channel is this? */
1022 int chan = slice / (s->sys->difseg_size * 27);
1024 /* slice within the DIF channel */
1025 int chan_slice = slice % (s->sys->difseg_size * 27);
1027 /* byte offset of this channel's data */
1028 int chan_offset = chan * s->sys->difseg_size * 150 * 80;
1030 dv_encode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
1031 &s->sys->video_place[slice*5]);
1036 #ifdef CONFIG_DECODERS
1037 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1038 144000 bytes for PAL - or twice those for 50Mbps) */
1039 static int dvvideo_decode_frame(AVCodecContext *avctx,
1040 void *data, int *data_size,
1041 uint8_t *buf, int buf_size)
1043 DVVideoContext *s = avctx->priv_data;
1045 s->sys = dv_frame_profile(buf);
1046 if (!s->sys || buf_size < s->sys->frame_size)
1047 return -1; /* NOTE: we only accept several full frames */
1049 if(s->picture.data[0])
1050 avctx->release_buffer(avctx, &s->picture);
1052 s->picture.reference = 0;
1053 s->picture.key_frame = 1;
1054 s->picture.pict_type = FF_I_TYPE;
1055 avctx->pix_fmt = s->sys->pix_fmt;
1056 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1057 if(avctx->get_buffer(avctx, &s->picture) < 0) {
1058 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1061 s->picture.interlaced_frame = 1;
1062 s->picture.top_field_first = 0;
1065 avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
1066 s->sys->n_difchan * s->sys->difseg_size * 27);
1071 *data_size = sizeof(AVFrame);
1072 *(AVFrame*)data= s->picture;
1074 return s->sys->frame_size;
1079 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, uint8_t* buf)
1082 * Here's what SMPTE314M says about these two:
1083 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1084 * as track application IDs (APTn = 001, AP1n =
1085 * 001, AP2n = 001, AP3n = 001), if the source signal
1086 * comes from a digital VCR. If the signal source is
1087 * unknown, all bits for these data shall be set to 1.
1088 * (page 12) STYPE: STYPE defines a signal type of video signal
1089 * 00000b = 4:1:1 compression
1090 * 00100b = 4:2:2 compression
1092 * Now, I've got two problems with these statements:
1093 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1094 * It seems that for PAL as defined in IEC 61834 we have to set
1095 * APT to 000 and for SMPTE314M to 001.
1096 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1097 * compression scheme (if any).
1099 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1100 int stype = (c->sys->pix_fmt == PIX_FMT_YUV422P ? 4 : 0);
1103 if((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) == 17) /* 16:9 */
1106 buf[0] = (uint8_t)pack_id;
1108 case dv_header525: /* I can't imagine why these two weren't defined as real */
1109 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1110 buf[1] = 0xf8 | /* reserved -- always 1 */
1111 (apt & 0x07); /* APT: Track application ID */
1112 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1113 (0x0f << 3) | /* reserved -- always 1 */
1114 (apt & 0x07); /* AP1: Audio application ID */
1115 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1116 (0x0f << 3) | /* reserved -- always 1 */
1117 (apt & 0x07); /* AP2: Video application ID */
1118 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1119 (0x0f << 3) | /* reserved -- always 1 */
1120 (apt & 0x07); /* AP3: Subcode application ID */
1122 case dv_video_source:
1123 buf[1] = 0xff; /* reserved -- always 1 */
1124 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1125 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1126 (3 << 4) | /* CLF: color frames id (see ITU-R BT.470-4) */
1127 0xf; /* reserved -- always 1 */
1128 buf[3] = (3 << 6) | /* reserved -- always 1 */
1129 (c->sys->dsf << 5) | /* system: 60fields/50fields */
1130 stype; /* signal type video compression */
1131 buf[4] = 0xff; /* VISC: 0xff -- no information */
1133 case dv_video_control:
1134 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1135 0x3f; /* reserved -- always 1 */
1136 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1138 buf[3] = (1 << 7) | /* Frame/field flag 1 -- frame, 0 -- field */
1139 (1 << 6) | /* First/second field flag 0 -- field 2, 1 -- field 1 */
1140 (1 << 5) | /* Frame change flag 0 -- same picture as before, 1 -- different */
1141 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1142 0xc; /* reserved -- always b1100 */
1143 buf[4] = 0xff; /* reserved -- always 1 */
1146 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1151 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1155 for (chan = 0; chan < c->sys->n_difchan; chan++) {
1156 for (i = 0; i < c->sys->difseg_size; i++) {
1157 memset(buf, 0xff, 80 * 6); /* First 6 DIF blocks are for control data */
1159 /* DV header: 1DIF */
1160 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1161 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1162 buf += 72; /* unused bytes */
1164 /* DV subcode: 2DIFs */
1165 for (j = 0; j < 2; j++) {
1166 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1167 for (k = 0; k < 6; k++)
1168 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1169 buf += 29; /* unused bytes */
1172 /* DV VAUX: 3DIFS */
1173 for (j = 0; j < 3; j++) {
1174 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1175 buf += dv_write_pack(dv_video_source, c, buf);
1176 buf += dv_write_pack(dv_video_control, c, buf);
1178 buf += dv_write_pack(dv_video_source, c, buf);
1179 buf += dv_write_pack(dv_video_control, c, buf);
1180 buf += 4*5 + 2; /* unused bytes */
1183 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1184 for (j = 0; j < 135; j++) {
1186 memset(buf, 0xff, 80);
1187 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1188 buf += 77; /* audio control & shuffled PCM audio */
1190 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1191 buf += 77; /* 1 video macro block: 1 bytes control
1192 4 * 14 bytes Y 8x8 data
1193 10 bytes Cr 8x8 data
1194 10 bytes Cb 8x8 data */
1201 #ifdef CONFIG_ENCODERS
1202 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1205 DVVideoContext *s = c->priv_data;
1207 s->sys = dv_codec_profile(c);
1210 if(buf_size < s->sys->frame_size)
1213 c->pix_fmt = s->sys->pix_fmt;
1214 s->picture = *((AVFrame *)data);
1215 s->picture.key_frame = 1;
1216 s->picture.pict_type = FF_I_TYPE;
1219 c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
1220 s->sys->n_difchan * s->sys->difseg_size * 27);
1224 dv_format_frame(s, buf);
1226 return s->sys->frame_size;
1230 static int dvvideo_close(AVCodecContext *c)
1232 DVVideoContext *s = c->priv_data;
1234 if(s->picture.data[0])
1235 c->release_buffer(c, &s->picture);
1241 #ifdef CONFIG_DVVIDEO_ENCODER
1242 AVCodec dvvideo_encoder = {
1246 sizeof(DVVideoContext),
1248 dvvideo_encode_frame,
1249 .pix_fmts = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, -1},
1251 #endif // CONFIG_DVVIDEO_ENCODER
1253 #ifdef CONFIG_DVVIDEO_DECODER
1254 AVCodec dvvideo_decoder = {
1258 sizeof(DVVideoContext),
1262 dvvideo_decode_frame,