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"
47 #include "simple_idct.h"
50 #include "dv_tablegen.h"
55 typedef struct DVVideoContext {
58 AVCodecContext *avctx;
61 uint8_t dv_zigzag[2][64];
63 void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
64 void (*fdct[2])(DCTELEM *block);
65 void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
66 me_cmp_func ildct_cmp;
69 #define TEX_VLC_BITS 9
71 /* XXX: also include quantization */
72 static RL_VLC_ELEM dv_rl_vlc[1184];
74 static inline int dv_work_pool_size(const DVprofile *d)
76 int size = d->n_difchan*d->difseg_size*27;
77 if (DV_PROFILE_IS_1080i50(d))
79 if (DV_PROFILE_IS_720p50(d))
84 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
87 static const uint8_t off[] = { 2, 6, 8, 0, 4 };
88 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
89 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
90 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
92 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
93 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
95 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
100 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
101 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
104 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
105 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
106 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
107 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
108 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
109 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
110 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
111 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
112 {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
113 {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
114 {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
115 {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
116 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
121 for (m=0; m<5; m++) {
124 blk = (chan*11+seq)*27+slot;
126 if (chan == 0 && seq == 11) {
135 i = (4*chan + blk + off[m])%11;
138 x = shuf1[m] + (chan&1)*9 + k%9;
139 y = (i*3+k/9)*2 + (chan>>1) + 1;
141 tbl[m] = (x<<1)|(y<<9);
144 blk = (chan*10+seq)*27+slot;
146 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
149 x = shuf1[m]+(chan&1)*9 + k%9;
150 y = (i*3+k/9)*2 + (chan>>1) + 4;
153 x = remap[y][0]+((x-80)<<(y>59));
156 tbl[m] = (x<<1)|(y<<9);
159 blk = (chan*10+seq)*27+slot;
161 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
162 k = (blk/5)%27 + (i&1)*3;
164 x = shuf2[m] + k%6 + 6*(chan&1);
165 y = l_start[i] + k/6 + 45*(chan>>1);
166 tbl[m] = (x<<1)|(y<<9);
169 switch (d->pix_fmt) {
170 case PIX_FMT_YUV422P:
171 x = shuf3[m] + slot/3;
173 ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
174 tbl[m] = (x<<1)|(y<<8);
176 case PIX_FMT_YUV420P:
177 x = shuf3[m] + slot/3;
179 ((seq + off[m]) % d->difseg_size)*3;
180 tbl[m] = (x<<1)|(y<<9);
182 case PIX_FMT_YUV411P:
183 i = (seq + off[m]) % d->difseg_size;
184 k = slot + ((m==1||m==2)?3:0);
186 x = l_start_shuffled[m] + k/6;
187 y = serpent2[k] + i*6;
190 tbl[m] = (x<<2)|(y<<8);
199 static int dv_init_dynamic_tables(const DVprofile *d)
202 uint32_t *factor1, *factor2;
203 const int *iweight1, *iweight2;
205 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
207 for (c=0; c<d->n_difchan; c++) {
208 for (s=0; s<d->difseg_size; s++) {
210 for (j=0; j<27; j++) {
212 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
213 !(DV_PROFILE_IS_720p50(d) && s > 9)) {
214 dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
215 d->work_chunks[i++].buf_offset = p;
223 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
224 factor1 = &d->idct_factor[0];
225 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
226 if (d->height == 720) {
227 iweight1 = &dv_iweight_720_y[0];
228 iweight2 = &dv_iweight_720_c[0];
230 iweight1 = &dv_iweight_1080_y[0];
231 iweight2 = &dv_iweight_1080_c[0];
233 if (DV_PROFILE_IS_HD(d)) {
234 for (c = 0; c < 4; c++) {
235 for (s = 0; s < 16; s++) {
236 for (i = 0; i < 64; i++) {
237 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
238 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
243 iweight1 = &dv_iweight_88[0];
244 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
245 for (s = 0; s < 22; s++) {
246 for (i = c = 0; c < 4; c++) {
247 for (; i < dv_quant_areas[c]; i++) {
248 *factor1 = iweight1[i] << (dv_quant_shifts[s][c] + 1);
249 *factor2++ = (*factor1++) << 1;
260 static av_cold int dvvideo_init(AVCodecContext *avctx)
262 DVVideoContext *s = avctx->priv_data;
269 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
270 uint8_t new_dv_vlc_len[NB_DV_VLC*2];
271 uint8_t new_dv_vlc_run[NB_DV_VLC*2];
272 int16_t new_dv_vlc_level[NB_DV_VLC*2];
276 /* it's faster to include sign bit in a generic VLC parsing scheme */
277 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
278 new_dv_vlc_bits[j] = dv_vlc_bits[i];
279 new_dv_vlc_len[j] = dv_vlc_len[i];
280 new_dv_vlc_run[j] = dv_vlc_run[i];
281 new_dv_vlc_level[j] = dv_vlc_level[i];
283 if (dv_vlc_level[i]) {
284 new_dv_vlc_bits[j] <<= 1;
288 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
289 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
290 new_dv_vlc_run[j] = dv_vlc_run[i];
291 new_dv_vlc_level[j] = -dv_vlc_level[i];
295 /* NOTE: as a trick, we use the fact the no codes are unused
296 to accelerate the parsing of partial codes */
297 init_vlc(&dv_vlc, TEX_VLC_BITS, j,
298 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
299 assert(dv_vlc.table_size == 1184);
301 for (i = 0; i < dv_vlc.table_size; i++){
302 int code = dv_vlc.table[i][0];
303 int len = dv_vlc.table[i][1];
306 if (len < 0){ //more bits needed
310 run = new_dv_vlc_run [code] + 1;
311 level = new_dv_vlc_level[code];
313 dv_rl_vlc[i].len = len;
314 dv_rl_vlc[i].level = level;
315 dv_rl_vlc[i].run = run;
317 ff_free_vlc(&dv_vlc);
319 dv_vlc_map_tableinit();
322 /* Generic DSP setup */
323 ff_dsputil_init(&dsp, avctx);
324 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
325 s->get_pixels = dsp.get_pixels;
326 s->ildct_cmp = dsp.ildct_cmp[5];
329 s->fdct[0] = dsp.fdct;
330 s->idct_put[0] = dsp.idct_put;
331 for (i = 0; i < 64; i++)
332 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
335 s->fdct[1] = dsp.fdct248;
336 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP
338 for (i = 0; i < 64; i++){
339 int j = ff_zigzag248_direct[i];
340 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
343 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
345 avctx->coded_frame = &s->picture;
347 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
352 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
354 if (!avpriv_dv_codec_profile(avctx)) {
355 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video\n",
356 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
360 return dvvideo_init(avctx);
363 typedef struct BlockInfo {
364 const uint32_t *factor_table;
365 const uint8_t *scan_table;
366 uint8_t pos; /* position in block */
367 void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
368 uint8_t partial_bit_count;
369 uint32_t partial_bit_buffer;
373 /* bit budget for AC only in 5 MBs */
374 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
375 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
377 static inline int put_bits_left(PutBitContext* s)
379 return (s->buf_end - s->buf) * 8 - put_bits_count(s);
382 /* decode AC coefficients */
383 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
385 int last_index = gb->size_in_bits;
386 const uint8_t *scan_table = mb->scan_table;
387 const uint32_t *factor_table = mb->factor_table;
389 int partial_bit_count = mb->partial_bit_count;
390 int level, run, vlc_len, index;
393 UPDATE_CACHE(re, gb);
395 /* if we must parse a partial VLC, we do it here */
396 if (partial_bit_count > 0) {
397 re_cache = re_cache >> partial_bit_count | mb->partial_bit_buffer;
398 re_index -= partial_bit_count;
399 mb->partial_bit_count = 0;
402 /* get the AC coefficients until last_index is reached */
404 av_dlog(NULL, "%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16),
406 /* our own optimized GET_RL_VLC */
407 index = NEG_USR32(re_cache, TEX_VLC_BITS);
408 vlc_len = dv_rl_vlc[index].len;
410 index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
411 vlc_len = TEX_VLC_BITS - vlc_len;
413 level = dv_rl_vlc[index].level;
414 run = dv_rl_vlc[index].run;
416 /* gotta check if we're still within gb boundaries */
417 if (re_index + vlc_len > last_index) {
418 /* should be < 16 bits otherwise a codeword could have been parsed */
419 mb->partial_bit_count = last_index - re_index;
420 mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
421 re_index = last_index;
426 av_dlog(NULL, "run=%d level=%d\n", run, level);
431 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;
432 block[scan_table[pos]] = level;
434 UPDATE_CACHE(re, gb);
436 CLOSE_READER(re, gb);
440 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
442 int bits_left = get_bits_left(gb);
443 while (bits_left >= MIN_CACHE_BITS) {
444 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
445 bits_left -= MIN_CACHE_BITS;
448 put_bits(pb, bits_left, get_bits(gb, bits_left));
452 static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
454 *mb_x = work_chunk->mb_coordinates[m] & 0xff;
455 *mb_y = work_chunk->mb_coordinates[m] >> 8;
457 /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
458 if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
459 *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */
463 /* mb_x and mb_y are in units of 8 pixels */
464 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
466 DVVideoContext *s = avctx->priv_data;
467 DVwork_chunk *work_chunk = arg;
468 int quant, dc, dct_mode, class1, j;
469 int mb_index, mb_x, mb_y, last_index;
470 int y_stride, linesize;
471 DCTELEM *block, *block1;
474 const uint8_t *buf_ptr;
475 PutBitContext pb, vs_pb;
477 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
478 LOCAL_ALIGNED_16(DCTELEM, sblock, [5*DV_MAX_BPM], [64]);
479 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [ 80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
480 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [5*80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
481 const int log2_blocksize = 3-s->avctx->lowres;
482 int is_field_mode[5];
484 assert((((int)mb_bit_buffer) & 7) == 0);
485 assert((((int)vs_bit_buffer) & 7) == 0);
487 memset(sblock, 0, 5*DV_MAX_BPM*sizeof(*sblock));
489 /* pass 1: read DC and AC coefficients in blocks */
490 buf_ptr = &s->buf[work_chunk->buf_offset*80];
491 block1 = &sblock[0][0];
493 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
494 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
496 quant = buf_ptr[3] & 0x0f;
498 init_put_bits(&pb, mb_bit_buffer, 80);
501 is_field_mode[mb_index] = 0;
502 for (j = 0; j < s->sys->bpm; j++) {
503 last_index = s->sys->block_sizes[j];
504 init_get_bits(&gb, buf_ptr, last_index);
507 dc = get_sbits(&gb, 9);
508 dct_mode = get_bits1(&gb);
509 class1 = get_bits(&gb, 2);
510 if (DV_PROFILE_IS_HD(s->sys)) {
511 mb->idct_put = s->idct_put[0];
512 mb->scan_table = s->dv_zigzag[0];
513 mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64];
514 is_field_mode[mb_index] |= !j && dct_mode;
516 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
517 mb->scan_table = s->dv_zigzag[dct_mode];
518 mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 +
519 (quant + dv_quant_offset[class1])*64];
522 /* convert to unsigned because 128 is not added in the
526 buf_ptr += last_index >> 3;
528 mb->partial_bit_count = 0;
530 av_dlog(avctx, "MB block: %d, %d ", mb_index, j);
531 dv_decode_ac(&gb, mb, block);
533 /* write the remaining bits in a new buffer only if the
542 /* pass 2: we can do it just after */
543 av_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
546 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
547 put_bits32(&pb, 0); // padding must be zeroed
549 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
550 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
551 dv_decode_ac(&gb, mb, block);
552 /* if still not finished, no need to parse other blocks */
557 /* all blocks are finished, so the extra bytes can be used at
558 the video segment level */
559 if (j >= s->sys->bpm)
560 bit_copy(&vs_pb, &gb);
563 /* we need a pass over the whole video segment */
564 av_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
565 block = &sblock[0][0];
567 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
568 put_bits32(&vs_pb, 0); // padding must be zeroed
569 flush_put_bits(&vs_pb);
570 for (mb_index = 0; mb_index < 5; mb_index++) {
571 for (j = 0; j < s->sys->bpm; j++) {
573 av_dlog(avctx, "start %d:%d\n", mb_index, j);
574 dv_decode_ac(&gb, mb, block);
576 if (mb->pos >= 64 && mb->pos < 127)
577 av_log(avctx, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
583 /* compute idct and place blocks */
584 block = &sblock[0][0];
586 for (mb_index = 0; mb_index < 5; mb_index++) {
587 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
589 /* idct_put'ting luminance */
590 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
591 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
592 (s->sys->height >= 720 && mb_y != 134)) {
593 y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
595 y_stride = (2 << log2_blocksize);
597 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize);
598 linesize = s->picture.linesize[0] << is_field_mode[mb_index];
599 mb[0] .idct_put(y_ptr , linesize, block + 0*64);
600 if (s->sys->video_stype == 4) { /* SD 422 */
601 mb[2].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 2*64);
603 mb[1].idct_put(y_ptr + (1 << log2_blocksize) , linesize, block + 1*64);
604 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2*64);
605 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
610 /* idct_put'ting chrominance */
611 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
612 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
613 for (j = 2; j; j--) {
614 uint8_t *c_ptr = s->picture.data[j] + c_offset;
615 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
616 uint64_t aligned_pixels[64/8];
617 uint8_t *pixels = (uint8_t*)aligned_pixels;
618 uint8_t *c_ptr1, *ptr1;
620 mb->idct_put(pixels, 8, block);
621 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
622 ptr1 = pixels + (1 << (log2_blocksize - 1));
623 c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
624 for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
625 c_ptr[x] = pixels[x];
631 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
632 s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
633 linesize = s->picture.linesize[j] << is_field_mode[mb_index];
634 (mb++)-> idct_put(c_ptr , linesize, block); block += 64;
635 if (s->sys->bpm == 8) {
636 (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
645 /* Converts run and level (where level != 0) pair into VLC, returning bit size */
646 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
649 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
650 *vlc = dv_vlc_map[run][level].vlc | sign;
651 size = dv_vlc_map[run][level].size;
654 if (level < DV_VLC_MAP_LEV_SIZE) {
655 *vlc = dv_vlc_map[0][level].vlc | sign;
656 size = dv_vlc_map[0][level].size;
658 *vlc = 0xfe00 | (level << 1) | sign;
662 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
663 (0x1f80 | (run - 1))) << size;
664 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
671 static av_always_inline int dv_rl2vlc_size(int run, int level)
675 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
676 size = dv_vlc_map[run][level].size;
679 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
681 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
687 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
689 *vlc = dv_vlc_map[run][l].vlc | sign;
690 return dv_vlc_map[run][l].size;
693 static av_always_inline int dv_rl2vlc_size(int run, int l)
695 return dv_vlc_map[run][l].size;
699 typedef struct EncBlockInfo {
709 uint8_t partial_bit_count;
710 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
713 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
714 PutBitContext* pb_pool,
715 PutBitContext* pb_end)
718 PutBitContext* pb = pb_pool;
719 int size = bi->partial_bit_count;
720 uint32_t vlc = bi->partial_bit_buffer;
722 bi->partial_bit_count = bi->partial_bit_buffer = 0;
724 /* Find suitable storage space */
725 for (; size > (bits_left = put_bits_left(pb)); pb++) {
728 put_bits(pb, bits_left, vlc >> size);
729 vlc = vlc & ((1 << size) - 1);
731 if (pb + 1 >= pb_end) {
732 bi->partial_bit_count = size;
733 bi->partial_bit_buffer = vlc;
739 put_bits(pb, size, vlc);
741 if (bi->cur_ac >= 64)
744 /* Construct the next VLC */
746 bi->cur_ac = bi->next[prev];
747 if (bi->cur_ac < 64){
748 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
750 size = 4; vlc = 6; /* End Of Block stamp */
756 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
757 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
758 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
760 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
761 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
769 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
772 const uint8_t* zigzag_scan;
773 LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
775 /* We offer two different methods for class number assignment: the
776 method suggested in SMPTE 314M Table 22, and an improved
777 method. The SMPTE method is very conservative; it assigns class
778 3 (i.e. severe quantization) to any block where the largest AC
779 component is greater than 36. FFmpeg's DV encoder tracks AC bit
780 consumption precisely, so there is no need to bias most blocks
781 towards strongly lossy compression. Instead, we assign class 2
782 to most blocks, and use class 3 only when strictly necessary
783 (for blocks whose largest AC component exceeds 255). */
785 #if 0 /* SMPTE spec method */
786 static const int classes[] = {12, 24, 36, 0xffff};
787 #else /* improved FFmpeg method */
788 static const int classes[] = {-1, -1, 255, 0xffff};
790 int max = classes[0];
793 assert((((int)blk) & 15) == 0);
795 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
796 bi->partial_bit_count = 0;
797 bi->partial_bit_buffer = 0;
800 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
801 s->get_pixels(blk, data, linesize);
802 s->fdct[bi->dct_mode](blk);
804 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
805 which is precisely what the spec calls for in the "dummy" blocks. */
806 memset(blk, 0, 64*sizeof(*blk));
811 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
812 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
814 for (area = 0; area < 4; area++) {
815 bi->prev[area] = prev;
816 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
817 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
818 int level = blk[zigzag_scan[i]];
820 if (level + 15 > 30U) {
821 bi->sign[i] = (level >> 31) & 1;
822 /* weight it and and shift down into range, adding for rounding */
823 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
824 AND the 2x doubling of the weights */
825 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
829 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
836 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
844 for (area = 0; area < 4; area++) {
845 bi->prev[area] = prev;
846 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
847 for (; i < mb_area_start[area+1]; i = bi->next[i]) {
851 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
860 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
863 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
866 int i, j, k, a, prev, a2;
869 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
872 for (i = 0; i < 5; i++) {
878 for (j = 0; j < 6; j++, b++) {
879 for (a = 0; a < 4; a++) {
880 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
881 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
884 assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
885 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
888 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
891 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
892 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
895 assert(b->mb[b->next[k]]);
896 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
897 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
898 assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
901 b->next[prev] = b->next[k];
906 size[i] += b->bit_size[a];
909 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
912 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
915 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
917 size[0] = 5 * 6 * 4; //EOB
918 for (j = 0; j < 6 *5; j++, b++) {
920 for (k = b->next[prev]; k < 64; k = b->next[k]) {
921 if (b->mb[k] < a && b->mb[k] > -a){
922 b->next[prev] = b->next[k];
924 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
932 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
934 DVVideoContext *s = avctx->priv_data;
935 DVwork_chunk *work_chunk = arg;
937 int mb_x, mb_y, c_offset, linesize, y_stride;
940 LOCAL_ALIGNED_8(uint8_t, scratch, [64]);
941 EncBlockInfo enc_blks[5*DV_MAX_BPM];
942 PutBitContext pbs[5*DV_MAX_BPM];
944 EncBlockInfo* enc_blk;
946 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
947 int* qnosp = &qnos[0];
949 dif = &s->buf[work_chunk->buf_offset*80];
950 enc_blk = &enc_blks[0];
951 for (mb_index = 0; mb_index < 5; mb_index++) {
952 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
954 /* initializing luminance blocks */
955 if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
956 (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
957 (s->sys->height >= 720 && mb_y != 134)) {
958 y_stride = s->picture.linesize[0] << 3;
962 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
963 linesize = s->picture.linesize[0];
965 if (s->sys->video_stype == 4) { /* SD 422 */
967 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
968 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +
969 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +
970 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);
973 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +
974 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +
975 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +
976 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
980 /* initializing chrominance blocks */
981 c_offset = (((mb_y >> (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
982 (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
983 for (j = 2; j; j--) {
984 uint8_t *c_ptr = s->picture.data[j] + c_offset;
985 linesize = s->picture.linesize[j];
986 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
987 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
989 uint8_t* b = scratch;
990 for (i = 0; i < 8; i++) {
991 d = c_ptr + (linesize << 3);
992 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
993 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
1001 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);
1002 if (s->sys->bpm == 8) {
1003 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
1008 if (vs_total_ac_bits < vs_bit_size)
1009 dv_guess_qnos(&enc_blks[0], qnosp);
1011 /* DIF encoding process */
1012 for (j=0; j<5*s->sys->bpm;) {
1018 /* First pass over individual cells only */
1019 for (i=0; i<s->sys->bpm; i++, j++) {
1020 int sz = s->sys->block_sizes[i]>>3;
1022 init_put_bits(&pbs[j], dif, sz);
1023 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
1024 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1025 put_bits(&pbs[j], 2, enc_blks[j].cno);
1027 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1031 /* Second pass over each MB space */
1032 pb = &pbs[start_mb];
1033 for (i=0; i<s->sys->bpm; i++) {
1034 if (enc_blks[start_mb+i].partial_bit_count)
1035 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1039 /* Third and final pass over the whole video segment space */
1041 for (j=0; j<5*s->sys->bpm; j++) {
1042 if (enc_blks[j].partial_bit_count)
1043 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1044 if (enc_blks[j].partial_bit_count)
1045 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
1048 for (j=0; j<5*s->sys->bpm; j++) {
1050 int size = pbs[j].size_in_bits >> 3;
1051 flush_put_bits(&pbs[j]);
1052 pos = put_bits_count(&pbs[j]) >> 3;
1054 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
1057 memset(pbs[j].buf + pos, 0xff, size - pos);
1063 #if CONFIG_DVVIDEO_DECODER
1064 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1065 144000 bytes for PAL - or twice those for 50Mbps) */
1066 static int dvvideo_decode_frame(AVCodecContext *avctx,
1067 void *data, int *data_size,
1070 const uint8_t *buf = avpkt->data;
1071 int buf_size = avpkt->size;
1072 DVVideoContext *s = avctx->priv_data;
1073 const uint8_t* vsc_pack;
1076 s->sys = avpriv_dv_frame_profile2(avctx, s->sys, buf, buf_size);
1077 if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) {
1078 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
1079 return -1; /* NOTE: we only accept several full frames */
1082 if (s->picture.data[0])
1083 avctx->release_buffer(avctx, &s->picture);
1085 avcodec_get_frame_defaults(&s->picture);
1086 s->picture.reference = 0;
1087 s->picture.key_frame = 1;
1088 s->picture.pict_type = AV_PICTURE_TYPE_I;
1089 avctx->pix_fmt = s->sys->pix_fmt;
1090 avctx->time_base = s->sys->time_base;
1091 avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1092 if (avctx->get_buffer(avctx, &s->picture) < 0) {
1093 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1096 s->picture.interlaced_frame = 1;
1097 s->picture.top_field_first = 0;
1100 avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1101 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1106 *data_size = sizeof(AVFrame);
1107 *(AVFrame*)data = s->picture;
1109 /* Determine the codec's sample_aspect ratio from the packet */
1110 vsc_pack = buf + 80*5 + 48 + 5;
1111 if ( *vsc_pack == dv_video_control ) {
1112 apt = buf[4] & 0x07;
1113 is16_9 = (vsc_pack[2] & 0x07) == 0x02 || (!apt && (vsc_pack[2] & 0x07) == 0x07);
1114 avctx->sample_aspect_ratio = s->sys->sar[is16_9];
1117 return s->sys->frame_size;
1119 #endif /* CONFIG_DVVIDEO_DECODER */
1122 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1126 * Here's what SMPTE314M says about these two:
1127 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1128 * as track application IDs (APTn = 001, AP1n =
1129 * 001, AP2n = 001, AP3n = 001), if the source signal
1130 * comes from a digital VCR. If the signal source is
1131 * unknown, all bits for these data shall be set to 1.
1132 * (page 12) STYPE: STYPE defines a signal type of video signal
1133 * 00000b = 4:1:1 compression
1134 * 00100b = 4:2:2 compression
1136 * Now, I've got two problems with these statements:
1137 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1138 * It seems that for PAL as defined in IEC 61834 we have to set
1139 * APT to 000 and for SMPTE314M to 001.
1140 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1141 * compression scheme (if any).
1143 int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1146 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1149 buf[0] = (uint8_t)pack_id;
1151 case dv_header525: /* I can't imagine why these two weren't defined as real */
1152 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1153 buf[1] = 0xf8 | /* reserved -- always 1 */
1154 (apt & 0x07); /* APT: Track application ID */
1155 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1156 (0x0f << 3) | /* reserved -- always 1 */
1157 (apt & 0x07); /* AP1: Audio application ID */
1158 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1159 (0x0f << 3) | /* reserved -- always 1 */
1160 (apt & 0x07); /* AP2: Video application ID */
1161 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1162 (0x0f << 3) | /* reserved -- always 1 */
1163 (apt & 0x07); /* AP3: Subcode application ID */
1165 case dv_video_source:
1166 buf[1] = 0xff; /* reserved -- always 1 */
1167 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1168 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1169 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1170 0xf; /* reserved -- always 1 */
1171 buf[3] = (3 << 6) | /* reserved -- always 1 */
1172 (c->sys->dsf << 5) | /* system: 60fields/50fields */
1173 c->sys->video_stype; /* signal type video compression */
1174 buf[4] = 0xff; /* VISC: 0xff -- no information */
1176 case dv_video_control:
1177 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1178 0x3f; /* reserved -- always 1 */
1179 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1181 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1182 (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1183 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1184 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1185 0xc; /* reserved -- always b1100 */
1186 buf[4] = 0xff; /* reserved -- always 1 */
1189 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1194 #if CONFIG_DVVIDEO_ENCODER
1195 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
1196 uint8_t seq_num, uint8_t dif_num,
1199 buf[0] = (uint8_t)t; /* Section type */
1200 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
1201 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
1202 7; /* reserved -- always 1 */
1203 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
1208 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)
1210 if (syb_num == 0 || syb_num == 6) {
1211 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1212 (0 << 4) | /* AP3 (Subcode application ID) */
1213 0x0f; /* reserved -- always 1 */
1215 else if (syb_num == 11) {
1216 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1217 0x7f; /* reserved -- always 1 */
1220 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1221 (0 << 4) | /* APT (Track application ID) */
1222 0x0f; /* reserved -- always 1 */
1224 buf[1] = 0xf0 | /* reserved -- always 1 */
1225 (syb_num & 0x0f); /* SSYB number 0 - 11 */
1226 buf[2] = 0xff; /* reserved -- always 1 */
1230 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1234 for (chan = 0; chan < c->sys->n_difchan; chan++) {
1235 for (i = 0; i < c->sys->difseg_size; i++) {
1236 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1238 /* DV header: 1DIF */
1239 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1240 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1241 buf += 72; /* unused bytes */
1243 /* DV subcode: 2DIFs */
1244 for (j = 0; j < 2; j++) {
1245 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1246 for (k = 0; k < 6; k++)
1247 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1248 buf += 29; /* unused bytes */
1251 /* DV VAUX: 3DIFS */
1252 for (j = 0; j < 3; j++) {
1253 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1254 buf += dv_write_pack(dv_video_source, c, buf);
1255 buf += dv_write_pack(dv_video_control, c, buf);
1257 buf += dv_write_pack(dv_video_source, c, buf);
1258 buf += dv_write_pack(dv_video_control, c, buf);
1259 buf += 4*5 + 2; /* unused bytes */
1262 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1263 for (j = 0; j < 135; j++) {
1265 memset(buf, 0xff, 80);
1266 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1267 buf += 77; /* audio control & shuffled PCM audio */
1269 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1270 buf += 77; /* 1 video macroblock: 1 bytes control
1271 4 * 14 bytes Y 8x8 data
1272 10 bytes Cr 8x8 data
1273 10 bytes Cb 8x8 data */
1280 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
1281 const AVFrame *frame, int *got_packet)
1283 DVVideoContext *s = c->priv_data;
1286 s->sys = avpriv_dv_codec_profile(c);
1287 if (!s->sys || dv_init_dynamic_tables(s->sys))
1289 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)
1292 c->pix_fmt = s->sys->pix_fmt;
1293 s->picture = *frame;
1294 s->picture.key_frame = 1;
1295 s->picture.pict_type = AV_PICTURE_TYPE_I;
1298 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1299 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1303 dv_format_frame(s, pkt->data);
1305 pkt->flags |= AV_PKT_FLAG_KEY;
1312 static int dvvideo_close(AVCodecContext *c)
1314 DVVideoContext *s = c->priv_data;
1316 if (s->picture.data[0])
1317 c->release_buffer(c, &s->picture);
1323 #if CONFIG_DVVIDEO_ENCODER
1324 AVCodec ff_dvvideo_encoder = {
1326 .type = AVMEDIA_TYPE_VIDEO,
1327 .id = CODEC_ID_DVVIDEO,
1328 .priv_data_size = sizeof(DVVideoContext),
1329 .init = dvvideo_init_encoder,
1330 .encode2 = dvvideo_encode_frame,
1331 .capabilities = CODEC_CAP_SLICE_THREADS,
1332 .pix_fmts = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1333 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1335 #endif // CONFIG_DVVIDEO_ENCODER
1337 #if CONFIG_DVVIDEO_DECODER
1338 AVCodec ff_dvvideo_decoder = {
1340 .type = AVMEDIA_TYPE_VIDEO,
1341 .id = CODEC_ID_DVVIDEO,
1342 .priv_data_size = sizeof(DVVideoContext),
1343 .init = dvvideo_init,
1344 .close = dvvideo_close,
1345 .decode = dvvideo_decode_frame,
1346 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
1348 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),