FFmpeg  4.3
dnxhddec.c
Go to the documentation of this file.
1 /*
2  * VC3/DNxHD decoder.
3  * Copyright (c) 2007 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
4  * Copyright (c) 2011 MirriAd Ltd
5  * Copyright (c) 2015 Christophe Gisquet
6  *
7  * 10 bit support added by MirriAd Ltd, Joseph Artsimovich <joseph@mirriad.com>
8  * Slice multithreading and MB interlaced support added by Christophe Gisquet
9  *
10  * This file is part of FFmpeg.
11  *
12  * FFmpeg is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU Lesser General Public
14  * License as published by the Free Software Foundation; either
15  * version 2.1 of the License, or (at your option) any later version.
16  *
17  * FFmpeg is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20  * Lesser General Public License for more details.
21  *
22  * You should have received a copy of the GNU Lesser General Public
23  * License along with FFmpeg; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25  */
26 
27 #include "libavutil/imgutils.h"
28 #include "avcodec.h"
29 #include "blockdsp.h"
30 #define UNCHECKED_BITSTREAM_READER 1
31 #include "get_bits.h"
32 #include "dnxhddata.h"
33 #include "idctdsp.h"
34 #include "internal.h"
35 #include "profiles.h"
36 #include "thread.h"
37 
38 typedef struct RowContext {
39  DECLARE_ALIGNED(32, int16_t, blocks)[12][64];
40  int luma_scale[64];
41  int chroma_scale[64];
43  int last_dc[3];
45  int errors;
46  /** -1:not set yet 0:off=RGB 1:on=YUV 2:variable */
47  int format;
48 } RowContext;
49 
50 typedef struct DNXHDContext {
54  const uint8_t* buf;
55  int buf_size;
56  int64_t cid; ///< compression id
57  unsigned int width, height;
59  unsigned int mb_width, mb_height;
60  uint32_t mb_scan_index[512];
61  int data_offset; // End of mb_scan_index, where macroblocks start
62  int cur_field; ///< current interlaced field
67  int bit_depth; // 8, 10, 12 or 0 if not initialized at all.
68  int is_444;
69  int alpha;
70  int lla;
71  int mbaff;
72  int act;
74  RowContext *row, int n);
75 } DNXHDContext;
76 
77 #define DNXHD_VLC_BITS 9
78 #define DNXHD_DC_VLC_BITS 7
79 
80 static int dnxhd_decode_dct_block_8(const DNXHDContext *ctx,
81  RowContext *row, int n);
83  RowContext *row, int n);
85  RowContext *row, int n);
87  RowContext *row, int n);
89  RowContext *row, int n);
90 
92 {
94 
95  ctx->avctx = avctx;
96  ctx->cid = -1;
99  }
100 
103 
104  ctx->rows = av_mallocz_array(avctx->thread_count, sizeof(RowContext));
105  if (!ctx->rows)
106  return AVERROR(ENOMEM);
107 
108  return 0;
109 }
110 
111 static int dnxhd_init_vlc(DNXHDContext *ctx, uint32_t cid, int bitdepth)
112 {
113  if (cid != ctx->cid) {
114  int index;
115 
116  if ((index = ff_dnxhd_get_cid_table(cid)) < 0) {
117  av_log(ctx->avctx, AV_LOG_ERROR, "unsupported cid %"PRIu32"\n", cid);
118  return AVERROR(ENOSYS);
119  }
120  if (ff_dnxhd_cid_table[index].bit_depth != bitdepth &&
122  av_log(ctx->avctx, AV_LOG_ERROR, "bit depth mismatches %d %d\n", ff_dnxhd_cid_table[index].bit_depth, bitdepth);
123  return AVERROR_INVALIDDATA;
124  }
125  ctx->cid_table = &ff_dnxhd_cid_table[index];
126  av_log(ctx->avctx, AV_LOG_VERBOSE, "Profile cid %"PRIu32".\n", cid);
127 
128  ff_free_vlc(&ctx->ac_vlc);
129  ff_free_vlc(&ctx->dc_vlc);
130  ff_free_vlc(&ctx->run_vlc);
131 
132  init_vlc(&ctx->ac_vlc, DNXHD_VLC_BITS, 257,
133  ctx->cid_table->ac_bits, 1, 1,
134  ctx->cid_table->ac_codes, 2, 2, 0);
135  init_vlc(&ctx->dc_vlc, DNXHD_DC_VLC_BITS, bitdepth > 8 ? 14 : 12,
136  ctx->cid_table->dc_bits, 1, 1,
137  ctx->cid_table->dc_codes, 1, 1, 0);
138  init_vlc(&ctx->run_vlc, DNXHD_VLC_BITS, 62,
139  ctx->cid_table->run_bits, 1, 1,
140  ctx->cid_table->run_codes, 2, 2, 0);
141 
142  ctx->cid = cid;
143  }
144  return 0;
145 }
146 
147 static int dnxhd_get_profile(int cid)
148 {
149  switch(cid) {
150  case 1270:
151  return FF_PROFILE_DNXHR_444;
152  case 1271:
153  return FF_PROFILE_DNXHR_HQX;
154  case 1272:
155  return FF_PROFILE_DNXHR_HQ;
156  case 1273:
157  return FF_PROFILE_DNXHR_SQ;
158  case 1274:
159  return FF_PROFILE_DNXHR_LB;
160  }
161  return FF_PROFILE_DNXHD;
162 }
163 
165  const uint8_t *buf, int buf_size,
166  int first_field)
167 {
168  int i, cid, ret;
169  int old_bit_depth = ctx->bit_depth, bitdepth;
170  uint64_t header_prefix;
171  if (buf_size < 0x280) {
172  av_log(ctx->avctx, AV_LOG_ERROR,
173  "buffer too small (%d < 640).\n", buf_size);
174  return AVERROR_INVALIDDATA;
175  }
176 
177  header_prefix = ff_dnxhd_parse_header_prefix(buf);
178  if (header_prefix == 0) {
179  av_log(ctx->avctx, AV_LOG_ERROR,
180  "unknown header 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n",
181  buf[0], buf[1], buf[2], buf[3], buf[4]);
182  return AVERROR_INVALIDDATA;
183  }
184  if (buf[5] & 2) { /* interlaced */
185  ctx->cur_field = buf[5] & 1;
186  frame->interlaced_frame = 1;
187  frame->top_field_first = first_field ^ ctx->cur_field;
188  av_log(ctx->avctx, AV_LOG_DEBUG,
189  "interlaced %d, cur field %d\n", buf[5] & 3, ctx->cur_field);
190  } else {
191  ctx->cur_field = 0;
192  }
193  ctx->mbaff = (buf[0x6] >> 5) & 1;
194  ctx->alpha = buf[0x7] & 1;
195  ctx->lla = (buf[0x7] >> 1) & 1;
196  if (ctx->alpha)
197  avpriv_request_sample(ctx->avctx, "alpha");
198 
199  ctx->height = AV_RB16(buf + 0x18);
200  ctx->width = AV_RB16(buf + 0x1a);
201 
202  switch(buf[0x21] >> 5) {
203  case 1: bitdepth = 8; break;
204  case 2: bitdepth = 10; break;
205  case 3: bitdepth = 12; break;
206  default:
207  av_log(ctx->avctx, AV_LOG_ERROR,
208  "Unknown bitdepth indicator (%d)\n", buf[0x21] >> 5);
209  return AVERROR_INVALIDDATA;
210  }
211 
212  cid = AV_RB32(buf + 0x28);
213 
214  ctx->avctx->profile = dnxhd_get_profile(cid);
215 
216  if ((ret = dnxhd_init_vlc(ctx, cid, bitdepth)) < 0)
217  return ret;
218  if (ctx->mbaff && ctx->cid_table->cid != 1260)
219  av_log(ctx->avctx, AV_LOG_WARNING,
220  "Adaptive MB interlace flag in an unsupported profile.\n");
221 
222  switch ((buf[0x2C] >> 1) & 3) {
223  case 0: frame->colorspace = AVCOL_SPC_BT709; break;
224  case 1: frame->colorspace = AVCOL_SPC_BT2020_NCL; break;
225  case 2: frame->colorspace = AVCOL_SPC_BT2020_CL; break;
226  case 3: frame->colorspace = AVCOL_SPC_UNSPECIFIED; break;
227  }
228 
229  ctx->act = buf[0x2C] & 1;
230  if (ctx->act && ctx->cid_table->cid != 1256 && ctx->cid_table->cid != 1270)
231  av_log(ctx->avctx, AV_LOG_WARNING,
232  "Adaptive color transform in an unsupported profile.\n");
233 
234  ctx->is_444 = (buf[0x2C] >> 6) & 1;
235  if (ctx->is_444) {
236  if (bitdepth == 8) {
237  avpriv_request_sample(ctx->avctx, "4:4:4 8 bits");
238  return AVERROR_INVALIDDATA;
239  } else if (bitdepth == 10) {
240  ctx->decode_dct_block = dnxhd_decode_dct_block_10_444;
241  ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P10
243  } else {
244  ctx->decode_dct_block = dnxhd_decode_dct_block_12_444;
245  ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P12
247  }
248  } else if (bitdepth == 12) {
249  ctx->decode_dct_block = dnxhd_decode_dct_block_12;
250  ctx->pix_fmt = AV_PIX_FMT_YUV422P12;
251  } else if (bitdepth == 10) {
252  if (ctx->avctx->profile == FF_PROFILE_DNXHR_HQX)
253  ctx->decode_dct_block = dnxhd_decode_dct_block_10_444;
254  else
255  ctx->decode_dct_block = dnxhd_decode_dct_block_10;
256  ctx->pix_fmt = AV_PIX_FMT_YUV422P10;
257  } else {
258  ctx->decode_dct_block = dnxhd_decode_dct_block_8;
259  ctx->pix_fmt = AV_PIX_FMT_YUV422P;
260  }
261 
262  ctx->avctx->bits_per_raw_sample = ctx->bit_depth = bitdepth;
263  if (ctx->bit_depth != old_bit_depth) {
264  ff_blockdsp_init(&ctx->bdsp, ctx->avctx);
265  ff_idctdsp_init(&ctx->idsp, ctx->avctx);
266  ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable,
268  }
269 
270  // make sure profile size constraints are respected
271  // DNx100 allows 1920->1440 and 1280->960 subsampling
272  if (ctx->width != ctx->cid_table->width &&
273  ctx->cid_table->width != DNXHD_VARIABLE) {
274  av_reduce(&ctx->avctx->sample_aspect_ratio.num,
275  &ctx->avctx->sample_aspect_ratio.den,
276  ctx->width, ctx->cid_table->width, 255);
277  ctx->width = ctx->cid_table->width;
278  }
279 
280  if (buf_size < ctx->cid_table->coding_unit_size) {
281  av_log(ctx->avctx, AV_LOG_ERROR, "incorrect frame size (%d < %u).\n",
282  buf_size, ctx->cid_table->coding_unit_size);
283  return AVERROR_INVALIDDATA;
284  }
285 
286  ctx->mb_width = (ctx->width + 15)>> 4;
287  ctx->mb_height = AV_RB16(buf + 0x16c);
288 
289  if ((ctx->height + 15) >> 4 == ctx->mb_height && frame->interlaced_frame)
290  ctx->height <<= 1;
291 
292  av_log(ctx->avctx, AV_LOG_VERBOSE, "%dx%d, 4:%s %d bits, MBAFF=%d ACT=%d\n",
293  ctx->width, ctx->height, ctx->is_444 ? "4:4" : "2:2",
294  ctx->bit_depth, ctx->mbaff, ctx->act);
295 
296  // Newer format supports variable mb_scan_index sizes
297  if (ctx->mb_height > 68 && ff_dnxhd_check_header_prefix_hr(header_prefix)) {
298  ctx->data_offset = 0x170 + (ctx->mb_height << 2);
299  } else {
300  if (ctx->mb_height > 68) {
301  av_log(ctx->avctx, AV_LOG_ERROR,
302  "mb height too big: %d\n", ctx->mb_height);
303  return AVERROR_INVALIDDATA;
304  }
305  ctx->data_offset = 0x280;
306  }
307  if ((ctx->mb_height << frame->interlaced_frame) > (ctx->height + 15) >> 4) {
308  av_log(ctx->avctx, AV_LOG_ERROR,
309  "mb height too big: %d\n", ctx->mb_height);
310  return AVERROR_INVALIDDATA;
311  }
312 
313  if (buf_size < ctx->data_offset) {
314  av_log(ctx->avctx, AV_LOG_ERROR,
315  "buffer too small (%d < %d).\n", buf_size, ctx->data_offset);
316  return AVERROR_INVALIDDATA;
317  }
318 
319  if (ctx->mb_height > FF_ARRAY_ELEMS(ctx->mb_scan_index)) {
320  av_log(ctx->avctx, AV_LOG_ERROR,
321  "mb_height too big (%d > %"SIZE_SPECIFIER").\n", ctx->mb_height, FF_ARRAY_ELEMS(ctx->mb_scan_index));
322  return AVERROR_INVALIDDATA;
323  }
324 
325  for (i = 0; i < ctx->mb_height; i++) {
326  ctx->mb_scan_index[i] = AV_RB32(buf + 0x170 + (i << 2));
327  ff_dlog(ctx->avctx, "mb scan index %d, pos %d: %"PRIu32"\n",
328  i, 0x170 + (i << 2), ctx->mb_scan_index[i]);
329  if (buf_size - ctx->data_offset < ctx->mb_scan_index[i]) {
330  av_log(ctx->avctx, AV_LOG_ERROR,
331  "invalid mb scan index (%"PRIu32" vs %u).\n",
332  ctx->mb_scan_index[i], buf_size - ctx->data_offset);
333  return AVERROR_INVALIDDATA;
334  }
335  }
336 
337  return 0;
338 }
339 
341  RowContext *row,
342  int n,
343  int index_bits,
344  int level_bias,
345  int level_shift,
346  int dc_shift)
347 {
348  int i, j, index1, index2, len, flags;
349  int level, component, sign;
350  const int *scale;
351  const uint8_t *weight_matrix;
352  const uint8_t *ac_info = ctx->cid_table->ac_info;
353  int16_t *block = row->blocks[n];
354  const int eob_index = ctx->cid_table->eob_index;
355  int ret = 0;
356  OPEN_READER(bs, &row->gb);
357 
358  ctx->bdsp.clear_block(block);
359 
360  if (!ctx->is_444) {
361  if (n & 2) {
362  component = 1 + (n & 1);
363  scale = row->chroma_scale;
364  weight_matrix = ctx->cid_table->chroma_weight;
365  } else {
366  component = 0;
367  scale = row->luma_scale;
368  weight_matrix = ctx->cid_table->luma_weight;
369  }
370  } else {
371  component = (n >> 1) % 3;
372  if (component) {
373  scale = row->chroma_scale;
374  weight_matrix = ctx->cid_table->chroma_weight;
375  } else {
376  scale = row->luma_scale;
377  weight_matrix = ctx->cid_table->luma_weight;
378  }
379  }
380 
381  UPDATE_CACHE(bs, &row->gb);
382  GET_VLC(len, bs, &row->gb, ctx->dc_vlc.table, DNXHD_DC_VLC_BITS, 1);
383  if (len < 0) {
384  ret = len;
385  goto error;
386  }
387  if (len) {
388  level = GET_CACHE(bs, &row->gb);
389  LAST_SKIP_BITS(bs, &row->gb, len);
390  sign = ~level >> 31;
391  level = (NEG_USR32(sign ^ level, len) ^ sign) - sign;
392  row->last_dc[component] += level * (1 << dc_shift);
393  }
394  block[0] = row->last_dc[component];
395 
396  i = 0;
397 
398  UPDATE_CACHE(bs, &row->gb);
399  GET_VLC(index1, bs, &row->gb, ctx->ac_vlc.table,
400  DNXHD_VLC_BITS, 2);
401 
402  while (index1 != eob_index) {
403  level = ac_info[2*index1+0];
404  flags = ac_info[2*index1+1];
405 
406  sign = SHOW_SBITS(bs, &row->gb, 1);
407  SKIP_BITS(bs, &row->gb, 1);
408 
409  if (flags & 1) {
410  level += SHOW_UBITS(bs, &row->gb, index_bits) << 7;
411  SKIP_BITS(bs, &row->gb, index_bits);
412  }
413 
414  if (flags & 2) {
415  UPDATE_CACHE(bs, &row->gb);
416  GET_VLC(index2, bs, &row->gb, ctx->run_vlc.table,
417  DNXHD_VLC_BITS, 2);
418  i += ctx->cid_table->run[index2];
419  }
420 
421  if (++i > 63) {
422  av_log(ctx->avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", n, i);
423  ret = -1;
424  break;
425  }
426 
427  j = ctx->scantable.permutated[i];
428  level *= scale[i];
429  level += scale[i] >> 1;
430  if (level_bias < 32 || weight_matrix[i] != level_bias)
431  level += level_bias; // 1<<(level_shift-1)
432  level >>= level_shift;
433 
434  block[j] = (level ^ sign) - sign;
435 
436  UPDATE_CACHE(bs, &row->gb);
437  GET_VLC(index1, bs, &row->gb, ctx->ac_vlc.table,
438  DNXHD_VLC_BITS, 2);
439  }
440 error:
441  CLOSE_READER(bs, &row->gb);
442  return ret;
443 }
444 
446  RowContext *row, int n)
447 {
448  return dnxhd_decode_dct_block(ctx, row, n, 4, 32, 6, 0);
449 }
450 
452  RowContext *row, int n)
453 {
454  return dnxhd_decode_dct_block(ctx, row, n, 6, 8, 4, 0);
455 }
456 
458  RowContext *row, int n)
459 {
460  return dnxhd_decode_dct_block(ctx, row, n, 6, 32, 6, 0);
461 }
462 
464  RowContext *row, int n)
465 {
466  return dnxhd_decode_dct_block(ctx, row, n, 6, 8, 4, 2);
467 }
468 
470  RowContext *row, int n)
471 {
472  return dnxhd_decode_dct_block(ctx, row, n, 6, 32, 4, 2);
473 }
474 
476  AVFrame *frame, int x, int y)
477 {
478  int shift1 = ctx->bit_depth >= 10;
479  int dct_linesize_luma = frame->linesize[0];
480  int dct_linesize_chroma = frame->linesize[1];
481  uint8_t *dest_y, *dest_u, *dest_v;
482  int dct_y_offset, dct_x_offset;
483  int qscale, i, act;
484  int interlaced_mb = 0;
485 
486  if (ctx->mbaff) {
487  interlaced_mb = get_bits1(&row->gb);
488  qscale = get_bits(&row->gb, 10);
489  } else {
490  qscale = get_bits(&row->gb, 11);
491  }
492  act = get_bits1(&row->gb);
493  if (act) {
494  if (!ctx->act) {
495  static int act_warned;
496  if (!act_warned) {
497  act_warned = 1;
498  av_log(ctx->avctx, AV_LOG_ERROR,
499  "ACT flag set, in violation of frame header.\n");
500  }
501  } else if (row->format == -1) {
502  row->format = act;
503  } else if (row->format != act) {
504  row->format = 2; // Variable
505  }
506  }
507 
508  if (qscale != row->last_qscale) {
509  for (i = 0; i < 64; i++) {
510  row->luma_scale[i] = qscale * ctx->cid_table->luma_weight[i];
511  row->chroma_scale[i] = qscale * ctx->cid_table->chroma_weight[i];
512  }
513  row->last_qscale = qscale;
514  }
515 
516  for (i = 0; i < 8 + 4 * ctx->is_444; i++) {
517  if (ctx->decode_dct_block(ctx, row, i) < 0)
518  return AVERROR_INVALIDDATA;
519  }
520 
521  if (frame->interlaced_frame) {
522  dct_linesize_luma <<= 1;
523  dct_linesize_chroma <<= 1;
524  }
525 
526  dest_y = frame->data[0] + ((y * dct_linesize_luma) << 4) + (x << (4 + shift1));
527  dest_u = frame->data[1] + ((y * dct_linesize_chroma) << 4) + (x << (3 + shift1 + ctx->is_444));
528  dest_v = frame->data[2] + ((y * dct_linesize_chroma) << 4) + (x << (3 + shift1 + ctx->is_444));
529 
530  if (frame->interlaced_frame && ctx->cur_field) {
531  dest_y += frame->linesize[0];
532  dest_u += frame->linesize[1];
533  dest_v += frame->linesize[2];
534  }
535  if (interlaced_mb) {
536  dct_linesize_luma <<= 1;
537  dct_linesize_chroma <<= 1;
538  }
539 
540  dct_y_offset = interlaced_mb ? frame->linesize[0] : (dct_linesize_luma << 3);
541  dct_x_offset = 8 << shift1;
542  if (!ctx->is_444) {
543  ctx->idsp.idct_put(dest_y, dct_linesize_luma, row->blocks[0]);
544  ctx->idsp.idct_put(dest_y + dct_x_offset, dct_linesize_luma, row->blocks[1]);
545  ctx->idsp.idct_put(dest_y + dct_y_offset, dct_linesize_luma, row->blocks[4]);
546  ctx->idsp.idct_put(dest_y + dct_y_offset + dct_x_offset, dct_linesize_luma, row->blocks[5]);
547 
548  if (!(ctx->avctx->flags & AV_CODEC_FLAG_GRAY)) {
549  dct_y_offset = interlaced_mb ? frame->linesize[1] : (dct_linesize_chroma << 3);
550  ctx->idsp.idct_put(dest_u, dct_linesize_chroma, row->blocks[2]);
551  ctx->idsp.idct_put(dest_v, dct_linesize_chroma, row->blocks[3]);
552  ctx->idsp.idct_put(dest_u + dct_y_offset, dct_linesize_chroma, row->blocks[6]);
553  ctx->idsp.idct_put(dest_v + dct_y_offset, dct_linesize_chroma, row->blocks[7]);
554  }
555  } else {
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[6]);
559  ctx->idsp.idct_put(dest_y + dct_y_offset + dct_x_offset, dct_linesize_luma, row->blocks[7]);
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_u + dct_x_offset, dct_linesize_chroma, row->blocks[3]);
565  ctx->idsp.idct_put(dest_u + dct_y_offset, dct_linesize_chroma, row->blocks[8]);
566  ctx->idsp.idct_put(dest_u + dct_y_offset + dct_x_offset, dct_linesize_chroma, row->blocks[9]);
567  ctx->idsp.idct_put(dest_v, dct_linesize_chroma, row->blocks[4]);
568  ctx->idsp.idct_put(dest_v + dct_x_offset, dct_linesize_chroma, row->blocks[5]);
569  ctx->idsp.idct_put(dest_v + dct_y_offset, dct_linesize_chroma, row->blocks[10]);
570  ctx->idsp.idct_put(dest_v + dct_y_offset + dct_x_offset, dct_linesize_chroma, row->blocks[11]);
571  }
572  }
573 
574  return 0;
575 }
576 
578  int rownb, int threadnb)
579 {
580  const DNXHDContext *ctx = avctx->priv_data;
581  uint32_t offset = ctx->mb_scan_index[rownb];
582  RowContext *row = ctx->rows + threadnb;
583  int x, ret;
584 
585  row->last_dc[0] =
586  row->last_dc[1] =
587  row->last_dc[2] = 1 << (ctx->bit_depth + 2); // for levels +2^(bitdepth-1)
588  ret = init_get_bits8(&row->gb, ctx->buf + offset, ctx->buf_size - offset);
589  if (ret < 0) {
590  row->errors++;
591  return ret;
592  }
593  for (x = 0; x < ctx->mb_width; x++) {
594  int ret = dnxhd_decode_macroblock(ctx, row, data, x, rownb);
595  if (ret < 0) {
596  row->errors++;
597  return ret;
598  }
599  }
600 
601  return 0;
602 }
603 
605  int *got_frame, AVPacket *avpkt)
606 {
607  const uint8_t *buf = avpkt->data;
608  int buf_size = avpkt->size;
610  ThreadFrame frame = { .f = data };
611  AVFrame *picture = data;
612  int first_field = 1;
613  int ret, i;
614 
615  ff_dlog(avctx, "frame size %d\n", buf_size);
616 
617  for (i = 0; i < avctx->thread_count; i++)
618  ctx->rows[i].format = -1;
619 
620 decode_coding_unit:
621  if ((ret = dnxhd_decode_header(ctx, picture, buf, buf_size, first_field)) < 0)
622  return ret;
623 
624  if ((avctx->width || avctx->height) &&
625  (ctx->width != avctx->width || ctx->height != avctx->height)) {
626  av_log(avctx, AV_LOG_WARNING, "frame size changed: %dx%d -> %ux%u\n",
627  avctx->width, avctx->height, ctx->width, ctx->height);
628  first_field = 1;
629  }
630  if (avctx->pix_fmt != AV_PIX_FMT_NONE && avctx->pix_fmt != ctx->pix_fmt) {
631  av_log(avctx, AV_LOG_WARNING, "pix_fmt changed: %s -> %s\n",
633  first_field = 1;
634  }
635 
636  avctx->pix_fmt = ctx->pix_fmt;
637  ret = ff_set_dimensions(avctx, ctx->width, ctx->height);
638  if (ret < 0)
639  return ret;
640 
641  if (first_field) {
642  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
643  return ret;
644  picture->pict_type = AV_PICTURE_TYPE_I;
645  picture->key_frame = 1;
646  }
647 
648  ctx->buf_size = buf_size - ctx->data_offset;
649  ctx->buf = buf + ctx->data_offset;
650  avctx->execute2(avctx, dnxhd_decode_row, picture, NULL, ctx->mb_height);
651 
652  if (first_field && picture->interlaced_frame) {
653  buf += ctx->cid_table->coding_unit_size;
654  buf_size -= ctx->cid_table->coding_unit_size;
655  first_field = 0;
656  goto decode_coding_unit;
657  }
658 
659  ret = 0;
660  for (i = 0; i < avctx->thread_count; i++) {
661  ret += ctx->rows[i].errors;
662  ctx->rows[i].errors = 0;
663  }
664 
665  if (ctx->act) {
666  static int act_warned;
667  int format = ctx->rows[0].format;
668  for (i = 1; i < avctx->thread_count; i++) {
669  if (ctx->rows[i].format != format &&
670  ctx->rows[i].format != -1 /* not run */) {
671  format = 2;
672  break;
673  }
674  }
675  switch (format) {
676  case -1:
677  case 2:
678  if (!act_warned) {
679  act_warned = 1;
680  av_log(ctx->avctx, AV_LOG_ERROR,
681  "Unsupported: variable ACT flag.\n");
682  }
683  break;
684  case 0:
685  ctx->pix_fmt = ctx->bit_depth==10
687  break;
688  case 1:
689  ctx->pix_fmt = ctx->bit_depth==10
691  break;
692  }
693  }
694  avctx->pix_fmt = ctx->pix_fmt;
695  if (ret) {
696  av_log(ctx->avctx, AV_LOG_ERROR, "%d lines with errors\n", ret);
697  return AVERROR_INVALIDDATA;
698  }
699 
700  *got_frame = 1;
701  return avpkt->size;
702 }
703 
705 {
707 
708  ff_free_vlc(&ctx->ac_vlc);
709  ff_free_vlc(&ctx->dc_vlc);
710  ff_free_vlc(&ctx->run_vlc);
711 
712  av_freep(&ctx->rows);
713 
714  return 0;
715 }
716 
718  .name = "dnxhd",
719  .long_name = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
720  .type = AVMEDIA_TYPE_VIDEO,
721  .id = AV_CODEC_ID_DNXHD,
722  .priv_data_size = sizeof(DNXHDContext),
724  .close = dnxhd_decode_close,
726  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
729 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:29
AVCodec
AVCodec.
Definition: codec.h:190
bit_depth
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:254
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
ff_init_scantable
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
level
uint8_t level
Definition: svq3.c:209
ff_dnxhd_decoder
AVCodec ff_dnxhd_decoder
Definition: dnxhddec.c:717
ff_dnxhd_check_header_prefix_hr
static av_always_inline uint64_t ff_dnxhd_check_header_prefix_hr(uint64_t prefix)
Definition: dnxhddata.h:67
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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:45
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1154
DNXHDContext::buf_size
int buf_size
Definition: dnxhddec.c:55
DNXHDContext::is_444
int is_444
Definition: dnxhddec.c:68
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:706
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:355
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
data
const char data[16]
Definition: mxf.c:91
AV_RB16
#define AV_RB16
Definition: intreadwrite.h:53
DNXHDContext::rows
RowContext * rows
Definition: dnxhddec.c:52
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:190
FF_PROFILE_DNXHD
#define FF_PROFILE_DNXHD
Definition: avcodec.h:1874
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
DNXHDContext::alpha
int alpha
Definition: dnxhddec.c:69
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
BlockDSPContext
Definition: blockdsp.h:35
AVCOL_SPC_BT2020_CL
@ AVCOL_SPC_BT2020_CL
ITU-R BT2020 constant luminance system.
Definition: pixfmt.h:521
thread.h
dnxhd_decode_header
static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame, const uint8_t *buf, int buf_size, int first_field)
Definition: dnxhddec.c:164
CIDEntry::coding_unit_size
unsigned int coding_unit_size
Definition: dnxhddata.h:46
DNXHDContext::ac_vlc
VLC ac_vlc
Definition: dnxhddec.c:63
DNXHDContext::height
unsigned int height
Definition: dnxhddec.c:57
DNXHDContext::mb_scan_index
uint32_t mb_scan_index[512]
Definition: dnxhddec.c:60
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:215
DNXHD_VLC_BITS
#define DNXHD_VLC_BITS
Definition: dnxhddec.c:77
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
DNXHDContext::mb_height
unsigned int mb_height
Definition: dnxhddec.c:59
RowContext::chroma_scale
int chroma_scale[64]
Definition: dnxhddec.c:41
DNXHDContext::cur_field
int cur_field
current interlaced field
Definition: dnxhddec.c:62
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1785
DNXHDContext
Definition: dnxhddec.c:50
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:413
DNXHDContext::idsp
IDCTDSPContext idsp
Definition: dnxhddec.c:64
GetBitContext
Definition: get_bits.h:61
ff_thread_get_buffer
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
x
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration it may help to try out the ‘ssh’ command with one or more ‘ v’ options You should get detailed output concerning your SSH configuration and the authentication process The only thing left is to automate the execution of the fate sh script and the synchronisation of the samples directory Uploading new samples to the fate suite *****************************************If you need a sample uploaded send a mail to samples request This is for developers who have an account on the fate suite server If you upload new please make sure they are as small as space on each network bandwidth and so on benefit from smaller test cases Also keep in mind older checkouts use existing sample that means in practice generally do not remove or overwrite files as it likely would break older checkouts or releases Also all needed samples for a commit should be ideally before the push If you need an account for frequently uploading samples or you wish to help others by doing that send a mail to ffmpeg devel rsync vauL Duo x
Definition: fate.txt:150
DNXHDContext::bit_depth
int bit_depth
Definition: dnxhddec.c:67
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:378
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:714
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:1875
CIDEntry
Definition: dnxhddata.h:42
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:400
CIDEntry::bit_depth
int bit_depth
Definition: dnxhddata.h:49
dnxhddata.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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:677
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
dnxhd_decode_close
static av_cold int dnxhd_decode_close(AVCodecContext *avctx)
Definition: dnxhddec.c:704
dnxhd_get_profile
static int dnxhd_get_profile(int cid)
Definition: dnxhddec.c:147
dnxhd_decode_frame
static int dnxhd_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: dnxhddec.c:604
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1466
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
DNXHD_DC_VLC_BITS
#define DNXHD_DC_VLC_BITS
Definition: dnxhddec.c:78
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
ctx
AVFormatContext * ctx
Definition: movenc.c:48
RowContext::luma_scale
int luma_scale[64]
Definition: dnxhddec.c:40
get_bits.h
DNXHDContext::act
int act
Definition: dnxhddec.c:72
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:193
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:359
DNXHDContext::mb_width
unsigned int mb_width
Definition: dnxhddec.c:59
ff_dnxhd_profiles
const AVProfile ff_dnxhd_profiles[]
Definition: profiles.c:48
if
if(ret)
Definition: filter_design.txt:179
FF_PROFILE_DNXHR_HQ
#define FF_PROFILE_DNXHR_HQ
Definition: avcodec.h:1877
ff_dnxhd_cid_table
const CIDEntry ff_dnxhd_cid_table[]
Definition: dnxhddata.c:935
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
DNXHDContext::data_offset
int data_offset
Definition: dnxhddec.c:61
dnxhd_decode_dct_block_12_444
static int dnxhd_decode_dct_block_12_444(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:469
NULL
#define NULL
Definition: coverity.c:32
DNXHDContext::avctx
AVCodecContext * avctx
Definition: dnxhddec.c:51
DNXHD_VARIABLE
#define DNXHD_VARIABLE
Indicate that a CIDEntry value must be read in the bitstream.
Definition: dnxhddata.h:40
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
DNXHDContext::lla
int lla
Definition: dnxhddec.c:70
profiles.h
DNXHDContext::bdsp
BlockDSPContext bdsp
Definition: dnxhddec.c:53
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:398
ff_dnxhd_get_cid_table
int ff_dnxhd_get_cid_table(int cid)
Definition: dnxhddata.c:1078
AV_RB32
#define AV_RB32
Definition: intreadwrite.h:130
dnxhd_decode_init
static av_cold int dnxhd_decode_init(AVCodecContext *avctx)
Definition: dnxhddec.c:91
index
int index
Definition: gxfenc.c:89
RowContext::format
int format
-1:not set yet 0:off=RGB 1:on=YUV 2:variable
Definition: dnxhddec.c:47
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
cid
int cid
Definition: mxfenc.c:1971
shift1
static const int shift1[6]
Definition: dxa.c:50
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:383
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
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:340
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
AVPacket::size
int size
Definition: packet.h:356
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:186
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:402
RowContext
Definition: dnxhddec.c:38
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:404
RowContext::gb
GetBitContext gb
Definition: dnxhddec.c:42
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:110
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:39
RowContext::last_qscale
int last_qscale
Definition: dnxhddec.c:44
DNXHDContext::cid
int64_t cid
compression id
Definition: dnxhddec.c:56
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:112
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:447
NEG_USR32
#define NEG_USR32(a, s)
Definition: mathops.h:166
DNXHDContext::decode_dct_block
int(* decode_dct_block)(const struct DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:73
FF_PROFILE_DNXHR_SQ
#define FF_PROFILE_DNXHR_SQ
Definition: avcodec.h:1876
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:520
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:414
av_always_inline
#define av_always_inline
Definition: attributes.h:49
uint8_t
uint8_t
Definition: audio_convert.c:194
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
len
int len
Definition: vorbis_enc_data.h:452
DNXHDContext::run_vlc
VLC run_vlc
Definition: dnxhddec.c:63
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:512
AVCodecContext::height
int height
Definition: avcodec.h:699
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
DNXHDContext::pix_fmt
enum AVPixelFormat pix_fmt
Definition: dnxhddec.c:58
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:86
RowContext::last_dc
int last_dc[3]
Definition: dnxhddec.c:43
IDCTDSPContext
Definition: idctdsp.h:53
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:38
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:262
DNXHDContext::buf
const uint8_t * buf
Definition: dnxhddec.c:54
AVCodecContext
main external API structure.
Definition: avcodec.h:526
ThreadFrame
Definition: thread.h:34
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
VLC
Definition: vlc.h:26
dnxhd_init_vlc
static int dnxhd_init_vlc(DNXHDContext *ctx, uint32_t cid, int bitdepth)
Definition: dnxhddec.c:111
profiles
static const AVProfile profiles[]
Definition: libfdk-aacenc.c:428
FF_PROFILE_DNXHR_HQX
#define FF_PROFILE_DNXHR_HQX
Definition: avcodec.h:1878
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:714
DNXHDContext::width
unsigned int width
Definition: dnxhddec.c:57
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:104
DNXHDContext::mbaff
int mbaff
Definition: dnxhddec.c:71
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
ScanTable
Scantable.
Definition: idctdsp.h:31
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
AVPacket
This structure stores compressed data.
Definition: packet.h:332
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
dnxhd_decode_macroblock
static int dnxhd_decode_macroblock(const DNXHDContext *ctx, RowContext *row, AVFrame *frame, int x, int y)
Definition: dnxhddec.c:475
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
FF_PROFILE_DNXHR_444
#define FF_PROFILE_DNXHR_444
Definition: avcodec.h:1879
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:699
dnxhd_decode_dct_block_10_444
static int dnxhd_decode_dct_block_10_444(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:457
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:564
dnxhd_decode_row
static int dnxhd_decode_row(AVCodecContext *avctx, void *data, int rownb, int threadnb)
Definition: dnxhddec.c:577
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
DNXHDContext::dc_vlc
VLC dc_vlc
Definition: dnxhddec.c:63
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
AVCOL_SPC_BT709
@ AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
Definition: pixfmt.h:511
int
int
Definition: ffmpeg_filter.c:192
first_field
static int first_field(const struct video_data *s)
Definition: v4l2.c:234
dnxhd_decode_dct_block_8
static int dnxhd_decode_dct_block_8(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:445
DNXHDContext::cid_table
const CIDEntry * cid_table
Definition: dnxhddec.c:66
dnxhd_decode_dct_block_10
static int dnxhd_decode_dct_block_10(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:451
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:1845
AV_CODEC_ID_DNXHD
@ AV_CODEC_ID_DNXHD
Definition: codec_id.h:148
dnxhd_decode_dct_block_12
static int dnxhd_decode_dct_block_12(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:463
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:2465
DNXHDContext::scantable
ScanTable scantable
Definition: dnxhddec.c:65