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;
56  uint8_t pos; /* position in block */
57  void (*idct_put)(uint8_t *dest, int line_size, 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;
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) +
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 << 2;
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  const uint8_t *vsc_pack;
503  int apt, is16_9, ret;
504  const AVDVProfile *sys;
505 
506  sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
507  if (!sys || buf_size < sys->frame_size) {
508  av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
509  return -1; /* NOTE: we only accept several full frames */
510  }
511 
512  if (sys != s->sys) {
513  ret = ff_dv_init_dynamic_tables(s, sys);
514  if (ret < 0) {
515  av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
516  return ret;
517  }
518  dv_init_weight_tables(s, sys);
519  s->sys = sys;
520  }
521 
522  s->frame = data;
523  s->frame->key_frame = 1;
525  avctx->pix_fmt = s->sys->pix_fmt;
526  avctx->framerate = av_inv_q(s->sys->time_base);
527 
528  ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
529  if (ret < 0)
530  return ret;
531 
532  /* Determine the codec's sample_aspect ratio from the packet */
533  vsc_pack = buf + 80 * 5 + 48 + 5;
534  if (*vsc_pack == dv_video_control) {
535  apt = buf[4] & 0x07;
536  is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
537  (!apt && (vsc_pack[2] & 0x07) == 0x07);
538  ff_set_sar(avctx, s->sys->sar[is16_9]);
539  }
540 
541  if ((ret = ff_get_buffer(avctx, s->frame, 0)) < 0)
542  return ret;
543  s->frame->interlaced_frame = 1;
544  s->frame->top_field_first = 0;
545 
546  /* Determine the codec's field order from the packet */
547  if ( *vsc_pack == dv_video_control ) {
548  s->frame->top_field_first = !(vsc_pack[3] & 0x40);
549  }
550 
551  s->buf = buf;
552  avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
553  dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
554 
555  emms_c();
556 
557  /* return image */
558  *got_frame = 1;
559 
560  return s->sys->frame_size;
561 }
562 
564  .name = "dvvideo",
565  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
566  .type = AVMEDIA_TYPE_VIDEO,
567  .id = AV_CODEC_ID_DVVIDEO,
568  .priv_data_size = sizeof(DVVideoContext),
572  .max_lowres = 3,
573 };
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:202
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:3303
AVFrame * frame
Definition: dv.h:42
const char * s
Definition: avisynth_c.h:631
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
uint32_t idct_factor[2 *4 *16 *64]
Definition: dv.h:53
misc image utilities
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:167
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:260
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:216
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int size
Definition: avcodec.h:1423
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1721
uint8_t run
Definition: svq3.c:149
const uint8_t ff_dv_quant_offset[4]
Definition: dvdata.c:70
void(* idct_put)(uint8_t *dest, int line_size, int16_t *block)
Definition: dvdec.c:57
AVCodec.
Definition: avcodec.h:3473
static const uint16_t dv_iweight_88[64]
Definition: dvdec.c:65
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:245
uint8_t * buf
Definition: dv.h:44
AVCodecContext * avctx
Definition: dv.h:43
static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
Definition: dvdec.c:176
if()
Definition: avfilter.c:975
uint8_t
#define av_cold
Definition: attributes.h:74
#define mb
void(* idct_put[2])(uint8_t *dest, int line_size, int16_t *block)
Definition: dv.h:50
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
void ff_simple_idct248_put(uint8_t *dest, int line_size, int16_t *block)
Definition: simple_idct.c:92
uint8_t * data
Definition: avcodec.h:1422
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:231
bitstream reader API header.
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:367
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:3014
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:588
DVwork_chunk work_chunks[4 *12 *27]
Definition: dv.h:52
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:173
#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:175
int error_concealment
error concealment flags
Definition: avcodec.h:2831
static int dv_work_pool_size(const AVDVProfile *d)
Definition: dv.h:101
AVCodec ff_dvvideo_decoder
Definition: dvdec.c:563
int frame_size
Definition: dv_profile.h:42
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:3480
static void dv_init_weight_tables(DVVideoContext *ctx, const AVDVProfile *d)
Definition: dvdec.c:130
#define CLOSE_READER(name, gb)
Definition: get_bits.h:144
#define FFMAX(a, b)
Definition: common.h:64
Libavcodec external API header.
int8_t len
Definition: get_bits.h:71
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:242
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
float y
#define DV_MAX_BPM
maximum number of blocks per macroblock in any DV format
Definition: dv.h:91
ret
Definition: avfilter.c:974
#define NEG_USR32(a, s)
Definition: mathops.h:175
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
int size_in_bits
Definition: get_bits.h:57
#define DV_PROFILE_IS_HD(p)
Definition: dv.h:79
uint32_t partial_bit_buffer
Definition: dvdec.c:59
RL_VLC_ELEM ff_dv_rl_vlc[1664]
Definition: dv.c:53
float u
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:94
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:206
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:923
void(* idct_put)(uint8_t *dest, int line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
Definition: idctdsp.h:70
static void idct_put(FourXContext *f, int x, int y)
Definition: 4xm.c:550
static int dvvideo_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: dvdec.c:496
int frame_size
Definition: mxfenc.c:1803
const uint32_t * factor_table
Definition: dvdec.c:54
#define ff_dlog(ctx,...)
Definition: internal.h:54
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:199
uint8_t pos
Definition: dvdec.c:56
main external API structure.
Definition: avcodec.h:1501
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:1040
void * buf
Definition: avisynth_c.h:553
uint8_t dv_zigzag[2][64]
Definition: dv.h:46
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:304
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:410
av_cold int ff_dvvideo_init(AVCodecContext *avctx)
Definition: dv.c:199
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:117
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
const uint8_t * quant
#define MIN_CACHE_BITS
Definition: get_bits.h:125
static int16_t block1[64]
Definition: dct-test.c:111
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:133
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
uint8_t level
Definition: svq3.c:150
uint8_t run
Definition: get_bits.h:72
static const uint16_t dv_iweight_248[64]
Definition: dvdec.c:75
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:522
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:63
const uint8_t ff_dv_quant_shifts[22][4]
Definition: dvdata.c:45
#define OPEN_READER_NOSIZE(name, gb)
Definition: get_bits.h:128
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:93
static double c[64]
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:70
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:176
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:635
void * priv_data
Definition: avcodec.h:1543
float re
Definition: fft-test.c:73
int pixels
Definition: avisynth_c.h:298
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:3074
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:241
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:372
static void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
Definition: dv.h:111
simple idct header.
const AVDVProfile * sys
Definition: dv.h:41
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:237
int16_t level
Definition: get_bits.h:70
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;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);returnNULL;}returnac;}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;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->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);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
#define LOCAL_ALIGNED_16(t, v,...)
Definition: internal.h:120
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
Definition: dvdec.c:203
This structure stores compressed data.
Definition: avcodec.h:1399
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:856
static const int dv_iweight_bits
Definition: dvdec.c:63
bitstream writer API
static int16_t block[64]
Definition: dct-test.c:110