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 "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
63  VLC ac_vlc, dc_vlc, run_vlc;
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 {
93  DNXHDContext *ctx = avctx->priv_data;
94 
95  ctx->avctx = avctx;
96  ctx->cid = -1;
97  if (avctx->colorspace == AVCOL_SPC_UNSPECIFIED) {
98  avctx->colorspace = AVCOL_SPC_BT709;
99  }
100 
101  avctx->coded_width = FFALIGN(avctx->width, 16);
102  avctx->coded_height = FFALIGN(avctx->height, 16);
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  }
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 
148 {
149  DNXHDContext *ctx = avctx->priv_data;
150 
151  ctx->avctx = avctx;
152  // make sure VLC tables will be loaded when cid is parsed
153  ctx->cid = -1;
154 
155  ctx->rows = av_mallocz_array(avctx->thread_count, sizeof(RowContext));
156  if (!ctx->rows)
157  return AVERROR(ENOMEM);
158 
159  return 0;
160 }
161 
162 static int dnxhd_get_profile(int cid)
163 {
164  switch(cid) {
165  case 1270:
166  return FF_PROFILE_DNXHR_444;
167  case 1271:
168  return FF_PROFILE_DNXHR_HQX;
169  case 1272:
170  return FF_PROFILE_DNXHR_HQ;
171  case 1273:
172  return FF_PROFILE_DNXHR_SQ;
173  case 1274:
174  return FF_PROFILE_DNXHR_LB;
175  }
176  return FF_PROFILE_DNXHD;
177 }
178 
180  const uint8_t *buf, int buf_size,
181  int first_field)
182 {
183  int i, cid, ret;
184  int old_bit_depth = ctx->bit_depth, bitdepth;
185  uint64_t header_prefix;
186  if (buf_size < 0x280) {
187  av_log(ctx->avctx, AV_LOG_ERROR,
188  "buffer too small (%d < 640).\n", buf_size);
189  return AVERROR_INVALIDDATA;
190  }
191 
192  header_prefix = ff_dnxhd_parse_header_prefix(buf);
193  if (header_prefix == 0) {
194  av_log(ctx->avctx, AV_LOG_ERROR,
195  "unknown header 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n",
196  buf[0], buf[1], buf[2], buf[3], buf[4]);
197  return AVERROR_INVALIDDATA;
198  }
199  if (buf[5] & 2) { /* interlaced */
200  ctx->cur_field = buf[5] & 1;
201  frame->interlaced_frame = 1;
202  frame->top_field_first = first_field ^ ctx->cur_field;
203  av_log(ctx->avctx, AV_LOG_DEBUG,
204  "interlaced %d, cur field %d\n", buf[5] & 3, ctx->cur_field);
205  } else {
206  ctx->cur_field = 0;
207  }
208  ctx->mbaff = (buf[0x6] >> 5) & 1;
209  ctx->alpha = buf[0x7] & 1;
210  ctx->lla = (buf[0x7] >> 1) & 1;
211  if (ctx->alpha)
212  avpriv_request_sample(ctx->avctx, "alpha");
213 
214  ctx->height = AV_RB16(buf + 0x18);
215  ctx->width = AV_RB16(buf + 0x1a);
216 
217  switch(buf[0x21] >> 5) {
218  case 1: bitdepth = 8; break;
219  case 2: bitdepth = 10; break;
220  case 3: bitdepth = 12; break;
221  default:
222  av_log(ctx->avctx, AV_LOG_ERROR,
223  "Unknown bitdepth indicator (%d)\n", buf[0x21] >> 5);
224  return AVERROR_INVALIDDATA;
225  }
226 
227  cid = AV_RB32(buf + 0x28);
228 
229  ctx->avctx->profile = dnxhd_get_profile(cid);
230 
231  if ((ret = dnxhd_init_vlc(ctx, cid, bitdepth)) < 0)
232  return ret;
233  if (ctx->mbaff && ctx->cid_table->cid != 1260)
235  "Adaptive MB interlace flag in an unsupported profile.\n");
236 
237  switch ((buf[0x2C] >> 1) & 3) {
238  case 0: frame->colorspace = AVCOL_SPC_BT709; break;
239  case 1: frame->colorspace = AVCOL_SPC_BT2020_NCL; break;
240  case 2: frame->colorspace = AVCOL_SPC_BT2020_CL; break;
241  case 3: frame->colorspace = AVCOL_SPC_UNSPECIFIED; break;
242  }
243 
244  ctx->act = buf[0x2C] & 1;
245  if (ctx->act && ctx->cid_table->cid != 1256 && ctx->cid_table->cid != 1270)
247  "Adaptive color transform in an unsupported profile.\n");
248 
249  ctx->is_444 = (buf[0x2C] >> 6) & 1;
250  if (ctx->is_444) {
251  if (bitdepth == 8) {
252  avpriv_request_sample(ctx->avctx, "4:4:4 8 bits");
253  return AVERROR_INVALIDDATA;
254  } else if (bitdepth == 10) {
256  ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P10
258  } else {
260  ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P12
262  }
263  } else if (bitdepth == 12) {
266  } else if (bitdepth == 10) {
267  if (ctx->avctx->profile == FF_PROFILE_DNXHR_HQX)
269  else
272  } else {
275  }
276 
277  ctx->avctx->bits_per_raw_sample = ctx->bit_depth = bitdepth;
278  if (ctx->bit_depth != old_bit_depth) {
279  ff_blockdsp_init(&ctx->bdsp, ctx->avctx);
280  ff_idctdsp_init(&ctx->idsp, ctx->avctx);
283  }
284 
285  // make sure profile size constraints are respected
286  // DNx100 allows 1920->1440 and 1280->960 subsampling
287  if (ctx->width != ctx->cid_table->width &&
288  ctx->cid_table->width != DNXHD_VARIABLE) {
291  ctx->width, ctx->cid_table->width, 255);
292  ctx->width = ctx->cid_table->width;
293  }
294 
295  if (buf_size < ctx->cid_table->coding_unit_size) {
296  av_log(ctx->avctx, AV_LOG_ERROR, "incorrect frame size (%d < %u).\n",
297  buf_size, ctx->cid_table->coding_unit_size);
298  return AVERROR_INVALIDDATA;
299  }
300 
301  ctx->mb_width = (ctx->width + 15)>> 4;
302  ctx->mb_height = AV_RB16(buf + 0x16c);
303 
304  if ((ctx->height + 15) >> 4 == ctx->mb_height && frame->interlaced_frame)
305  ctx->height <<= 1;
306 
307  av_log(ctx->avctx, AV_LOG_VERBOSE, "%dx%d, 4:%s %d bits, MBAFF=%d ACT=%d\n",
308  ctx->width, ctx->height, ctx->is_444 ? "4:4" : "2:2",
309  ctx->bit_depth, ctx->mbaff, ctx->act);
310 
311  // Newer format supports variable mb_scan_index sizes
312  if (ctx->mb_height > 68 && ff_dnxhd_check_header_prefix_hr(header_prefix)) {
313  ctx->data_offset = 0x170 + (ctx->mb_height << 2);
314  } else {
315  if (ctx->mb_height > 68) {
316  av_log(ctx->avctx, AV_LOG_ERROR,
317  "mb height too big: %d\n", ctx->mb_height);
318  return AVERROR_INVALIDDATA;
319  }
320  ctx->data_offset = 0x280;
321  }
322  if ((ctx->mb_height << frame->interlaced_frame) > (ctx->height + 15) >> 4) {
323  av_log(ctx->avctx, AV_LOG_ERROR,
324  "mb height too big: %d\n", ctx->mb_height);
325  return AVERROR_INVALIDDATA;
326  }
327 
328  if (buf_size < ctx->data_offset) {
329  av_log(ctx->avctx, AV_LOG_ERROR,
330  "buffer too small (%d < %d).\n", buf_size, ctx->data_offset);
331  return AVERROR_INVALIDDATA;
332  }
333 
334  if (ctx->mb_height > FF_ARRAY_ELEMS(ctx->mb_scan_index)) {
335  av_log(ctx->avctx, AV_LOG_ERROR,
336  "mb_height too big (%d > %"SIZE_SPECIFIER").\n", ctx->mb_height, FF_ARRAY_ELEMS(ctx->mb_scan_index));
337  return AVERROR_INVALIDDATA;
338  }
339 
340  for (i = 0; i < ctx->mb_height; i++) {
341  ctx->mb_scan_index[i] = AV_RB32(buf + 0x170 + (i << 2));
342  ff_dlog(ctx->avctx, "mb scan index %d, pos %d: %"PRIu32"\n",
343  i, 0x170 + (i << 2), ctx->mb_scan_index[i]);
344  if (buf_size - ctx->data_offset < ctx->mb_scan_index[i]) {
345  av_log(ctx->avctx, AV_LOG_ERROR,
346  "invalid mb scan index (%"PRIu32" vs %u).\n",
347  ctx->mb_scan_index[i], buf_size - ctx->data_offset);
348  return AVERROR_INVALIDDATA;
349  }
350  }
351 
352  return 0;
353 }
354 
356  RowContext *row,
357  int n,
358  int index_bits,
359  int level_bias,
360  int level_shift,
361  int dc_shift)
362 {
363  int i, j, index1, index2, len, flags;
364  int level, component, sign;
365  const int *scale;
366  const uint8_t *weight_matrix;
367  const uint8_t *ac_info = ctx->cid_table->ac_info;
368  int16_t *block = row->blocks[n];
369  const int eob_index = ctx->cid_table->eob_index;
370  int ret = 0;
371  OPEN_READER(bs, &row->gb);
372 
373  ctx->bdsp.clear_block(block);
374 
375  if (!ctx->is_444) {
376  if (n & 2) {
377  component = 1 + (n & 1);
378  scale = row->chroma_scale;
379  weight_matrix = ctx->cid_table->chroma_weight;
380  } else {
381  component = 0;
382  scale = row->luma_scale;
383  weight_matrix = ctx->cid_table->luma_weight;
384  }
385  } else {
386  component = (n >> 1) % 3;
387  if (component) {
388  scale = row->chroma_scale;
389  weight_matrix = ctx->cid_table->chroma_weight;
390  } else {
391  scale = row->luma_scale;
392  weight_matrix = ctx->cid_table->luma_weight;
393  }
394  }
395 
396  UPDATE_CACHE(bs, &row->gb);
397  GET_VLC(len, bs, &row->gb, ctx->dc_vlc.table, DNXHD_DC_VLC_BITS, 1);
398  if (len < 0) {
399  ret = len;
400  goto error;
401  }
402  if (len) {
403  level = GET_CACHE(bs, &row->gb);
404  LAST_SKIP_BITS(bs, &row->gb, len);
405  sign = ~level >> 31;
406  level = (NEG_USR32(sign ^ level, len) ^ sign) - sign;
407  row->last_dc[component] += level * (1 << dc_shift);
408  }
409  block[0] = row->last_dc[component];
410 
411  i = 0;
412 
413  UPDATE_CACHE(bs, &row->gb);
414  GET_VLC(index1, bs, &row->gb, ctx->ac_vlc.table,
415  DNXHD_VLC_BITS, 2);
416 
417  while (index1 != eob_index) {
418  level = ac_info[2*index1+0];
419  flags = ac_info[2*index1+1];
420 
421  sign = SHOW_SBITS(bs, &row->gb, 1);
422  SKIP_BITS(bs, &row->gb, 1);
423 
424  if (flags & 1) {
425  level += SHOW_UBITS(bs, &row->gb, index_bits) << 7;
426  SKIP_BITS(bs, &row->gb, index_bits);
427  }
428 
429  if (flags & 2) {
430  UPDATE_CACHE(bs, &row->gb);
431  GET_VLC(index2, bs, &row->gb, ctx->run_vlc.table,
432  DNXHD_VLC_BITS, 2);
433  i += ctx->cid_table->run[index2];
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->scantable.permutated[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 
536  if (frame->interlaced_frame) {
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->interlaced_frame && 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;
624  DNXHDContext *ctx = avctx->priv_data;
625  ThreadFrame frame = { .f = data };
626  AVFrame *picture = data;
627  int first_field = 1;
628  int ret, i;
629 
630  ff_dlog(avctx, "frame size %d\n", buf_size);
631 
632  for (i = 0; i < avctx->thread_count; i++)
633  ctx->rows[i].format = -1;
634 
635 decode_coding_unit:
636  if ((ret = dnxhd_decode_header(ctx, picture, buf, buf_size, first_field)) < 0)
637  return ret;
638 
639  if ((avctx->width || avctx->height) &&
640  (ctx->width != avctx->width || ctx->height != avctx->height)) {
641  av_log(avctx, AV_LOG_WARNING, "frame size changed: %dx%d -> %ux%u\n",
642  avctx->width, avctx->height, ctx->width, ctx->height);
643  first_field = 1;
644  }
645  if (avctx->pix_fmt != AV_PIX_FMT_NONE && avctx->pix_fmt != ctx->pix_fmt) {
646  av_log(avctx, AV_LOG_WARNING, "pix_fmt changed: %s -> %s\n",
648  first_field = 1;
649  }
650 
651  avctx->pix_fmt = ctx->pix_fmt;
652  ret = ff_set_dimensions(avctx, ctx->width, ctx->height);
653  if (ret < 0)
654  return ret;
655 
656  if (first_field) {
657  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
658  return ret;
659  picture->pict_type = AV_PICTURE_TYPE_I;
660  picture->key_frame = 1;
661  }
662 
663  ctx->buf_size = buf_size - ctx->data_offset;
664  ctx->buf = buf + ctx->data_offset;
665  avctx->execute2(avctx, dnxhd_decode_row, picture, NULL, ctx->mb_height);
666 
667  if (first_field && picture->interlaced_frame) {
668  buf += ctx->cid_table->coding_unit_size;
669  buf_size -= ctx->cid_table->coding_unit_size;
670  first_field = 0;
671  goto decode_coding_unit;
672  }
673 
674  ret = 0;
675  for (i = 0; i < avctx->thread_count; i++) {
676  ret += ctx->rows[i].errors;
677  ctx->rows[i].errors = 0;
678  }
679 
680  if (ctx->act) {
681  static int act_warned;
682  int format = ctx->rows[0].format;
683  for (i = 1; i < avctx->thread_count; i++) {
684  if (ctx->rows[i].format != format &&
685  ctx->rows[i].format != -1 /* not run */) {
686  format = 2;
687  break;
688  }
689  }
690  switch (format) {
691  case -1:
692  case 2:
693  if (!act_warned) {
694  act_warned = 1;
695  av_log(ctx->avctx, AV_LOG_ERROR,
696  "Unsupported: variable ACT flag.\n");
697  }
698  break;
699  case 0:
700  ctx->pix_fmt = ctx->bit_depth==10
702  break;
703  case 1:
704  ctx->pix_fmt = ctx->bit_depth==10
706  break;
707  }
708  }
709  avctx->pix_fmt = ctx->pix_fmt;
710  if (ret) {
711  av_log(ctx->avctx, AV_LOG_ERROR, "%d lines with errors\n", ret);
712  return AVERROR_INVALIDDATA;
713  }
714 
715  *got_frame = 1;
716  return avpkt->size;
717 }
718 
720 {
721  DNXHDContext *ctx = avctx->priv_data;
722 
723  ff_free_vlc(&ctx->ac_vlc);
724  ff_free_vlc(&ctx->dc_vlc);
725  ff_free_vlc(&ctx->run_vlc);
726 
727  av_freep(&ctx->rows);
728 
729  return 0;
730 }
731 
733  .name = "dnxhd",
734  .long_name = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
735  .type = AVMEDIA_TYPE_VIDEO,
736  .id = AV_CODEC_ID_DNXHD,
737  .priv_data_size = sizeof(DNXHDContext),
739  .close = dnxhd_decode_close,
741  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
745 };
#define FF_PROFILE_DNXHD
Definition: avcodec.h:2969
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
Definition: pixfmt.h:511
int cid
Definition: mxfenc.c:1972
static int dnxhd_decode_dct_block_8(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:460
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static enum AVPixelFormat pix_fmt
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
const uint8_t * dc_bits
Definition: dnxhddata.h:52
IDCTDSPContext idsp
Definition: dnxhddec.c:64
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1809
int64_t cid
compression id
Definition: dnxhddec.c:56
static int dnxhd_get_profile(int cid)
Definition: dnxhddec.c:162
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
const uint8_t * luma_weight
Definition: dnxhddata.h:51
int(* decode_dct_block)(const struct DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:73
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
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static av_cold int dnxhd_decode_init_thread_copy(AVCodecContext *avctx)
Definition: dnxhddec.c:147
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 add an init_thread_copy() which re-allocates them for other threads.Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities.There will be very little speed gain at this point but it should work.If there are inter-frame dependencies
void(* clear_block)(int16_t *block)
Definition: blockdsp.h:36
#define avpriv_request_sample(...)
Scantable.
Definition: idctdsp.h:31
int num
Numerator.
Definition: rational.h:59
int size
Definition: avcodec.h:1534
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:413
const CIDEntry ff_dnxhd_cid_table[]
Definition: dnxhddata.c:935
const uint16_t * run_codes
Definition: dnxhddata.h:55
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:2000
RowContext * rows
Definition: dnxhddec.c:52
VLC run_vlc
Definition: dnxhddec.c:63
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1831
int errors
Definition: dnxhddec.c:45
uint8_t permutated[64]
Definition: idctdsp.h:33
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2852
static void error(const char *err)
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:87
int profile
profile
Definition: avcodec.h:2954
VLC dc_vlc
Definition: dnxhddec.c:63
AVCodec.
Definition: avcodec.h:3555
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
int luma_scale[64]
Definition: dnxhddec.c:40
const uint8_t * buf
Definition: dnxhddec.c:54
static av_cold int dnxhd_decode_close(AVCodecContext *avctx)
Definition: dnxhddec.c:719
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:82
static int dnxhd_decode_dct_block_12(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:478
const AVProfile ff_dnxhd_profiles[]
Definition: profiles.c:48
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
Multithreading support functions.
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:87
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
#define height
static av_always_inline int dnxhd_decode_dct_block(const DNXHDContext *ctx, RowContext *row, int n, int index_bits, int level_bias, int level_shift, int dc_shift)
Definition: dnxhddec.c:355
uint8_t * data
Definition: avcodec.h:1533
int format
-1:not set yet 0:off=RGB 1:on=YUV 2:variable
Definition: dnxhddec.c:47
#define ff_dlog(a,...)
const uint8_t * run_bits
Definition: dnxhddata.h:56
bitstream reader API header.
int bit_depth
Definition: dnxhddec.c:67
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
#define DNXHD_VLC_BITS
Definition: dnxhddec.c:77
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:442
unsigned int coding_unit_size
Definition: dnxhddata.h:46
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
#define DNXHD_DC_VLC_BITS
Definition: dnxhddec.c:78
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:402
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:901
#define FFALIGN(x, a)
Definition: macros.h:48
enum AVPixelFormat pix_fmt
Definition: dnxhddec.c:58
#define av_log(a,...)
static int first_field(const struct video_data *s)
Definition: v4l2.c:234
VLC ac_vlc
Definition: dnxhddec.c:63
const uint8_t * ac_bits
Definition: dnxhddata.h:54
const uint8_t * ac_info
Definition: dnxhddata.h:54
const uint16_t * ac_codes
Definition: dnxhddata.h:53
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int ff_dnxhd_get_cid_table(int cid)
Definition: dnxhddata.c:1078
unsigned int width
Definition: dnxhddata.h:44
static const int shift1[6]
Definition: dxa.c:50
static int dnxhd_decode_row(AVCodecContext *avctx, void *data, int rownb, int threadnb)
Definition: dnxhddec.c:592
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: vlc.h:38
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1701
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:550
unsigned int height
Definition: dnxhddec.c:57
const uint8_t * dc_codes
Definition: dnxhddata.h:52
const char * name
Name of the codec implementation.
Definition: avcodec.h:3562
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:400
#define FF_PROFILE_DNXHR_LB
Definition: avcodec.h:2970
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
static int dnxhd_decode_dct_block_10_444(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:472
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1055
static av_always_inline uint64_t ff_dnxhd_parse_header_prefix(const uint8_t *buf)
Definition: dnxhddata.h:86
Definition: vlc.h:26
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
const uint8_t * chroma_weight
Definition: dnxhddata.h:51
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:193
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:225
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
int width
picture width / height.
Definition: avcodec.h:1794
#define NEG_USR32(a, s)
Definition: mathops.h:166
static void decode_dct_block(RangeCoder *c, DCTBlockCoder *bc, uint8_t *dst, ptrdiff_t stride, int block_size, int *block, int mb_x, int mb_y)
Definition: mss3.c:565
const uint8_t * run
Definition: dnxhddata.h:56
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:226
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:520
AVFormatContext * ctx
Definition: movenc.c:48
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
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
ScanTable scantable
Definition: dnxhddec.c:65
unsigned int mb_width
Definition: dnxhddec.c:59
#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
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:96
#define FF_PROFILE_DNXHR_HQ
Definition: avcodec.h:2972
void(* idct_put)(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
Definition: idctdsp.h:72
static int dnxhd_decode_macroblock(const DNXHDContext *ctx, RowContext *row, AVFrame *frame, int x, int y)
Definition: dnxhddec.c:490
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
#define FF_ARRAY_ELEMS(a)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2880
if(ret)
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1059
int bit_depth
Definition: dnxhddata.h:49
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:2940
unsigned int width
Definition: dnxhddec.c:57
Libavcodec external API header.
int last_qscale
Definition: dnxhddec.c:44
int16_t blocks[12][64]
Definition: dnxhddec.c:39
int cur_field
current interlaced field
Definition: dnxhddec.c:62
unsigned int mb_height
Definition: dnxhddec.c:59
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
static int dnxhd_decode_dct_block_10(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:466
main external API structure.
Definition: avcodec.h:1621
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
int coded_height
Definition: avcodec.h:1809
int eob_index
Definition: dnxhddata.h:50
int index
Definition: gxfenc.c:89
int chroma_scale[64]
Definition: dnxhddec.c:41
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2249
static av_always_inline uint64_t ff_dnxhd_check_header_prefix_hr(uint64_t prefix)
Definition: dnxhddata.h:67
#define GET_CACHE(name, gb)
Definition: get_bits.h:215
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
#define FF_PROFILE_DNXHR_SQ
Definition: avcodec.h:2971
int is_444
Definition: dnxhddec.c:68
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:414
#define SIZE_SPECIFIER
Definition: internal.h:262
#define flags(name, subs,...)
Definition: cbs_av1.c:564
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:398
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:404
static int dnxhd_init_vlc(DNXHDContext *ctx, uint32_t cid, int bitdepth)
Definition: dnxhddec.c:111
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
uint8_t level
Definition: svq3.c:209
uint32_t mb_scan_index[512]
Definition: dnxhddec.c:60
ITU-R BT2020 constant luminance system.
Definition: pixfmt.h:521
#define DNXHD_VARIABLE
Indicate that a CIDEntry value must be read in the bitstream.
Definition: dnxhddata.h:40
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
int
#define FF_PROFILE_DNXHR_HQX
Definition: avcodec.h:2973
GetBitContext gb
Definition: dnxhddec.c:42
common internal api header.
int data_offset
Definition: dnxhddec.c:61
int den
Denominator.
Definition: rational.h:60
#define FF_PROFILE_DNXHR_444
Definition: avcodec.h:2974
int buf_size
Definition: dnxhddec.c:55
void * priv_data
Definition: avcodec.h:1648
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:447
static int dnxhd_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: dnxhddec.c:619
int len
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
AVCodecContext * avctx
Definition: dnxhddec.c:51
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
BlockDSPContext bdsp
Definition: dnxhddec.c:53
AVCodec ff_dnxhd_decoder
Definition: dnxhddec.c:732
const CIDEntry * cid_table
Definition: dnxhddec.c:66
#define av_freep(p)
#define av_always_inline
Definition: attributes.h:39
int cid
Definition: dnxhddata.h:43
static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame, const uint8_t *buf, int buf_size, int first_field)
Definition: dnxhddec.c:179
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
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
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1510
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:359
int last_dc[3]
Definition: dnxhddec.c:43
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:999
static int dnxhd_decode_dct_block_12_444(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:484
static av_cold int dnxhd_decode_init(AVCodecContext *avctx)
Definition: dnxhddec.c:91
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191