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 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
291  LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
292  const int log2_blocksize = 3-s->avctx->lowres;
293  int is_field_mode[5];
294 
295  av_assert1((((int) mb_bit_buffer) & 7) == 0);
296  av_assert1((((int) vs_bit_buffer) & 7) == 0);
297 
298  memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
299 
300  /* pass 1: read DC and AC coefficients in blocks */
301  buf_ptr = &s->buf[work_chunk->buf_offset * 80];
302  block1 = &sblock[0][0];
303  mb1 = mb_data;
304  init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
305  for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
306  /* skip header */
307  quant = buf_ptr[3] & 0x0f;
308  buf_ptr += 4;
309  init_put_bits(&pb, mb_bit_buffer, 80);
310  mb = mb1;
311  block = block1;
312  is_field_mode[mb_index] = 0;
313  for (j = 0; j < s->sys->bpm; j++) {
314  last_index = s->sys->block_sizes[j];
315  init_get_bits(&gb, buf_ptr, last_index);
316 
317  /* get the DC */
318  dc = get_sbits(&gb, 9);
319  dct_mode = get_bits1(&gb);
320  class1 = get_bits(&gb, 2);
321  if (DV_PROFILE_IS_HD(s->sys)) {
322  mb->idct_put = s->idct_put[0];
323  mb->scan_table = s->dv_zigzag[0];
324  mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
325  class1 * 16 * 64 +
326  quant * 64];
327  is_field_mode[mb_index] |= !j && dct_mode;
328  } else {
329  mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
330  mb->scan_table = s->dv_zigzag[dct_mode];
331  mb->factor_table =
332  &s->idct_factor[(class1 == 3) * 2 * 22 * 64 +
333  dct_mode * 22 * 64 +
334  (quant + ff_dv_quant_offset[class1]) * 64];
335  }
336  dc = dc << 2;
337  /* convert to unsigned because 128 is not added in the
338  * standard IDCT */
339  dc += 1024;
340  block[0] = dc;
341  buf_ptr += last_index >> 3;
342  mb->pos = 0;
343  mb->partial_bit_count = 0;
344 
345  ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
346  dv_decode_ac(&gb, mb, block);
347 
348  /* write the remaining bits in a new buffer only if the
349  * block is finished */
350  if (mb->pos >= 64)
351  bit_copy(&pb, &gb);
352 
353  block += 64;
354  mb++;
355  }
356 
357  /* pass 2: we can do it just after */
358  ff_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
359  block = block1;
360  mb = mb1;
361  init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
362  put_bits32(&pb, 0); // padding must be zeroed
363  flush_put_bits(&pb);
364  for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
365  if (mb->pos < 64 && get_bits_left(&gb) > 0) {
366  dv_decode_ac(&gb, mb, block);
367  /* if still not finished, no need to parse other blocks */
368  if (mb->pos < 64)
369  break;
370  }
371  }
372  /* all blocks are finished, so the extra bytes can be used at
373  * the video segment level */
374  if (j >= s->sys->bpm)
375  bit_copy(&vs_pb, &gb);
376  }
377 
378  /* we need a pass over the whole video segment */
379  ff_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
380  block = &sblock[0][0];
381  mb = mb_data;
382  init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
383  put_bits32(&vs_pb, 0); // padding must be zeroed
384  flush_put_bits(&vs_pb);
385  for (mb_index = 0; mb_index < 5; mb_index++) {
386  for (j = 0; j < s->sys->bpm; j++) {
387  if (mb->pos < 64 && get_bits_left(&gb) > 0) {
388  ff_dlog(avctx, "start %d:%d\n", mb_index, j);
389  dv_decode_ac(&gb, mb, block);
390  }
391  if (mb->pos >= 64 && mb->pos < 127)
392  av_log(avctx, AV_LOG_ERROR,
393  "AC EOB marker is absent pos=%d\n", mb->pos);
394  block += 64;
395  mb++;
396  }
397  }
398 
399  /* compute idct and place blocks */
400  block = &sblock[0][0];
401  mb = mb_data;
402  for (mb_index = 0; mb_index < 5; mb_index++) {
403  dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
404 
405  /* idct_put'ting luminance */
406  if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
407  (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
408  (s->sys->height >= 720 && mb_y != 134)) {
409  y_stride = (s->frame->linesize[0] <<
410  ((!is_field_mode[mb_index]) * log2_blocksize));
411  } else {
412  y_stride = (2 << log2_blocksize);
413  }
414  y_ptr = s->frame->data[0] +
415  ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
416  linesize = s->frame->linesize[0] << is_field_mode[mb_index];
417  mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
418  if (s->sys->video_stype == 4) { /* SD 422 */
419  mb[2].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 2 * 64);
420  } else {
421  mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);
422  mb[2].idct_put(y_ptr + y_stride, linesize, block + 2 * 64);
423  mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
424  }
425  mb += 4;
426  block += 4 * 64;
427 
428  /* idct_put'ting chrominance */
429  c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
430  (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
431  for (j = 2; j; j--) {
432  uint8_t *c_ptr = s->frame->data[j] + c_offset;
433  if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
434  uint64_t aligned_pixels[64 / 8];
435  uint8_t *pixels = (uint8_t *) aligned_pixels;
436  uint8_t *c_ptr1, *ptr1;
437  int x, y;
438  mb->idct_put(pixels, 8, block);
439  for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
440  ptr1 = pixels + ((1 << (log2_blocksize))>>1);
441  c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
442  for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
443  c_ptr[x] = pixels[x];
444  c_ptr1[x] = ptr1[x];
445  }
446  }
447  block += 64;
448  mb++;
449  } else {
450  y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
451  s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
452  linesize = s->frame->linesize[j] << is_field_mode[mb_index];
453  (mb++)->idct_put(c_ptr, linesize, block);
454  block += 64;
455  if (s->sys->bpm == 8) {
456  (mb++)->idct_put(c_ptr + y_stride, linesize, block);
457  block += 64;
458  }
459  }
460  }
461  }
462  return 0;
463 }
464 
465 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
466  * 144000 bytes for PAL - or twice those for 50Mbps) */
467 static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
468  int *got_frame, AVPacket *avpkt)
469 {
470  uint8_t *buf = avpkt->data;
471  int buf_size = avpkt->size;
472  DVVideoContext *s = avctx->priv_data;
473  const uint8_t *vsc_pack;
474  int apt, is16_9, ret;
475  const AVDVProfile *sys;
476 
477  sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
478  if (!sys || buf_size < sys->frame_size) {
479  av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
480  return -1; /* NOTE: we only accept several full frames */
481  }
482 
483  if (sys != s->sys) {
484  ret = ff_dv_init_dynamic_tables(s, sys);
485  if (ret < 0) {
486  av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
487  return ret;
488  }
489  dv_init_weight_tables(s, sys);
490  s->sys = sys;
491  }
492 
493  s->frame = data;
494  s->frame->key_frame = 1;
496  avctx->pix_fmt = s->sys->pix_fmt;
497  avctx->framerate = av_inv_q(s->sys->time_base);
498 
499  ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
500  if (ret < 0)
501  return ret;
502 
503  /* Determine the codec's sample_aspect ratio from the packet */
504  vsc_pack = buf + 80 * 5 + 48 + 5;
505  if (*vsc_pack == dv_video_control) {
506  apt = buf[4] & 0x07;
507  is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
508  (!apt && (vsc_pack[2] & 0x07) == 0x07);
509  ff_set_sar(avctx, s->sys->sar[is16_9]);
510  }
511 
512  if ((ret = ff_get_buffer(avctx, s->frame, 0)) < 0)
513  return ret;
514  s->frame->interlaced_frame = 1;
515  s->frame->top_field_first = 0;
516 
517  /* Determine the codec's field order from the packet */
518  if ( *vsc_pack == dv_video_control ) {
519  s->frame->top_field_first = !(vsc_pack[3] & 0x40);
520  }
521 
522  s->buf = buf;
523  avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
524  dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
525 
526  emms_c();
527 
528  /* return image */
529  *got_frame = 1;
530 
531  return s->sys->frame_size;
532 }
533 
535  .name = "dvvideo",
536  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
537  .type = AVMEDIA_TYPE_VIDEO,
538  .id = AV_CODEC_ID_DVVIDEO,
539  .priv_data_size = sizeof(DVVideoContext),
542  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
543  .max_lowres = 3,
544 };
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:3048
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:229
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int size
Definition: avcodec.h:1174
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1471
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:3206
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
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:794
uint8_t * data
Definition: avcodec.h:1173
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:244
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:2763
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
static int dv_work_pool_size(const AVDVProfile *d)
Definition: dv.h:101
AVCodec ff_dvvideo_decoder
Definition: dvdec.c:534
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:3213
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
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:635
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
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:467
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:1252
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:1035
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
#define CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:875
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
void * priv_data
Definition: avcodec.h:1294
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:2819
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:1150
static const int dv_iweight_bits
Definition: dvdec.c:63
bitstream writer API
static int16_t block[64]
Definition: dct-test.c:110