FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
dvdec.c
Go to the documentation of this file.
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  av_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  av_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  av_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  av_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  av_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  av_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 };
Generated on Sun Mar 8 2015 02:34:50 for FFmpeg by   doxygen 1.8.2