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