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