FFmpeg
dnxhddec.c
Go to the documentation of this file.
1 /*
2  * VC3/DNxHD decoder.
3  * Copyright (c) 2007 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
4  * Copyright (c) 2011 MirriAd Ltd
5  * Copyright (c) 2015 Christophe Gisquet
6  *
7  * 10 bit support added by MirriAd Ltd, Joseph Artsimovich <joseph@mirriad.com>
8  * Slice multithreading and MB interlaced support added by Christophe Gisquet
9  *
10  * This file is part of FFmpeg.
11  *
12  * FFmpeg is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU Lesser General Public
14  * License as published by the Free Software Foundation; either
15  * version 2.1 of the License, or (at your option) any later version.
16  *
17  * FFmpeg is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20  * Lesser General Public License for more details.
21  *
22  * You should have received a copy of the GNU Lesser General Public
23  * License along with FFmpeg; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25  */
26 
27 #include "libavutil/imgutils.h"
28 #include "libavutil/mem_internal.h"
29 
30 #include "avcodec.h"
31 #include "blockdsp.h"
32 #define UNCHECKED_BITSTREAM_READER 1
33 #include "get_bits.h"
34 #include "dnxhddata.h"
35 #include "idctdsp.h"
36 #include "internal.h"
37 #include "profiles.h"
38 #include "thread.h"
39 
40 typedef struct RowContext {
41  DECLARE_ALIGNED(32, int16_t, blocks)[12][64];
42  int luma_scale[64];
43  int chroma_scale[64];
45  int last_dc[3];
47  int errors;
48  /** -1:not set yet 0:off=RGB 1:on=YUV 2:variable */
49  int format;
50 } RowContext;
51 
52 typedef struct DNXHDContext {
56  const uint8_t* buf;
57  int buf_size;
58  int64_t cid; ///< compression id
59  unsigned int width, height;
61  unsigned int mb_width, mb_height;
62  uint32_t mb_scan_index[512];
63  int data_offset; // End of mb_scan_index, where macroblocks start
64  int cur_field; ///< current interlaced field
69  int bit_depth; // 8, 10, 12 or 0 if not initialized at all.
70  int is_444;
71  int alpha;
72  int lla;
73  int mbaff;
74  int act;
76  RowContext *row, int n);
77 } DNXHDContext;
78 
79 #define DNXHD_VLC_BITS 9
80 #define DNXHD_DC_VLC_BITS 7
81 
82 static int dnxhd_decode_dct_block_8(const DNXHDContext *ctx,
83  RowContext *row, int n);
85  RowContext *row, int n);
87  RowContext *row, int n);
89  RowContext *row, int n);
91  RowContext *row, int n);
92 
94 {
96 
97  ctx->avctx = avctx;
98  ctx->cid = -1;
101  }
102 
105 
106  ctx->rows = av_calloc(avctx->thread_count, sizeof(*ctx->rows));
107  if (!ctx->rows)
108  return AVERROR(ENOMEM);
109 
110  return 0;
111 }
112 
113 static int dnxhd_init_vlc(DNXHDContext *ctx, uint32_t cid, int bitdepth)
114 {
115  int ret;
116  if (cid != ctx->cid) {
118 
119  if (!cid_table) {
120  av_log(ctx->avctx, AV_LOG_ERROR, "unsupported cid %"PRIu32"\n", cid);
121  return AVERROR(ENOSYS);
122  }
123  if (cid_table->bit_depth != bitdepth &&
125  av_log(ctx->avctx, AV_LOG_ERROR, "bit depth mismatches %d %d\n",
126  cid_table->bit_depth, bitdepth);
127  return AVERROR_INVALIDDATA;
128  }
129  ctx->cid_table = cid_table;
130  av_log(ctx->avctx, AV_LOG_VERBOSE, "Profile cid %"PRIu32".\n", cid);
131 
132  ff_free_vlc(&ctx->ac_vlc);
133  ff_free_vlc(&ctx->dc_vlc);
134  ff_free_vlc(&ctx->run_vlc);
135 
136  if ((ret = init_vlc(&ctx->ac_vlc, DNXHD_VLC_BITS, 257,
137  ctx->cid_table->ac_bits, 1, 1,
138  ctx->cid_table->ac_codes, 2, 2, 0)) < 0)
139  goto out;
140  if ((ret = init_vlc(&ctx->dc_vlc, DNXHD_DC_VLC_BITS, bitdepth > 8 ? 14 : 12,
141  ctx->cid_table->dc_bits, 1, 1,
142  ctx->cid_table->dc_codes, 1, 1, 0)) < 0)
143  goto out;
144  if ((ret = init_vlc(&ctx->run_vlc, DNXHD_VLC_BITS, 62,
145  ctx->cid_table->run_bits, 1, 1,
146  ctx->cid_table->run_codes, 2, 2, 0)) < 0)
147  goto out;
148 
149  ctx->cid = cid;
150  }
151  ret = 0;
152 out:
153  if (ret < 0)
154  av_log(ctx->avctx, AV_LOG_ERROR, "init_vlc failed\n");
155  return ret;
156 }
157 
158 static int dnxhd_get_profile(int cid)
159 {
160  switch(cid) {
161  case 1270:
162  return FF_PROFILE_DNXHR_444;
163  case 1271:
164  return FF_PROFILE_DNXHR_HQX;
165  case 1272:
166  return FF_PROFILE_DNXHR_HQ;
167  case 1273:
168  return FF_PROFILE_DNXHR_SQ;
169  case 1274:
170  return FF_PROFILE_DNXHR_LB;
171  }
172  return FF_PROFILE_DNXHD;
173 }
174 
176  const uint8_t *buf, int buf_size,
177  int first_field)
178 {
179  int i, cid, ret;
180  int old_bit_depth = ctx->bit_depth, bitdepth;
181  uint64_t header_prefix;
182  if (buf_size < 0x280) {
183  av_log(ctx->avctx, AV_LOG_ERROR,
184  "buffer too small (%d < 640).\n", buf_size);
185  return AVERROR_INVALIDDATA;
186  }
187 
188  header_prefix = ff_dnxhd_parse_header_prefix(buf);
189  if (header_prefix == 0) {
190  av_log(ctx->avctx, AV_LOG_ERROR,
191  "unknown header 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n",
192  buf[0], buf[1], buf[2], buf[3], buf[4]);
193  return AVERROR_INVALIDDATA;
194  }
195  if (buf[5] & 2) { /* interlaced */
196  ctx->cur_field = first_field ? buf[5] & 1 : !ctx->cur_field;
197  frame->interlaced_frame = 1;
198  frame->top_field_first = first_field ^ ctx->cur_field;
199  av_log(ctx->avctx, AV_LOG_DEBUG,
200  "interlaced %d, cur field %d\n", buf[5] & 3, ctx->cur_field);
201  } else {
202  ctx->cur_field = 0;
203  }
204  ctx->mbaff = (buf[0x6] >> 5) & 1;
205  ctx->alpha = buf[0x7] & 1;
206  ctx->lla = (buf[0x7] >> 1) & 1;
207  if (ctx->alpha)
208  avpriv_request_sample(ctx->avctx, "alpha");
209 
210  ctx->height = AV_RB16(buf + 0x18);
211  ctx->width = AV_RB16(buf + 0x1a);
212 
213  switch(buf[0x21] >> 5) {
214  case 1: bitdepth = 8; break;
215  case 2: bitdepth = 10; break;
216  case 3: bitdepth = 12; break;
217  default:
218  av_log(ctx->avctx, AV_LOG_ERROR,
219  "Unknown bitdepth indicator (%d)\n", buf[0x21] >> 5);
220  return AVERROR_INVALIDDATA;
221  }
222 
223  cid = AV_RB32(buf + 0x28);
224 
225  ctx->avctx->profile = dnxhd_get_profile(cid);
226 
227  if ((ret = dnxhd_init_vlc(ctx, cid, bitdepth)) < 0)
228  return ret;
229  if (ctx->mbaff && ctx->cid_table->cid != 1260)
230  av_log(ctx->avctx, AV_LOG_WARNING,
231  "Adaptive MB interlace flag in an unsupported profile.\n");
232 
233  switch ((buf[0x2C] >> 1) & 3) {
234  case 0: frame->colorspace = AVCOL_SPC_BT709; break;
235  case 1: frame->colorspace = AVCOL_SPC_BT2020_NCL; break;
236  case 2: frame->colorspace = AVCOL_SPC_BT2020_CL; break;
237  case 3: frame->colorspace = AVCOL_SPC_UNSPECIFIED; break;
238  }
239 
240  ctx->act = buf[0x2C] & 1;
241  if (ctx->act && ctx->cid_table->cid != 1256 && ctx->cid_table->cid != 1270)
242  av_log(ctx->avctx, AV_LOG_WARNING,
243  "Adaptive color transform in an unsupported profile.\n");
244 
245  ctx->is_444 = (buf[0x2C] >> 6) & 1;
246  if (ctx->is_444) {
247  if (bitdepth == 8) {
248  avpriv_request_sample(ctx->avctx, "4:4:4 8 bits");
249  return AVERROR_INVALIDDATA;
250  } else if (bitdepth == 10) {
251  ctx->decode_dct_block = dnxhd_decode_dct_block_10_444;
252  ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P10
254  } else {
255  ctx->decode_dct_block = dnxhd_decode_dct_block_12_444;
256  ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P12
258  }
259  } else if (bitdepth == 12) {
260  ctx->decode_dct_block = dnxhd_decode_dct_block_12;
261  ctx->pix_fmt = AV_PIX_FMT_YUV422P12;
262  } else if (bitdepth == 10) {
263  if (ctx->avctx->profile == FF_PROFILE_DNXHR_HQX)
264  ctx->decode_dct_block = dnxhd_decode_dct_block_10_444;
265  else
266  ctx->decode_dct_block = dnxhd_decode_dct_block_10;
267  ctx->pix_fmt = AV_PIX_FMT_YUV422P10;
268  } else {
269  ctx->decode_dct_block = dnxhd_decode_dct_block_8;
270  ctx->pix_fmt = AV_PIX_FMT_YUV422P;
271  }
272 
273  ctx->avctx->bits_per_raw_sample = ctx->bit_depth = bitdepth;
274  if (ctx->bit_depth != old_bit_depth) {
275  ff_blockdsp_init(&ctx->bdsp, ctx->avctx);
276  ff_idctdsp_init(&ctx->idsp, ctx->avctx);
277  ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable,
279  }
280 
281  // make sure profile size constraints are respected
282  // DNx100 allows 1920->1440 and 1280->960 subsampling
283  if (ctx->width != ctx->cid_table->width &&
284  ctx->cid_table->width != DNXHD_VARIABLE) {
285  av_reduce(&ctx->avctx->sample_aspect_ratio.num,
286  &ctx->avctx->sample_aspect_ratio.den,
287  ctx->width, ctx->cid_table->width, 255);
288  ctx->width = ctx->cid_table->width;
289  }
290 
291  if (buf_size < ctx->cid_table->coding_unit_size) {
292  av_log(ctx->avctx, AV_LOG_ERROR, "incorrect frame size (%d < %u).\n",
293  buf_size, ctx->cid_table->coding_unit_size);
294  return AVERROR_INVALIDDATA;
295  }
296 
297  ctx->mb_width = (ctx->width + 15)>> 4;
298  ctx->mb_height = AV_RB16(buf + 0x16c);
299 
300  if ((ctx->height + 15) >> 4 == ctx->mb_height && frame->interlaced_frame)
301  ctx->height <<= 1;
302 
303  av_log(ctx->avctx, AV_LOG_VERBOSE, "%dx%d, 4:%s %d bits, MBAFF=%d ACT=%d\n",
304  ctx->width, ctx->height, ctx->is_444 ? "4:4" : "2:2",
305  ctx->bit_depth, ctx->mbaff, ctx->act);
306 
307  // Newer format supports variable mb_scan_index sizes
308  if (ctx->mb_height > 68 && ff_dnxhd_check_header_prefix_hr(header_prefix)) {
309  ctx->data_offset = 0x170 + (ctx->mb_height << 2);
310  } else {
311  if (ctx->mb_height > 68) {
312  av_log(ctx->avctx, AV_LOG_ERROR,
313  "mb height too big: %d\n", ctx->mb_height);
314  return AVERROR_INVALIDDATA;
315  }
316  ctx->data_offset = 0x280;
317  }
318  if ((ctx->mb_height << frame->interlaced_frame) > (ctx->height + 15) >> 4) {
319  av_log(ctx->avctx, AV_LOG_ERROR,
320  "mb height too big: %d\n", ctx->mb_height);
321  return AVERROR_INVALIDDATA;
322  }
323 
324  if (buf_size < ctx->data_offset) {
325  av_log(ctx->avctx, AV_LOG_ERROR,
326  "buffer too small (%d < %d).\n", buf_size, ctx->data_offset);
327  return AVERROR_INVALIDDATA;
328  }
329 
330  if (ctx->mb_height > FF_ARRAY_ELEMS(ctx->mb_scan_index)) {
331  av_log(ctx->avctx, AV_LOG_ERROR,
332  "mb_height too big (%d > %"SIZE_SPECIFIER").\n", ctx->mb_height, FF_ARRAY_ELEMS(ctx->mb_scan_index));
333  return AVERROR_INVALIDDATA;
334  }
335 
336  for (i = 0; i < ctx->mb_height; i++) {
337  ctx->mb_scan_index[i] = AV_RB32(buf + 0x170 + (i << 2));
338  ff_dlog(ctx->avctx, "mb scan index %d, pos %d: %"PRIu32"\n",
339  i, 0x170 + (i << 2), ctx->mb_scan_index[i]);
340  if (buf_size - ctx->data_offset < ctx->mb_scan_index[i]) {
341  av_log(ctx->avctx, AV_LOG_ERROR,
342  "invalid mb scan index (%"PRIu32" vs %u).\n",
343  ctx->mb_scan_index[i], buf_size - ctx->data_offset);
344  return AVERROR_INVALIDDATA;
345  }
346  }
347 
348  return 0;
349 }
350 
352  RowContext *row,
353  int n,
354  int index_bits,
355  int level_bias,
356  int level_shift,
357  int dc_shift)
358 {
359  int i, j, index1, index2, len, flags;
360  int level, component, sign;
361  const int *scale;
362  const uint8_t *weight_matrix;
363  const uint8_t *ac_info = ctx->cid_table->ac_info;
364  int16_t *block = row->blocks[n];
365  const int eob_index = ctx->cid_table->eob_index;
366  int ret = 0;
367  OPEN_READER(bs, &row->gb);
368 
369  ctx->bdsp.clear_block(block);
370 
371  if (!ctx->is_444) {
372  if (n & 2) {
373  component = 1 + (n & 1);
374  scale = row->chroma_scale;
375  weight_matrix = ctx->cid_table->chroma_weight;
376  } else {
377  component = 0;
378  scale = row->luma_scale;
379  weight_matrix = ctx->cid_table->luma_weight;
380  }
381  } else {
382  component = (n >> 1) % 3;
383  if (component) {
384  scale = row->chroma_scale;
385  weight_matrix = ctx->cid_table->chroma_weight;
386  } else {
387  scale = row->luma_scale;
388  weight_matrix = ctx->cid_table->luma_weight;
389  }
390  }
391 
392  UPDATE_CACHE(bs, &row->gb);
393  GET_VLC(len, bs, &row->gb, ctx->dc_vlc.table, DNXHD_DC_VLC_BITS, 1);
394  if (len < 0) {
395  ret = len;
396  goto error;
397  }
398  if (len) {
399  level = GET_CACHE(bs, &row->gb);
400  LAST_SKIP_BITS(bs, &row->gb, len);
401  sign = ~level >> 31;
402  level = (NEG_USR32(sign ^ level, len) ^ sign) - sign;
403  row->last_dc[component] += level * (1 << dc_shift);
404  }
405  block[0] = row->last_dc[component];
406 
407  i = 0;
408 
409  UPDATE_CACHE(bs, &row->gb);
410  GET_VLC(index1, bs, &row->gb, ctx->ac_vlc.table,
411  DNXHD_VLC_BITS, 2);
412 
413  while (index1 != eob_index) {
414  level = ac_info[2*index1+0];
415  flags = ac_info[2*index1+1];
416 
417  sign = SHOW_SBITS(bs, &row->gb, 1);
418  SKIP_BITS(bs, &row->gb, 1);
419 
420  if (flags & 1) {
421  level += SHOW_UBITS(bs, &row->gb, index_bits) << 7;
422  SKIP_BITS(bs, &row->gb, index_bits);
423  }
424 
425  if (flags & 2) {
426  UPDATE_CACHE(bs, &row->gb);
427  GET_VLC(index2, bs, &row->gb, ctx->run_vlc.table,
428  DNXHD_VLC_BITS, 2);
429  i += ctx->cid_table->run[index2];
430  }
431 
432  if (++i > 63) {
433  av_log(ctx->avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", n, i);
434  ret = -1;
435  break;
436  }
437 
438  j = ctx->scantable.permutated[i];
439  level *= scale[i];
440  level += scale[i] >> 1;
441  if (level_bias < 32 || weight_matrix[i] != level_bias)
442  level += level_bias; // 1<<(level_shift-1)
443  level >>= level_shift;
444 
445  block[j] = (level ^ sign) - sign;
446 
447  UPDATE_CACHE(bs, &row->gb);
448  GET_VLC(index1, bs, &row->gb, ctx->ac_vlc.table,
449  DNXHD_VLC_BITS, 2);
450  }
451 error:
452  CLOSE_READER(bs, &row->gb);
453  return ret;
454 }
455 
457  RowContext *row, int n)
458 {
459  return dnxhd_decode_dct_block(ctx, row, n, 4, 32, 6, 0);
460 }
461 
463  RowContext *row, int n)
464 {
465  return dnxhd_decode_dct_block(ctx, row, n, 6, 8, 4, 0);
466 }
467 
469  RowContext *row, int n)
470 {
471  return dnxhd_decode_dct_block(ctx, row, n, 6, 32, 6, 0);
472 }
473 
475  RowContext *row, int n)
476 {
477  return dnxhd_decode_dct_block(ctx, row, n, 6, 8, 4, 2);
478 }
479 
481  RowContext *row, int n)
482 {
483  return dnxhd_decode_dct_block(ctx, row, n, 6, 32, 4, 2);
484 }
485 
487  AVFrame *frame, int x, int y)
488 {
489  int shift1 = ctx->bit_depth >= 10;
490  int dct_linesize_luma = frame->linesize[0];
491  int dct_linesize_chroma = frame->linesize[1];
492  uint8_t *dest_y, *dest_u, *dest_v;
493  int dct_y_offset, dct_x_offset;
494  int qscale, i, act;
495  int interlaced_mb = 0;
496 
497  if (ctx->mbaff) {
498  interlaced_mb = get_bits1(&row->gb);
499  qscale = get_bits(&row->gb, 10);
500  } else {
501  qscale = get_bits(&row->gb, 11);
502  }
503  act = get_bits1(&row->gb);
504  if (act) {
505  if (!ctx->act) {
506  static int act_warned;
507  if (!act_warned) {
508  act_warned = 1;
509  av_log(ctx->avctx, AV_LOG_ERROR,
510  "ACT flag set, in violation of frame header.\n");
511  }
512  } else if (row->format == -1) {
513  row->format = act;
514  } else if (row->format != act) {
515  row->format = 2; // Variable
516  }
517  }
518 
519  if (qscale != row->last_qscale) {
520  for (i = 0; i < 64; i++) {
521  row->luma_scale[i] = qscale * ctx->cid_table->luma_weight[i];
522  row->chroma_scale[i] = qscale * ctx->cid_table->chroma_weight[i];
523  }
524  row->last_qscale = qscale;
525  }
526 
527  for (i = 0; i < 8 + 4 * ctx->is_444; i++) {
528  if (ctx->decode_dct_block(ctx, row, i) < 0)
529  return AVERROR_INVALIDDATA;
530  }
531 
532  if (frame->interlaced_frame) {
533  dct_linesize_luma <<= 1;
534  dct_linesize_chroma <<= 1;
535  }
536 
537  dest_y = frame->data[0] + ((y * dct_linesize_luma) << 4) + (x << (4 + shift1));
538  dest_u = frame->data[1] + ((y * dct_linesize_chroma) << 4) + (x << (3 + shift1 + ctx->is_444));
539  dest_v = frame->data[2] + ((y * dct_linesize_chroma) << 4) + (x << (3 + shift1 + ctx->is_444));
540 
541  if (frame->interlaced_frame && ctx->cur_field) {
542  dest_y += frame->linesize[0];
543  dest_u += frame->linesize[1];
544  dest_v += frame->linesize[2];
545  }
546  if (interlaced_mb) {
547  dct_linesize_luma <<= 1;
548  dct_linesize_chroma <<= 1;
549  }
550 
551  dct_y_offset = interlaced_mb ? frame->linesize[0] : (dct_linesize_luma << 3);
552  dct_x_offset = 8 << shift1;
553  if (!ctx->is_444) {
554  ctx->idsp.idct_put(dest_y, dct_linesize_luma, row->blocks[0]);
555  ctx->idsp.idct_put(dest_y + dct_x_offset, dct_linesize_luma, row->blocks[1]);
556  ctx->idsp.idct_put(dest_y + dct_y_offset, dct_linesize_luma, row->blocks[4]);
557  ctx->idsp.idct_put(dest_y + dct_y_offset + dct_x_offset, dct_linesize_luma, row->blocks[5]);
558 
559  if (!(ctx->avctx->flags & AV_CODEC_FLAG_GRAY)) {
560  dct_y_offset = interlaced_mb ? frame->linesize[1] : (dct_linesize_chroma << 3);
561  ctx->idsp.idct_put(dest_u, dct_linesize_chroma, row->blocks[2]);
562  ctx->idsp.idct_put(dest_v, dct_linesize_chroma, row->blocks[3]);
563  ctx->idsp.idct_put(dest_u + dct_y_offset, dct_linesize_chroma, row->blocks[6]);
564  ctx->idsp.idct_put(dest_v + dct_y_offset, dct_linesize_chroma, row->blocks[7]);
565  }
566  } else {
567  ctx->idsp.idct_put(dest_y, dct_linesize_luma, row->blocks[0]);
568  ctx->idsp.idct_put(dest_y + dct_x_offset, dct_linesize_luma, row->blocks[1]);
569  ctx->idsp.idct_put(dest_y + dct_y_offset, dct_linesize_luma, row->blocks[6]);
570  ctx->idsp.idct_put(dest_y + dct_y_offset + dct_x_offset, dct_linesize_luma, row->blocks[7]);
571 
572  if (!(ctx->avctx->flags & AV_CODEC_FLAG_GRAY)) {
573  dct_y_offset = interlaced_mb ? frame->linesize[1] : (dct_linesize_chroma << 3);
574  ctx->idsp.idct_put(dest_u, dct_linesize_chroma, row->blocks[2]);
575  ctx->idsp.idct_put(dest_u + dct_x_offset, dct_linesize_chroma, row->blocks[3]);
576  ctx->idsp.idct_put(dest_u + dct_y_offset, dct_linesize_chroma, row->blocks[8]);
577  ctx->idsp.idct_put(dest_u + dct_y_offset + dct_x_offset, dct_linesize_chroma, row->blocks[9]);
578  ctx->idsp.idct_put(dest_v, dct_linesize_chroma, row->blocks[4]);
579  ctx->idsp.idct_put(dest_v + dct_x_offset, dct_linesize_chroma, row->blocks[5]);
580  ctx->idsp.idct_put(dest_v + dct_y_offset, dct_linesize_chroma, row->blocks[10]);
581  ctx->idsp.idct_put(dest_v + dct_y_offset + dct_x_offset, dct_linesize_chroma, row->blocks[11]);
582  }
583  }
584 
585  return 0;
586 }
587 
589  int rownb, int threadnb)
590 {
591  const DNXHDContext *ctx = avctx->priv_data;
592  uint32_t offset = ctx->mb_scan_index[rownb];
593  RowContext *row = ctx->rows + threadnb;
594  int x, ret;
595 
596  row->last_dc[0] =
597  row->last_dc[1] =
598  row->last_dc[2] = 1 << (ctx->bit_depth + 2); // for levels +2^(bitdepth-1)
599  ret = init_get_bits8(&row->gb, ctx->buf + offset, ctx->buf_size - offset);
600  if (ret < 0) {
601  row->errors++;
602  return ret;
603  }
604  for (x = 0; x < ctx->mb_width; x++) {
605  int ret = dnxhd_decode_macroblock(ctx, row, data, x, rownb);
606  if (ret < 0) {
607  row->errors++;
608  return ret;
609  }
610  }
611 
612  return 0;
613 }
614 
616  int *got_frame, AVPacket *avpkt)
617 {
618  const uint8_t *buf = avpkt->data;
619  int buf_size = avpkt->size;
621  ThreadFrame frame = { .f = data };
622  AVFrame *picture = data;
623  int first_field = 1;
624  int ret, i;
625 
626  ff_dlog(avctx, "frame size %d\n", buf_size);
627 
628  for (i = 0; i < avctx->thread_count; i++)
629  ctx->rows[i].format = -1;
630 
631 decode_coding_unit:
632  if ((ret = dnxhd_decode_header(ctx, picture, buf, buf_size, first_field)) < 0)
633  return ret;
634 
635  if ((avctx->width || avctx->height) &&
636  (ctx->width != avctx->width || ctx->height != avctx->height)) {
637  av_log(avctx, AV_LOG_WARNING, "frame size changed: %dx%d -> %ux%u\n",
638  avctx->width, avctx->height, ctx->width, ctx->height);
639  first_field = 1;
640  }
641  if (avctx->pix_fmt != AV_PIX_FMT_NONE && avctx->pix_fmt != ctx->pix_fmt) {
642  av_log(avctx, AV_LOG_WARNING, "pix_fmt changed: %s -> %s\n",
644  first_field = 1;
645  }
646 
647  avctx->pix_fmt = ctx->pix_fmt;
648  ret = ff_set_dimensions(avctx, ctx->width, ctx->height);
649  if (ret < 0)
650  return ret;
651 
652  if (first_field) {
653  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
654  return ret;
655  picture->pict_type = AV_PICTURE_TYPE_I;
656  picture->key_frame = 1;
657  }
658 
659  ctx->buf_size = buf_size - ctx->data_offset;
660  ctx->buf = buf + ctx->data_offset;
661  avctx->execute2(avctx, dnxhd_decode_row, picture, NULL, ctx->mb_height);
662 
663  if (first_field && picture->interlaced_frame) {
664  buf += ctx->cid_table->coding_unit_size;
665  buf_size -= ctx->cid_table->coding_unit_size;
666  first_field = 0;
667  goto decode_coding_unit;
668  }
669 
670  ret = 0;
671  for (i = 0; i < avctx->thread_count; i++) {
672  ret += ctx->rows[i].errors;
673  ctx->rows[i].errors = 0;
674  }
675 
676  if (ctx->act) {
677  static int act_warned;
678  int format = ctx->rows[0].format;
679  for (i = 1; i < avctx->thread_count; i++) {
680  if (ctx->rows[i].format != format &&
681  ctx->rows[i].format != -1 /* not run */) {
682  format = 2;
683  break;
684  }
685  }
686  switch (format) {
687  case -1:
688  case 2:
689  if (!act_warned) {
690  act_warned = 1;
691  av_log(ctx->avctx, AV_LOG_ERROR,
692  "Unsupported: variable ACT flag.\n");
693  }
694  break;
695  case 0:
696  ctx->pix_fmt = ctx->bit_depth==10
698  break;
699  case 1:
700  ctx->pix_fmt = ctx->bit_depth==10
702  break;
703  }
704  }
705  avctx->pix_fmt = ctx->pix_fmt;
706  if (ret) {
707  av_log(ctx->avctx, AV_LOG_ERROR, "%d lines with errors\n", ret);
708  return AVERROR_INVALIDDATA;
709  }
710 
711  *got_frame = 1;
712  return avpkt->size;
713 }
714 
716 {
718 
719  ff_free_vlc(&ctx->ac_vlc);
720  ff_free_vlc(&ctx->dc_vlc);
721  ff_free_vlc(&ctx->run_vlc);
722 
723  av_freep(&ctx->rows);
724 
725  return 0;
726 }
727 
729  .name = "dnxhd",
730  .long_name = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
731  .type = AVMEDIA_TYPE_VIDEO,
732  .id = AV_CODEC_ID_DNXHD,
733  .priv_data_size = sizeof(DNXHDContext),
735  .close = dnxhd_decode_close,
737  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
740  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
741 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
AVCodec
AVCodec.
Definition: codec.h:202
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
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:42
ff_init_scantable
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
level
uint8_t level
Definition: svq3.c:204
ff_dnxhd_check_header_prefix_hr
static av_always_inline uint64_t ff_dnxhd_check_header_prefix_hr(uint64_t prefix)
Definition: dnxhddata.h:65
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
blockdsp.h
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
RowContext::errors
int errors
Definition: dnxhddec.c:47
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:960
mem_internal.h
out
FILE * out
Definition: movenc.c:54
DNXHDContext::buf_size
int buf_size
Definition: dnxhddec.c:57
DNXHDContext::is_444
int is_444
Definition: dnxhddec.c:70
GET_VLC
#define GET_VLC(code, name, gb, table, bits, max_depth)
If the vlc code is invalid and max_depth=1, then no bits will be removed.
Definition: get_bits.h:707
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
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
data
const char data[16]
Definition: mxf.c:143
DNXHDContext::rows
RowContext * rows
Definition: dnxhddec.c:54
FF_PROFILE_DNXHD
#define FF_PROFILE_DNXHD
Definition: avcodec.h:1540
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
DNXHDContext::alpha
int alpha
Definition: dnxhddec.c:71
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:179
BlockDSPContext
Definition: blockdsp.h:34
AVCOL_SPC_BT2020_CL
@ AVCOL_SPC_BT2020_CL
ITU-R BT2020 constant luminance system.
Definition: pixfmt.h:514
thread.h
dnxhd_decode_header
static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame, const uint8_t *buf, int buf_size, int first_field)
Definition: dnxhddec.c:175
CIDEntry::coding_unit_size
unsigned int coding_unit_size
Definition: dnxhddata.h:46
DNXHDContext::ac_vlc
VLC ac_vlc
Definition: dnxhddec.c:65
DNXHDContext::height
unsigned int height
Definition: dnxhddec.c:59
DNXHDContext::mb_scan_index
uint32_t mb_scan_index[512]
Definition: dnxhddec.c:62
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:216
DNXHD_VLC_BITS
#define DNXHD_VLC_BITS
Definition: dnxhddec.c:79
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
DNXHDContext::mb_height
unsigned int mb_height
Definition: dnxhddec.c:61
RowContext::chroma_scale
int chroma_scale[64]
Definition: dnxhddec.c:43
DNXHDContext::cur_field
int cur_field
current interlaced field
Definition: dnxhddec.c:64
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1440
DNXHDContext
Definition: dnxhddec.c:52
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:405
DNXHDContext::idsp
IDCTDSPContext idsp
Definition: dnxhddec.c:66
GetBitContext
Definition: get_bits.h:62
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
DNXHDContext::bit_depth
int bit_depth
Definition: dnxhddec.c:69
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:381
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:571
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
FF_PROFILE_DNXHR_LB
#define FF_PROFILE_DNXHR_LB
Definition: avcodec.h:1541
CIDEntry
Definition: dnxhddata.h:42
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:392
CIDEntry::bit_depth
int bit_depth
Definition: dnxhddata.h:49
dnxhddata.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:678
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:150
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
dnxhd_decode_close
static av_cold int dnxhd_decode_close(AVCodecContext *avctx)
Definition: dnxhddec.c:715
dnxhd_get_profile
static int dnxhd_get_profile(int cid)
Definition: dnxhddec.c:158
dnxhd_decode_frame
static int dnxhd_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: dnxhddec.c:615
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1215
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:213
DNXHD_DC_VLC_BITS
#define DNXHD_DC_VLC_BITS
Definition: dnxhddec.c:80
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
RowContext::luma_scale
int luma_scale[64]
Definition: dnxhddec.c:42
get_bits.h
DNXHDContext::act
int act
Definition: dnxhddec.c:74
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:194
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:431
DNXHDContext::mb_width
unsigned int mb_width
Definition: dnxhddec.c:61
ff_dnxhd_profiles
const AVProfile ff_dnxhd_profiles[]
Definition: profiles.c:48
if
if(ret)
Definition: filter_design.txt:179
FF_PROFILE_DNXHR_HQ
#define FF_PROFILE_DNXHR_HQ
Definition: avcodec.h:1543
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:113
DNXHDContext::data_offset
int data_offset
Definition: dnxhddec.c:63
dnxhd_decode_dct_block_12_444
static int dnxhd_decode_dct_block_12_444(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:480
NULL
#define NULL
Definition: coverity.c:32
DNXHDContext::avctx
AVCodecContext * avctx
Definition: dnxhddec.c:53
DNXHD_VARIABLE
#define DNXHD_VARIABLE
Indicate that a CIDEntry value must be read in the bitstream.
Definition: dnxhddata.h:40
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:499
DNXHDContext::lla
int lla
Definition: dnxhddec.c:72
profiles.h
DNXHDContext::bdsp
BlockDSPContext bdsp
Definition: dnxhddec.c:55
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:200
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:390
dnxhd_decode_init
static av_cold int dnxhd_decode_init(AVCodecContext *avctx)
Definition: dnxhddec.c:93
RowContext::format
int format
-1:not set yet 0:off=RGB 1:on=YUV 2:variable
Definition: dnxhddec.c:49
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
cid
int cid
Definition: mxfenc.c:2040
shift1
static const int shift1[6]
Definition: dxa.c:50
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:386
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
dnxhd_decode_dct_block
static av_always_inline int dnxhd_decode_dct_block(const DNXHDContext *ctx, RowContext *row, int n, int index_bits, int level_bias, int level_shift, int dc_shift)
Definition: dnxhddec.c:351
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:243
AVPacket::size
int size
Definition: packet.h:374
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
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:394
RowContext
Definition: dnxhddec.c:40
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:396
RowContext::gb
GetBitContext gb
Definition: dnxhddec.c:44
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:139
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:117
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
RowContext::blocks
int16_t blocks[12][64]
Definition: dnxhddec.c:41
RowContext::last_qscale
int last_qscale
Definition: dnxhddec.c:46
ff_dnxhd_get_cid_table
const CIDEntry * ff_dnxhd_get_cid_table(int cid)
Definition: dnxhddata.c:1078
DNXHDContext::cid
int64_t cid
compression id
Definition: dnxhddec.c:58
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:433
NEG_USR32
#define NEG_USR32(a, s)
Definition: mathops.h:166
DNXHDContext::decode_dct_block
int(* decode_dct_block)(const struct DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:75
i
int i
Definition: input.c:406
FF_PROFILE_DNXHR_SQ
#define FF_PROFILE_DNXHR_SQ
Definition: avcodec.h:1542
AVCOL_SPC_BT2020_NCL
@ AVCOL_SPC_BT2020_NCL
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:513
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:406
av_always_inline
#define av_always_inline
Definition: attributes.h:49
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
len
int len
Definition: vorbis_enc_data.h:426
DNXHDContext::run_vlc
VLC run_vlc
Definition: dnxhddec.c:65
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:505
AVCodecContext::height
int height
Definition: avcodec.h:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
DNXHDContext::pix_fmt
enum AVPixelFormat pix_fmt
Definition: dnxhddec.c:60
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:271
idctdsp.h
avcodec.h
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
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
ff_dnxhd_parse_header_prefix
static av_always_inline uint64_t ff_dnxhd_parse_header_prefix(const uint8_t *buf)
Definition: dnxhddata.h:84
RowContext::last_dc
int last_dc[3]
Definition: dnxhddec.c:45
IDCTDSPContext
Definition: idctdsp.h:53
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:193
DNXHDContext::buf
const uint8_t * buf
Definition: dnxhddec.c:56
AVCodecContext
main external API structure.
Definition: avcodec.h:383
ThreadFrame
Definition: thread.h:34
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:212
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
VLC
Definition: vlc.h:26
dnxhd_init_vlc
static int dnxhd_init_vlc(DNXHDContext *ctx, uint32_t cid, int bitdepth)
Definition: dnxhddec.c:113
ff_dnxhd_decoder
const AVCodec ff_dnxhd_decoder
Definition: dnxhddec.c:728
profiles
static const AVProfile profiles[]
Definition: libfdk-aacenc.c:429
FF_PROFILE_DNXHR_HQX
#define FF_PROFILE_DNXHR_HQX
Definition: avcodec.h:1544
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:571
DNXHDContext::width
unsigned int width
Definition: dnxhddec.c:59
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
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:86
DNXHDContext::mbaff
int mbaff
Definition: dnxhddec.c:73
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
ScanTable
Scantable.
Definition: idctdsp.h:31
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
dnxhd_decode_macroblock
static int dnxhd_decode_macroblock(const DNXHDContext *ctx, RowContext *row, AVFrame *frame, int x, int y)
Definition: dnxhddec.c:486
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
format
fg outputs[0] format
Definition: ffmpeg_filter.c:175
FF_PROFILE_DNXHR_444
#define FF_PROFILE_DNXHR_444
Definition: avcodec.h:1545
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
dnxhd_decode_dct_block_10_444
static int dnxhd_decode_dct_block_10_444(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:468
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
dnxhd_decode_row
static int dnxhd_decode_row(AVCodecContext *avctx, void *data, int rownb, int threadnb)
Definition: dnxhddec.c:588
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
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
DNXHDContext::dc_vlc
VLC dc_vlc
Definition: dnxhddec.c:65
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:59
AVCOL_SPC_BT709
@ AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
Definition: pixfmt.h:504
int
int
Definition: ffmpeg_filter.c:156
first_field
static int first_field(const struct video_data *s)
Definition: v4l2.c:236
dnxhd_decode_dct_block_8
static int dnxhd_decode_dct_block_8(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:456
DNXHDContext::cid_table
const CIDEntry * cid_table
Definition: dnxhddec.c:68
dnxhd_decode_dct_block_10
static int dnxhd_decode_dct_block_10(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:462
AVCodecContext::execute2
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
Definition: avcodec.h:1511
AV_CODEC_ID_DNXHD
@ AV_CODEC_ID_DNXHD
Definition: codec_id.h:149
dnxhd_decode_dct_block_12
static int dnxhd_decode_dct_block_12(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:474
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2460
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
DNXHDContext::scantable
ScanTable scantable
Definition: dnxhddec.c:67