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
68  uint8_t permutated_scantable[64];
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;
199  if (first_field ^ ctx->cur_field)
201  av_log(ctx->avctx, AV_LOG_DEBUG,
202  "interlaced %d, cur field %d\n", buf[5] & 3, ctx->cur_field);
203  } else {
204  ctx->cur_field = 0;
205  }
206  ctx->mbaff = (buf[0x6] >> 5) & 1;
207  ctx->alpha = buf[0x7] & 1;
208  ctx->lla = (buf[0x7] >> 1) & 1;
209  if (ctx->alpha)
210  avpriv_request_sample(ctx->avctx, "alpha");
211 
212  ctx->height = AV_RB16(buf + 0x18);
213  ctx->width = AV_RB16(buf + 0x1a);
214 
215  switch(buf[0x21] >> 5) {
216  case 1: bitdepth = 8; break;
217  case 2: bitdepth = 10; break;
218  case 3: bitdepth = 12; break;
219  default:
220  av_log(ctx->avctx, AV_LOG_ERROR,
221  "Unknown bitdepth indicator (%d)\n", buf[0x21] >> 5);
222  return AVERROR_INVALIDDATA;
223  }
224 
225  cid = AV_RB32(buf + 0x28);
226 
227  ctx->avctx->profile = dnxhd_get_profile(cid);
228 
229  if ((ret = dnxhd_init_vlc(ctx, cid, bitdepth)) < 0)
230  return ret;
231  if (ctx->mbaff && ctx->cid_table->cid != 1260)
232  av_log(ctx->avctx, AV_LOG_WARNING,
233  "Adaptive MB interlace flag in an unsupported profile.\n");
234 
235  switch ((buf[0x2C] >> 1) & 3) {
236  case 0: frame->colorspace = AVCOL_SPC_BT709; break;
237  case 1: frame->colorspace = AVCOL_SPC_BT2020_NCL; break;
238  case 2: frame->colorspace = AVCOL_SPC_BT2020_CL; break;
239  case 3: frame->colorspace = AVCOL_SPC_UNSPECIFIED; break;
240  }
241 
242  ctx->act = buf[0x2C] & 1;
243  if (ctx->act && ctx->cid_table->cid != 1256 && ctx->cid_table->cid != 1270)
244  av_log(ctx->avctx, AV_LOG_WARNING,
245  "Adaptive color transform in an unsupported profile.\n");
246 
247  ctx->is_444 = (buf[0x2C] >> 6) & 1;
248  if (ctx->is_444) {
249  if (bitdepth == 8) {
250  avpriv_request_sample(ctx->avctx, "4:4:4 8 bits");
251  return AVERROR_INVALIDDATA;
252  } else if (bitdepth == 10) {
253  ctx->decode_dct_block = dnxhd_decode_dct_block_10_444;
254  ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P10
256  } else {
257  ctx->decode_dct_block = dnxhd_decode_dct_block_12_444;
258  ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P12
260  }
261  } else if (bitdepth == 12) {
262  ctx->decode_dct_block = dnxhd_decode_dct_block_12;
263  ctx->pix_fmt = AV_PIX_FMT_YUV422P12;
264  } else if (bitdepth == 10) {
265  if (ctx->avctx->profile == FF_PROFILE_DNXHR_HQX)
266  ctx->decode_dct_block = dnxhd_decode_dct_block_10_444;
267  else
268  ctx->decode_dct_block = dnxhd_decode_dct_block_10;
269  ctx->pix_fmt = AV_PIX_FMT_YUV422P10;
270  } else {
271  ctx->decode_dct_block = dnxhd_decode_dct_block_8;
272  ctx->pix_fmt = AV_PIX_FMT_YUV422P;
273  }
274 
275  ctx->avctx->bits_per_raw_sample = ctx->bit_depth = bitdepth;
276  if (ctx->bit_depth != old_bit_depth) {
277  ff_blockdsp_init(&ctx->bdsp);
278  ff_idctdsp_init(&ctx->idsp, ctx->avctx);
279  ff_permute_scantable(ctx->permutated_scantable, ff_zigzag_direct,
280  ctx->idsp.idct_permutation);
281  }
282 
283  // make sure profile size constraints are respected
284  // DNx100 allows 1920->1440 and 1280->960 subsampling
285  if (ctx->width != ctx->cid_table->width &&
286  ctx->cid_table->width != DNXHD_VARIABLE) {
287  av_reduce(&ctx->avctx->sample_aspect_ratio.num,
288  &ctx->avctx->sample_aspect_ratio.den,
289  ctx->width, ctx->cid_table->width, 255);
290  ctx->width = ctx->cid_table->width;
291  }
292 
293  if (buf_size < ctx->cid_table->coding_unit_size) {
294  av_log(ctx->avctx, AV_LOG_ERROR, "incorrect frame size (%d < %u).\n",
295  buf_size, ctx->cid_table->coding_unit_size);
296  return AVERROR_INVALIDDATA;
297  }
298 
299  ctx->mb_width = (ctx->width + 15)>> 4;
300  ctx->mb_height = AV_RB16(buf + 0x16c);
301 
302  if ((ctx->height + 15) >> 4 == ctx->mb_height && (frame->flags & AV_FRAME_FLAG_INTERLACED))
303  ctx->height <<= 1;
304 
305  av_log(ctx->avctx, AV_LOG_VERBOSE, "%dx%d, 4:%s %d bits, MBAFF=%d ACT=%d\n",
306  ctx->width, ctx->height, ctx->is_444 ? "4:4" : "2:2",
307  ctx->bit_depth, ctx->mbaff, ctx->act);
308 
309  // Newer format supports variable mb_scan_index sizes
310  if (ctx->mb_height > 68 && ff_dnxhd_check_header_prefix_hr(header_prefix)) {
311  ctx->data_offset = 0x170 + (ctx->mb_height << 2);
312  } else {
313  if (ctx->mb_height > 68) {
314  av_log(ctx->avctx, AV_LOG_ERROR,
315  "mb height too big: %d\n", ctx->mb_height);
316  return AVERROR_INVALIDDATA;
317  }
318  ctx->data_offset = 0x280;
319  }
320  if ((ctx->mb_height << !!(frame->flags & AV_FRAME_FLAG_INTERLACED)) > (ctx->height + 15) >> 4) {
321  av_log(ctx->avctx, AV_LOG_ERROR,
322  "mb height too big: %d\n", ctx->mb_height);
323  return AVERROR_INVALIDDATA;
324  }
325 
326  if (buf_size < ctx->data_offset) {
327  av_log(ctx->avctx, AV_LOG_ERROR,
328  "buffer too small (%d < %d).\n", buf_size, ctx->data_offset);
329  return AVERROR_INVALIDDATA;
330  }
331 
332  if (ctx->mb_height > FF_ARRAY_ELEMS(ctx->mb_scan_index)) {
333  av_log(ctx->avctx, AV_LOG_ERROR,
334  "mb_height too big (%d > %"SIZE_SPECIFIER").\n", ctx->mb_height, FF_ARRAY_ELEMS(ctx->mb_scan_index));
335  return AVERROR_INVALIDDATA;
336  }
337 
338  for (i = 0; i < ctx->mb_height; i++) {
339  ctx->mb_scan_index[i] = AV_RB32(buf + 0x170 + (i << 2));
340  ff_dlog(ctx->avctx, "mb scan index %d, pos %d: %"PRIu32"\n",
341  i, 0x170 + (i << 2), ctx->mb_scan_index[i]);
342  if (buf_size - ctx->data_offset < ctx->mb_scan_index[i]) {
343  av_log(ctx->avctx, AV_LOG_ERROR,
344  "invalid mb scan index (%"PRIu32" vs %u).\n",
345  ctx->mb_scan_index[i], buf_size - ctx->data_offset);
346  return AVERROR_INVALIDDATA;
347  }
348  }
349 
350  return 0;
351 }
352 
354  RowContext *row,
355  int n,
356  int index_bits,
357  int level_bias,
358  int level_shift,
359  int dc_shift)
360 {
361  int i, j, index1, index2, len, flags;
362  int level, component, sign;
363  const int *scale;
364  const uint8_t *weight_matrix;
365  const uint8_t *ac_info = ctx->cid_table->ac_info;
366  int16_t *block = row->blocks[n];
367  const int eob_index = ctx->cid_table->eob_index;
368  int ret = 0;
369  OPEN_READER(bs, &row->gb);
370 
371  ctx->bdsp.clear_block(block);
372 
373  if (!ctx->is_444) {
374  if (n & 2) {
375  component = 1 + (n & 1);
376  scale = row->chroma_scale;
377  weight_matrix = ctx->cid_table->chroma_weight;
378  } else {
379  component = 0;
380  scale = row->luma_scale;
381  weight_matrix = ctx->cid_table->luma_weight;
382  }
383  } else {
384  component = (n >> 1) % 3;
385  if (component) {
386  scale = row->chroma_scale;
387  weight_matrix = ctx->cid_table->chroma_weight;
388  } else {
389  scale = row->luma_scale;
390  weight_matrix = ctx->cid_table->luma_weight;
391  }
392  }
393 
394  UPDATE_CACHE(bs, &row->gb);
395  GET_VLC(len, bs, &row->gb, ctx->dc_vlc.table, DNXHD_DC_VLC_BITS, 1);
396  if (len < 0) {
397  ret = len;
398  goto error;
399  }
400  if (len) {
401  level = GET_CACHE(bs, &row->gb);
402  LAST_SKIP_BITS(bs, &row->gb, len);
403  sign = ~level >> 31;
404  level = (NEG_USR32(sign ^ level, len) ^ sign) - sign;
405  row->last_dc[component] += level * (1 << dc_shift);
406  }
407  block[0] = row->last_dc[component];
408 
409  i = 0;
410 
411  UPDATE_CACHE(bs, &row->gb);
412  GET_VLC(index1, bs, &row->gb, ctx->ac_vlc.table,
413  DNXHD_VLC_BITS, 2);
414 
415  while (index1 != eob_index) {
416  level = ac_info[2*index1+0];
417  flags = ac_info[2*index1+1];
418 
419  sign = SHOW_SBITS(bs, &row->gb, 1);
420  SKIP_BITS(bs, &row->gb, 1);
421 
422  if (flags & 1) {
423  level += SHOW_UBITS(bs, &row->gb, index_bits) << 7;
424  SKIP_BITS(bs, &row->gb, index_bits);
425  }
426 
427  if (flags & 2) {
428  UPDATE_CACHE(bs, &row->gb);
429  GET_VLC(index2, bs, &row->gb, ctx->run_vlc.table,
430  DNXHD_VLC_BITS, 2);
431  i += ctx->cid_table->run[index2];
432  }
433 
434  if (++i > 63) {
435  av_log(ctx->avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", n, i);
436  ret = -1;
437  break;
438  }
439 
440  j = ctx->permutated_scantable[i];
441  level *= scale[i];
442  level += scale[i] >> 1;
443  if (level_bias < 32 || weight_matrix[i] != level_bias)
444  level += level_bias; // 1<<(level_shift-1)
445  level >>= level_shift;
446 
447  block[j] = (level ^ sign) - sign;
448 
449  UPDATE_CACHE(bs, &row->gb);
450  GET_VLC(index1, bs, &row->gb, ctx->ac_vlc.table,
451  DNXHD_VLC_BITS, 2);
452  }
453 error:
454  CLOSE_READER(bs, &row->gb);
455  return ret;
456 }
457 
459  RowContext *row, int n)
460 {
461  return dnxhd_decode_dct_block(ctx, row, n, 4, 32, 6, 0);
462 }
463 
465  RowContext *row, int n)
466 {
467  return dnxhd_decode_dct_block(ctx, row, n, 6, 8, 4, 0);
468 }
469 
471  RowContext *row, int n)
472 {
473  return dnxhd_decode_dct_block(ctx, row, n, 6, 32, 6, 0);
474 }
475 
477  RowContext *row, int n)
478 {
479  return dnxhd_decode_dct_block(ctx, row, n, 6, 8, 4, 2);
480 }
481 
483  RowContext *row, int n)
484 {
485  return dnxhd_decode_dct_block(ctx, row, n, 6, 32, 4, 2);
486 }
487 
489  AVFrame *frame, int x, int y)
490 {
491  int shift1 = ctx->bit_depth >= 10;
492  int dct_linesize_luma = frame->linesize[0];
493  int dct_linesize_chroma = frame->linesize[1];
494  uint8_t *dest_y, *dest_u, *dest_v;
495  int dct_y_offset, dct_x_offset;
496  int qscale, i, act;
497  int interlaced_mb = 0;
498 
499  if (ctx->mbaff) {
500  interlaced_mb = get_bits1(&row->gb);
501  qscale = get_bits(&row->gb, 10);
502  } else {
503  qscale = get_bits(&row->gb, 11);
504  }
505  act = get_bits1(&row->gb);
506  if (act) {
507  if (!ctx->act) {
508  static int act_warned;
509  if (!act_warned) {
510  act_warned = 1;
511  av_log(ctx->avctx, AV_LOG_ERROR,
512  "ACT flag set, in violation of frame header.\n");
513  }
514  } else if (row->format == -1) {
515  row->format = act;
516  } else if (row->format != act) {
517  row->format = 2; // Variable
518  }
519  }
520 
521  if (qscale != row->last_qscale) {
522  for (i = 0; i < 64; i++) {
523  row->luma_scale[i] = qscale * ctx->cid_table->luma_weight[i];
524  row->chroma_scale[i] = qscale * ctx->cid_table->chroma_weight[i];
525  }
526  row->last_qscale = qscale;
527  }
528 
529  for (i = 0; i < 8 + 4 * ctx->is_444; i++) {
530  if (ctx->decode_dct_block(ctx, row, i) < 0)
531  return AVERROR_INVALIDDATA;
532  }
533 
534  if (frame->flags & AV_FRAME_FLAG_INTERLACED) {
535  dct_linesize_luma <<= 1;
536  dct_linesize_chroma <<= 1;
537  }
538 
539  dest_y = frame->data[0] + ((y * dct_linesize_luma) << 4) + (x << (4 + shift1));
540  dest_u = frame->data[1] + ((y * dct_linesize_chroma) << 4) + (x << (3 + shift1 + ctx->is_444));
541  dest_v = frame->data[2] + ((y * dct_linesize_chroma) << 4) + (x << (3 + shift1 + ctx->is_444));
542 
543  if ((frame->flags & AV_FRAME_FLAG_INTERLACED) && ctx->cur_field) {
544  dest_y += frame->linesize[0];
545  dest_u += frame->linesize[1];
546  dest_v += frame->linesize[2];
547  }
548  if (interlaced_mb) {
549  dct_linesize_luma <<= 1;
550  dct_linesize_chroma <<= 1;
551  }
552 
553  dct_y_offset = interlaced_mb ? frame->linesize[0] : (dct_linesize_luma << 3);
554  dct_x_offset = 8 << shift1;
555  if (!ctx->is_444) {
556  ctx->idsp.idct_put(dest_y, dct_linesize_luma, row->blocks[0]);
557  ctx->idsp.idct_put(dest_y + dct_x_offset, dct_linesize_luma, row->blocks[1]);
558  ctx->idsp.idct_put(dest_y + dct_y_offset, dct_linesize_luma, row->blocks[4]);
559  ctx->idsp.idct_put(dest_y + dct_y_offset + dct_x_offset, dct_linesize_luma, row->blocks[5]);
560 
561  if (!(ctx->avctx->flags & AV_CODEC_FLAG_GRAY)) {
562  dct_y_offset = interlaced_mb ? frame->linesize[1] : (dct_linesize_chroma << 3);
563  ctx->idsp.idct_put(dest_u, dct_linesize_chroma, row->blocks[2]);
564  ctx->idsp.idct_put(dest_v, dct_linesize_chroma, row->blocks[3]);
565  ctx->idsp.idct_put(dest_u + dct_y_offset, dct_linesize_chroma, row->blocks[6]);
566  ctx->idsp.idct_put(dest_v + dct_y_offset, dct_linesize_chroma, row->blocks[7]);
567  }
568  } else {
569  ctx->idsp.idct_put(dest_y, dct_linesize_luma, row->blocks[0]);
570  ctx->idsp.idct_put(dest_y + dct_x_offset, dct_linesize_luma, row->blocks[1]);
571  ctx->idsp.idct_put(dest_y + dct_y_offset, dct_linesize_luma, row->blocks[6]);
572  ctx->idsp.idct_put(dest_y + dct_y_offset + dct_x_offset, dct_linesize_luma, row->blocks[7]);
573 
574  if (!(ctx->avctx->flags & AV_CODEC_FLAG_GRAY)) {
575  dct_y_offset = interlaced_mb ? frame->linesize[1] : (dct_linesize_chroma << 3);
576  ctx->idsp.idct_put(dest_u, dct_linesize_chroma, row->blocks[2]);
577  ctx->idsp.idct_put(dest_u + dct_x_offset, dct_linesize_chroma, row->blocks[3]);
578  ctx->idsp.idct_put(dest_u + dct_y_offset, dct_linesize_chroma, row->blocks[8]);
579  ctx->idsp.idct_put(dest_u + dct_y_offset + dct_x_offset, dct_linesize_chroma, row->blocks[9]);
580  ctx->idsp.idct_put(dest_v, dct_linesize_chroma, row->blocks[4]);
581  ctx->idsp.idct_put(dest_v + dct_x_offset, dct_linesize_chroma, row->blocks[5]);
582  ctx->idsp.idct_put(dest_v + dct_y_offset, dct_linesize_chroma, row->blocks[10]);
583  ctx->idsp.idct_put(dest_v + dct_y_offset + dct_x_offset, dct_linesize_chroma, row->blocks[11]);
584  }
585  }
586 
587  return 0;
588 }
589 
591  int rownb, int threadnb)
592 {
593  const DNXHDContext *ctx = avctx->priv_data;
594  uint32_t offset = ctx->mb_scan_index[rownb];
595  RowContext *row = ctx->rows + threadnb;
596  int x, ret;
597 
598  row->last_dc[0] =
599  row->last_dc[1] =
600  row->last_dc[2] = 1 << (ctx->bit_depth + 2); // for levels +2^(bitdepth-1)
601  ret = init_get_bits8(&row->gb, ctx->buf + offset, ctx->buf_size - offset);
602  if (ret < 0) {
603  row->errors++;
604  return ret;
605  }
606  for (x = 0; x < ctx->mb_width; x++) {
607  int ret = dnxhd_decode_macroblock(ctx, row, data, x, rownb);
608  if (ret < 0) {
609  row->errors++;
610  return ret;
611  }
612  }
613 
614  return 0;
615 }
616 
618  int *got_frame, AVPacket *avpkt)
619 {
620  const uint8_t *buf = avpkt->data;
621  int buf_size = avpkt->size;
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, picture, 0)) < 0)
654  return ret;
655  picture->pict_type = AV_PICTURE_TYPE_I;
656  picture->flags |= AV_FRAME_FLAG_KEY;
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->flags & AV_FRAME_FLAG_INTERLACED)) {
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  .p.name = "dnxhd",
730  CODEC_LONG_NAME("VC3/DNxHD"),
731  .p.type = AVMEDIA_TYPE_VIDEO,
732  .p.id = AV_CODEC_ID_DNXHD,
733  .priv_data_size = sizeof(DNXHDContext),
735  .close = dnxhd_decode_close,
737  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
740 };
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:1023
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:553
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
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:148
DNXHDContext::rows
RowContext * rows
Definition: dnxhddec.c:55
FFCodec
Definition: codec_internal.h:127
FF_PROFILE_DNXHD
#define FF_PROFILE_DNXHD
Definition: avcodec.h:1604
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:216
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:639
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:607
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: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
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:631
DNXHDContext::mb_scan_index
uint32_t mb_scan_index[512]
Definition: dnxhddec.c:63
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:253
DNXHD_VLC_BITS
#define DNXHD_VLC_BITS
Definition: dnxhddec.c:80
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:325
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:131
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:617
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1526
DNXHDContext
Definition: dnxhddec.c:53
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:481
DNXHDContext::idsp
IDCTDSPContext idsp
Definition: dnxhddec.c:67
GetBitContext
Definition: get_bits.h:107
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
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:630
ff_dnxhd_decoder
const FFCodec ff_dnxhd_decoder
Definition: dnxhddec.c:728
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:1605
CIDEntry
Definition: dnxhddata.h:43
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:468
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:524
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:618
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:187
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:159
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
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:1222
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:250
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
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:231
DNXHDContext::mb_width
unsigned int mb_width
Definition: dnxhddec.c:62
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
ff_dnxhd_profiles
const AVProfile ff_dnxhd_profiles[]
Definition: profiles.c:60
if
if(ret)
Definition: filter_design.txt:179
FF_PROFILE_DNXHR_HQ
#define FF_PROFILE_DNXHR_HQ
Definition: avcodec.h:1607
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: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:482
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:378
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:237
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:466
dnxhd_decode_init
static av_cold int dnxhd_decode_init(AVCodecContext *avctx)
Definition: dnxhddec.c:94
cid
uint16_t cid
Definition: mxfenc.c:2147
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:432
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:353
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:310
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:114
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:87
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:470
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:472
RowContext::gb
GetBitContext gb
Definition: dnxhddec.c:45
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:176
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:42
RowContext::last_qscale
int last_qscale
Definition: dnxhddec.c:47
DNXHDContext::permutated_scantable
uint8_t permutated_scantable[64]
Definition: dnxhddec.c:68
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
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:76
FF_PROFILE_DNXHR_SQ
#define FF_PROFILE_DNXHR_SQ
Definition: avcodec.h:1606
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:606
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:482
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:66
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:598
AVCodecContext::height
int height
Definition: avcodec.h:615
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:652
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:626
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:262
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:44
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:149
DNXHDContext::buf
const uint8_t * buf
Definition: dnxhddec.c:57
AVCodecContext
main external API structure.
Definition: avcodec.h:435
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:249
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:1608
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:630
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
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:462
dnxhd_decode_macroblock
static int dnxhd_decode_macroblock(const DNXHDContext *ctx, RowContext *row, AVFrame *frame, int x, int y)
Definition: dnxhddec.c:488
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
FF_PROFILE_DNXHR_444
#define FF_PROFILE_DNXHR_444
Definition: avcodec.h:1609
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:615
dnxhd_decode_dct_block_10_444
static int dnxhd_decode_dct_block_10_444(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:470
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:590
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:597
int
int
Definition: ffmpeg_filter.c:354
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:458
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:464
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:1575
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:476
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:2856
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