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
41 #include "libavutil/pixdesc.h"
46 #include "simple_idct.h"
48 #include "dv_tablegen.h"
53 typedef struct DVVideoContext {
56 AVCodecContext *avctx;
59 uint8_t dv_zigzag[2][64];
61 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
62 void (*fdct[2])(DCTELEM *block);
63 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
64 me_cmp_func ildct_cmp;
67 #define TEX_VLC_BITS 9
69 /* XXX: also include quantization */
70 static RL_VLC_ELEM dv_rl_vlc[1184];
72 static inline int dv_work_pool_size(const DVprofile *d)
74 int size = d->n_difchan*d->difseg_size*27;
75 if (DV_PROFILE_IS_1080i50(d))
77 if (DV_PROFILE_IS_720p50(d))
82 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
85 static const uint8_t off[] = { 2, 6, 8, 0, 4 };
86 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
87 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
88 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
90 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
91 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
93 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
98 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
99 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
102 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
103 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
104 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
105 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
106 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
107 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
108 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
109 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
110 {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
111 {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
112 {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
113 {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
114 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
119 for (m=0; m<5; m++) {
122 blk = (chan*11+seq)*27+slot;
124 if (chan == 0 && seq == 11) {
133 i = (4*chan + blk + off[m])%11;
136 x = shuf1[m] + (chan&1)*9 + k%9;
137 y = (i*3+k/9)*2 + (chan>>1) + 1;
139 tbl[m] = (x<<1)|(y<<9);
142 blk = (chan*10+seq)*27+slot;
144 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
147 x = shuf1[m]+(chan&1)*9 + k%9;
148 y = (i*3+k/9)*2 + (chan>>1) + 4;
151 x = remap[y][0]+((x-80)<<(y>59));
154 tbl[m] = (x<<1)|(y<<9);
157 blk = (chan*10+seq)*27+slot;
159 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
160 k = (blk/5)%27 + (i&1)*3;
162 x = shuf2[m] + k%6 + 6*(chan&1);
163 y = l_start[i] + k/6 + 45*(chan>>1);
164 tbl[m] = (x<<1)|(y<<9);
167 switch (d->pix_fmt) {
168 case PIX_FMT_YUV422P:
169 x = shuf3[m] + slot/3;
171 ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
172 tbl[m] = (x<<1)|(y<<8);
174 case PIX_FMT_YUV420P:
175 x = shuf3[m] + slot/3;
177 ((seq + off[m]) % d->difseg_size)*3;
178 tbl[m] = (x<<1)|(y<<9);
180 case PIX_FMT_YUV411P:
181 i = (seq + off[m]) % d->difseg_size;
182 k = slot + ((m==1||m==2)?3:0);
184 x = l_start_shuffled[m] + k/6;
185 y = serpent2[k] + i*6;
188 tbl[m] = (x<<2)|(y<<8);
197 static int dv_init_dynamic_tables(const DVprofile *d)
200 uint32_t *factor1, *factor2;
201 const int *iweight1, *iweight2;
203 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
205 for (c=0; c<d->n_difchan; c++) {
206 for (s=0; s<d->difseg_size; s++) {
208 for (j=0; j<27; j++) {
210 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
211 !(DV_PROFILE_IS_720p50(d) && s > 9)) {
212 dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
213 d->work_chunks[i++].buf_offset = p;
221 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
222 factor1 = &d->idct_factor[0];
223 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
224 if (d->height == 720) {
225 iweight1 = &dv_iweight_720_y[0];
226 iweight2 = &dv_iweight_720_c[0];
228 iweight1 = &dv_iweight_1080_y[0];
229 iweight2 = &dv_iweight_1080_c[0];
231 if (DV_PROFILE_IS_HD(d)) {
232 for (c = 0; c < 4; c++) {
233 for (s = 0; s < 16; s++) {
234 for (i = 0; i < 64; i++) {
235 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
236 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
241 iweight1 = &dv_iweight_88[0];
242 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
243 for (s = 0; s < 22; s++) {
244 for (i = c = 0; c < 4; c++) {
245 for (; i < dv_quant_areas[c]; i++) {
246 *factor1 = iweight1[i] << (dv_quant_shifts[s][c] + 1);
247 *factor2++ = (*factor1++) << 1;
258 static av_cold int dvvideo_init(AVCodecContext *avctx)
260 DVVideoContext *s = avctx->priv_data;
267 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
268 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
269 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
270 int16_t new_dv_vlc_level[NB_DV_VLC*2];
274 /* it's faster to include sign bit in a generic VLC parsing scheme */
275 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
276 new_dv_vlc_bits[j] = dv_vlc_bits[i];
277 new_dv_vlc_len[j] = dv_vlc_len[i];
278 new_dv_vlc_run[j] = dv_vlc_run[i];
279 new_dv_vlc_level[j] = dv_vlc_level[i];
281 if (dv_vlc_level[i]) {
282 new_dv_vlc_bits[j] <<= 1;
286 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
287 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
288 new_dv_vlc_run[j] = dv_vlc_run[i];
289 new_dv_vlc_level[j] = -dv_vlc_level[i];
293 /* NOTE: as a trick, we use the fact the no codes are unused
294 to accelerate the parsing of partial codes */
295 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
296 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
297 assert(dv_vlc.table_size == 1184);
299 for (i = 0; i < dv_vlc.table_size; i++){
300 int code = dv_vlc.table[i][0];
301 int len = dv_vlc.table[i][1];
304 if (len < 0){ //more bits needed
308 run = new_dv_vlc_run [code] + 1;
309 level = new_dv_vlc_level[code];
311 dv_rl_vlc[i].len = len;
312 dv_rl_vlc[i].level = level;
313 dv_rl_vlc[i].run = run;
317 dv_vlc_map_tableinit();
320 /* Generic DSP setup */
321 dsputil_init(&dsp, avctx);
322 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
323 s->get_pixels = dsp.get_pixels;
324 s->ildct_cmp = dsp.ildct_cmp[5];
327 s->fdct[0] = dsp.fdct;
328 s->idct_put[0] = dsp.idct_put;
329 for (i = 0; i < 64; i++)
330 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
333 s->fdct[1] = dsp.fdct248;
334 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
336 for (i = 0; i < 64; i++){
337 int j = ff_zigzag248_direct[i];
338 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
341 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
343 avctx->coded_frame = &s->picture;
345 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
350 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
352 if (!avpriv_dv_codec_profile(avctx)) {
353 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video\n",
354 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
358 return dvvideo_init(avctx);
361 typedef struct BlockInfo {
362 const uint32_t *factor_table;
363 const uint8_t *scan_table;
364 uint8_t pos; /* position in block */
365 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
366 uint8_t partial_bit_count;
367 uint32_t partial_bit_buffer;
371 /* bit budget for AC only in 5 MBs */
372 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
373 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
375 static inline int put_bits_left(PutBitContext* s)
377 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
380 /* decode AC coefficients */
381 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
383 int last_index = gb->size_in_bits;
384 const uint8_t *scan_table = mb->scan_table;
385 const uint32_t *factor_table = mb->factor_table;
387 int partial_bit_count = mb->partial_bit_count;
388 int level, run, vlc_len, index;
391 UPDATE_CACHE(re, gb);
393 /* if we must parse a partial VLC, we do it here */
394 if (partial_bit_count > 0) {
395 re_cache = re_cache >> partial_bit_count | mb->partial_bit_buffer;
396 re_index -= partial_bit_count;
397 mb->partial_bit_count = 0;
400 /* get the AC coefficients until last_index is reached */
402 av_dlog(NULL, "%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16),
404 /* our own optimized GET_RL_VLC */
405 index = NEG_USR32(re_cache, TEX_VLC_BITS);
406 vlc_len = dv_rl_vlc[index].len;
408 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
409 vlc_len = TEX_VLC_BITS - vlc_len;
411 level = dv_rl_vlc[index].level;
412 run = dv_rl_vlc[index].run;
414 /* gotta check if we're still within gb boundaries */
415 if (re_index + vlc_len > last_index) {
416 /* should be < 16 bits otherwise a codeword could have been parsed */
417 mb->partial_bit_count = last_index - re_index;
418 mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
419 re_index = last_index;
424 av_dlog(NULL, "run=%d level=%d\n", run, level);
429 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;
430 block[scan_table[pos]] = level;
432 UPDATE_CACHE(re, gb);
434 CLOSE_READER(re, gb);
438 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
440 int bits_left = get_bits_left(gb);
441 while (bits_left >= MIN_CACHE_BITS) {
442 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
443 bits_left -= MIN_CACHE_BITS;
446 put_bits(pb, bits_left, get_bits(gb, bits_left));
450 static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
452 *mb_x = work_chunk->mb_coordinates[m] & 0xff;
453 *mb_y = work_chunk->mb_coordinates[m] >> 8;
455 /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
456 if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
457 *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */
461 /* mb_x and mb_y are in units of 8 pixels */
462 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
464 DVVideoContext *s = avctx->priv_data;
465 DVwork_chunk *work_chunk = arg;
466 int quant, dc, dct_mode, class1, j;
467 int mb_index, mb_x, mb_y, last_index;
468 int y_stride, linesize;
469 DCTELEM *block, *block1;
472 const uint8_t *buf_ptr;
473 PutBitContext pb, vs_pb;
475 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
476 LOCAL_ALIGNED_16(DCTELEM, sblock, [5*DV_MAX_BPM], [64]);
477 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [ 80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
478 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [5*80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
479 const int log2_blocksize = 3-s->avctx->lowres;
480 int is_field_mode[5];
482 assert((((int)mb_bit_buffer) & 7) == 0);
483 assert((((int)vs_bit_buffer) & 7) == 0);
485 memset(sblock, 0, 5*DV_MAX_BPM*sizeof(*sblock));
487 /* pass 1: read DC and AC coefficients in blocks */
488 buf_ptr = &s->buf[work_chunk->buf_offset*80];
489 block1 = &sblock[0][0];
491 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
492 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
494 quant = buf_ptr[3] & 0x0f;
496 init_put_bits(&pb, mb_bit_buffer, 80);
499 is_field_mode[mb_index] = 0;
500 for (j = 0; j < s->sys->bpm; j++) {
501 last_index = s->sys->block_sizes[j];
502 init_get_bits(&gb, buf_ptr, last_index);
505 dc = get_sbits(&gb, 9);
506 dct_mode = get_bits1(&gb);
507 class1 = get_bits(&gb, 2);
508 if (DV_PROFILE_IS_HD(s->sys)) {
509 mb->idct_put = s->idct_put[0];
510 mb->scan_table = s->dv_zigzag[0];
511 mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64];
512 is_field_mode[mb_index] |= !j && dct_mode;
514 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
515 mb->scan_table = s->dv_zigzag[dct_mode];
516 mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 +
517 (quant + dv_quant_offset[class1])*64];
520 /* convert to unsigned because 128 is not added in the
524 buf_ptr += last_index >> 3;
526 mb->partial_bit_count = 0;
528 av_dlog(avctx, "MB block: %d, %d ", mb_index, j);
529 dv_decode_ac(&gb, mb, block);
531 /* write the remaining bits in a new buffer only if the
540 /* pass 2: we can do it just after */
541 av_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
544 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
545 put_bits32(&pb, 0); // padding must be zeroed
547 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
548 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
549 dv_decode_ac(&gb, mb, block);
550 /* if still not finished, no need to parse other blocks */
555 /* all blocks are finished, so the extra bytes can be used at
556 the video segment level */
557 if (j >= s->sys->bpm)
558 bit_copy(&vs_pb, &gb);
561 /* we need a pass over the whole video segment */
562 av_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
563 block = &sblock[0][0];
565 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
566 put_bits32(&vs_pb, 0); // padding must be zeroed
567 flush_put_bits(&vs_pb);
568 for (mb_index = 0; mb_index < 5; mb_index++) {
569 for (j = 0; j < s->sys->bpm; j++) {
571 av_dlog(avctx, "start %d:%d\n", mb_index, j);
572 dv_decode_ac(&gb, mb, block);
574 if (mb->pos >= 64 && mb->pos < 127)
575 av_log(avctx, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
581 /* compute idct and place blocks */
582 block = &sblock[0][0];
584 for (mb_index = 0; mb_index < 5; mb_index++) {
585 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
587 /* idct_put'ting luminance */
588 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
589 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
590 (s->sys->height >= 720 && mb_y != 134)) {
591 y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
593 y_stride = (2 << log2_blocksize);
595 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize);
596 linesize = s->picture.linesize[0] << is_field_mode[mb_index];
597 mb[0] .idct_put(y_ptr , linesize, block + 0*64);
598 if (s->sys->video_stype == 4) { /* SD 422 */
599 mb[2].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 2*64);
601 mb[1].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 1*64);
602 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2*64);
603 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
608 /* idct_put'ting chrominance */
609 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
610 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
611 for (j = 2; j; j--) {
612 uint8_t *c_ptr = s->picture.data[j] + c_offset;
613 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
614 uint64_t aligned_pixels[64/8];
615 uint8_t *pixels = (uint8_t*)aligned_pixels;
616 uint8_t *c_ptr1, *ptr1;
618 mb->idct_put(pixels, 8, block);
619 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
620 ptr1 = pixels + (1 << (log2_blocksize - 1));
621 c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
622 for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
623 c_ptr[x] = pixels[x];
629 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
630 s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
631 linesize = s->picture.linesize[j] << is_field_mode[mb_index];
632 (mb++)-> idct_put(c_ptr , linesize, block); block += 64;
633 if (s->sys->bpm == 8) {
634 (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
643 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
644 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
647 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
648 *vlc = dv_vlc_map[run][level].vlc | sign;
649 size = dv_vlc_map[run][level].size;
652 if (level < DV_VLC_MAP_LEV_SIZE) {
653 *vlc = dv_vlc_map[0][level].vlc | sign;
654 size = dv_vlc_map[0][level].size;
656 *vlc = 0xfe00 | (level << 1) | sign;
660 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
661 (0x1f80 | (run - 1))) << size;
662 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
669 static av_always_inline int dv_rl2vlc_size(int run, int level)
673 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
674 size = dv_vlc_map[run][level].size;
677 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
679 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
685 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
687 *vlc = dv_vlc_map[run][l].vlc | sign;
688 return dv_vlc_map[run][l].size;
691 static av_always_inline int dv_rl2vlc_size(int run, int l)
693 return dv_vlc_map[run][l].size;
697 typedef struct EncBlockInfo {
707 uint8_t partial_bit_count;
708 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
711 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
712 PutBitContext* pb_pool,
713 PutBitContext* pb_end)
716 PutBitContext* pb = pb_pool;
717 int size = bi->partial_bit_count;
718 uint32_t vlc = bi->partial_bit_buffer;
720 bi->partial_bit_count = bi->partial_bit_buffer = 0;
722 /* Find suitable storage space */
723 for (; size > (bits_left = put_bits_left(pb)); pb++) {
726 put_bits(pb, bits_left, vlc >> size);
727 vlc = vlc & ((1 << size) - 1);
729 if (pb + 1 >= pb_end) {
730 bi->partial_bit_count = size;
731 bi->partial_bit_buffer = vlc;
737 put_bits(pb, size, vlc);
739 if (bi->cur_ac >= 64)
742 /* Construct the next VLC */
744 bi->cur_ac = bi->next[prev];
745 if (bi->cur_ac < 64){
746 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
748 size = 4; vlc = 6; /* End Of Block stamp */
754 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
755 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
756 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
758 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
759 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
767 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
770 const uint8_t* zigzag_scan;
771 LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
773 /* We offer two different methods for class number assignment: the
774 method suggested in SMPTE 314M Table 22, and an improved
775 method. The SMPTE method is very conservative; it assigns class
776 3 (i.e. severe quantization) to any block where the largest AC
777 component is greater than 36. FFmpeg's DV encoder tracks AC bit
778 consumption precisely, so there is no need to bias most blocks
779 towards strongly lossy compression. Instead, we assign class 2
780 to most blocks, and use class 3 only when strictly necessary
781 (for blocks whose largest AC component exceeds 255). */
783 #if 0 /* SMPTE spec method */
784 static const int classes[] = {12, 24, 36, 0xffff};
785 #else /* improved FFmpeg method */
786 static const int classes[] = {-1, -1, 255, 0xffff};
788 int max = classes[0];
791 assert((((int)blk) & 15) == 0);
793 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
794 bi->partial_bit_count = 0;
795 bi->partial_bit_buffer = 0;
798 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
799 s->get_pixels(blk, data, linesize);
800 s->fdct[bi->dct_mode](blk);
802 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
803 which is precisely what the spec calls for in the "dummy" blocks. */
804 memset(blk, 0, 64*sizeof(*blk));
809 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
810 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
812 for (area = 0; area < 4; area++) {
813 bi->prev[area] = prev;
814 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
815 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
816 int level = blk[zigzag_scan[i]];
818 if (level + 15 > 30U) {
819 bi->sign[i] = (level >> 31) & 1;
820 /* weight it and and shift down into range, adding for rounding */
821 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
822 AND the 2x doubling of the weights */
823 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
827 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
834 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
842 for (area = 0; area < 4; area++) {
843 bi->prev[area] = prev;
844 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
845 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
849 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
858 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
861 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
864 int i, j, k, a, prev, a2;
867 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
870 for (i = 0; i < 5; i++) {
876 for (j = 0; j < 6; j++, b++) {
877 for (a = 0; a < 4; a++) {
878 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
879 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
882 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
883 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
886 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
889 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
890 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
893 assert(b->mb[b->next[k]]);
894 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
895 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
896 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
899 b->next[prev] = b->next[k];
904 size[i] += b->bit_size[a];
907 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
910 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
913 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
915 size[0] = 5 * 6 * 4; //EOB
916 for (j = 0; j < 6 *5; j++, b++) {
918 for (k = b->next[prev]; k < 64; k = b->next[k]) {
919 if (b->mb[k] < a && b->mb[k] > -a){
920 b->next[prev] = b->next[k];
922 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
930 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
932 DVVideoContext *s = avctx->priv_data;
933 DVwork_chunk *work_chunk = arg;
935 int mb_x, mb_y, c_offset, linesize, y_stride;
938 LOCAL_ALIGNED_8(uint8_t, scratch, [64]);
939 EncBlockInfo enc_blks[5*DV_MAX_BPM];
940 PutBitContext pbs[5*DV_MAX_BPM];
942 EncBlockInfo* enc_blk;
944 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
945 int* qnosp = &qnos[0];
947 dif = &s->buf[work_chunk->buf_offset*80];
948 enc_blk = &enc_blks[0];
949 for (mb_index = 0; mb_index < 5; mb_index++) {
950 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
952 /* initializing luminance blocks */
953 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
954 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
955 (s->sys->height >= 720 && mb_y != 134)) {
956 y_stride = s->picture.linesize[0] << 3;
960 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
961 linesize = s->picture.linesize[0];
963 if (s->sys->video_stype == 4) { /* SD 422 */
965 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
966 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
967 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
968 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
971 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
972 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
973 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
974 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
978 /* initializing chrominance blocks */
979 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
980 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
981 for (j = 2; j; j--) {
982 uint8_t *c_ptr = s->picture.data[j] + c_offset;
983 linesize = s->picture.linesize[j];
984 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
985 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
987 uint8_t* b = scratch;
988 for (i = 0; i < 8; i++) {
989 d = c_ptr + (linesize << 3);
990 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
991 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
999 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
1000 if (s->sys->bpm == 8) {
1001 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
1006 if (vs_total_ac_bits < vs_bit_size)
1007 dv_guess_qnos(&enc_blks[0], qnosp);
1009 /* DIF encoding process */
1010 for (j=0; j<5*s->sys->bpm;) {
1016 /* First pass over individual cells only */
1017 for (i=0; i<s->sys->bpm; i++, j++) {
1018 int sz = s->sys->block_sizes[i]>>3;
1020 init_put_bits(&pbs[j], dif, sz);
1021 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
1022 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1023 put_bits(&pbs[j], 2, enc_blks[j].cno);
1025 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1029 /* Second pass over each MB space */
1030 pb = &pbs[start_mb];
1031 for (i=0; i<s->sys->bpm; i++) {
1032 if (enc_blks[start_mb+i].partial_bit_count)
1033 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1037 /* Third and final pass over the whole video segment space */
1039 for (j=0; j<5*s->sys->bpm; j++) {
1040 if (enc_blks[j].partial_bit_count)
1041 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1042 if (enc_blks[j].partial_bit_count)
1043 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
1046 for (j=0; j<5*s->sys->bpm; j++) {
1048 int size = pbs[j].size_in_bits >> 3;
1049 flush_put_bits(&pbs[j]);
1050 pos = put_bits_count(&pbs[j]) >> 3;
1052 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
1055 memset(pbs[j].buf + pos, 0xff, size - pos);
1061 #if CONFIG_DVVIDEO_DECODER
1062 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1063 144000 bytes for PAL - or twice those for 50Mbps) */
1064 static int dvvideo_decode_frame(AVCodecContext *avctx,
1065 void *data, int *data_size,
1068 const uint8_t *buf = avpkt->data;
1069 int buf_size = avpkt->size;
1070 DVVideoContext *s = avctx->priv_data;
1071 const uint8_t* vsc_pack;
1074 s->sys = avpriv_dv_frame_profile2(avctx, s->sys, buf, buf_size);
1075 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) {
1076 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
1077 return -1; /* NOTE: we only accept several full frames */
1080 if (s->picture.data[0])
1081 avctx->release_buffer(avctx, &s->picture);
1083 avcodec_get_frame_defaults(&s->picture);
1084 s->picture.reference = 0;
1085 s->picture.key_frame = 1;
1086 s->picture.pict_type = AV_PICTURE_TYPE_I;
1087 avctx->pix_fmt = s->sys->pix_fmt;
1088 avctx->time_base = s->sys->time_base;
1089 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1090 if (avctx->get_buffer(avctx, &s->picture) < 0) {
1091 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1094 s->picture.interlaced_frame = 1;
1095 s->picture.top_field_first = 0;
1098 avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1099 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1104 *data_size = sizeof(AVFrame);
1105 *(AVFrame*)data = s->picture;
1107 /* Determine the codec's sample_aspect ratio from the packet */
1108 vsc_pack = buf + 80*5 + 48 + 5;
1109 if ( *vsc_pack == dv_video_control ) {
1110 apt = buf[4] & 0x07;
1111 is16_9 = (vsc_pack[2] & 0x07) == 0x02 || (!apt && (vsc_pack[2] & 0x07) == 0x07);
1112 avctx->sample_aspect_ratio = s->sys->sar[is16_9];
1115 return s->sys->frame_size;
1117 #endif /* CONFIG_DVVIDEO_DECODER */
1120 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1124 * Here's what SMPTE314M says about these two:
1125 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1126 * as track application IDs (APTn = 001, AP1n =
1127 * 001, AP2n = 001, AP3n = 001), if the source signal
1128 * comes from a digital VCR. If the signal source is
1129 * unknown, all bits for these data shall be set to 1.
1130 * (page 12) STYPE: STYPE defines a signal type of video signal
1131 * 00000b = 4:1:1 compression
1132 * 00100b = 4:2:2 compression
1134 * Now, I've got two problems with these statements:
1135 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1136 * It seems that for PAL as defined in IEC 61834 we have to set
1137 * APT to 000 and for SMPTE314M to 001.
1138 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1139 * compression scheme (if any).
1141 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1144 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1147 buf[0] = (uint8_t)pack_id;
1149 case dv_header525: /* I can't imagine why these two weren't defined as real */
1150 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1151 buf[1] = 0xf8 | /* reserved -- always 1 */
1152 (apt & 0x07); /* APT: Track application ID */
1153 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1154 (0x0f << 3) | /* reserved -- always 1 */
1155 (apt & 0x07); /* AP1: Audio application ID */
1156 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1157 (0x0f << 3) | /* reserved -- always 1 */
1158 (apt & 0x07); /* AP2: Video application ID */
1159 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1160 (0x0f << 3) | /* reserved -- always 1 */
1161 (apt & 0x07); /* AP3: Subcode application ID */
1163 case dv_video_source:
1164 buf[1] = 0xff; /* reserved -- always 1 */
1165 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1166 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1167 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1168 0xf; /* reserved -- always 1 */
1169 buf[3] = (3 << 6) | /* reserved -- always 1 */
1170 (c->sys->dsf << 5) | /* system: 60fields/50fields */
1171 c->sys->video_stype; /* signal type video compression */
1172 buf[4] = 0xff; /* VISC: 0xff -- no information */
1174 case dv_video_control:
1175 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1176 0x3f; /* reserved -- always 1 */
1177 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1179 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1180 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1181 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1182 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1183 0xc; /* reserved -- always b1100 */
1184 buf[4] = 0xff; /* reserved -- always 1 */
1187 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1192 #if CONFIG_DVVIDEO_ENCODER
1193 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1197 for (chan = 0; chan < c->sys->n_difchan; chan++) {
1198 for (i = 0; i < c->sys->difseg_size; i++) {
1199 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1201 /* DV header: 1DIF */
1202 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1203 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1204 buf += 72; /* unused bytes */
1206 /* DV subcode: 2DIFs */
1207 for (j = 0; j < 2; j++) {
1208 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1209 for (k = 0; k < 6; k++)
1210 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1211 buf += 29; /* unused bytes */
1214 /* DV VAUX: 3DIFS */
1215 for (j = 0; j < 3; j++) {
1216 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1217 buf += dv_write_pack(dv_video_source, c, buf);
1218 buf += dv_write_pack(dv_video_control, c, buf);
1220 buf += dv_write_pack(dv_video_source, c, buf);
1221 buf += dv_write_pack(dv_video_control, c, buf);
1222 buf += 4*5 + 2; /* unused bytes */
1225 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1226 for (j = 0; j < 135; j++) {
1228 memset(buf, 0xff, 80);
1229 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1230 buf += 77; /* audio control & shuffled PCM audio */
1232 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1233 buf += 77; /* 1 video macroblock: 1 bytes control
1234 4 * 14 bytes Y 8x8 data
1235 10 bytes Cr 8x8 data
1236 10 bytes Cb 8x8 data */
1243 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1246 DVVideoContext *s = c->priv_data;
1248 s->sys = avpriv_dv_codec_profile(c);
1249 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1252 c->pix_fmt = s->sys->pix_fmt;
1253 s->picture = *((AVFrame *)data);
1254 s->picture.key_frame = 1;
1255 s->picture.pict_type = AV_PICTURE_TYPE_I;
1258 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1259 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1263 dv_format_frame(s, buf);
1265 return s->sys->frame_size;
1269 static int dvvideo_close(AVCodecContext *c)
1271 DVVideoContext *s = c->priv_data;
1273 if (s->picture.data[0])
1274 c->release_buffer(c, &s->picture);
1280 #if CONFIG_DVVIDEO_ENCODER
1281 AVCodec ff_dvvideo_encoder = {
1283 .type = AVMEDIA_TYPE_VIDEO,
1284 .id = CODEC_ID_DVVIDEO,
1285 .priv_data_size = sizeof(DVVideoContext),
1286 .init = dvvideo_init_encoder,
1287 .encode = dvvideo_encode_frame,
1288 .capabilities = CODEC_CAP_SLICE_THREADS,
1289 .pix_fmts = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1290 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1292 #endif // CONFIG_DVVIDEO_ENCODER
1294 #if CONFIG_DVVIDEO_DECODER
1295 AVCodec ff_dvvideo_decoder = {
1297 .type = AVMEDIA_TYPE_VIDEO,
1298 .id = CODEC_ID_DVVIDEO,
1299 .priv_data_size = sizeof(DVVideoContext),
1300 .init = dvvideo_init,
1301 .close = dvvideo_close,
1302 .decode = dvvideo_decode_frame,
1303 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
1305 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),