FFmpeg  4.0
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;
56  uint8_t pos; /* position in block */
57  void (*idct_put)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
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 
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 
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;
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;
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=%04"PRIx32" index=%u\n",
226  pos, SHOW_UBITS(re, gb, 16), 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) +
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))) >>
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) {
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 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
291  LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
292  const int log2_blocksize = 3-s->avctx->lowres;
293  int is_field_mode[5];
294  int vs_bit_buffer_damaged = 0;
295  int mb_bit_buffer_damaged[5] = {0};
296  int retried = 0;
297  int sta;
298 
299  av_assert1((((int) mb_bit_buffer) & 7) == 0);
300  av_assert1((((int) vs_bit_buffer) & 7) == 0);
301 
302 retry:
303 
304  memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
305 
306  /* pass 1: read DC and AC coefficients in blocks */
307  buf_ptr = &s->buf[work_chunk->buf_offset * 80];
308  block1 = &sblock[0][0];
309  mb1 = mb_data;
310  init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
311  for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
312  /* skip header */
313  quant = buf_ptr[3] & 0x0f;
314  if (avctx->error_concealment) {
315  if ((buf_ptr[3] >> 4) == 0x0E)
316  vs_bit_buffer_damaged = 1;
317  if (!mb_index) {
318  sta = buf_ptr[3] >> 4;
319  } else if (sta != (buf_ptr[3] >> 4))
320  vs_bit_buffer_damaged = 1;
321  }
322  buf_ptr += 4;
323  init_put_bits(&pb, mb_bit_buffer, 80);
324  mb = mb1;
325  block = block1;
326  is_field_mode[mb_index] = 0;
327  for (j = 0; j < s->sys->bpm; j++) {
328  last_index = s->sys->block_sizes[j];
329  init_get_bits(&gb, buf_ptr, last_index);
330 
331  /* get the DC */
332  dc = get_sbits(&gb, 9);
333  dct_mode = get_bits1(&gb);
334  class1 = get_bits(&gb, 2);
335  if (DV_PROFILE_IS_HD(s->sys)) {
336  mb->idct_put = s->idct_put[0];
337  mb->scan_table = s->dv_zigzag[0];
338  mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
339  class1 * 16 * 64 +
340  quant * 64];
341  is_field_mode[mb_index] |= !j && dct_mode;
342  } else {
343  mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
344  mb->scan_table = s->dv_zigzag[dct_mode];
345  mb->factor_table =
346  &s->idct_factor[(class1 == 3) * 2 * 22 * 64 +
347  dct_mode * 22 * 64 +
348  (quant + ff_dv_quant_offset[class1]) * 64];
349  }
350  dc = dc * 4;
351  /* convert to unsigned because 128 is not added in the
352  * standard IDCT */
353  dc += 1024;
354  block[0] = dc;
355  buf_ptr += last_index >> 3;
356  mb->pos = 0;
357  mb->partial_bit_count = 0;
358 
359  ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
360  dv_decode_ac(&gb, mb, block);
361 
362  /* write the remaining bits in a new buffer only if the
363  * block is finished */
364  if (mb->pos >= 64)
365  bit_copy(&pb, &gb);
366  if (mb->pos >= 64 && mb->pos < 127)
367  vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
368 
369  block += 64;
370  mb++;
371  }
372 
373  if (mb_bit_buffer_damaged[mb_index] > 0)
374  continue;
375 
376  /* pass 2: we can do it just after */
377  ff_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
378  block = block1;
379  mb = mb1;
380  init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
381  put_bits32(&pb, 0); // padding must be zeroed
382  flush_put_bits(&pb);
383  for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
384  if (mb->pos < 64 && get_bits_left(&gb) > 0) {
385  dv_decode_ac(&gb, mb, block);
386  /* if still not finished, no need to parse other blocks */
387  if (mb->pos < 64)
388  break;
389  if (mb->pos < 127)
390  vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
391  }
392  }
393  /* all blocks are finished, so the extra bytes can be used at
394  * the video segment level */
395  if (j >= s->sys->bpm)
396  bit_copy(&vs_pb, &gb);
397  }
398 
399  /* we need a pass over the whole video segment */
400  ff_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
401  block = &sblock[0][0];
402  mb = mb_data;
403  init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
404  put_bits32(&vs_pb, 0); // padding must be zeroed
405  flush_put_bits(&vs_pb);
406  for (mb_index = 0; mb_index < 5; mb_index++) {
407  for (j = 0; j < s->sys->bpm; j++) {
408  if (mb->pos < 64 && get_bits_left(&gb) > 0 && !vs_bit_buffer_damaged) {
409  ff_dlog(avctx, "start %d:%d\n", mb_index, j);
410  dv_decode_ac(&gb, mb, block);
411  }
412 
413  if (mb->pos >= 64 && mb->pos < 127) {
414  av_log(avctx, AV_LOG_ERROR,
415  "AC EOB marker is absent pos=%d\n", mb->pos);
416  vs_bit_buffer_damaged = 1;
417  }
418  block += 64;
419  mb++;
420  }
421  }
422  if (vs_bit_buffer_damaged && !retried) {
423  av_log(avctx, AV_LOG_ERROR, "Concealing bitstream errors\n");
424  retried = 1;
425  goto retry;
426  }
427 
428  /* compute idct and place blocks */
429  block = &sblock[0][0];
430  mb = mb_data;
431  for (mb_index = 0; mb_index < 5; mb_index++) {
432  dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
433 
434  /* idct_put'ting luminance */
435  if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
436  (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
437  (s->sys->height >= 720 && mb_y != 134)) {
438  y_stride = (s->frame->linesize[0] <<
439  ((!is_field_mode[mb_index]) * log2_blocksize));
440  } else {
441  y_stride = (2 << log2_blocksize);
442  }
443  y_ptr = s->frame->data[0] +
444  ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
445  linesize = s->frame->linesize[0] << is_field_mode[mb_index];
446  mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
447  if (s->sys->video_stype == 4) { /* SD 422 */
448  mb[2].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 2 * 64);
449  } else {
450  mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);
451  mb[2].idct_put(y_ptr + y_stride, linesize, block + 2 * 64);
452  mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
453  }
454  mb += 4;
455  block += 4 * 64;
456 
457  /* idct_put'ting chrominance */
458  c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
459  (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
460  for (j = 2; j; j--) {
461  uint8_t *c_ptr = s->frame->data[j] + c_offset;
462  if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
463  uint64_t aligned_pixels[64 / 8];
464  uint8_t *pixels = (uint8_t *) aligned_pixels;
465  uint8_t *c_ptr1, *ptr1;
466  int x, y;
467  mb->idct_put(pixels, 8, block);
468  for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
469  ptr1 = pixels + ((1 << (log2_blocksize))>>1);
470  c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
471  for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
472  c_ptr[x] = pixels[x];
473  c_ptr1[x] = ptr1[x];
474  }
475  }
476  block += 64;
477  mb++;
478  } else {
479  y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
480  s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
481  linesize = s->frame->linesize[j] << is_field_mode[mb_index];
482  (mb++)->idct_put(c_ptr, linesize, block);
483  block += 64;
484  if (s->sys->bpm == 8) {
485  (mb++)->idct_put(c_ptr + y_stride, linesize, block);
486  block += 64;
487  }
488  }
489  }
490  }
491  return 0;
492 }
493 
494 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
495  * 144000 bytes for PAL - or twice those for 50Mbps) */
496 static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
497  int *got_frame, AVPacket *avpkt)
498 {
499  uint8_t *buf = avpkt->data;
500  int buf_size = avpkt->size;
501  DVVideoContext *s = avctx->priv_data;
502  AVFrame *frame = data;
503  const uint8_t *vsc_pack;
504  int apt, is16_9, ret;
505  const AVDVProfile *sys;
506 
507  sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
508  if (!sys || buf_size < sys->frame_size) {
509  av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
510  return -1; /* NOTE: we only accept several full frames */
511  }
512 
513  if (sys != s->sys) {
514  ret = ff_dv_init_dynamic_tables(s, sys);
515  if (ret < 0) {
516  av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
517  return ret;
518  }
519  dv_init_weight_tables(s, sys);
520  s->sys = sys;
521  }
522 
523  s->frame = frame;
524  frame->key_frame = 1;
525  frame->pict_type = AV_PICTURE_TYPE_I;
526  avctx->pix_fmt = s->sys->pix_fmt;
527  avctx->framerate = av_inv_q(s->sys->time_base);
528 
529  ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
530  if (ret < 0)
531  return ret;
532 
533  /* Determine the codec's sample_aspect ratio from the packet */
534  vsc_pack = buf + 80 * 5 + 48 + 5;
535  if (*vsc_pack == dv_video_control) {
536  apt = buf[4] & 0x07;
537  is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
538  (!apt && (vsc_pack[2] & 0x07) == 0x07);
539  ff_set_sar(avctx, s->sys->sar[is16_9]);
540  }
541 
542  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
543  return ret;
544  frame->interlaced_frame = 1;
545  frame->top_field_first = 0;
546 
547  /* Determine the codec's field order from the packet */
548  if ( *vsc_pack == dv_video_control ) {
549  frame->top_field_first = !(vsc_pack[3] & 0x40);
550  }
551 
552  s->buf = buf;
553  avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
554  dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
555 
556  emms_c();
557 
558  /* return image */
559  *got_frame = 1;
560 
561  return s->sys->frame_size;
562 }
563 
565  .name = "dvvideo",
566  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
567  .type = AVMEDIA_TYPE_VIDEO,
568  .id = AV_CODEC_ID_DVVIDEO,
569  .priv_data_size = sizeof(DVVideoContext),
573  .max_lowres = 3,
574 };
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:250
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:3040
const char * s
Definition: avisynth_c.h:768
This structure describes decoded (raw) audio or video data.
Definition: frame.h:218
uint32_t idct_factor[2 *4 *16 *64]
Definition: dv.h:54
float re
Definition: fft.c:82
misc image utilities
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:207
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:269
const uint8_t * block_sizes
Definition: dv_profile.h:52
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:104
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int size
Definition: avcodec.h:1431
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1727
uint8_t run
Definition: svq3.c:206
const uint8_t ff_dv_quant_offset[4]
Definition: dvdata.c:70
int stride
Definition: mace.c:144
AVCodec.
Definition: avcodec.h:3408
static const uint16_t dv_iweight_88[64]
Definition: dvdec.c:65
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:254
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
uint8_t * buf
Definition: dv.h:45
static int16_t block[64]
Definition: dct.c:115
AVCodecContext * avctx
Definition: dv.h:44
static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
Definition: dvdec.c:176
uint8_t
#define av_cold
Definition: attributes.h:82
#define mb
const uint8_t ff_dv_zigzag248_direct[64]
Definition: dvdata.c:33
const AVDVProfile * ff_dv_frame_profile(AVCodecContext *codec, const AVDVProfile *sys, const uint8_t *frame, unsigned buf_size)
Get a DV profile for the provided compressed frame.
Definition: dv_profile.c:260
#define emms_c()
Definition: internal.h:55
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:344
static AVFrame * frame
const char data[16]
Definition: mxf.c:90
uint8_t * data
Definition: avcodec.h:1430
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
Definition: utils.c:119
#define ff_dlog(a,...)
bitstream reader API header.
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:365
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:2749
enum AVPixelFormat pix_fmt
Definition: dv_profile.h:50
AVRational time_base
Definition: dv_profile.h:45
#define av_log(a,...)
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:596
DVwork_chunk work_chunks[4 *12 *27]
Definition: dv.h:53
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:161
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static void bit_copy(PutBitContext *pb, GetBitContext *gb)
Definition: dvdec.c:263
static const uint16_t dv_iweight_720_y[64]
Definition: dvdec.c:109
int shift_offset
Definition: dvdec.c:60
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
int error_concealment
error concealment flags
Definition: avcodec.h:2588
static int dv_work_pool_size(const AVDVProfile *d)
Definition: dv.h:104
AVCodec ff_dvvideo_decoder
Definition: dvdec.c:564
int frame_size
Definition: dv_profile.h:42
const AVFrame * frame
Definition: dv.h:43
const char * arg
Definition: jacosubdec.c:66
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: avcodec.h:3415
static void dv_init_weight_tables(DVVideoContext *ctx, const AVDVProfile *d)
Definition: dvdec.c:130
#define CLOSE_READER(name, gb)
Definition: get_bits.h:132
#define FFMAX(a, b)
Definition: common.h:94
int8_t len
Definition: vlc.h:34
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
common internal API header
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:301
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define DV_MAX_BPM
maximum number of blocks per macroblock in any DV format
Definition: dv.h:94
#define NEG_USR32(a, s)
Definition: mathops.h:166
int size_in_bits
Definition: get_bits.h:59
AVFormatContext * ctx
Definition: movenc.c:48
#define DV_PROFILE_IS_HD(p)
Definition: dv.h:82
uint32_t partial_bit_buffer
Definition: dvdec.c:59
RL_VLC_ELEM ff_dv_rl_vlc[1664]
Definition: dv.c:52
static const uint16_t dv_iweight_1080_y[64]
The "inverse" DV100 weights are actually just the spec weights (zig-zagged).
Definition: dvdec.c:89
const uint8_t * scan_table
Definition: dvdec.c:55
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:96
void(* idct_put)(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
Definition: idctdsp.h:72
if(ret< 0)
Definition: vf_mcdeint.c:279
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:194
static const uint16_t dv_iweight_720_c[64]
Definition: dvdec.c:119
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1019
static int dvvideo_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: dvdec.c:496
int frame_size
Definition: mxfenc.c:1947
Libavcodec external API header.
const uint32_t * factor_table
Definition: dvdec.c:54
typedef void(RENAME(mix_any_func_type))
static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
Definition: dvdec.c:275
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:249
uint8_t pos
Definition: dvdec.c:56
main external API structure.
Definition: avcodec.h:1518
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1891
void * buf
Definition: avisynth_c.h:690
uint8_t dv_zigzag[2][64]
Definition: dv.h:47
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:321
AVRational sar[2]
Definition: dv_profile.h:49
int index
Definition: gxfenc.c:89
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:433
av_cold int ff_dvvideo_init(AVCodecContext *avctx)
Definition: dv.c:198
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
int video_stype
Definition: dv_profile.h:41
uint8_t partial_bit_count
Definition: dvdec.c:58
static const uint16_t dv_iweight_1080_c[64]
Definition: dvdec.c:99
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> dc
const uint8_t * quant
#define MIN_CACHE_BITS
Definition: get_bits.h:113
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:232
uint8_t level
Definition: svq3.c:207
uint8_t run
Definition: vlc.h:35
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
static const uint16_t dv_iweight_248[64]
Definition: dvdec.c:75
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:62
const uint8_t ff_dv_quant_shifts[22][4]
Definition: dvdata.c:45
#define OPEN_READER_NOSIZE(name, gb)
Definition: get_bits.h:116
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
#define TEX_VLC_BITS
Definition: dv.h:96
void ff_simple_idct248_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
Definition: simple_idct.c:106
static double c[64]
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:69
Constants for DV codec.
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
int ff_dv_init_dynamic_tables(DVVideoContext *ctx, const AVDVProfile *d)
Definition: dv.c:175
uint16_t buf_offset
Definition: dv.h:36
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:773
void * priv_data
Definition: avcodec.h:1545
int pixels
Definition: avisynth_c.h:429
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:370
static void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
Definition: dv.h:114
simple idct header.
const AVDVProfile * sys
Definition: dv.h:42
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:296
int16_t level
Definition: vlc.h:33
static int16_t block1[64]
Definition: dct.c:116
void(* idct_put)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: dvdec.c:57
#define LOCAL_ALIGNED_16(t, v,...)
Definition: internal.h:131
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
Definition: dvdec.c:203
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:2809
This structure stores compressed data.
Definition: avcodec.h:1407
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:959
void(* idct_put[2])(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: dv.h:51
static const int dv_iweight_bits
Definition: dvdec.c:63
bitstream writer API