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
37 * @file libavcodec/dv.c
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];
58 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
59 void (*fdct[2])(DCTELEM *block);
60 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
61 me_cmp_func ildct_cmp;
64 #define TEX_VLC_BITS 9
67 #define DV_VLC_MAP_RUN_SIZE 15
68 #define DV_VLC_MAP_LEV_SIZE 23
70 #define DV_VLC_MAP_RUN_SIZE 64
71 #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
74 /* XXX: also include quantization */
75 static RL_VLC_ELEM dv_rl_vlc[1184];
76 /* VLC encoding lookup table */
77 static struct dv_vlc_pair {
80 } dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE];
82 static inline int dv_work_pool_size(const DVprofile *d)
84 int size = d->n_difchan*d->difseg_size*27;
85 if (DV_PROFILE_IS_1080i50(d))
87 if (DV_PROFILE_IS_720p50(d))
92 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
95 static const uint8_t off[] = { 2, 6, 8, 0, 4 };
96 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
97 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
98 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
100 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
101 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
103 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
108 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
109 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
112 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
113 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
114 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
115 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
116 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
117 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
118 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
119 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
120 {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
121 {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
122 {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
123 {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
124 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
129 for (m=0; m<5; m++) {
132 blk = (chan*11+seq)*27+slot;
134 if (chan == 0 && seq == 11) {
143 i = (4*chan + blk + off[m])%11;
146 x = shuf1[m] + (chan&1)*9 + k%9;
147 y = (i*3+k/9)*2 + (chan>>1) + 1;
149 tbl[m] = (x<<1)|(y<<9);
152 blk = (chan*10+seq)*27+slot;
154 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
157 x = shuf1[m]+(chan&1)*9 + k%9;
158 y = (i*3+k/9)*2 + (chan>>1) + 4;
161 x = remap[y][0]+((x-80)<<(y>59));
164 tbl[m] = (x<<1)|(y<<9);
167 blk = (chan*10+seq)*27+slot;
169 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
170 k = (blk/5)%27 + (i&1)*3;
172 x = shuf2[m] + k%6 + 6*(chan&1);
173 y = l_start[i] + k/6 + 45*(chan>>1);
174 tbl[m] = (x<<1)|(y<<9);
177 switch (d->pix_fmt) {
178 case PIX_FMT_YUV422P:
179 x = shuf3[m] + slot/3;
181 ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
182 tbl[m] = (x<<1)|(y<<8);
184 case PIX_FMT_YUV420P:
185 x = shuf3[m] + slot/3;
187 ((seq + off[m]) % d->difseg_size)*3;
188 tbl[m] = (x<<1)|(y<<9);
190 case PIX_FMT_YUV411P:
191 i = (seq + off[m]) % d->difseg_size;
192 k = slot + ((m==1||m==2)?3:0);
194 x = l_start_shuffled[m] + k/6;
195 y = serpent2[k] + i*6;
198 tbl[m] = (x<<2)|(y<<8);
207 static int dv_init_dynamic_tables(const DVprofile *d)
210 uint32_t *factor1, *factor2;
211 const int *iweight1, *iweight2;
213 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
215 for (c=0; c<d->n_difchan; c++) {
216 for (s=0; s<d->difseg_size; s++) {
218 for (j=0; j<27; j++) {
220 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
221 !(DV_PROFILE_IS_720p50(d) && s > 9)) {
222 dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
223 d->work_chunks[i++].buf_offset = p;
231 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
232 factor1 = &d->idct_factor[0];
233 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
234 if (d->height == 720) {
235 iweight1 = &dv_iweight_720_y[0];
236 iweight2 = &dv_iweight_720_c[0];
238 iweight1 = &dv_iweight_1080_y[0];
239 iweight2 = &dv_iweight_1080_c[0];
241 if (DV_PROFILE_IS_HD(d)) {
242 for (c = 0; c < 4; c++) {
243 for (s = 0; s < 16; s++) {
244 for (i = 0; i < 64; i++) {
245 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
246 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
251 iweight1 = &dv_iweight_88[0];
252 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
253 for (s = 0; s < 22; s++) {
254 for (i = c = 0; c < 4; c++) {
255 for (; i < dv_quant_areas[c]; i++) {
256 *factor1 = iweight1[i] << (dv_quant_shifts[s][c] + 1);
257 *factor2++ = (*factor1++) << 1;
268 static av_cold int dvvideo_init(AVCodecContext *avctx)
270 DVVideoContext *s = avctx->priv_data;
277 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
278 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
279 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
280 int16_t new_dv_vlc_level[NB_DV_VLC*2];
284 /* it's faster to include sign bit in a generic VLC parsing scheme */
285 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
286 new_dv_vlc_bits[j] = dv_vlc_bits[i];
287 new_dv_vlc_len[j] = dv_vlc_len[i];
288 new_dv_vlc_run[j] = dv_vlc_run[i];
289 new_dv_vlc_level[j] = dv_vlc_level[i];
291 if (dv_vlc_level[i]) {
292 new_dv_vlc_bits[j] <<= 1;
296 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
297 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
298 new_dv_vlc_run[j] = dv_vlc_run[i];
299 new_dv_vlc_level[j] = -dv_vlc_level[i];
303 /* NOTE: as a trick, we use the fact the no codes are unused
304 to accelerate the parsing of partial codes */
305 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
306 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
307 assert(dv_vlc.table_size == 1184);
309 for (i = 0; i < dv_vlc.table_size; i++){
310 int code = dv_vlc.table[i][0];
311 int len = dv_vlc.table[i][1];
314 if (len < 0){ //more bits needed
318 run = new_dv_vlc_run [code] + 1;
319 level = new_dv_vlc_level[code];
321 dv_rl_vlc[i].len = len;
322 dv_rl_vlc[i].level = level;
323 dv_rl_vlc[i].run = run;
327 for (i = 0; i < NB_DV_VLC - 1; i++) {
328 if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
331 if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
335 if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
338 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc =
339 dv_vlc_bits[i] << (!!dv_vlc_level[i]);
340 dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size =
341 dv_vlc_len[i] + (!!dv_vlc_level[i]);
343 for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
345 for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
346 if (dv_vlc_map[i][j].size == 0) {
347 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
348 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
349 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
350 dv_vlc_map[0][j].size;
354 for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
355 if (dv_vlc_map[i][j].size == 0) {
356 dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
357 (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
358 dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
359 dv_vlc_map[0][j].size;
361 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
362 dv_vlc_map[i][j].vlc | 1;
363 dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
364 dv_vlc_map[i][j].size;
370 /* Generic DSP setup */
371 dsputil_init(&dsp, avctx);
372 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
373 s->get_pixels = dsp.get_pixels;
374 s->ildct_cmp = dsp.ildct_cmp[5];
377 s->fdct[0] = dsp.fdct;
378 s->idct_put[0] = dsp.idct_put;
379 for (i = 0; i < 64; i++)
380 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
383 s->fdct[1] = dsp.fdct248;
384 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
386 for (i = 0; i < 64; i++){
387 int j = ff_zigzag248_direct[i];
388 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
391 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
393 avctx->coded_frame = &s->picture;
400 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
402 typedef struct BlockInfo {
403 const uint32_t *factor_table;
404 const uint8_t *scan_table;
405 uint8_t pos; /* position in block */
406 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
407 uint8_t partial_bit_count;
408 uint16_t partial_bit_buffer;
412 /* bit budget for AC only in 5 MBs */
413 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
414 /* see dv_88_areas and dv_248_areas for details */
415 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
417 static inline int get_bits_left(GetBitContext *s)
419 return s->size_in_bits - get_bits_count(s);
422 static inline int put_bits_left(PutBitContext* s)
424 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
427 /* decode ac coefficients */
428 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
430 int last_index = gb->size_in_bits;
431 const uint8_t *scan_table = mb->scan_table;
432 const uint32_t *factor_table = mb->factor_table;
434 int partial_bit_count = mb->partial_bit_count;
435 int level, run, vlc_len, index;
438 UPDATE_CACHE(re, gb);
440 /* if we must parse a partial vlc, we do it here */
441 if (partial_bit_count > 0) {
442 re_cache = ((unsigned)re_cache >> partial_bit_count) |
443 (mb->partial_bit_buffer << (sizeof(re_cache) * 8 - partial_bit_count));
444 re_index -= partial_bit_count;
445 mb->partial_bit_count = 0;
448 /* get the AC coefficients until last_index is reached */
451 printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
453 /* our own optimized GET_RL_VLC */
454 index = NEG_USR32(re_cache, TEX_VLC_BITS);
455 vlc_len = dv_rl_vlc[index].len;
457 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
458 vlc_len = TEX_VLC_BITS - vlc_len;
460 level = dv_rl_vlc[index].level;
461 run = dv_rl_vlc[index].run;
463 /* gotta check if we're still within gb boundaries */
464 if (re_index + vlc_len > last_index) {
465 /* should be < 16 bits otherwise a codeword could have been parsed */
466 mb->partial_bit_count = last_index - re_index;
467 mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
468 re_index = last_index;
474 printf("run=%d level=%d\n", run, level);
480 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;
481 block[scan_table[pos]] = level;
483 UPDATE_CACHE(re, gb);
485 CLOSE_READER(re, gb);
489 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
491 int bits_left = get_bits_left(gb);
492 while (bits_left >= MIN_CACHE_BITS) {
493 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
494 bits_left -= MIN_CACHE_BITS;
497 put_bits(pb, bits_left, get_bits(gb, bits_left));
501 static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
503 *mb_x = work_chunk->mb_coordinates[m] & 0xff;
504 *mb_y = work_chunk->mb_coordinates[m] >> 8;
506 /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
507 if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
508 *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */
512 /* mb_x and mb_y are in units of 8 pixels */
513 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
515 DVVideoContext *s = avctx->priv_data;
516 DVwork_chunk *work_chunk = arg;
517 int quant, dc, dct_mode, class1, j;
518 int mb_index, mb_x, mb_y, last_index;
519 int y_stride, linesize;
520 DCTELEM *block, *block1;
523 const uint8_t *buf_ptr;
524 PutBitContext pb, vs_pb;
526 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
527 DECLARE_ALIGNED_16(DCTELEM, sblock[5*DV_MAX_BPM][64]);
528 DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
529 DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
530 const int log2_blocksize = 3-s->avctx->lowres;
531 int is_field_mode[5];
533 assert((((int)mb_bit_buffer) & 7) == 0);
534 assert((((int)vs_bit_buffer) & 7) == 0);
536 memset(sblock, 0, sizeof(sblock));
538 /* pass 1 : read DC and AC coefficients in blocks */
539 buf_ptr = &s->buf[work_chunk->buf_offset*80];
540 block1 = &sblock[0][0];
542 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
543 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
545 quant = buf_ptr[3] & 0x0f;
547 init_put_bits(&pb, mb_bit_buffer, 80);
550 is_field_mode[mb_index] = 0;
551 for (j = 0; j < s->sys->bpm; j++) {
552 last_index = s->sys->block_sizes[j];
553 init_get_bits(&gb, buf_ptr, last_index);
556 dc = get_sbits(&gb, 9);
557 dct_mode = get_bits1(&gb);
558 class1 = get_bits(&gb, 2);
559 if (DV_PROFILE_IS_HD(s->sys)) {
560 mb->idct_put = s->idct_put[0];
561 mb->scan_table = s->dv_zigzag[0];
562 mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64];
563 is_field_mode[mb_index] |= !j && dct_mode;
565 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
566 mb->scan_table = s->dv_zigzag[dct_mode];
567 mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 +
568 (quant + dv_quant_offset[class1])*64];
571 /* convert to unsigned because 128 is not added in the
575 buf_ptr += last_index >> 3;
577 mb->partial_bit_count = 0;
580 printf("MB block: %d, %d ", mb_index, j);
582 dv_decode_ac(&gb, mb, block);
584 /* write the remaining bits in a new buffer only if the
593 /* pass 2 : we can do it just after */
595 printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
599 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
601 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
602 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
603 dv_decode_ac(&gb, mb, block);
604 /* if still not finished, no need to parse other blocks */
609 /* all blocks are finished, so the extra bytes can be used at
610 the video segment level */
611 if (j >= s->sys->bpm)
612 bit_copy(&vs_pb, &gb);
615 /* we need a pass other the whole video segment */
617 printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
619 block = &sblock[0][0];
621 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
622 flush_put_bits(&vs_pb);
623 for (mb_index = 0; mb_index < 5; mb_index++) {
624 for (j = 0; j < s->sys->bpm; j++) {
627 printf("start %d:%d\n", mb_index, j);
629 dv_decode_ac(&gb, mb, block);
631 if (mb->pos >= 64 && mb->pos < 127)
632 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
638 /* compute idct and place blocks */
639 block = &sblock[0][0];
641 for (mb_index = 0; mb_index < 5; mb_index++) {
642 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
644 /* idct_put'ting luminance */
645 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
646 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
647 (s->sys->height >= 720 && mb_y != 134)) {
648 y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
650 y_stride = (2 << log2_blocksize);
652 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize);
653 linesize = s->picture.linesize[0] << is_field_mode[mb_index];
654 mb[0] .idct_put(y_ptr , linesize, block + 0*64);
655 if (s->sys->video_stype == 4) { /* SD 422 */
656 mb[2].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 2*64);
658 mb[1].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 1*64);
659 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2*64);
660 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
665 /* idct_put'ting chrominance */
666 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
667 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
668 for (j = 2; j; j--) {
669 uint8_t *c_ptr = s->picture.data[j] + c_offset;
670 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
671 uint64_t aligned_pixels[64/8];
672 uint8_t *pixels = (uint8_t*)aligned_pixels;
673 uint8_t *c_ptr1, *ptr1;
675 mb->idct_put(pixels, 8, block);
676 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
677 ptr1 = pixels + (1 << (log2_blocksize - 1));
678 c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
679 for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
680 c_ptr[x] = pixels[x];
686 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
687 s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
688 linesize = s->picture.linesize[j] << is_field_mode[mb_index];
689 (mb++)-> idct_put(c_ptr , linesize, block); block += 64;
690 if (s->sys->bpm == 8) {
691 (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
700 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
701 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
704 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
705 *vlc = dv_vlc_map[run][level].vlc | sign;
706 size = dv_vlc_map[run][level].size;
709 if (level < DV_VLC_MAP_LEV_SIZE) {
710 *vlc = dv_vlc_map[0][level].vlc | sign;
711 size = dv_vlc_map[0][level].size;
713 *vlc = 0xfe00 | (level << 1) | sign;
717 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
718 (0x1f80 | (run - 1))) << size;
719 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
726 static av_always_inline int dv_rl2vlc_size(int run, int level)
730 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
731 size = dv_vlc_map[run][level].size;
734 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
736 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
742 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
744 *vlc = dv_vlc_map[run][l].vlc | sign;
745 return dv_vlc_map[run][l].size;
748 static av_always_inline int dv_rl2vlc_size(int run, int l)
750 return dv_vlc_map[run][l].size;
754 typedef struct EncBlockInfo {
764 uint8_t partial_bit_count;
765 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
768 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
769 PutBitContext* pb_pool,
770 PutBitContext* pb_end)
773 PutBitContext* pb = pb_pool;
774 int size = bi->partial_bit_count;
775 uint32_t vlc = bi->partial_bit_buffer;
777 bi->partial_bit_count = bi->partial_bit_buffer = 0;
779 /* Find suitable storage space */
780 for (; size > (bits_left = put_bits_left(pb)); pb++) {
783 put_bits(pb, bits_left, vlc >> size);
784 vlc = vlc & ((1 << size) - 1);
786 if (pb + 1 >= pb_end) {
787 bi->partial_bit_count = size;
788 bi->partial_bit_buffer = vlc;
794 put_bits(pb, size, vlc);
796 if (bi->cur_ac >= 64)
799 /* Construct the next VLC */
801 bi->cur_ac = bi->next[prev];
802 if (bi->cur_ac < 64){
803 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
805 size = 4; vlc = 6; /* End Of Block stamp */
811 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
812 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
813 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
815 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
816 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
824 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
827 const uint8_t* zigzag_scan;
828 DECLARE_ALIGNED_16(DCTELEM, blk[64]);
830 /* We offer two different methods for class number assignment: the
831 method suggested in SMPTE 314M Table 22, and an improved
832 method. The SMPTE method is very conservative; it assigns class
833 3 (i.e. severe quantization) to any block where the largest AC
834 component is greater than 36. FFmpeg's DV encoder tracks AC bit
835 consumption precisely, so there is no need to bias most blocks
836 towards strongly lossy compression. Instead, we assign class 2
837 to most blocks, and use class 3 only when strictly necessary
838 (for blocks whose largest AC component exceeds 255). */
840 #if 0 /* SMPTE spec method */
841 static const int classes[] = {12, 24, 36, 0xffff};
842 #else /* improved FFmpeg method */
843 static const int classes[] = {-1, -1, 255, 0xffff};
845 int max = classes[0];
848 assert((((int)blk) & 15) == 0);
850 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
851 bi->partial_bit_count = 0;
852 bi->partial_bit_buffer = 0;
855 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
856 s->get_pixels(blk, data, linesize);
857 s->fdct[bi->dct_mode](blk);
859 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
860 which is precisely what the spec calls for in the "dummy" blocks. */
861 memset(blk, 0, sizeof(blk));
866 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
867 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
869 for (area = 0; area < 4; area++) {
870 bi->prev[area] = prev;
871 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
872 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
873 int level = blk[zigzag_scan[i]];
875 if (level + 15 > 30U) {
876 bi->sign[i] = (level >> 31) & 1;
877 /* weigh it and and shift down into range, adding for rounding */
878 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
879 AND the 2x doubling of the weights */
880 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
884 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
891 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
899 for (area = 0; area < 4; area++) {
900 bi->prev[area] = prev;
901 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
902 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
906 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
915 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
918 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
921 int i, j, k, a, prev, a2;
924 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
927 for (i = 0; i < 5; i++) {
933 for (j = 0; j < 6; j++, b++) {
934 for (a = 0; a < 4; a++) {
935 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
936 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
939 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
940 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
943 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
946 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
947 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
950 assert(b->mb[b->next[k]]);
951 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
952 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
953 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
956 b->next[prev] = b->next[k];
961 size[i] += b->bit_size[a];
964 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
967 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
970 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
972 size[0] = 5 * 6 * 4; //EOB
973 for (j = 0; j < 6 *5; j++, b++) {
975 for (k = b->next[prev]; k < 64; k = b->next[k]) {
976 if (b->mb[k] < a && b->mb[k] > -a){
977 b->next[prev] = b->next[k];
979 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
987 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
989 DVVideoContext *s = avctx->priv_data;
990 DVwork_chunk *work_chunk = arg;
992 int mb_x, mb_y, c_offset, linesize, y_stride;
996 EncBlockInfo enc_blks[5*DV_MAX_BPM];
997 PutBitContext pbs[5*DV_MAX_BPM];
999 EncBlockInfo* enc_blk;
1000 int vs_bit_size = 0;
1001 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
1002 int* qnosp = &qnos[0];
1004 dif = &s->buf[work_chunk->buf_offset*80];
1005 enc_blk = &enc_blks[0];
1006 for (mb_index = 0; mb_index < 5; mb_index++) {
1007 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
1009 /* initializing luminance blocks */
1010 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
1011 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
1012 (s->sys->height >= 720 && mb_y != 134)) {
1013 y_stride = s->picture.linesize[0] << 3;
1017 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
1018 linesize = s->picture.linesize[0];
1020 if (s->sys->video_stype == 4) { /* SD 422 */
1022 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
1023 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
1024 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
1025 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
1028 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
1029 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
1030 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
1031 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
1035 /* initializing chrominance blocks */
1036 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
1037 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
1038 for (j = 2; j; j--) {
1039 uint8_t *c_ptr = s->picture.data[j] + c_offset;
1040 linesize = s->picture.linesize[j];
1041 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
1042 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
1044 uint8_t* b = scratch;
1045 for (i = 0; i < 8; i++) {
1046 d = c_ptr + (linesize << 3);
1047 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
1048 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
1056 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
1057 if (s->sys->bpm == 8) {
1058 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
1063 if (vs_total_ac_bits < vs_bit_size)
1064 dv_guess_qnos(&enc_blks[0], qnosp);
1066 /* DIF encoding process */
1067 for (j=0; j<5*s->sys->bpm;) {
1073 /* First pass over individual cells only */
1074 for (i=0; i<s->sys->bpm; i++, j++) {
1075 int sz = s->sys->block_sizes[i]>>3;
1077 init_put_bits(&pbs[j], dif, sz);
1078 put_bits(&pbs[j], 9, (uint16_t)(((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2));
1079 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1080 put_bits(&pbs[j], 2, enc_blks[j].cno);
1082 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1086 /* Second pass over each MB space */
1087 pb = &pbs[start_mb];
1088 for (i=0; i<s->sys->bpm; i++) {
1089 if (enc_blks[start_mb+i].partial_bit_count)
1090 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1094 /* Third and final pass over the whole video segment space */
1096 for (j=0; j<5*s->sys->bpm; j++) {
1097 if (enc_blks[j].partial_bit_count)
1098 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1099 if (enc_blks[j].partial_bit_count)
1100 av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
1103 for (j=0; j<5*s->sys->bpm; j++)
1104 flush_put_bits(&pbs[j]);
1109 #if CONFIG_DVVIDEO_DECODER
1110 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1111 144000 bytes for PAL - or twice those for 50Mbps) */
1112 static int dvvideo_decode_frame(AVCodecContext *avctx,
1113 void *data, int *data_size,
1116 const uint8_t *buf = avpkt->data;
1117 int buf_size = avpkt->size;
1118 DVVideoContext *s = avctx->priv_data;
1120 s->sys = dv_frame_profile(buf);
1121 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1122 return -1; /* NOTE: we only accept several full frames */
1124 if (s->picture.data[0])
1125 avctx->release_buffer(avctx, &s->picture);
1127 s->picture.reference = 0;
1128 s->picture.key_frame = 1;
1129 s->picture.pict_type = FF_I_TYPE;
1130 avctx->pix_fmt = s->sys->pix_fmt;
1131 avctx->time_base = s->sys->time_base;
1132 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1133 if (avctx->get_buffer(avctx, &s->picture) < 0) {
1134 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1137 s->picture.interlaced_frame = 1;
1138 s->picture.top_field_first = 0;
1141 avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1142 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1147 *data_size = sizeof(AVFrame);
1148 *(AVFrame*)data = s->picture;
1150 return s->sys->frame_size;
1152 #endif /* CONFIG_DVVIDEO_DECODER */
1155 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1159 * Here's what SMPTE314M says about these two:
1160 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1161 * as track application IDs (APTn = 001, AP1n =
1162 * 001, AP2n = 001, AP3n = 001), if the source signal
1163 * comes from a digital VCR. If the signal source is
1164 * unknown, all bits for these data shall be set to 1.
1165 * (page 12) STYPE: STYPE defines a signal type of video signal
1166 * 00000b = 4:1:1 compression
1167 * 00100b = 4:2:2 compression
1169 * Now, I've got two problems with these statements:
1170 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1171 * It seems that for PAL as defined in IEC 61834 we have to set
1172 * APT to 000 and for SMPTE314M to 001.
1173 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1174 * compression scheme (if any).
1176 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1179 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1182 buf[0] = (uint8_t)pack_id;
1184 case dv_header525: /* I can't imagine why these two weren't defined as real */
1185 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1186 buf[1] = 0xf8 | /* reserved -- always 1 */
1187 (apt & 0x07); /* APT: Track application ID */
1188 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1189 (0x0f << 3) | /* reserved -- always 1 */
1190 (apt & 0x07); /* AP1: Audio application ID */
1191 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1192 (0x0f << 3) | /* reserved -- always 1 */
1193 (apt & 0x07); /* AP2: Video application ID */
1194 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1195 (0x0f << 3) | /* reserved -- always 1 */
1196 (apt & 0x07); /* AP3: Subcode application ID */
1198 case dv_video_source:
1199 buf[1] = 0xff; /* reserved -- always 1 */
1200 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1201 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1202 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1203 0xf; /* reserved -- always 1 */
1204 buf[3] = (3 << 6) | /* reserved -- always 1 */
1205 (c->sys->dsf << 5) | /* system: 60fields/50fields */
1206 c->sys->video_stype; /* signal type video compression */
1207 buf[4] = 0xff; /* VISC: 0xff -- no information */
1209 case dv_video_control:
1210 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1211 0x3f; /* reserved -- always 1 */
1212 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1214 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1215 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1216 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1217 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1218 0xc; /* reserved -- always b1100 */
1219 buf[4] = 0xff; /* reserved -- always 1 */
1222 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1227 #if CONFIG_DVVIDEO_ENCODER
1228 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1232 for (chan = 0; chan < c->sys->n_difchan; chan++) {
1233 for (i = 0; i < c->sys->difseg_size; i++) {
1234 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1236 /* DV header: 1DIF */
1237 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1238 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1239 buf += 72; /* unused bytes */
1241 /* DV subcode: 2DIFs */
1242 for (j = 0; j < 2; j++) {
1243 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1244 for (k = 0; k < 6; k++)
1245 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1246 buf += 29; /* unused bytes */
1249 /* DV VAUX: 3DIFS */
1250 for (j = 0; j < 3; j++) {
1251 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1252 buf += dv_write_pack(dv_video_source, c, buf);
1253 buf += dv_write_pack(dv_video_control, c, buf);
1255 buf += dv_write_pack(dv_video_source, c, buf);
1256 buf += dv_write_pack(dv_video_control, c, buf);
1257 buf += 4*5 + 2; /* unused bytes */
1260 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1261 for (j = 0; j < 135; j++) {
1263 memset(buf, 0xff, 80);
1264 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1265 buf += 77; /* audio control & shuffled PCM audio */
1267 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1268 buf += 77; /* 1 video macroblock: 1 bytes control
1269 4 * 14 bytes Y 8x8 data
1270 10 bytes Cr 8x8 data
1271 10 bytes Cb 8x8 data */
1278 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1281 DVVideoContext *s = c->priv_data;
1283 s->sys = dv_codec_profile(c);
1284 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1287 c->pix_fmt = s->sys->pix_fmt;
1288 s->picture = *((AVFrame *)data);
1289 s->picture.key_frame = 1;
1290 s->picture.pict_type = FF_I_TYPE;
1293 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1294 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1298 dv_format_frame(s, buf);
1300 return s->sys->frame_size;
1304 static int dvvideo_close(AVCodecContext *c)
1306 DVVideoContext *s = c->priv_data;
1308 if (s->picture.data[0])
1309 c->release_buffer(c, &s->picture);
1315 #if CONFIG_DVVIDEO_ENCODER
1316 AVCodec dvvideo_encoder = {
1320 sizeof(DVVideoContext),
1322 dvvideo_encode_frame,
1323 .pix_fmts = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1324 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1326 #endif // CONFIG_DVVIDEO_ENCODER
1328 #if CONFIG_DVVIDEO_DECODER
1329 AVCodec dvvideo_decoder = {
1333 sizeof(DVVideoContext),
1337 dvvideo_decode_frame,
1340 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),