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