avidec: avoid infinite loop due to negative ast->sample_size
[ffmpeg.git] / libavcodec / dvdec.c
1 /*
2  * DV decoder
3  * Copyright (c) 2002 Fabrice Bellard
4  * Copyright (c) 2004 Roman Shaposhnik
5  *
6  * 50 Mbps (DVCPRO50) support
7  * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
8  *
9  * 100 Mbps (DVCPRO HD) support
10  * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)
11  * Final code by Roman Shaposhnik
12  *
13  * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
14  * of DV technical info.
15  *
16  * This file is part of FFmpeg.
17  *
18  * FFmpeg is free software; you can redistribute it and/or
19  * modify it under the terms of the GNU Lesser General Public
20  * License as published by the Free Software Foundation; either
21  * version 2.1 of the License, or (at your option) any later version.
22  *
23  * FFmpeg is distributed in the hope that it will be useful,
24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
26  * Lesser General Public License for more details.
27  *
28  * You should have received a copy of the GNU Lesser General Public
29  * License along with FFmpeg; if not, write to the Free Software
30  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31  */
32
33 /**
34  * @file
35  * DV decoder
36  */
37
38 #include "libavutil/avassert.h"
39 #include "libavutil/imgutils.h"
40 #include "libavutil/internal.h"
41 #include "libavutil/pixdesc.h"
42
43 #include "avcodec.h"
44 #include "dv.h"
45 #include "dv_profile_internal.h"
46 #include "dvdata.h"
47 #include "get_bits.h"
48 #include "idctdsp.h"
49 #include "internal.h"
50 #include "put_bits.h"
51 #include "simple_idct.h"
52
53 typedef struct BlockInfo {
54     const uint32_t *factor_table;
55     const uint8_t *scan_table;
56     uint8_t pos; /* position in block */
57     void (*idct_put)(uint8_t *dest, int line_size, int16_t *block);
58     uint8_t partial_bit_count;
59     uint32_t partial_bit_buffer;
60     int shift_offset;
61 } BlockInfo;
62
63 static const int dv_iweight_bits = 14;
64
65 static const uint16_t dv_iweight_88[64] = {
66     32768, 16705, 16705, 17734, 17032, 17734, 18205, 18081,
67     18081, 18205, 18725, 18562, 19195, 18562, 18725, 19266,
68     19091, 19705, 19705, 19091, 19266, 21407, 19643, 20267,
69     20228, 20267, 19643, 21407, 22725, 21826, 20853, 20806,
70     20806, 20853, 21826, 22725, 23170, 23170, 21407, 21400,
71     21407, 23170, 23170, 24598, 23786, 22018, 22018, 23786,
72     24598, 25251, 24465, 22654, 24465, 25251, 25972, 25172,
73     25172, 25972, 26722, 27969, 26722, 29692, 29692, 31521,
74 };
75 static const uint16_t dv_iweight_248[64] = {
76     32768, 16384, 16705, 16705, 17734, 17734, 17734, 17734,
77     18081, 18081, 18725, 18725, 21407, 21407, 19091, 19091,
78     19195, 19195, 18205, 18205, 18725, 18725, 19705, 19705,
79     20267, 20267, 21826, 21826, 23170, 23170, 20806, 20806,
80     20267, 20267, 19266, 19266, 21407, 21407, 20853, 20853,
81     21400, 21400, 23786, 23786, 24465, 24465, 22018, 22018,
82     23170, 23170, 22725, 22725, 24598, 24598, 24465, 24465,
83     25172, 25172, 27969, 27969, 25972, 25972, 29692, 29692
84 };
85
86 /**
87  * The "inverse" DV100 weights are actually just the spec weights (zig-zagged).
88  */
89 static const uint16_t dv_iweight_1080_y[64] = {
90     128,  16,  16,  17,  17,  17,  18,  18,
91      18,  18,  18,  18,  19,  18,  18,  19,
92      19,  19,  19,  19,  19,  42,  38,  40,
93      40,  40,  38,  42,  44,  43,  41,  41,
94      41,  41,  43,  44,  45,  45,  42,  42,
95      42,  45,  45,  48,  46,  43,  43,  46,
96      48,  49,  48,  44,  48,  49, 101,  98,
97      98, 101, 104, 109, 104, 116, 116, 123,
98 };
99 static const uint16_t dv_iweight_1080_c[64] = {
100     128,  16,  16,  17,  17,  17,  25,  25,
101      25,  25,  26,  25,  26,  25,  26,  26,
102      26,  27,  27,  26,  26,  42,  38,  40,
103      40,  40,  38,  42,  44,  43,  41,  41,
104      41,  41,  43,  44,  91,  91,  84,  84,
105      84,  91,  91,  96,  93,  86,  86,  93,
106      96, 197, 191, 177, 191, 197, 203, 197,
107     197, 203, 209, 219, 209, 232, 232, 246,
108 };
109 static const uint16_t dv_iweight_720_y[64] = {
110     128,  16,  16,  17,  17,  17,  18,  18,
111      18,  18,  18,  18,  19,  18,  18,  19,
112      19,  19,  19,  19,  19,  42,  38,  40,
113      40,  40,  38,  42,  44,  43,  41,  41,
114      41,  41,  43,  44,  68,  68,  63,  63,
115      63,  68,  68,  96,  92,  86,  86,  92,
116      96,  98,  96,  88,  96,  98, 202, 196,
117     196, 202, 208, 218, 208, 232, 232, 246,
118 };
119 static const uint16_t dv_iweight_720_c[64] = {
120     128,  24,  24,  26,  26,  26,  36,  36,
121      36,  36,  36,  36,  38,  36,  36,  38,
122      38,  38,  38,  38,  38,  84,  76,  80,
123      80,  80,  76,  84,  88,  86,  82,  82,
124      82,  82,  86,  88, 182, 182, 168, 168,
125     168, 182, 182, 192, 186, 192, 172, 186,
126     192, 394, 382, 354, 382, 394, 406, 394,
127     394, 406, 418, 438, 418, 464, 464, 492,
128 };
129
130 static void dv_init_weight_tables(DVVideoContext *ctx, const AVDVProfile *d)
131 {
132     int j, i, c, s;
133     uint32_t *factor1 = &ctx->idct_factor[0],
134              *factor2 = &ctx->idct_factor[DV_PROFILE_IS_HD(d) ? 4096 : 2816];
135
136     if (DV_PROFILE_IS_HD(d)) {
137         /* quantization quanta by QNO for DV100 */
138         static const uint8_t dv100_qstep[16] = {
139             1, /* QNO = 0 and 1 both have no quantization */
140             1,
141             2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
142         };
143         const uint16_t *iweight1, *iweight2;
144
145         if (d->height == 720) {
146             iweight1 = &dv_iweight_720_y[0];
147             iweight2 = &dv_iweight_720_c[0];
148         } else {
149             iweight1 = &dv_iweight_1080_y[0];
150             iweight2 = &dv_iweight_1080_c[0];
151         }
152         for (c = 0; c < 4; c++) {
153             for (s = 0; s < 16; s++) {
154                 for (i = 0; i < 64; i++) {
155                     *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
156                     *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
157                 }
158             }
159         }
160     } else {
161         static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
162         const uint16_t *iweight1 = &dv_iweight_88[0];
163         for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
164             for (s = 0; s < 22; s++) {
165                 for (i = c = 0; c < 4; c++) {
166                     for (; i < dv_quant_areas[c]; i++) {
167                         *factor1   = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
168                         *factor2++ = (*factor1++) << 1;
169                     }
170                 }
171             }
172         }
173     }
174 }
175
176 static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
177 {
178     DVVideoContext *s = avctx->priv_data;
179     IDCTDSPContext idsp;
180     int i;
181
182     memset(&idsp,0, sizeof(idsp));
183     ff_idctdsp_init(&idsp, avctx);
184
185     for (i = 0; i < 64; i++)
186         s->dv_zigzag[0][i] = idsp.idct_permutation[ff_zigzag_direct[i]];
187
188     if (avctx->lowres){
189         for (i = 0; i < 64; i++){
190             int j = ff_dv_zigzag248_direct[i];
191             s->dv_zigzag[1][i] = idsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
192         }
193     }else
194         memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
195
196     s->idct_put[0] = idsp.idct_put;
197     s->idct_put[1] = ff_simple_idct248_put;
198
199     return ff_dvvideo_init(avctx);
200 }
201
202 /* decode AC coefficients */
203 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
204 {
205     int last_index = gb->size_in_bits;
206     const uint8_t  *scan_table   = mb->scan_table;
207     const uint32_t *factor_table = mb->factor_table;
208     int pos                      = mb->pos;
209     int partial_bit_count        = mb->partial_bit_count;
210     int level, run, vlc_len, index;
211
212     OPEN_READER_NOSIZE(re, gb);
213     UPDATE_CACHE(re, gb);
214
215     /* if we must parse a partial VLC, we do it here */
216     if (partial_bit_count > 0) {
217         re_cache              = re_cache >> partial_bit_count |
218                                 mb->partial_bit_buffer;
219         re_index             -= partial_bit_count;
220         mb->partial_bit_count = 0;
221     }
222
223     /* get the AC coefficients until last_index is reached */
224     for (;;) {
225         ff_dlog(NULL, "%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16),
226                 re_index);
227         /* our own optimized GET_RL_VLC */
228         index   = NEG_USR32(re_cache, TEX_VLC_BITS);
229         vlc_len = ff_dv_rl_vlc[index].len;
230         if (vlc_len < 0) {
231             index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
232                     ff_dv_rl_vlc[index].level;
233             vlc_len = TEX_VLC_BITS - vlc_len;
234         }
235         level = ff_dv_rl_vlc[index].level;
236         run   = ff_dv_rl_vlc[index].run;
237
238         /* gotta check if we're still within gb boundaries */
239         if (re_index + vlc_len > last_index) {
240             /* should be < 16 bits otherwise a codeword could have been parsed */
241             mb->partial_bit_count  = last_index - re_index;
242             mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
243             re_index               = last_index;
244             break;
245         }
246         re_index += vlc_len;
247
248         ff_dlog(NULL, "run=%d level=%d\n", run, level);
249         pos += run;
250         if (pos >= 64)
251             break;
252
253         level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>
254                 dv_iweight_bits;
255         block[scan_table[pos]] = level;
256
257         UPDATE_CACHE(re, gb);
258     }
259     CLOSE_READER(re, gb);
260     mb->pos = pos;
261 }
262
263 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
264 {
265     int bits_left = get_bits_left(gb);
266     while (bits_left >= MIN_CACHE_BITS) {
267         put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
268         bits_left -= MIN_CACHE_BITS;
269     }
270     if (bits_left > 0)
271         put_bits(pb, bits_left, get_bits(gb, bits_left));
272 }
273
274 /* mb_x and mb_y are in units of 8 pixels */
275 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
276 {
277     DVVideoContext *s = avctx->priv_data;
278     DVwork_chunk *work_chunk = arg;
279     int quant, dc, dct_mode, class1, j;
280     int mb_index, mb_x, mb_y, last_index;
281     int y_stride, linesize;
282     int16_t *block, *block1;
283     int c_offset;
284     uint8_t *y_ptr;
285     const uint8_t *buf_ptr;
286     PutBitContext pb, vs_pb;
287     GetBitContext gb;
288     BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
289     LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);
290     LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80     + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
291     LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
292     const int log2_blocksize = 3-s->avctx->lowres;
293     int is_field_mode[5];
294
295     av_assert1((((int) mb_bit_buffer) & 7) == 0);
296     av_assert1((((int) vs_bit_buffer) & 7) == 0);
297
298     memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
299
300     /* pass 1: read DC and AC coefficients in blocks */
301     buf_ptr = &s->buf[work_chunk->buf_offset * 80];
302     block1  = &sblock[0][0];
303     mb1     = mb_data;
304     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
305     for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
306         /* skip header */
307         quant    = buf_ptr[3] & 0x0f;
308         buf_ptr += 4;
309         init_put_bits(&pb, mb_bit_buffer, 80);
310         mb    = mb1;
311         block = block1;
312         is_field_mode[mb_index] = 0;
313         for (j = 0; j < s->sys->bpm; j++) {
314             last_index = s->sys->block_sizes[j];
315             init_get_bits(&gb, buf_ptr, last_index);
316
317             /* get the DC */
318             dc       = get_sbits(&gb, 9);
319             dct_mode = get_bits1(&gb);
320             class1   = get_bits(&gb, 2);
321             if (DV_PROFILE_IS_HD(s->sys)) {
322                 mb->idct_put     = s->idct_put[0];
323                 mb->scan_table   = s->dv_zigzag[0];
324                 mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
325                                                    class1       * 16 * 64 +
326                                                    quant             * 64];
327                 is_field_mode[mb_index] |= !j && dct_mode;
328             } else {
329                 mb->idct_put     = s->idct_put[dct_mode && log2_blocksize == 3];
330                 mb->scan_table   = s->dv_zigzag[dct_mode];
331                 mb->factor_table =
332                     &s->idct_factor[(class1 == 3)               * 2 * 22 * 64 +
333                                     dct_mode                        * 22 * 64 +
334                                     (quant + ff_dv_quant_offset[class1]) * 64];
335             }
336             dc = dc << 2;
337             /* convert to unsigned because 128 is not added in the
338              * standard IDCT */
339             dc                   += 1024;
340             block[0]              = dc;
341             buf_ptr              += last_index >> 3;
342             mb->pos               = 0;
343             mb->partial_bit_count = 0;
344
345             ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
346             dv_decode_ac(&gb, mb, block);
347
348             /* write the remaining bits in a new buffer only if the
349              * block is finished */
350             if (mb->pos >= 64)
351                 bit_copy(&pb, &gb);
352
353             block += 64;
354             mb++;
355         }
356
357         /* pass 2: we can do it just after */
358         ff_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
359         block = block1;
360         mb    = mb1;
361         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
362         put_bits32(&pb, 0); // padding must be zeroed
363         flush_put_bits(&pb);
364         for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
365             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
366                 dv_decode_ac(&gb, mb, block);
367                 /* if still not finished, no need to parse other blocks */
368                 if (mb->pos < 64)
369                     break;
370             }
371         }
372         /* all blocks are finished, so the extra bytes can be used at
373          * the video segment level */
374         if (j >= s->sys->bpm)
375             bit_copy(&vs_pb, &gb);
376     }
377
378     /* we need a pass over the whole video segment */
379     ff_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
380     block = &sblock[0][0];
381     mb    = mb_data;
382     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
383     put_bits32(&vs_pb, 0); // padding must be zeroed
384     flush_put_bits(&vs_pb);
385     for (mb_index = 0; mb_index < 5; mb_index++) {
386         for (j = 0; j < s->sys->bpm; j++) {
387             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
388                 ff_dlog(avctx, "start %d:%d\n", mb_index, j);
389                 dv_decode_ac(&gb, mb, block);
390             }
391             if (mb->pos >= 64 && mb->pos < 127)
392                 av_log(avctx, AV_LOG_ERROR,
393                        "AC EOB marker is absent pos=%d\n", mb->pos);
394             block += 64;
395             mb++;
396         }
397     }
398
399     /* compute idct and place blocks */
400     block = &sblock[0][0];
401     mb    = mb_data;
402     for (mb_index = 0; mb_index < 5; mb_index++) {
403         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
404
405         /* idct_put'ting luminance */
406         if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P)                      ||
407             (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
408             (s->sys->height >= 720 && mb_y != 134)) {
409             y_stride = (s->frame->linesize[0] <<
410                         ((!is_field_mode[mb_index]) * log2_blocksize));
411         } else {
412             y_stride = (2 << log2_blocksize);
413         }
414         y_ptr    = s->frame->data[0] +
415                    ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
416         linesize = s->frame->linesize[0] << is_field_mode[mb_index];
417         mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
418         if (s->sys->video_stype == 4) { /* SD 422 */
419             mb[2].idct_put(y_ptr + (1 << log2_blocksize),            linesize, block + 2 * 64);
420         } else {
421             mb[1].idct_put(y_ptr + (1 << log2_blocksize),            linesize, block + 1 * 64);
422             mb[2].idct_put(y_ptr                         + y_stride, linesize, block + 2 * 64);
423             mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
424         }
425         mb    += 4;
426         block += 4 * 64;
427
428         /* idct_put'ting chrominance */
429         c_offset = (((mb_y >>  (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
430                      (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
431         for (j = 2; j; j--) {
432             uint8_t *c_ptr = s->frame->data[j] + c_offset;
433             if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
434                 uint64_t aligned_pixels[64 / 8];
435                 uint8_t *pixels = (uint8_t *) aligned_pixels;
436                 uint8_t *c_ptr1, *ptr1;
437                 int x, y;
438                 mb->idct_put(pixels, 8, block);
439                 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
440                     ptr1   = pixels + ((1 << (log2_blocksize))>>1);
441                     c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
442                     for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
443                         c_ptr[x]  = pixels[x];
444                         c_ptr1[x] = ptr1[x];
445                     }
446                 }
447                 block += 64;
448                 mb++;
449             } else {
450                 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
451                            s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
452                 linesize = s->frame->linesize[j] << is_field_mode[mb_index];
453                 (mb++)->idct_put(c_ptr, linesize, block);
454                 block += 64;
455                 if (s->sys->bpm == 8) {
456                     (mb++)->idct_put(c_ptr + y_stride, linesize, block);
457                     block += 64;
458                 }
459             }
460         }
461     }
462     return 0;
463 }
464
465 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
466  * 144000 bytes for PAL - or twice those for 50Mbps) */
467 static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
468                                 int *got_frame, AVPacket *avpkt)
469 {
470     uint8_t *buf = avpkt->data;
471     int buf_size = avpkt->size;
472     DVVideoContext *s = avctx->priv_data;
473     const uint8_t *vsc_pack;
474     int apt, is16_9, ret;
475     const AVDVProfile *sys;
476
477     sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
478     if (!sys || buf_size < sys->frame_size) {
479         av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
480         return -1; /* NOTE: we only accept several full frames */
481     }
482
483     if (sys != s->sys) {
484         ret = ff_dv_init_dynamic_tables(s, sys);
485         if (ret < 0) {
486             av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
487             return ret;
488         }
489         dv_init_weight_tables(s, sys);
490         s->sys = sys;
491     }
492
493     s->frame            = data;
494     s->frame->key_frame = 1;
495     s->frame->pict_type = AV_PICTURE_TYPE_I;
496     avctx->pix_fmt      = s->sys->pix_fmt;
497     avctx->framerate    = av_inv_q(s->sys->time_base);
498
499     ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
500     if (ret < 0)
501         return ret;
502
503     /* Determine the codec's sample_aspect ratio from the packet */
504     vsc_pack = buf + 80 * 5 + 48 + 5;
505     if (*vsc_pack == dv_video_control) {
506         apt    = buf[4] & 0x07;
507         is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
508                  (!apt && (vsc_pack[2] & 0x07) == 0x07);
509         ff_set_sar(avctx, s->sys->sar[is16_9]);
510     }
511
512     if ((ret = ff_get_buffer(avctx, s->frame, 0)) < 0)
513         return ret;
514     s->frame->interlaced_frame = 1;
515     s->frame->top_field_first  = 0;
516
517     /* Determine the codec's field order from the packet */
518     if ( *vsc_pack == dv_video_control ) {
519         s->frame->top_field_first = !(vsc_pack[3] & 0x40);
520     }
521
522     s->buf = buf;
523     avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
524                    dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
525
526     emms_c();
527
528     /* return image */
529     *got_frame = 1;
530
531     return s->sys->frame_size;
532 }
533
534 AVCodec ff_dvvideo_decoder = {
535     .name           = "dvvideo",
536     .long_name      = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
537     .type           = AVMEDIA_TYPE_VIDEO,
538     .id             = AV_CODEC_ID_DVVIDEO,
539     .priv_data_size = sizeof(DVVideoContext),
540     .init           = dvvideo_decode_init,
541     .decode         = dvvideo_decode_frame,
542     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
543     .max_lowres     = 3,
544 };