FFmpeg
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/mem_internal.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/thread.h"
44 
45 #include "avcodec.h"
46 #include "dv.h"
47 #include "dv_profile_internal.h"
48 #include "dvdata.h"
49 #include "get_bits.h"
50 #include "internal.h"
51 #include "put_bits.h"
52 #include "simple_idct.h"
53 #include "thread.h"
54 
55 typedef struct BlockInfo {
56  const uint32_t *factor_table;
57  const uint8_t *scan_table;
58  uint8_t pos; /* position in block */
59  void (*idct_put)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
63 } BlockInfo;
64 
65 static const int dv_iweight_bits = 14;
66 
67 static const uint16_t dv_iweight_88[64] = {
68  32768, 16705, 16705, 17734, 17032, 17734, 18205, 18081,
69  18081, 18205, 18725, 18562, 19195, 18562, 18725, 19266,
70  19091, 19705, 19705, 19091, 19266, 21407, 19643, 20267,
71  20228, 20267, 19643, 21407, 22725, 21826, 20853, 20806,
72  20806, 20853, 21826, 22725, 23170, 23170, 21407, 21400,
73  21407, 23170, 23170, 24598, 23786, 22018, 22018, 23786,
74  24598, 25251, 24465, 22654, 24465, 25251, 25972, 25172,
75  25172, 25972, 26722, 27969, 26722, 29692, 29692, 31521,
76 };
77 static const uint16_t dv_iweight_248[64] = {
78  32768, 16384, 16705, 16705, 17734, 17734, 17734, 17734,
79  18081, 18081, 18725, 18725, 21407, 21407, 19091, 19091,
80  19195, 19195, 18205, 18205, 18725, 18725, 19705, 19705,
81  20267, 20267, 21826, 21826, 23170, 23170, 20806, 20806,
82  20267, 20267, 19266, 19266, 21407, 21407, 20853, 20853,
83  21400, 21400, 23786, 23786, 24465, 24465, 22018, 22018,
84  23170, 23170, 22725, 22725, 24598, 24598, 24465, 24465,
85  25172, 25172, 27969, 27969, 25972, 25972, 29692, 29692
86 };
87 
88 /**
89  * The "inverse" DV100 weights are actually just the spec weights (zig-zagged).
90  */
91 static const uint16_t dv_iweight_1080_y[64] = {
92  128, 16, 16, 17, 17, 17, 18, 18,
93  18, 18, 18, 18, 19, 18, 18, 19,
94  19, 19, 19, 19, 19, 42, 38, 40,
95  40, 40, 38, 42, 44, 43, 41, 41,
96  41, 41, 43, 44, 45, 45, 42, 42,
97  42, 45, 45, 48, 46, 43, 43, 46,
98  48, 49, 48, 44, 48, 49, 101, 98,
99  98, 101, 104, 109, 104, 116, 116, 123,
100 };
101 static const uint16_t dv_iweight_1080_c[64] = {
102  128, 16, 16, 17, 17, 17, 25, 25,
103  25, 25, 26, 25, 26, 25, 26, 26,
104  26, 27, 27, 26, 26, 42, 38, 40,
105  40, 40, 38, 42, 44, 43, 41, 41,
106  41, 41, 43, 44, 91, 91, 84, 84,
107  84, 91, 91, 96, 93, 86, 86, 93,
108  96, 197, 191, 177, 191, 197, 203, 197,
109  197, 203, 209, 219, 209, 232, 232, 246,
110 };
111 static const uint16_t dv_iweight_720_y[64] = {
112  128, 16, 16, 17, 17, 17, 18, 18,
113  18, 18, 18, 18, 19, 18, 18, 19,
114  19, 19, 19, 19, 19, 42, 38, 40,
115  40, 40, 38, 42, 44, 43, 41, 41,
116  41, 41, 43, 44, 68, 68, 63, 63,
117  63, 68, 68, 96, 92, 86, 86, 92,
118  96, 98, 96, 88, 96, 98, 202, 196,
119  196, 202, 208, 218, 208, 232, 232, 246,
120 };
121 static const uint16_t dv_iweight_720_c[64] = {
122  128, 24, 24, 26, 26, 26, 36, 36,
123  36, 36, 36, 36, 38, 36, 36, 38,
124  38, 38, 38, 38, 38, 84, 76, 80,
125  80, 80, 76, 84, 88, 86, 82, 82,
126  82, 82, 86, 88, 182, 182, 168, 168,
127  168, 182, 182, 192, 186, 192, 172, 186,
128  192, 394, 382, 354, 382, 394, 406, 394,
129  394, 406, 418, 438, 418, 464, 464, 492,
130 };
131 
132 #define TEX_VLC_BITS 10
133 
134 /* XXX: also include quantization */
135 static RL_VLC_ELEM dv_rl_vlc[1664];
136 
137 static void dv_init_static(void)
138 {
140  VLC dv_vlc = { .table = vlc_buf, .table_allocated = FF_ARRAY_ELEMS(vlc_buf) };
141  uint16_t new_dv_vlc_bits[NB_DV_VLC * 2];
142  uint8_t new_dv_vlc_len[NB_DV_VLC * 2];
143  uint8_t new_dv_vlc_run[NB_DV_VLC * 2];
144  int16_t new_dv_vlc_level[NB_DV_VLC * 2];
145  int i, j;
146 
147  /* it's faster to include sign bit in a generic VLC parsing scheme */
148  for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
149  new_dv_vlc_bits[j] = ff_dv_vlc_bits[i];
150  new_dv_vlc_len[j] = ff_dv_vlc_len[i];
151  new_dv_vlc_run[j] = ff_dv_vlc_run[i];
152  new_dv_vlc_level[j] = ff_dv_vlc_level[i];
153 
154  if (ff_dv_vlc_level[i]) {
155  new_dv_vlc_bits[j] <<= 1;
156  new_dv_vlc_len[j]++;
157 
158  j++;
159  new_dv_vlc_bits[j] = (ff_dv_vlc_bits[i] << 1) | 1;
160  new_dv_vlc_len[j] = ff_dv_vlc_len[i] + 1;
161  new_dv_vlc_run[j] = ff_dv_vlc_run[i];
162  new_dv_vlc_level[j] = -ff_dv_vlc_level[i];
163  }
164  }
165 
166  /* NOTE: as a trick, we use the fact the no codes are unused
167  * to accelerate the parsing of partial codes */
168  init_vlc(&dv_vlc, TEX_VLC_BITS, j, new_dv_vlc_len,
169  1, 1, new_dv_vlc_bits, 2, 2, INIT_VLC_USE_NEW_STATIC);
170  av_assert1(dv_vlc.table_size == 1664);
171 
172  for (int i = 0; i < dv_vlc.table_size; i++) {
173  int code = dv_vlc.table[i][0];
174  int len = dv_vlc.table[i][1];
175  int level, run;
176 
177  if (len < 0) { // more bits needed
178  run = 0;
179  level = code;
180  } else {
181  run = new_dv_vlc_run[code] + 1;
182  level = new_dv_vlc_level[code];
183  }
184  dv_rl_vlc[i].len = len;
185  dv_rl_vlc[i].level = level;
186  dv_rl_vlc[i].run = run;
187  }
188 }
189 
191 {
192  int j, i, c, s;
193  uint32_t *factor1 = &ctx->idct_factor[0],
194  *factor2 = &ctx->idct_factor[DV_PROFILE_IS_HD(d) ? 4096 : 2816];
195 
196  if (DV_PROFILE_IS_HD(d)) {
197  /* quantization quanta by QNO for DV100 */
198  static const uint8_t dv100_qstep[16] = {
199  1, /* QNO = 0 and 1 both have no quantization */
200  1,
201  2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
202  };
203  const uint16_t *iweight1, *iweight2;
204 
205  if (d->height == 720) {
206  iweight1 = &dv_iweight_720_y[0];
207  iweight2 = &dv_iweight_720_c[0];
208  } else {
209  iweight1 = &dv_iweight_1080_y[0];
210  iweight2 = &dv_iweight_1080_c[0];
211  }
212  for (c = 0; c < 4; c++) {
213  for (s = 0; s < 16; s++) {
214  for (i = 0; i < 64; i++) {
215  *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
216  *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
217  }
218  }
219  }
220  } else {
221  static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
222  const uint16_t *iweight1 = &dv_iweight_88[0];
223  for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
224  for (s = 0; s < 22; s++) {
225  for (i = c = 0; c < 4; c++) {
226  for (; i < dv_quant_areas[c]; i++) {
227  *factor1 = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
228  *factor2++ = (*factor1++) << 1;
229  }
230  }
231  }
232  }
233  }
234 }
235 
237 {
238  static AVOnce init_static_once = AV_ONCE_INIT;
239  DVVideoContext *s = avctx->priv_data;
240  int i;
241 
242  ff_idctdsp_init(&s->idsp, avctx);
243 
244  for (i = 0; i < 64; i++)
245  s->dv_zigzag[0][i] = s->idsp.idct_permutation[ff_zigzag_direct[i]];
246 
247  if (avctx->lowres){
248  for (i = 0; i < 64; i++){
249  int j = ff_dv_zigzag248_direct[i];
250  s->dv_zigzag[1][i] = s->idsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
251  }
252  }else
253  memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
254 
255  s->idct_put[0] = s->idsp.idct_put;
256  s->idct_put[1] = ff_simple_idct248_put;
257 
258  ff_thread_once(&init_static_once, dv_init_static);
259 
260  return ff_dvvideo_init(avctx);
261 }
262 
263 /* decode AC coefficients */
264 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
265 {
266  int last_index = gb->size_in_bits;
267  const uint8_t *scan_table = mb->scan_table;
268  const uint32_t *factor_table = mb->factor_table;
269  int pos = mb->pos;
270  int partial_bit_count = mb->partial_bit_count;
271  int level, run, vlc_len, index;
272 
273  OPEN_READER_NOSIZE(re, gb);
274  UPDATE_CACHE(re, gb);
275 
276  /* if we must parse a partial VLC, we do it here */
277  if (partial_bit_count > 0) {
278  re_cache = re_cache >> partial_bit_count |
279  mb->partial_bit_buffer;
280  re_index -= partial_bit_count;
281  mb->partial_bit_count = 0;
282  }
283 
284  /* get the AC coefficients until last_index is reached */
285  for (;;) {
286  ff_dlog(NULL, "%2d: bits=%04"PRIx32" index=%u\n",
287  pos, SHOW_UBITS(re, gb, 16), re_index);
288  /* our own optimized GET_RL_VLC */
289  index = NEG_USR32(re_cache, TEX_VLC_BITS);
290  vlc_len = dv_rl_vlc[index].len;
291  if (vlc_len < 0) {
292  index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
294  vlc_len = TEX_VLC_BITS - vlc_len;
295  }
297  run = dv_rl_vlc[index].run;
298 
299  /* gotta check if we're still within gb boundaries */
300  if (re_index + vlc_len > last_index) {
301  /* should be < 16 bits otherwise a codeword could have been parsed */
302  mb->partial_bit_count = last_index - re_index;
303  mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
304  re_index = last_index;
305  break;
306  }
307  re_index += vlc_len;
308 
309  ff_dlog(NULL, "run=%d level=%d\n", run, level);
310  pos += run;
311  if (pos >= 64)
312  break;
313 
314  level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>
316  block[scan_table[pos]] = level;
317 
318  UPDATE_CACHE(re, gb);
319  }
320  CLOSE_READER(re, gb);
321  mb->pos = pos;
322 }
323 
324 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
325 {
326  int bits_left = get_bits_left(gb);
327  while (bits_left >= MIN_CACHE_BITS) {
329  bits_left -= MIN_CACHE_BITS;
330  }
331  if (bits_left > 0)
332  put_bits(pb, bits_left, get_bits(gb, bits_left));
333 }
334 
335 static av_always_inline void put_block_8x4(int16_t *block, uint8_t *av_restrict p, int stride)
336 {
337  int i, j;
338 
339  for (i = 0; i < 4; i++) {
340  for (j = 0; j < 8; j++)
341  p[j] = av_clip_uint8(block[j]);
342  block += 8;
343  p += stride;
344  }
345 }
346 
348  int stride, int16_t *blocks)
349 {
350  s->idsp.idct(blocks + 0*64);
351  s->idsp.idct(blocks + 1*64);
352 
353  put_block_8x4(blocks+0*64, data, stride<<1);
354  put_block_8x4(blocks+0*64 + 4*8, data + 8, stride<<1);
355  put_block_8x4(blocks+1*64, data + stride, stride<<1);
356  put_block_8x4(blocks+1*64 + 4*8, data + 8 + stride, stride<<1);
357 }
358 
360  int stride, int16_t *blocks)
361 {
362  s->idsp.idct(blocks + 0*64);
363  s->idsp.idct(blocks + 1*64);
364  s->idsp.idct(blocks + 2*64);
365  s->idsp.idct(blocks + 3*64);
366 
367  put_block_8x4(blocks+0*64, data, stride<<1);
368  put_block_8x4(blocks+0*64 + 4*8, data + 16, stride<<1);
369  put_block_8x4(blocks+1*64, data + 8, stride<<1);
370  put_block_8x4(blocks+1*64 + 4*8, data + 24, stride<<1);
371  put_block_8x4(blocks+2*64, data + stride, stride<<1);
372  put_block_8x4(blocks+2*64 + 4*8, data + 16 + stride, stride<<1);
373  put_block_8x4(blocks+3*64, data + 8 + stride, stride<<1);
374  put_block_8x4(blocks+3*64 + 4*8, data + 24 + stride, stride<<1);
375 }
376 
377 /* mb_x and mb_y are in units of 8 pixels */
378 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
379 {
380  DVVideoContext *s = avctx->priv_data;
381  DVwork_chunk *work_chunk = arg;
382  int quant, dc, dct_mode, class1, j;
383  int mb_index, mb_x, mb_y, last_index;
384  int y_stride, linesize;
385  int16_t *block, *block1;
386  int c_offset;
387  uint8_t *y_ptr;
388  const uint8_t *buf_ptr;
389  PutBitContext pb, vs_pb;
390  GetBitContext gb;
391  BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
392  LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);
393  LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
394  LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
395  const int log2_blocksize = 3-s->avctx->lowres;
396  int is_field_mode[5];
397  int vs_bit_buffer_damaged = 0;
398  int mb_bit_buffer_damaged[5] = {0};
399  int retried = 0;
400  int sta;
401 
402  av_assert1((((int) mb_bit_buffer) & 7) == 0);
403  av_assert1((((int) vs_bit_buffer) & 7) == 0);
404 
405 retry:
406 
407  memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
408 
409  /* pass 1: read DC and AC coefficients in blocks */
410  buf_ptr = &s->buf[work_chunk->buf_offset * 80];
411  block1 = &sblock[0][0];
412  mb1 = mb_data;
413  init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
414  for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
415  /* skip header */
416  quant = buf_ptr[3] & 0x0f;
417  if (avctx->error_concealment) {
418  if ((buf_ptr[3] >> 4) == 0x0E)
419  vs_bit_buffer_damaged = 1;
420  if (!mb_index) {
421  sta = buf_ptr[3] >> 4;
422  } else if (sta != (buf_ptr[3] >> 4))
423  vs_bit_buffer_damaged = 1;
424  }
425  buf_ptr += 4;
426  init_put_bits(&pb, mb_bit_buffer, 80);
427  mb = mb1;
428  block = block1;
429  is_field_mode[mb_index] = 0;
430  for (j = 0; j < s->sys->bpm; j++) {
431  last_index = s->sys->block_sizes[j];
432  init_get_bits(&gb, buf_ptr, last_index);
433 
434  /* get the DC */
435  dc = get_sbits(&gb, 9);
436  dct_mode = get_bits1(&gb);
437  class1 = get_bits(&gb, 2);
438  if (DV_PROFILE_IS_HD(s->sys)) {
439  mb->idct_put = s->idct_put[0];
440  mb->scan_table = s->dv_zigzag[0];
441  mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
442  class1 * 16 * 64 +
443  quant * 64];
444  is_field_mode[mb_index] |= !j && dct_mode;
445  } else {
446  mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
447  mb->scan_table = s->dv_zigzag[dct_mode];
448  mb->factor_table =
449  &s->idct_factor[(class1 == 3) * 2 * 22 * 64 +
450  dct_mode * 22 * 64 +
451  (quant + ff_dv_quant_offset[class1]) * 64];
452  }
453  dc = dc * 4;
454  /* convert to unsigned because 128 is not added in the
455  * standard IDCT */
456  dc += 1024;
457  block[0] = dc;
458  buf_ptr += last_index >> 3;
459  mb->pos = 0;
460  mb->partial_bit_count = 0;
461 
462  ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
463  dv_decode_ac(&gb, mb, block);
464 
465  /* write the remaining bits in a new buffer only if the
466  * block is finished */
467  if (mb->pos >= 64)
468  bit_copy(&pb, &gb);
469  if (mb->pos >= 64 && mb->pos < 127)
470  vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
471 
472  block += 64;
473  mb++;
474  }
475 
476  if (mb_bit_buffer_damaged[mb_index] > 0)
477  continue;
478 
479  /* pass 2: we can do it just after */
480  ff_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
481  block = block1;
482  mb = mb1;
483  init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
484  put_bits32(&pb, 0); // padding must be zeroed
485  flush_put_bits(&pb);
486  for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
487  if (mb->pos < 64 && get_bits_left(&gb) > 0) {
488  dv_decode_ac(&gb, mb, block);
489  /* if still not finished, no need to parse other blocks */
490  if (mb->pos < 64)
491  break;
492  if (mb->pos < 127)
493  vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
494  }
495  }
496  /* all blocks are finished, so the extra bytes can be used at
497  * the video segment level */
498  if (j >= s->sys->bpm)
499  bit_copy(&vs_pb, &gb);
500  }
501 
502  /* we need a pass over the whole video segment */
503  ff_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
504  block = &sblock[0][0];
505  mb = mb_data;
506  init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
507  put_bits32(&vs_pb, 0); // padding must be zeroed
508  flush_put_bits(&vs_pb);
509  for (mb_index = 0; mb_index < 5; mb_index++) {
510  for (j = 0; j < s->sys->bpm; j++) {
511  if (mb->pos < 64 && get_bits_left(&gb) > 0 && !vs_bit_buffer_damaged) {
512  ff_dlog(avctx, "start %d:%d\n", mb_index, j);
513  dv_decode_ac(&gb, mb, block);
514  }
515 
516  if (mb->pos >= 64 && mb->pos < 127) {
517  av_log(avctx, AV_LOG_ERROR,
518  "AC EOB marker is absent pos=%d\n", mb->pos);
519  vs_bit_buffer_damaged = 1;
520  }
521  block += 64;
522  mb++;
523  }
524  }
525  if (vs_bit_buffer_damaged && !retried) {
526  av_log(avctx, AV_LOG_ERROR, "Concealing bitstream errors\n");
527  retried = 1;
528  goto retry;
529  }
530 
531  /* compute idct and place blocks */
532  block = &sblock[0][0];
533  mb = mb_data;
534  for (mb_index = 0; mb_index < 5; mb_index++) {
535  dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
536 
537  /* idct_put'ting luminance */
538  if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
539  (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
540  (s->sys->height >= 720 && mb_y != 134)) {
541  y_stride = (s->frame->linesize[0] <<
542  ((!is_field_mode[mb_index]) * log2_blocksize));
543  } else {
544  y_stride = (2 << log2_blocksize);
545  }
546  y_ptr = s->frame->data[0] +
547  ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
548  if (mb_y == 134 && is_field_mode[mb_index]) {
549  dv100_idct_put_last_row_field_luma(s, y_ptr, s->frame->linesize[0], block);
550  } else {
551  linesize = s->frame->linesize[0] << is_field_mode[mb_index];
552  mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
553  if (s->sys->video_stype == 4) { /* SD 422 */
554  mb[2].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 2 * 64);
555  } else {
556  mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);
557  mb[2].idct_put(y_ptr + y_stride, linesize, block + 2 * 64);
558  mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
559  }
560  }
561  mb += 4;
562  block += 4 * 64;
563 
564  /* idct_put'ting chrominance */
565  c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
566  (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
567  for (j = 2; j; j--) {
568  uint8_t *c_ptr = s->frame->data[j] + c_offset;
569  if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
570  uint64_t aligned_pixels[64 / 8];
571  uint8_t *pixels = (uint8_t *) aligned_pixels;
572  uint8_t *c_ptr1, *ptr1;
573  int x, y;
574  mb->idct_put(pixels, 8, block);
575  for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
576  ptr1 = pixels + ((1 << (log2_blocksize))>>1);
577  c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
578  for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
579  c_ptr[x] = pixels[x];
580  c_ptr1[x] = ptr1[x];
581  }
582  }
583  block += 64;
584  mb++;
585  } else {
586  y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
587  s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
588  if (mb_y == 134 && is_field_mode[mb_index]) {
589  dv100_idct_put_last_row_field_chroma(s, c_ptr, s->frame->linesize[j], block);
590  mb += 2;
591  block += 2*64;
592  } else {
593  linesize = s->frame->linesize[j] << is_field_mode[mb_index];
594  (mb++)->idct_put(c_ptr, linesize, block);
595  block += 64;
596  if (s->sys->bpm == 8) {
597  (mb++)->idct_put(c_ptr + y_stride, linesize, block);
598  block += 64;
599  }
600  }
601  }
602  }
603  }
604  return 0;
605 }
606 
607 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
608  * 144000 bytes for PAL - or twice those for 50Mbps) */
609 static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
610  int *got_frame, AVPacket *avpkt)
611 {
612  uint8_t *buf = avpkt->data;
613  int buf_size = avpkt->size;
614  DVVideoContext *s = avctx->priv_data;
615  ThreadFrame frame = { .f = data };
616  const uint8_t *vsc_pack;
617  int apt, is16_9, ret;
618  const AVDVProfile *sys;
619 
620  sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
621  if (!sys || buf_size < sys->frame_size) {
622  av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
623  return -1; /* NOTE: we only accept several full frames */
624  }
625 
626  if (sys != s->sys) {
628  if (ret < 0) {
629  av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
630  return ret;
631  }
632  dv_init_weight_tables(s, sys);
633  s->sys = sys;
634  }
635 
636  s->frame = frame.f;
637  frame.f->key_frame = 1;
638  frame.f->pict_type = AV_PICTURE_TYPE_I;
639  avctx->pix_fmt = s->sys->pix_fmt;
640  avctx->framerate = av_inv_q(s->sys->time_base);
641 
642  ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
643  if (ret < 0)
644  return ret;
645 
646  /* Determine the codec's sample_aspect ratio from the packet */
647  vsc_pack = buf + 80 * 5 + 48 + 5;
648  if (*vsc_pack == dv_video_control) {
649  apt = buf[4] & 0x07;
650  is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
651  (!apt && (vsc_pack[2] & 0x07) == 0x07);
652  ff_set_sar(avctx, s->sys->sar[is16_9]);
653  }
654 
655  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
656  return ret;
657 
658  /* Determine the codec's field order from the packet */
659  if ( *vsc_pack == dv_video_control ) {
660  if (avctx->height == 720) {
661  frame.f->interlaced_frame = 0;
662  frame.f->top_field_first = 0;
663  } else if (avctx->height == 1080) {
664  frame.f->interlaced_frame = 1;
665  frame.f->top_field_first = (vsc_pack[3] & 0x40) == 0x40;
666  } else {
667  frame.f->interlaced_frame = (vsc_pack[3] & 0x10) == 0x10;
668  frame.f->top_field_first = !(vsc_pack[3] & 0x40);
669  }
670  }
671 
672  s->buf = buf;
673  avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
674  dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
675 
676  emms_c();
677 
678  /* return image */
679  *got_frame = 1;
680 
681  return s->sys->frame_size;
682 }
683 
685  .name = "dvvideo",
686  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
687  .type = AVMEDIA_TYPE_VIDEO,
688  .id = AV_CODEC_ID_DVVIDEO,
689  .priv_data_size = sizeof(DVVideoContext),
693  .max_lowres = 3,
694  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
695 };
AVCodec
AVCodec.
Definition: codec.h:197
stride
int stride
Definition: mace.c:144
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
level
uint8_t level
Definition: svq3.c:204
DV_MAX_BPM
#define DV_MAX_BPM
maximum number of blocks per macroblock in any DV format
Definition: dv.h:97
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
put_bits32
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:290
DVwork_chunk::buf_offset
uint16_t buf_offset
Definition: dv.h:37
mem_internal.h
dv100_idct_put_last_row_field_luma
static void dv100_idct_put_last_row_field_luma(DVVideoContext *s, uint8_t *data, int stride, int16_t *blocks)
Definition: dvdec.c:359
dv_profile_internal.h
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
thread.h
ff_dv_frame_profile
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
NB_DV_VLC
#define NB_DV_VLC
Definition: dvdata.h:29
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:61
BlockInfo::pos
uint8_t pos
Definition: dvdec.c:58
GetBitContext::size_in_bits
int size_in_bits
Definition: get_bits.h:68
ff_dvvideo_decoder
const AVCodec ff_dvvideo_decoder
Definition: dvdec.c:684
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
pixdesc.h
index
fg index
Definition: ffmpeg_filter.c:168
DVwork_chunk
Definition: dv.h:36
bit_copy
static void bit_copy(PutBitContext *pb, GetBitContext *gb)
Definition: dvdec.c:324
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:365
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
RL_VLC_ELEM::run
uint8_t run
Definition: vlc.h:35
data
const char data[16]
Definition: mxf.c:142
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
dv_init_weight_tables
static void dv_init_weight_tables(DVVideoContext *ctx, const AVDVProfile *d)
Definition: dvdec.c:190
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
thread.h
OPEN_READER_NOSIZE
#define OPEN_READER_NOSIZE(name, gb)
Definition: get_bits.h:133
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1816
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
VLC_TYPE
#define VLC_TYPE
Definition: vlc.h:24
GetBitContext
Definition: get_bits.h:61
ff_thread_get_buffer
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
dv100_idct_put_last_row_field_chroma
static void dv100_idct_put_last_row_field_chroma(DVVideoContext *s, uint8_t *data, int stride, int16_t *blocks)
Definition: dvdec.c:347
ff_simple_idct248_put
void ff_simple_idct248_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
Definition: simple_idct.c:106
dv_iweight_720_y
static const uint16_t dv_iweight_720_y[64]
Definition: dvdec.c:111
BlockInfo::partial_bit_buffer
uint32_t partial_bit_buffer
Definition: dvdec.c:61
dv_iweight_88
static const uint16_t dv_iweight_88[64]
Definition: dvdec.c:67
dv_iweight_1080_y
static const uint16_t dv_iweight_1080_y[64]
The "inverse" DV100 weights are actually just the spec weights (zig-zagged).
Definition: dvdec.c:91
avassert.h
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
ff_dv_init_dynamic_tables
int ff_dv_init_dynamic_tables(DVVideoContext *ctx, const AVDVProfile *d)
Definition: dv.c:172
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
dv_decode_video_segment
static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
Definition: dvdec.c:378
dvvideo_decode_init
static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
Definition: dvdec.c:236
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
s
#define s(width, name)
Definition: cbs_vp9.c:257
dv_decode_ac
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
Definition: dvdec.c:264
frame_size
int frame_size
Definition: mxfenc.c:2206
AVCodecContext::error_concealment
int error_concealment
error concealment flags
Definition: avcodec.h:1398
LOCAL_ALIGNED_16
#define LOCAL_ALIGNED_16(t, v,...)
Definition: mem_internal.h:130
BlockInfo::factor_table
const uint32_t * factor_table
Definition: dvdec.c:56
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
ctx
AVFormatContext * ctx
Definition: movenc.c:48
get_bits.h
simple_idct.h
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
PutBitContext
Definition: put_bits.h:49
arg
const char * arg
Definition: jacosubdec.c:67
dv_iweight_720_c
static const uint16_t dv_iweight_720_c[64]
Definition: dvdec.c:121
if
if(ret)
Definition: filter_design.txt:179
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
ff_dv_quant_shifts
const uint8_t ff_dv_quant_shifts[22][4]
Definition: dvdata.c:45
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
NULL
#define NULL
Definition: coverity.c:32
run
uint8_t run
Definition: svq3.c:203
idct_put
static void idct_put(FourXContext *f, int x, int y)
Definition: 4xm.c:558
BlockInfo::idct_put
void(* idct_put)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
Definition: dvdec.c:59
DVVideoContext
Definition: dv.h:41
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
INIT_VLC_USE_NEW_STATIC
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:95
AVOnce
#define AVOnce
Definition: thread.h:172
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
BlockInfo
Definition: dvdec.c:55
RL_VLC_ELEM::len
int8_t len
Definition: vlc.h:34
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
dv.h
AVCodecContext::lowres
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1538
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:366
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
RL_VLC_ELEM
Definition: vlc.h:32
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
dv_rl_vlc
static RL_VLC_ELEM dv_rl_vlc[1664]
Definition: dvdec.c:135
ff_dv_zigzag248_direct
const uint8_t ff_dv_zigzag248_direct[64]
Definition: dvdata.c:33
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:112
BlockInfo::shift_offset
int shift_offset
Definition: dvdec.c:62
ff_dv_vlc_level
const uint8_t ff_dv_vlc_level[NB_DV_VLC]
Definition: dvdata.c:242
DV_PROFILE_IS_HD
#define DV_PROFILE_IS_HD(p)
Definition: dv.h:84
ff_dv_vlc_run
const uint8_t ff_dv_vlc_run[NB_DV_VLC]
Definition: dvdata.c:187
mb
#define mb
Definition: vf_colormatrix.c:101
NEG_USR32
#define NEG_USR32(a, s)
Definition: mathops.h:166
i
int i
Definition: input.c:407
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:79
ff_dv_vlc_bits
const uint16_t ff_dv_vlc_bits[NB_DV_VLC]
Definition: dvdata.c:77
dv_iweight_248
static const uint16_t dv_iweight_248[64]
Definition: dvdec.c:77
internal.h
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
MIN_CACHE_BITS
#define MIN_CACHE_BITS
Definition: get_bits.h:128
av_always_inline
#define av_always_inline
Definition: attributes.h:49
AV_CODEC_ID_DVVIDEO
@ AV_CODEC_ID_DVVIDEO
Definition: codec_id.h:73
dv_work_pool_size
static int dv_work_pool_size(const AVDVProfile *d)
Definition: dv.h:103
dv_video_control
@ dv_video_control
Definition: dv.h:78
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
put_block_8x4
static av_always_inline void put_block_8x4(int16_t *block, uint8_t *av_restrict p, int stride)
Definition: dvdec.c:335
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
BlockInfo::scan_table
const uint8_t * scan_table
Definition: dvdec.c:57
len
int len
Definition: vorbis_enc_data.h:452
AVCodecContext::height
int height
Definition: avcodec.h:674
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:711
avcodec.h
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
ff_dv_vlc_len
const uint8_t ff_dv_vlc_len[NB_DV_VLC]
Definition: dvdata.c:132
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
dv_calculate_mb_xy
static void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
Definition: dv.h:113
TEX_VLC_BITS
#define TEX_VLC_BITS
Definition: dvdec.c:132
pos
unsigned int pos
Definition: spdifenc.c:412
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:192
ff_set_sar
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:99
vlc_buf
static VLC_TYPE vlc_buf[16716][2]
Definition: clearvideo.c:86
AVCodecContext
main external API structure.
Definition: avcodec.h:501
ThreadFrame
Definition: thread.h:34
ff_dv_quant_offset
const uint8_t ff_dv_quant_offset[4]
Definition: dvdata.c:70
AVCodecContext::execute
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:1597
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
VLC
Definition: vlc.h:26
AVDVProfile
Definition: dv_profile.h:39
av_clip_uint8
#define av_clip_uint8
Definition: common.h:128
VLC::table_size
int table_size
Definition: vlc.h:29
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_set_dimensions
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:84
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:142
quant
const uint8_t * quant
Definition: vorbis_enc_data.h:458
ff_dvvideo_init
av_cold int ff_dvvideo_init(AVCodecContext *avctx)
Definition: dv.c:195
dv_iweight_1080_c
static const uint16_t dv_iweight_1080_c[64]
Definition: dvdec.c:101
AVPacket
This structure stores compressed data.
Definition: packet.h:342
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:528
dv_init_static
static void dv_init_static(void)
Definition: dvdec.c:137
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
d
d
Definition: ffmpeg_filter.c:156
imgutils.h
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
dvvideo_decode_frame
static int dvvideo_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: dvdec.c:609
put_bits.h
dv_iweight_bits
static const int dv_iweight_bits
Definition: dvdec.c:65
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
block1
static int16_t block1[64]
Definition: dct.c:117
RL_VLC_ELEM::level
int16_t level
Definition: vlc.h:33
dvdata.h
BlockInfo::partial_bit_count
uint8_t partial_bit_count
Definition: dvdec.c:60
re
float re
Definition: fft.c:82