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/mem_internal.h"
28 #include "libavutil/pixdesc.h"
29 
30 #include "avcodec.h"
31 #include "blockdsp.h"
32 #include "codec_internal.h"
33 #include "decode.h"
34 #define UNCHECKED_BITSTREAM_READER 1
35 #include "get_bits.h"
36 #include "dnxhddata.h"
37 #include "idctdsp.h"
38 #include "profiles.h"
39 #include "thread.h"
40 
41 typedef struct RowContext {
42  DECLARE_ALIGNED(32, int16_t, blocks)[12][64];
43  int luma_scale[64];
44  int chroma_scale[64];
46  int last_dc[3];
48  int errors;
49  /** -1:not set yet 0:off=RGB 1:on=YUV 2:variable */
50  int format;
51 } RowContext;
52 
53 typedef struct DNXHDContext {
57  const uint8_t* buf;
58  int buf_size;
59  int64_t cid; ///< compression id
60  unsigned int width, height;
62  unsigned int mb_width, mb_height;
63  uint32_t mb_scan_index[512];
64  int data_offset; // End of mb_scan_index, where macroblocks start
65  int cur_field; ///< current interlaced field
70  int bit_depth; // 8, 10, 12 or 0 if not initialized at all.
71  int is_444;
72  int alpha;
73  int lla;
74  int mbaff;
75  int act;
77  RowContext *row, int n);
78 } DNXHDContext;
79 
80 #define DNXHD_VLC_BITS 9
81 #define DNXHD_DC_VLC_BITS 7
82 
83 static int dnxhd_decode_dct_block_8(const DNXHDContext *ctx,
84  RowContext *row, int n);
86  RowContext *row, int n);
88  RowContext *row, int n);
90  RowContext *row, int n);
92  RowContext *row, int n);
93 
95 {
97 
98  ctx->avctx = avctx;
99  ctx->cid = -1;
102  }
103 
106 
107  ctx->rows = av_calloc(avctx->thread_count, sizeof(*ctx->rows));
108  if (!ctx->rows)
109  return AVERROR(ENOMEM);
110 
111  return 0;
112 }
113 
114 static int dnxhd_init_vlc(DNXHDContext *ctx, uint32_t cid, int bitdepth)
115 {
116  int ret;
117  if (cid != ctx->cid) {
119 
120  if (!cid_table) {
121  av_log(ctx->avctx, AV_LOG_ERROR, "unsupported cid %"PRIu32"\n", cid);
122  return AVERROR(ENOSYS);
123  }
124  if (cid_table->bit_depth != bitdepth &&
126  av_log(ctx->avctx, AV_LOG_ERROR, "bit depth mismatches %d %d\n",
127  cid_table->bit_depth, bitdepth);
128  return AVERROR_INVALIDDATA;
129  }
130  ctx->cid_table = cid_table;
131  av_log(ctx->avctx, AV_LOG_VERBOSE, "Profile cid %"PRIu32".\n", cid);
132 
133  ff_free_vlc(&ctx->ac_vlc);
134  ff_free_vlc(&ctx->dc_vlc);
135  ff_free_vlc(&ctx->run_vlc);
136 
137  if ((ret = init_vlc(&ctx->ac_vlc, DNXHD_VLC_BITS, 257,
138  ctx->cid_table->ac_bits, 1, 1,
139  ctx->cid_table->ac_codes, 2, 2, 0)) < 0)
140  goto out;
141  if ((ret = init_vlc(&ctx->dc_vlc, DNXHD_DC_VLC_BITS, bitdepth > 8 ? 14 : 12,
142  ctx->cid_table->dc_bits, 1, 1,
143  ctx->cid_table->dc_codes, 1, 1, 0)) < 0)
144  goto out;
145  if ((ret = init_vlc(&ctx->run_vlc, DNXHD_VLC_BITS, 62,
146  ctx->cid_table->run_bits, 1, 1,
147  ctx->cid_table->run_codes, 2, 2, 0)) < 0)
148  goto out;
149 
150  ctx->cid = cid;
151  }
152  ret = 0;
153 out:
154  if (ret < 0)
155  av_log(ctx->avctx, AV_LOG_ERROR, "init_vlc failed\n");
156  return ret;
157 }
158 
159 static int dnxhd_get_profile(int cid)
160 {
161  switch(cid) {
162  case 1270:
163  return FF_PROFILE_DNXHR_444;
164  case 1271:
165  return FF_PROFILE_DNXHR_HQX;
166  case 1272:
167  return FF_PROFILE_DNXHR_HQ;
168  case 1273:
169  return FF_PROFILE_DNXHR_SQ;
170  case 1274:
171  return FF_PROFILE_DNXHR_LB;
172  }
173  return FF_PROFILE_DNXHD;
174 }
175 
177  const uint8_t *buf, int buf_size,
178  int first_field)
179 {
180  int i, cid, ret;
181  int old_bit_depth = ctx->bit_depth, bitdepth;
182  uint64_t header_prefix;
183  if (buf_size < 0x280) {
184  av_log(ctx->avctx, AV_LOG_ERROR,
185  "buffer too small (%d < 640).\n", buf_size);
186  return AVERROR_INVALIDDATA;
187  }
188 
189  header_prefix = ff_dnxhd_parse_header_prefix(buf);
190  if (header_prefix == 0) {
191  av_log(ctx->avctx, AV_LOG_ERROR,
192  "unknown header 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n",
193  buf[0], buf[1], buf[2], buf[3], buf[4]);
194  return AVERROR_INVALIDDATA;
195  }
196  if (buf[5] & 2) { /* interlaced */
197  ctx->cur_field = first_field ? buf[5] & 1 : !ctx->cur_field;
198  frame->interlaced_frame = 1;
199  frame->top_field_first = first_field ^ ctx->cur_field;
200  av_log(ctx->avctx, AV_LOG_DEBUG,
201  "interlaced %d, cur field %d\n", buf[5] & 3, ctx->cur_field);
202  } else {
203  ctx->cur_field = 0;
204  }
205  ctx->mbaff = (buf[0x6] >> 5) & 1;
206  ctx->alpha = buf[0x7] & 1;
207  ctx->lla = (buf[0x7] >> 1) & 1;
208  if (ctx->alpha)
209  avpriv_request_sample(ctx->avctx, "alpha");
210 
211  ctx->height = AV_RB16(buf + 0x18);
212  ctx->width = AV_RB16(buf + 0x1a);
213 
214  switch(buf[0x21] >> 5) {
215  case 1: bitdepth = 8; break;
216  case 2: bitdepth = 10; break;
217  case 3: bitdepth = 12; break;
218  default:
219  av_log(ctx->avctx, AV_LOG_ERROR,
220  "Unknown bitdepth indicator (%d)\n", buf[0x21] >> 5);
221  return AVERROR_INVALIDDATA;
222  }
223 
224  cid = AV_RB32(buf + 0x28);
225 
226  ctx->avctx->profile = dnxhd_get_profile(cid);
227 
228  if ((ret = dnxhd_init_vlc(ctx, cid, bitdepth)) < 0)
229  return ret;
230  if (ctx->mbaff && ctx->cid_table->cid != 1260)
231  av_log(ctx->avctx, AV_LOG_WARNING,
232  "Adaptive MB interlace flag in an unsupported profile.\n");
233 
234  switch ((buf[0x2C] >> 1) & 3) {
235  case 0: frame->colorspace = AVCOL_SPC_BT709; break;
236  case 1: frame->colorspace = AVCOL_SPC_BT2020_NCL; break;
237  case 2: frame->colorspace = AVCOL_SPC_BT2020_CL; break;
238  case 3: frame->colorspace = AVCOL_SPC_UNSPECIFIED; break;
239  }
240 
241  ctx->act = buf[0x2C] & 1;
242  if (ctx->act && ctx->cid_table->cid != 1256 && ctx->cid_table->cid != 1270)
243  av_log(ctx->avctx, AV_LOG_WARNING,
244  "Adaptive color transform in an unsupported profile.\n");
245 
246  ctx->is_444 = (buf[0x2C] >> 6) & 1;
247  if (ctx->is_444) {
248  if (bitdepth == 8) {
249  avpriv_request_sample(ctx->avctx, "4:4:4 8 bits");
250  return AVERROR_INVALIDDATA;
251  } else if (bitdepth == 10) {
252  ctx->decode_dct_block = dnxhd_decode_dct_block_10_444;
253  ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P10
255  } else {
256  ctx->decode_dct_block = dnxhd_decode_dct_block_12_444;
257  ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P12
259  }
260  } else if (bitdepth == 12) {
261  ctx->decode_dct_block = dnxhd_decode_dct_block_12;
262  ctx->pix_fmt = AV_PIX_FMT_YUV422P12;
263  } else if (bitdepth == 10) {
264  if (ctx->avctx->profile == FF_PROFILE_DNXHR_HQX)
265  ctx->decode_dct_block = dnxhd_decode_dct_block_10_444;
266  else
267  ctx->decode_dct_block = dnxhd_decode_dct_block_10;
268  ctx->pix_fmt = AV_PIX_FMT_YUV422P10;
269  } else {
270  ctx->decode_dct_block = dnxhd_decode_dct_block_8;
271  ctx->pix_fmt = AV_PIX_FMT_YUV422P;
272  }
273 
274  ctx->avctx->bits_per_raw_sample = ctx->bit_depth = bitdepth;
275  if (ctx->bit_depth != old_bit_depth) {
276  ff_blockdsp_init(&ctx->bdsp);
277  ff_idctdsp_init(&ctx->idsp, ctx->avctx);
278  ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable,
280  }
281 
282  // make sure profile size constraints are respected
283  // DNx100 allows 1920->1440 and 1280->960 subsampling
284  if (ctx->width != ctx->cid_table->width &&
285  ctx->cid_table->width != DNXHD_VARIABLE) {
286  av_reduce(&ctx->avctx->sample_aspect_ratio.num,
287  &ctx->avctx->sample_aspect_ratio.den,
288  ctx->width, ctx->cid_table->width, 255);
289  ctx->width = ctx->cid_table->width;
290  }
291 
292  if (buf_size < ctx->cid_table->coding_unit_size) {
293  av_log(ctx->avctx, AV_LOG_ERROR, "incorrect frame size (%d < %u).\n",
294  buf_size, ctx->cid_table->coding_unit_size);
295  return AVERROR_INVALIDDATA;
296  }
297 
298  ctx->mb_width = (ctx->width + 15)>> 4;
299  ctx->mb_height = AV_RB16(buf + 0x16c);
300 
301  if ((ctx->height + 15) >> 4 == ctx->mb_height && frame->interlaced_frame)
302  ctx->height <<= 1;
303 
304  av_log(ctx->avctx, AV_LOG_VERBOSE, "%dx%d, 4:%s %d bits, MBAFF=%d ACT=%d\n",
305  ctx->width, ctx->height, ctx->is_444 ? "4:4" : "2:2",
306  ctx->bit_depth, ctx->mbaff, ctx->act);
307 
308  // Newer format supports variable mb_scan_index sizes
309  if (ctx->mb_height > 68 && ff_dnxhd_check_header_prefix_hr(header_prefix)) {
310  ctx->data_offset = 0x170 + (ctx->mb_height << 2);
311  } else {
312  if (ctx->mb_height > 68) {
313  av_log(ctx->avctx, AV_LOG_ERROR,
314  "mb height too big: %d\n", ctx->mb_height);
315  return AVERROR_INVALIDDATA;
316  }
317  ctx->data_offset = 0x280;
318  }
319  if ((ctx->mb_height << frame->interlaced_frame) > (ctx->height + 15) >> 4) {
320  av_log(ctx->avctx, AV_LOG_ERROR,
321  "mb height too big: %d\n", ctx->mb_height);
322  return AVERROR_INVALIDDATA;
323  }
324 
325  if (buf_size < ctx->data_offset) {
326  av_log(ctx->avctx, AV_LOG_ERROR,
327  "buffer too small (%d < %d).\n", buf_size, ctx->data_offset);
328  return AVERROR_INVALIDDATA;
329  }
330 
331  if (ctx->mb_height > FF_ARRAY_ELEMS(ctx->mb_scan_index)) {
332  av_log(ctx->avctx, AV_LOG_ERROR,
333  "mb_height too big (%d > %"SIZE_SPECIFIER").\n", ctx->mb_height, FF_ARRAY_ELEMS(ctx->mb_scan_index));
334  return AVERROR_INVALIDDATA;
335  }
336 
337  for (i = 0; i < ctx->mb_height; i++) {
338  ctx->mb_scan_index[i] = AV_RB32(buf + 0x170 + (i << 2));
339  ff_dlog(ctx->avctx, "mb scan index %d, pos %d: %"PRIu32"\n",
340  i, 0x170 + (i << 2), ctx->mb_scan_index[i]);
341  if (buf_size - ctx->data_offset < ctx->mb_scan_index[i]) {
342  av_log(ctx->avctx, AV_LOG_ERROR,
343  "invalid mb scan index (%"PRIu32" vs %u).\n",
344  ctx->mb_scan_index[i], buf_size - ctx->data_offset);
345  return AVERROR_INVALIDDATA;
346  }
347  }
348 
349  return 0;
350 }
351 
353  RowContext *row,
354  int n,
355  int index_bits,
356  int level_bias,
357  int level_shift,
358  int dc_shift)
359 {
360  int i, j, index1, index2, len, flags;
361  int level, component, sign;
362  const int *scale;
363  const uint8_t *weight_matrix;
364  const uint8_t *ac_info = ctx->cid_table->ac_info;
365  int16_t *block = row->blocks[n];
366  const int eob_index = ctx->cid_table->eob_index;
367  int ret = 0;
368  OPEN_READER(bs, &row->gb);
369 
370  ctx->bdsp.clear_block(block);
371 
372  if (!ctx->is_444) {
373  if (n & 2) {
374  component = 1 + (n & 1);
375  scale = row->chroma_scale;
376  weight_matrix = ctx->cid_table->chroma_weight;
377  } else {
378  component = 0;
379  scale = row->luma_scale;
380  weight_matrix = ctx->cid_table->luma_weight;
381  }
382  } else {
383  component = (n >> 1) % 3;
384  if (component) {
385  scale = row->chroma_scale;
386  weight_matrix = ctx->cid_table->chroma_weight;
387  } else {
388  scale = row->luma_scale;
389  weight_matrix = ctx->cid_table->luma_weight;
390  }
391  }
392 
393  UPDATE_CACHE(bs, &row->gb);
394  GET_VLC(len, bs, &row->gb, ctx->dc_vlc.table, DNXHD_DC_VLC_BITS, 1);
395  if (len < 0) {
396  ret = len;
397  goto error;
398  }
399  if (len) {
400  level = GET_CACHE(bs, &row->gb);
401  LAST_SKIP_BITS(bs, &row->gb, len);
402  sign = ~level >> 31;
403  level = (NEG_USR32(sign ^ level, len) ^ sign) - sign;
404  row->last_dc[component] += level * (1 << dc_shift);
405  }
406  block[0] = row->last_dc[component];
407 
408  i = 0;
409 
410  UPDATE_CACHE(bs, &row->gb);
411  GET_VLC(index1, bs, &row->gb, ctx->ac_vlc.table,
412  DNXHD_VLC_BITS, 2);
413 
414  while (index1 != eob_index) {
415  level = ac_info[2*index1+0];
416  flags = ac_info[2*index1+1];
417 
418  sign = SHOW_SBITS(bs, &row->gb, 1);
419  SKIP_BITS(bs, &row->gb, 1);
420 
421  if (flags & 1) {
422  level += SHOW_UBITS(bs, &row->gb, index_bits) << 7;
423  SKIP_BITS(bs, &row->gb, index_bits);
424  }
425 
426  if (flags & 2) {
427  UPDATE_CACHE(bs, &row->gb);
428  GET_VLC(index2, bs, &row->gb, ctx->run_vlc.table,
429  DNXHD_VLC_BITS, 2);
430  i += ctx->cid_table->run[index2];
431  }
432 
433  if (++i > 63) {
434  av_log(ctx->avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", n, i);
435  ret = -1;
436  break;
437  }
438 
439  j = ctx->scantable.permutated[i];
440  level *= scale[i];
441  level += scale[i] >> 1;
442  if (level_bias < 32 || weight_matrix[i] != level_bias)
443  level += level_bias; // 1<<(level_shift-1)
444  level >>= level_shift;
445 
446  block[j] = (level ^ sign) - sign;
447 
448  UPDATE_CACHE(bs, &row->gb);
449  GET_VLC(index1, bs, &row->gb, ctx->ac_vlc.table,
450  DNXHD_VLC_BITS, 2);
451  }
452 error:
453  CLOSE_READER(bs, &row->gb);
454  return ret;
455 }
456 
458  RowContext *row, int n)
459 {
460  return dnxhd_decode_dct_block(ctx, row, n, 4, 32, 6, 0);
461 }
462 
464  RowContext *row, int n)
465 {
466  return dnxhd_decode_dct_block(ctx, row, n, 6, 8, 4, 0);
467 }
468 
470  RowContext *row, int n)
471 {
472  return dnxhd_decode_dct_block(ctx, row, n, 6, 32, 6, 0);
473 }
474 
476  RowContext *row, int n)
477 {
478  return dnxhd_decode_dct_block(ctx, row, n, 6, 8, 4, 2);
479 }
480 
482  RowContext *row, int n)
483 {
484  return dnxhd_decode_dct_block(ctx, row, n, 6, 32, 4, 2);
485 }
486 
488  AVFrame *frame, int x, int y)
489 {
490  int shift1 = ctx->bit_depth >= 10;
491  int dct_linesize_luma = frame->linesize[0];
492  int dct_linesize_chroma = frame->linesize[1];
493  uint8_t *dest_y, *dest_u, *dest_v;
494  int dct_y_offset, dct_x_offset;
495  int qscale, i, act;
496  int interlaced_mb = 0;
497 
498  if (ctx->mbaff) {
499  interlaced_mb = get_bits1(&row->gb);
500  qscale = get_bits(&row->gb, 10);
501  } else {
502  qscale = get_bits(&row->gb, 11);
503  }
504  act = get_bits1(&row->gb);
505  if (act) {
506  if (!ctx->act) {
507  static int act_warned;
508  if (!act_warned) {
509  act_warned = 1;
510  av_log(ctx->avctx, AV_LOG_ERROR,
511  "ACT flag set, in violation of frame header.\n");
512  }
513  } else if (row->format == -1) {
514  row->format = act;
515  } else if (row->format != act) {
516  row->format = 2; // Variable
517  }
518  }
519 
520  if (qscale != row->last_qscale) {
521  for (i = 0; i < 64; i++) {
522  row->luma_scale[i] = qscale * ctx->cid_table->luma_weight[i];
523  row->chroma_scale[i] = qscale * ctx->cid_table->chroma_weight[i];
524  }
525  row->last_qscale = qscale;
526  }
527 
528  for (i = 0; i < 8 + 4 * ctx->is_444; i++) {
529  if (ctx->decode_dct_block(ctx, row, i) < 0)
530  return AVERROR_INVALIDDATA;
531  }
532 
533  if (frame->interlaced_frame) {
534  dct_linesize_luma <<= 1;
535  dct_linesize_chroma <<= 1;
536  }
537 
538  dest_y = frame->data[0] + ((y * dct_linesize_luma) << 4) + (x << (4 + shift1));
539  dest_u = frame->data[1] + ((y * dct_linesize_chroma) << 4) + (x << (3 + shift1 + ctx->is_444));
540  dest_v = frame->data[2] + ((y * dct_linesize_chroma) << 4) + (x << (3 + shift1 + ctx->is_444));
541 
542  if (frame->interlaced_frame && ctx->cur_field) {
543  dest_y += frame->linesize[0];
544  dest_u += frame->linesize[1];
545  dest_v += frame->linesize[2];
546  }
547  if (interlaced_mb) {
548  dct_linesize_luma <<= 1;
549  dct_linesize_chroma <<= 1;
550  }
551 
552  dct_y_offset = interlaced_mb ? frame->linesize[0] : (dct_linesize_luma << 3);
553  dct_x_offset = 8 << shift1;
554  if (!ctx->is_444) {
555  ctx->idsp.idct_put(dest_y, dct_linesize_luma, row->blocks[0]);
556  ctx->idsp.idct_put(dest_y + dct_x_offset, dct_linesize_luma, row->blocks[1]);
557  ctx->idsp.idct_put(dest_y + dct_y_offset, dct_linesize_luma, row->blocks[4]);
558  ctx->idsp.idct_put(dest_y + dct_y_offset + dct_x_offset, dct_linesize_luma, row->blocks[5]);
559 
560  if (!(ctx->avctx->flags & AV_CODEC_FLAG_GRAY)) {
561  dct_y_offset = interlaced_mb ? frame->linesize[1] : (dct_linesize_chroma << 3);
562  ctx->idsp.idct_put(dest_u, dct_linesize_chroma, row->blocks[2]);
563  ctx->idsp.idct_put(dest_v, dct_linesize_chroma, row->blocks[3]);
564  ctx->idsp.idct_put(dest_u + dct_y_offset, dct_linesize_chroma, row->blocks[6]);
565  ctx->idsp.idct_put(dest_v + dct_y_offset, dct_linesize_chroma, row->blocks[7]);
566  }
567  } else {
568  ctx->idsp.idct_put(dest_y, dct_linesize_luma, row->blocks[0]);
569  ctx->idsp.idct_put(dest_y + dct_x_offset, dct_linesize_luma, row->blocks[1]);
570  ctx->idsp.idct_put(dest_y + dct_y_offset, dct_linesize_luma, row->blocks[6]);
571  ctx->idsp.idct_put(dest_y + dct_y_offset + dct_x_offset, dct_linesize_luma, row->blocks[7]);
572 
573  if (!(ctx->avctx->flags & AV_CODEC_FLAG_GRAY)) {
574  dct_y_offset = interlaced_mb ? frame->linesize[1] : (dct_linesize_chroma << 3);
575  ctx->idsp.idct_put(dest_u, dct_linesize_chroma, row->blocks[2]);
576  ctx->idsp.idct_put(dest_u + dct_x_offset, dct_linesize_chroma, row->blocks[3]);
577  ctx->idsp.idct_put(dest_u + dct_y_offset, dct_linesize_chroma, row->blocks[8]);
578  ctx->idsp.idct_put(dest_u + dct_y_offset + dct_x_offset, dct_linesize_chroma, row->blocks[9]);
579  ctx->idsp.idct_put(dest_v, dct_linesize_chroma, row->blocks[4]);
580  ctx->idsp.idct_put(dest_v + dct_x_offset, dct_linesize_chroma, row->blocks[5]);
581  ctx->idsp.idct_put(dest_v + dct_y_offset, dct_linesize_chroma, row->blocks[10]);
582  ctx->idsp.idct_put(dest_v + dct_y_offset + dct_x_offset, dct_linesize_chroma, row->blocks[11]);
583  }
584  }
585 
586  return 0;
587 }
588 
590  int rownb, int threadnb)
591 {
592  const DNXHDContext *ctx = avctx->priv_data;
593  uint32_t offset = ctx->mb_scan_index[rownb];
594  RowContext *row = ctx->rows + threadnb;
595  int x, ret;
596 
597  row->last_dc[0] =
598  row->last_dc[1] =
599  row->last_dc[2] = 1 << (ctx->bit_depth + 2); // for levels +2^(bitdepth-1)
600  ret = init_get_bits8(&row->gb, ctx->buf + offset, ctx->buf_size - offset);
601  if (ret < 0) {
602  row->errors++;
603  return ret;
604  }
605  for (x = 0; x < ctx->mb_width; x++) {
606  int ret = dnxhd_decode_macroblock(ctx, row, data, x, rownb);
607  if (ret < 0) {
608  row->errors++;
609  return ret;
610  }
611  }
612 
613  return 0;
614 }
615 
617  int *got_frame, AVPacket *avpkt)
618 {
619  const uint8_t *buf = avpkt->data;
620  int buf_size = avpkt->size;
622  int first_field = 1;
623  int ret, i;
624 
625  ff_dlog(avctx, "frame size %d\n", buf_size);
626 
627  for (i = 0; i < avctx->thread_count; i++)
628  ctx->rows[i].format = -1;
629 
630 decode_coding_unit:
631  if ((ret = dnxhd_decode_header(ctx, picture, buf, buf_size, first_field)) < 0)
632  return ret;
633 
634  if ((avctx->width || avctx->height) &&
635  (ctx->width != avctx->width || ctx->height != avctx->height)) {
636  av_log(avctx, AV_LOG_WARNING, "frame size changed: %dx%d -> %ux%u\n",
637  avctx->width, avctx->height, ctx->width, ctx->height);
638  first_field = 1;
639  }
640  if (avctx->pix_fmt != AV_PIX_FMT_NONE && avctx->pix_fmt != ctx->pix_fmt) {
641  av_log(avctx, AV_LOG_WARNING, "pix_fmt changed: %s -> %s\n",
643  first_field = 1;
644  }
645 
646  avctx->pix_fmt = ctx->pix_fmt;
647  ret = ff_set_dimensions(avctx, ctx->width, ctx->height);
648  if (ret < 0)
649  return ret;
650 
651  if (first_field) {
652  if ((ret = ff_thread_get_buffer(avctx, picture, 0)) < 0)
653  return ret;
654  picture->pict_type = AV_PICTURE_TYPE_I;
655  picture->key_frame = 1;
656  }
657 
658  ctx->buf_size = buf_size - ctx->data_offset;
659  ctx->buf = buf + ctx->data_offset;
660  avctx->execute2(avctx, dnxhd_decode_row, picture, NULL, ctx->mb_height);
661 
662  if (first_field && picture->interlaced_frame) {
663  buf += ctx->cid_table->coding_unit_size;
664  buf_size -= ctx->cid_table->coding_unit_size;
665  first_field = 0;
666  goto decode_coding_unit;
667  }
668 
669  ret = 0;
670  for (i = 0; i < avctx->thread_count; i++) {
671  ret += ctx->rows[i].errors;
672  ctx->rows[i].errors = 0;
673  }
674 
675  if (ctx->act) {
676  static int act_warned;
677  int format = ctx->rows[0].format;
678  for (i = 1; i < avctx->thread_count; i++) {
679  if (ctx->rows[i].format != format &&
680  ctx->rows[i].format != -1 /* not run */) {
681  format = 2;
682  break;
683  }
684  }
685  switch (format) {
686  case -1:
687  case 2:
688  if (!act_warned) {
689  act_warned = 1;
690  av_log(ctx->avctx, AV_LOG_ERROR,
691  "Unsupported: variable ACT flag.\n");
692  }
693  break;
694  case 0:
695  ctx->pix_fmt = ctx->bit_depth==10
697  break;
698  case 1:
699  ctx->pix_fmt = ctx->bit_depth==10
701  break;
702  }
703  }
704  avctx->pix_fmt = ctx->pix_fmt;
705  if (ret) {
706  av_log(ctx->avctx, AV_LOG_ERROR, "%d lines with errors\n", ret);
707  return AVERROR_INVALIDDATA;
708  }
709 
710  *got_frame = 1;
711  return avpkt->size;
712 }
713 
715 {
717 
718  ff_free_vlc(&ctx->ac_vlc);
719  ff_free_vlc(&ctx->dc_vlc);
720  ff_free_vlc(&ctx->run_vlc);
721 
722  av_freep(&ctx->rows);
723 
724  return 0;
725 }
726 
728  .p.name = "dnxhd",
729  CODEC_LONG_NAME("VC3/DNxHD"),
730  .p.type = AVMEDIA_TYPE_VIDEO,
731  .p.id = AV_CODEC_ID_DNXHD,
732  .priv_data_size = sizeof(DNXHDContext),
734  .close = dnxhd_decode_close,
736  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
739 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
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:66
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:48
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:975
mem_internal.h
out
FILE * out
Definition: movenc.c:54
DNXHDContext::buf_size
int buf_size
Definition: dnxhddec.c:58
DNXHDContext::is_444
int is_444
Definition: dnxhddec.c:71
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:696
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
pixdesc.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:43
data
const char data[16]
Definition: mxf.c:146
DNXHDContext::rows
RowContext * rows
Definition: dnxhddec.c:55
FFCodec
Definition: codec_internal.h:119
FF_PROFILE_DNXHD
#define FF_PROFILE_DNXHD
Definition: avcodec.h:1565
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
DNXHDContext::alpha
int alpha
Definition: dnxhddec.c:72
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
BlockDSPContext
Definition: blockdsp.h:32
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:91
AVCOL_SPC_BT2020_CL
@ AVCOL_SPC_BT2020_CL
ITU-R BT2020 constant luminance system.
Definition: pixfmt.h:568
thread.h
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:240
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:176
CIDEntry::coding_unit_size
unsigned int coding_unit_size
Definition: dnxhddata.h:47
DNXHDContext::ac_vlc
VLC ac_vlc
Definition: dnxhddec.c:66
DNXHDContext::height
unsigned int height
Definition: dnxhddec.c:60
DNXHDContext::mb_scan_index
uint32_t mb_scan_index[512]
Definition: dnxhddec.c:63
init
static int init
Definition: av_tx.c:47
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:215
DNXHD_VLC_BITS
#define DNXHD_VLC_BITS
Definition: dnxhddec.c:80
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
DNXHDContext::mb_height
unsigned int mb_height
Definition: dnxhddec.c:62
RowContext::chroma_scale
int chroma_scale[64]
Definition: dnxhddec.c:44
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
DNXHDContext::cur_field
int cur_field
current interlaced field
Definition: dnxhddec.c:65
dnxhd_decode_frame
static int dnxhd_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_frame, AVPacket *avpkt)
Definition: dnxhddec.c:616
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1466
DNXHDContext
Definition: dnxhddec.c:53
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:447
DNXHDContext::idsp
IDCTDSPContext idsp
Definition: dnxhddec.c:67
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
DNXHDContext::bit_depth
int bit_depth
Definition: dnxhddec.c:70
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:417
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:586
ff_dnxhd_decoder
const FFCodec ff_dnxhd_decoder
Definition: dnxhddec.c:727
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:1566
CIDEntry
Definition: dnxhddata.h:43
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:434
CIDEntry::bit_depth
int bit_depth
Definition: dnxhddata.h:50
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:667
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
dnxhd_decode_close
static av_cold int dnxhd_decode_close(AVCodecContext *avctx)
Definition: dnxhddec.c:714
dnxhd_get_profile
static int dnxhd_get_profile(int cid)
Definition: dnxhddec.c:159
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:279
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c)
Definition: blockdsp.c:58
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1334
format
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 format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
DNXHD_DC_VLC_BITS
#define DNXHD_DC_VLC_BITS
Definition: dnxhddec.c:81
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:43
decode.h
get_bits.h
DNXHDContext::act
int act
Definition: dnxhddec.c:75
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:193
DNXHDContext::mb_width
unsigned int mb_width
Definition: dnxhddec.c:62
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
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:1568
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:64
dnxhd_decode_dct_block_12_444
static int dnxhd_decode_dct_block_12_444(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:481
NULL
#define NULL
Definition: coverity.c:32
DNXHDContext::avctx
AVCodecContext * avctx
Definition: dnxhddec.c:54
DNXHD_VARIABLE
#define DNXHD_VARIABLE
Indicate that a CIDEntry value must be read in the bitstream.
Definition: dnxhddata.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
DNXHDContext::lla
int lla
Definition: dnxhddec.c:73
profiles.h
DNXHDContext::bdsp
BlockDSPContext bdsp
Definition: dnxhddec.c:56
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:432
dnxhd_decode_init
static av_cold int dnxhd_decode_init(AVCodecContext *avctx)
Definition: dnxhddec.c:94
cid
uint16_t cid
Definition: mxfenc.c:2042
RowContext::format
int format
-1:not set yet 0:off=RGB 1:on=YUV 2:variable
Definition: dnxhddec.c:50
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
shift1
static const int shift1[6]
Definition: dxa.c:48
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:422
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:352
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:259
AVPacket::size
int size
Definition: packet.h:375
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:115
codec_internal.h
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:436
RowContext
Definition: dnxhddec.c:41
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:438
RowContext::gb
GetBitContext gb
Definition: dnxhddec.c:45
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
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:42
RowContext::last_qscale
int last_qscale
Definition: dnxhddec.c:47
ff_dnxhd_get_cid_table
const CIDEntry * ff_dnxhd_get_cid_table(int cid)
Definition: dnxhddata.c:1080
DNXHDContext::cid
int64_t cid
compression id
Definition: dnxhddec.c:59
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:477
NEG_USR32
#define NEG_USR32(a, s)
Definition: mathops.h:169
DNXHDContext::decode_dct_block
int(* decode_dct_block)(const struct DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:76
FF_PROFILE_DNXHR_SQ
#define FF_PROFILE_DNXHR_SQ
Definition: avcodec.h:1567
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVCOL_SPC_BT2020_NCL
@ AVCOL_SPC_BT2020_NCL
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:567
ff_init_scantable
av_cold void ff_init_scantable(const uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:30
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:448
av_always_inline
#define av_always_inline
Definition: attributes.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
len
int len
Definition: vorbis_enc_data.h:426
DNXHDContext::run_vlc
VLC run_vlc
Definition: dnxhddec.c:66
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:559
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
DNXHDContext::pix_fmt
enum AVPixelFormat pix_fmt
Definition: dnxhddec.c:61
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: vlc.c:375
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:85
RowContext::last_dc
int last_dc[3]
Definition: dnxhddec.c:46
IDCTDSPContext
Definition: idctdsp.h:53
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:150
DNXHDContext::buf
const uint8_t * buf
Definition: dnxhddec.c:57
AVCodecContext
main external API structure.
Definition: avcodec.h:398
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
VLC
Definition: vlc.h:31
dnxhd_init_vlc
static int dnxhd_init_vlc(DNXHDContext *ctx, uint32_t cid, int bitdepth)
Definition: dnxhddec.c:114
FF_PROFILE_DNXHR_HQX
#define FF_PROFILE_DNXHR_HQX
Definition: avcodec.h:1569
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:586
DNXHDContext::width
unsigned int width
Definition: dnxhddec.c:60
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
DNXHDContext::mbaff
int mbaff
Definition: dnxhddec.c:74
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
ScanTable
Scantable.
Definition: idctdsp.h:31
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
dnxhd_decode_macroblock
static int dnxhd_decode_macroblock(const DNXHDContext *ctx, RowContext *row, AVFrame *frame, int x, int y)
Definition: dnxhddec.c:487
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
FF_PROFILE_DNXHR_444
#define FF_PROFILE_DNXHR_444
Definition: avcodec.h:1570
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
dnxhd_decode_dct_block_10_444
static int dnxhd_decode_dct_block_10_444(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:469
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:589
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:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
DNXHDContext::dc_vlc
VLC dc_vlc
Definition: dnxhddec.c:66
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:558
int
int
Definition: ffmpeg_filter.c:156
first_field
static int first_field(const struct video_data *s)
Definition: v4l2.c:246
dnxhd_decode_dct_block_8
static int dnxhd_decode_dct_block_8(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:457
DNXHDContext::cid_table
const CIDEntry * cid_table
Definition: dnxhddec.c:69
dnxhd_decode_dct_block_10
static int dnxhd_decode_dct_block_10(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:463
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:1536
AV_CODEC_ID_DNXHD
@ AV_CODEC_ID_DNXHD
Definition: codec_id.h:151
dnxhd_decode_dct_block_12
static int dnxhd_decode_dct_block_12(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:475
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:2780
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:68