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 {
95  DNXHDContext *ctx = avctx->priv_data;
96 
97  ctx->avctx = avctx;
98  ctx->cid = -1;
99  if (avctx->colorspace == AVCOL_SPC_UNSPECIFIED) {
100  avctx->colorspace = AVCOL_SPC_BT709;
101  }
102 
103  avctx->coded_width = FFALIGN(avctx->width, 16);
104  avctx->coded_height = FFALIGN(avctx->height, 16);
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) {
116  int index;
117 
118  if ((index = ff_dnxhd_get_cid_table(cid)) < 0) {
119  av_log(ctx->avctx, AV_LOG_ERROR, "unsupported cid %"PRIu32"\n", cid);
120  return AVERROR(ENOSYS);
121  }
122  if (ff_dnxhd_cid_table[index].bit_depth != bitdepth &&
124  av_log(ctx->avctx, AV_LOG_ERROR, "bit depth mismatches %d %d\n", ff_dnxhd_cid_table[index].bit_depth, bitdepth);
125  return AVERROR_INVALIDDATA;
126  }
128  av_log(ctx->avctx, AV_LOG_VERBOSE, "Profile cid %"PRIu32".\n", cid);
129 
130  ff_free_vlc(&ctx->ac_vlc);
131  ff_free_vlc(&ctx->dc_vlc);
132  ff_free_vlc(&ctx->run_vlc);
133 
134  init_vlc(&ctx->ac_vlc, DNXHD_VLC_BITS, 257,
135  ctx->cid_table->ac_bits, 1, 1,
136  ctx->cid_table->ac_codes, 2, 2, 0);
137  init_vlc(&ctx->dc_vlc, DNXHD_DC_VLC_BITS, bitdepth > 8 ? 14 : 12,
138  ctx->cid_table->dc_bits, 1, 1,
139  ctx->cid_table->dc_codes, 1, 1, 0);
140  init_vlc(&ctx->run_vlc, DNXHD_VLC_BITS, 62,
141  ctx->cid_table->run_bits, 1, 1,
142  ctx->cid_table->run_codes, 2, 2, 0);
143 
144  ctx->cid = cid;
145  }
146  return 0;
147 }
148 
149 static int dnxhd_get_profile(int cid)
150 {
151  switch(cid) {
152  case 1270:
153  return FF_PROFILE_DNXHR_444;
154  case 1271:
155  return FF_PROFILE_DNXHR_HQX;
156  case 1272:
157  return FF_PROFILE_DNXHR_HQ;
158  case 1273:
159  return FF_PROFILE_DNXHR_SQ;
160  case 1274:
161  return FF_PROFILE_DNXHR_LB;
162  }
163  return FF_PROFILE_DNXHD;
164 }
165 
167  const uint8_t *buf, int buf_size,
168  int first_field)
169 {
170  int i, cid, ret;
171  int old_bit_depth = ctx->bit_depth, bitdepth;
172  uint64_t header_prefix;
173  if (buf_size < 0x280) {
174  av_log(ctx->avctx, AV_LOG_ERROR,
175  "buffer too small (%d < 640).\n", buf_size);
176  return AVERROR_INVALIDDATA;
177  }
178 
179  header_prefix = ff_dnxhd_parse_header_prefix(buf);
180  if (header_prefix == 0) {
181  av_log(ctx->avctx, AV_LOG_ERROR,
182  "unknown header 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n",
183  buf[0], buf[1], buf[2], buf[3], buf[4]);
184  return AVERROR_INVALIDDATA;
185  }
186  if (buf[5] & 2) { /* interlaced */
187  ctx->cur_field = buf[5] & 1;
188  frame->interlaced_frame = 1;
189  frame->top_field_first = first_field ^ ctx->cur_field;
190  av_log(ctx->avctx, AV_LOG_DEBUG,
191  "interlaced %d, cur field %d\n", buf[5] & 3, ctx->cur_field);
192  } else {
193  ctx->cur_field = 0;
194  }
195  ctx->mbaff = (buf[0x6] >> 5) & 1;
196  ctx->alpha = buf[0x7] & 1;
197  ctx->lla = (buf[0x7] >> 1) & 1;
198  if (ctx->alpha)
199  avpriv_request_sample(ctx->avctx, "alpha");
200 
201  ctx->height = AV_RB16(buf + 0x18);
202  ctx->width = AV_RB16(buf + 0x1a);
203 
204  switch(buf[0x21] >> 5) {
205  case 1: bitdepth = 8; break;
206  case 2: bitdepth = 10; break;
207  case 3: bitdepth = 12; break;
208  default:
209  av_log(ctx->avctx, AV_LOG_ERROR,
210  "Unknown bitdepth indicator (%d)\n", buf[0x21] >> 5);
211  return AVERROR_INVALIDDATA;
212  }
213 
214  cid = AV_RB32(buf + 0x28);
215 
216  ctx->avctx->profile = dnxhd_get_profile(cid);
217 
218  if ((ret = dnxhd_init_vlc(ctx, cid, bitdepth)) < 0)
219  return ret;
220  if (ctx->mbaff && ctx->cid_table->cid != 1260)
222  "Adaptive MB interlace flag in an unsupported profile.\n");
223 
224  switch ((buf[0x2C] >> 1) & 3) {
225  case 0: frame->colorspace = AVCOL_SPC_BT709; break;
226  case 1: frame->colorspace = AVCOL_SPC_BT2020_NCL; break;
227  case 2: frame->colorspace = AVCOL_SPC_BT2020_CL; break;
228  case 3: frame->colorspace = AVCOL_SPC_UNSPECIFIED; break;
229  }
230 
231  ctx->act = buf[0x2C] & 1;
232  if (ctx->act && ctx->cid_table->cid != 1256 && ctx->cid_table->cid != 1270)
234  "Adaptive color transform in an unsupported profile.\n");
235 
236  ctx->is_444 = (buf[0x2C] >> 6) & 1;
237  if (ctx->is_444) {
238  if (bitdepth == 8) {
239  avpriv_request_sample(ctx->avctx, "4:4:4 8 bits");
240  return AVERROR_INVALIDDATA;
241  } else if (bitdepth == 10) {
243  ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P10
245  } else {
247  ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P12
249  }
250  } else if (bitdepth == 12) {
253  } else if (bitdepth == 10) {
254  if (ctx->avctx->profile == FF_PROFILE_DNXHR_HQX)
256  else
259  } else {
262  }
263 
264  ctx->avctx->bits_per_raw_sample = ctx->bit_depth = bitdepth;
265  if (ctx->bit_depth != old_bit_depth) {
266  ff_blockdsp_init(&ctx->bdsp, ctx->avctx);
267  ff_idctdsp_init(&ctx->idsp, ctx->avctx);
270  }
271 
272  // make sure profile size constraints are respected
273  // DNx100 allows 1920->1440 and 1280->960 subsampling
274  if (ctx->width != ctx->cid_table->width &&
275  ctx->cid_table->width != DNXHD_VARIABLE) {
278  ctx->width, ctx->cid_table->width, 255);
279  ctx->width = ctx->cid_table->width;
280  }
281 
282  if (buf_size < ctx->cid_table->coding_unit_size) {
283  av_log(ctx->avctx, AV_LOG_ERROR, "incorrect frame size (%d < %u).\n",
284  buf_size, ctx->cid_table->coding_unit_size);
285  return AVERROR_INVALIDDATA;
286  }
287 
288  ctx->mb_width = (ctx->width + 15)>> 4;
289  ctx->mb_height = AV_RB16(buf + 0x16c);
290 
291  if ((ctx->height + 15) >> 4 == ctx->mb_height && frame->interlaced_frame)
292  ctx->height <<= 1;
293 
294  av_log(ctx->avctx, AV_LOG_VERBOSE, "%dx%d, 4:%s %d bits, MBAFF=%d ACT=%d\n",
295  ctx->width, ctx->height, ctx->is_444 ? "4:4" : "2:2",
296  ctx->bit_depth, ctx->mbaff, ctx->act);
297 
298  // Newer format supports variable mb_scan_index sizes
299  if (ctx->mb_height > 68 && ff_dnxhd_check_header_prefix_hr(header_prefix)) {
300  ctx->data_offset = 0x170 + (ctx->mb_height << 2);
301  } else {
302  if (ctx->mb_height > 68) {
303  av_log(ctx->avctx, AV_LOG_ERROR,
304  "mb height too big: %d\n", ctx->mb_height);
305  return AVERROR_INVALIDDATA;
306  }
307  ctx->data_offset = 0x280;
308  }
309  if ((ctx->mb_height << frame->interlaced_frame) > (ctx->height + 15) >> 4) {
310  av_log(ctx->avctx, AV_LOG_ERROR,
311  "mb height too big: %d\n", ctx->mb_height);
312  return AVERROR_INVALIDDATA;
313  }
314 
315  if (buf_size < ctx->data_offset) {
316  av_log(ctx->avctx, AV_LOG_ERROR,
317  "buffer too small (%d < %d).\n", buf_size, ctx->data_offset);
318  return AVERROR_INVALIDDATA;
319  }
320 
321  if (ctx->mb_height > FF_ARRAY_ELEMS(ctx->mb_scan_index)) {
322  av_log(ctx->avctx, AV_LOG_ERROR,
323  "mb_height too big (%d > %"SIZE_SPECIFIER").\n", ctx->mb_height, FF_ARRAY_ELEMS(ctx->mb_scan_index));
324  return AVERROR_INVALIDDATA;
325  }
326 
327  for (i = 0; i < ctx->mb_height; i++) {
328  ctx->mb_scan_index[i] = AV_RB32(buf + 0x170 + (i << 2));
329  ff_dlog(ctx->avctx, "mb scan index %d, pos %d: %"PRIu32"\n",
330  i, 0x170 + (i << 2), ctx->mb_scan_index[i]);
331  if (buf_size - ctx->data_offset < ctx->mb_scan_index[i]) {
332  av_log(ctx->avctx, AV_LOG_ERROR,
333  "invalid mb scan index (%"PRIu32" vs %u).\n",
334  ctx->mb_scan_index[i], buf_size - ctx->data_offset);
335  return AVERROR_INVALIDDATA;
336  }
337  }
338 
339  return 0;
340 }
341 
343  RowContext *row,
344  int n,
345  int index_bits,
346  int level_bias,
347  int level_shift,
348  int dc_shift)
349 {
350  int i, j, index1, index2, len, flags;
351  int level, component, sign;
352  const int *scale;
353  const uint8_t *weight_matrix;
354  const uint8_t *ac_info = ctx->cid_table->ac_info;
355  int16_t *block = row->blocks[n];
356  const int eob_index = ctx->cid_table->eob_index;
357  int ret = 0;
358  OPEN_READER(bs, &row->gb);
359 
360  ctx->bdsp.clear_block(block);
361 
362  if (!ctx->is_444) {
363  if (n & 2) {
364  component = 1 + (n & 1);
365  scale = row->chroma_scale;
366  weight_matrix = ctx->cid_table->chroma_weight;
367  } else {
368  component = 0;
369  scale = row->luma_scale;
370  weight_matrix = ctx->cid_table->luma_weight;
371  }
372  } else {
373  component = (n >> 1) % 3;
374  if (component) {
375  scale = row->chroma_scale;
376  weight_matrix = ctx->cid_table->chroma_weight;
377  } else {
378  scale = row->luma_scale;
379  weight_matrix = ctx->cid_table->luma_weight;
380  }
381  }
382 
383  UPDATE_CACHE(bs, &row->gb);
384  GET_VLC(len, bs, &row->gb, ctx->dc_vlc.table, DNXHD_DC_VLC_BITS, 1);
385  if (len < 0) {
386  ret = len;
387  goto error;
388  }
389  if (len) {
390  level = GET_CACHE(bs, &row->gb);
391  LAST_SKIP_BITS(bs, &row->gb, len);
392  sign = ~level >> 31;
393  level = (NEG_USR32(sign ^ level, len) ^ sign) - sign;
394  row->last_dc[component] += level * (1 << dc_shift);
395  }
396  block[0] = row->last_dc[component];
397 
398  i = 0;
399 
400  UPDATE_CACHE(bs, &row->gb);
401  GET_VLC(index1, bs, &row->gb, ctx->ac_vlc.table,
402  DNXHD_VLC_BITS, 2);
403 
404  while (index1 != eob_index) {
405  level = ac_info[2*index1+0];
406  flags = ac_info[2*index1+1];
407 
408  sign = SHOW_SBITS(bs, &row->gb, 1);
409  SKIP_BITS(bs, &row->gb, 1);
410 
411  if (flags & 1) {
412  level += SHOW_UBITS(bs, &row->gb, index_bits) << 7;
413  SKIP_BITS(bs, &row->gb, index_bits);
414  }
415 
416  if (flags & 2) {
417  UPDATE_CACHE(bs, &row->gb);
418  GET_VLC(index2, bs, &row->gb, ctx->run_vlc.table,
419  DNXHD_VLC_BITS, 2);
420  i += ctx->cid_table->run[index2];
421  }
422 
423  if (++i > 63) {
424  av_log(ctx->avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", n, i);
425  ret = -1;
426  break;
427  }
428 
429  j = ctx->scantable.permutated[i];
430  level *= scale[i];
431  level += scale[i] >> 1;
432  if (level_bias < 32 || weight_matrix[i] != level_bias)
433  level += level_bias; // 1<<(level_shift-1)
434  level >>= level_shift;
435 
436  block[j] = (level ^ sign) - sign;
437 
438  UPDATE_CACHE(bs, &row->gb);
439  GET_VLC(index1, bs, &row->gb, ctx->ac_vlc.table,
440  DNXHD_VLC_BITS, 2);
441  }
442 error:
443  CLOSE_READER(bs, &row->gb);
444  return ret;
445 }
446 
448  RowContext *row, int n)
449 {
450  return dnxhd_decode_dct_block(ctx, row, n, 4, 32, 6, 0);
451 }
452 
454  RowContext *row, int n)
455 {
456  return dnxhd_decode_dct_block(ctx, row, n, 6, 8, 4, 0);
457 }
458 
460  RowContext *row, int n)
461 {
462  return dnxhd_decode_dct_block(ctx, row, n, 6, 32, 6, 0);
463 }
464 
466  RowContext *row, int n)
467 {
468  return dnxhd_decode_dct_block(ctx, row, n, 6, 8, 4, 2);
469 }
470 
472  RowContext *row, int n)
473 {
474  return dnxhd_decode_dct_block(ctx, row, n, 6, 32, 4, 2);
475 }
476 
478  AVFrame *frame, int x, int y)
479 {
480  int shift1 = ctx->bit_depth >= 10;
481  int dct_linesize_luma = frame->linesize[0];
482  int dct_linesize_chroma = frame->linesize[1];
483  uint8_t *dest_y, *dest_u, *dest_v;
484  int dct_y_offset, dct_x_offset;
485  int qscale, i, act;
486  int interlaced_mb = 0;
487 
488  if (ctx->mbaff) {
489  interlaced_mb = get_bits1(&row->gb);
490  qscale = get_bits(&row->gb, 10);
491  } else {
492  qscale = get_bits(&row->gb, 11);
493  }
494  act = get_bits1(&row->gb);
495  if (act) {
496  if (!ctx->act) {
497  static int act_warned;
498  if (!act_warned) {
499  act_warned = 1;
500  av_log(ctx->avctx, AV_LOG_ERROR,
501  "ACT flag set, in violation of frame header.\n");
502  }
503  } else if (row->format == -1) {
504  row->format = act;
505  } else if (row->format != act) {
506  row->format = 2; // Variable
507  }
508  }
509 
510  if (qscale != row->last_qscale) {
511  for (i = 0; i < 64; i++) {
512  row->luma_scale[i] = qscale * ctx->cid_table->luma_weight[i];
513  row->chroma_scale[i] = qscale * ctx->cid_table->chroma_weight[i];
514  }
515  row->last_qscale = qscale;
516  }
517 
518  for (i = 0; i < 8 + 4 * ctx->is_444; i++) {
519  if (ctx->decode_dct_block(ctx, row, i) < 0)
520  return AVERROR_INVALIDDATA;
521  }
522 
523  if (frame->interlaced_frame) {
524  dct_linesize_luma <<= 1;
525  dct_linesize_chroma <<= 1;
526  }
527 
528  dest_y = frame->data[0] + ((y * dct_linesize_luma) << 4) + (x << (4 + shift1));
529  dest_u = frame->data[1] + ((y * dct_linesize_chroma) << 4) + (x << (3 + shift1 + ctx->is_444));
530  dest_v = frame->data[2] + ((y * dct_linesize_chroma) << 4) + (x << (3 + shift1 + ctx->is_444));
531 
532  if (frame->interlaced_frame && ctx->cur_field) {
533  dest_y += frame->linesize[0];
534  dest_u += frame->linesize[1];
535  dest_v += frame->linesize[2];
536  }
537  if (interlaced_mb) {
538  dct_linesize_luma <<= 1;
539  dct_linesize_chroma <<= 1;
540  }
541 
542  dct_y_offset = interlaced_mb ? frame->linesize[0] : (dct_linesize_luma << 3);
543  dct_x_offset = 8 << shift1;
544  if (!ctx->is_444) {
545  ctx->idsp.idct_put(dest_y, dct_linesize_luma, row->blocks[0]);
546  ctx->idsp.idct_put(dest_y + dct_x_offset, dct_linesize_luma, row->blocks[1]);
547  ctx->idsp.idct_put(dest_y + dct_y_offset, dct_linesize_luma, row->blocks[4]);
548  ctx->idsp.idct_put(dest_y + dct_y_offset + dct_x_offset, dct_linesize_luma, row->blocks[5]);
549 
550  if (!(ctx->avctx->flags & AV_CODEC_FLAG_GRAY)) {
551  dct_y_offset = interlaced_mb ? frame->linesize[1] : (dct_linesize_chroma << 3);
552  ctx->idsp.idct_put(dest_u, dct_linesize_chroma, row->blocks[2]);
553  ctx->idsp.idct_put(dest_v, dct_linesize_chroma, row->blocks[3]);
554  ctx->idsp.idct_put(dest_u + dct_y_offset, dct_linesize_chroma, row->blocks[6]);
555  ctx->idsp.idct_put(dest_v + dct_y_offset, dct_linesize_chroma, row->blocks[7]);
556  }
557  } else {
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[6]);
561  ctx->idsp.idct_put(dest_y + dct_y_offset + dct_x_offset, dct_linesize_luma, row->blocks[7]);
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_u + dct_x_offset, dct_linesize_chroma, row->blocks[3]);
567  ctx->idsp.idct_put(dest_u + dct_y_offset, dct_linesize_chroma, row->blocks[8]);
568  ctx->idsp.idct_put(dest_u + dct_y_offset + dct_x_offset, dct_linesize_chroma, row->blocks[9]);
569  ctx->idsp.idct_put(dest_v, dct_linesize_chroma, row->blocks[4]);
570  ctx->idsp.idct_put(dest_v + dct_x_offset, dct_linesize_chroma, row->blocks[5]);
571  ctx->idsp.idct_put(dest_v + dct_y_offset, dct_linesize_chroma, row->blocks[10]);
572  ctx->idsp.idct_put(dest_v + dct_y_offset + dct_x_offset, dct_linesize_chroma, row->blocks[11]);
573  }
574  }
575 
576  return 0;
577 }
578 
580  int rownb, int threadnb)
581 {
582  const DNXHDContext *ctx = avctx->priv_data;
583  uint32_t offset = ctx->mb_scan_index[rownb];
584  RowContext *row = ctx->rows + threadnb;
585  int x, ret;
586 
587  row->last_dc[0] =
588  row->last_dc[1] =
589  row->last_dc[2] = 1 << (ctx->bit_depth + 2); // for levels +2^(bitdepth-1)
590  ret = init_get_bits8(&row->gb, ctx->buf + offset, ctx->buf_size - offset);
591  if (ret < 0) {
592  row->errors++;
593  return ret;
594  }
595  for (x = 0; x < ctx->mb_width; x++) {
596  int ret = dnxhd_decode_macroblock(ctx, row, data, x, rownb);
597  if (ret < 0) {
598  row->errors++;
599  return ret;
600  }
601  }
602 
603  return 0;
604 }
605 
607  int *got_frame, AVPacket *avpkt)
608 {
609  const uint8_t *buf = avpkt->data;
610  int buf_size = avpkt->size;
611  DNXHDContext *ctx = avctx->priv_data;
612  ThreadFrame frame = { .f = data };
613  AVFrame *picture = data;
614  int first_field = 1;
615  int ret, i;
616 
617  ff_dlog(avctx, "frame size %d\n", buf_size);
618 
619  for (i = 0; i < avctx->thread_count; i++)
620  ctx->rows[i].format = -1;
621 
622 decode_coding_unit:
623  if ((ret = dnxhd_decode_header(ctx, picture, buf, buf_size, first_field)) < 0)
624  return ret;
625 
626  if ((avctx->width || avctx->height) &&
627  (ctx->width != avctx->width || ctx->height != avctx->height)) {
628  av_log(avctx, AV_LOG_WARNING, "frame size changed: %dx%d -> %ux%u\n",
629  avctx->width, avctx->height, ctx->width, ctx->height);
630  first_field = 1;
631  }
632  if (avctx->pix_fmt != AV_PIX_FMT_NONE && avctx->pix_fmt != ctx->pix_fmt) {
633  av_log(avctx, AV_LOG_WARNING, "pix_fmt changed: %s -> %s\n",
635  first_field = 1;
636  }
637 
638  avctx->pix_fmt = ctx->pix_fmt;
639  ret = ff_set_dimensions(avctx, ctx->width, ctx->height);
640  if (ret < 0)
641  return ret;
642 
643  if (first_field) {
644  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
645  return ret;
646  picture->pict_type = AV_PICTURE_TYPE_I;
647  picture->key_frame = 1;
648  }
649 
650  ctx->buf_size = buf_size - ctx->data_offset;
651  ctx->buf = buf + ctx->data_offset;
652  avctx->execute2(avctx, dnxhd_decode_row, picture, NULL, ctx->mb_height);
653 
654  if (first_field && picture->interlaced_frame) {
655  buf += ctx->cid_table->coding_unit_size;
656  buf_size -= ctx->cid_table->coding_unit_size;
657  first_field = 0;
658  goto decode_coding_unit;
659  }
660 
661  ret = 0;
662  for (i = 0; i < avctx->thread_count; i++) {
663  ret += ctx->rows[i].errors;
664  ctx->rows[i].errors = 0;
665  }
666 
667  if (ctx->act) {
668  static int act_warned;
669  int format = ctx->rows[0].format;
670  for (i = 1; i < avctx->thread_count; i++) {
671  if (ctx->rows[i].format != format &&
672  ctx->rows[i].format != -1 /* not run */) {
673  format = 2;
674  break;
675  }
676  }
677  switch (format) {
678  case -1:
679  case 2:
680  if (!act_warned) {
681  act_warned = 1;
682  av_log(ctx->avctx, AV_LOG_ERROR,
683  "Unsupported: variable ACT flag.\n");
684  }
685  break;
686  case 0:
687  ctx->pix_fmt = ctx->bit_depth==10
689  break;
690  case 1:
691  ctx->pix_fmt = ctx->bit_depth==10
693  break;
694  }
695  }
696  avctx->pix_fmt = ctx->pix_fmt;
697  if (ret) {
698  av_log(ctx->avctx, AV_LOG_ERROR, "%d lines with errors\n", ret);
699  return AVERROR_INVALIDDATA;
700  }
701 
702  *got_frame = 1;
703  return avpkt->size;
704 }
705 
707 {
708  DNXHDContext *ctx = avctx->priv_data;
709 
710  ff_free_vlc(&ctx->ac_vlc);
711  ff_free_vlc(&ctx->dc_vlc);
712  ff_free_vlc(&ctx->run_vlc);
713 
714  av_freep(&ctx->rows);
715 
716  return 0;
717 }
718 
720  .name = "dnxhd",
721  .long_name = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
722  .type = AVMEDIA_TYPE_VIDEO,
723  .id = AV_CODEC_ID_DNXHD,
724  .priv_data_size = sizeof(DNXHDContext),
726  .close = dnxhd_decode_close,
728  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
731 };
#define FF_PROFILE_DNXHD
Definition: avcodec.h:1886
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
Definition: pixfmt.h:514
int cid
Definition: mxfenc.c:1997
static int dnxhd_decode_dct_block_8(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:447
#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:314
const uint8_t * dc_bits
Definition: dnxhddata.h:52
IDCTDSPContext idsp
Definition: dnxhddec.c:66
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:719
int64_t cid
compression id
Definition: dnxhddec.c:58
static int dnxhd_get_profile(int cid)
Definition: dnxhddec.c:149
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:200
const uint8_t * luma_weight
Definition: dnxhddata.h:51
int(* decode_dct_block)(const struct DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:75
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:106
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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: packet.h:364
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:415
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:910
RowContext * rows
Definition: dnxhddec.c:54
VLC run_vlc
Definition: dnxhddec.c:65
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:741
int errors
Definition: dnxhddec.c:47
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:1762
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:91
int profile
profile
Definition: avcodec.h:1871
VLC dc_vlc
Definition: dnxhddec.c:65
AVCodec.
Definition: codec.h:190
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
int luma_scale[64]
Definition: dnxhddec.c:42
const uint8_t * buf
Definition: dnxhddec.c:56
static av_cold int dnxhd_decode_close(AVCodecContext *avctx)
Definition: dnxhddec.c:706
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:88
static int dnxhd_decode_dct_block_12(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:465
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:91
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:117
#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:342
uint8_t * data
Definition: packet.h:363
int format
-1:not set yet 0:off=RGB 1:on=YUV 2:variable
Definition: dnxhddec.c:49
#define ff_dlog(a,...)
const uint8_t * run_bits
Definition: dnxhddata.h:56
bitstream reader API header.
int bit_depth
Definition: dnxhddec.c:69
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
#define DNXHD_VLC_BITS
Definition: dnxhddec.c:79
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:461
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:80
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:404
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
#define FFALIGN(x, a)
Definition: macros.h:48
enum AVPixelFormat pix_fmt
Definition: dnxhddec.c:60
#define av_log(a,...)
static int first_field(const struct video_data *s)
Definition: v4l2.c:234
VLC ac_vlc
Definition: dnxhddec.c:65
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 AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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:579
#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:115
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:611
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:569
unsigned int height
Definition: dnxhddec.c:59
const uint8_t * dc_codes
Definition: dnxhddata.h:52
const char * name
Name of the codec implementation.
Definition: codec.h:197
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
#define FF_PROFILE_DNXHR_LB
Definition: avcodec.h:1887
#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:459
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
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
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
static VLC dc_vlc
Definition: clearvideo.c:84
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:397
int width
picture width / height.
Definition: avcodec.h:704
#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:254
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:523
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:67
unsigned int mb_width
Definition: dnxhddec.c:61
#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:1889
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:477
#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:1790
if(ret)
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:110
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:1857
unsigned int width
Definition: dnxhddec.c:59
Libavcodec external API header.
int last_qscale
Definition: dnxhddec.c:46
int16_t blocks[12][64]
Definition: dnxhddec.c:41
int cur_field
current interlaced field
Definition: dnxhddec.c:64
unsigned int mb_height
Definition: dnxhddec.c:61
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:345
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static int dnxhd_decode_dct_block_10(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:453
main external API structure.
Definition: avcodec.h:531
#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:719
static const AVProfile profiles[]
int eob_index
Definition: dnxhddata.h:50
int index
Definition: gxfenc.c:89
int chroma_scale[64]
Definition: dnxhddec.c:43
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1159
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:1888
static VLC ac_vlc
Definition: clearvideo.c:84
int is_444
Definition: dnxhddec.c:70
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:416
#define SIZE_SPECIFIER
Definition: internal.h:191
#define flags(name, subs,...)
Definition: cbs_av1.c:561
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:406
static int dnxhd_init_vlc(DNXHDContext *ctx, uint32_t cid, int bitdepth)
Definition: dnxhddec.c:113
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
uint8_t level
Definition: svq3.c:206
uint32_t mb_scan_index[512]
Definition: dnxhddec.c:62
ITU-R BT2020 constant luminance system.
Definition: pixfmt.h:524
#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:1890
GetBitContext gb
Definition: dnxhddec.c:44
common internal api header.
int data_offset
Definition: dnxhddec.c:63
int den
Denominator.
Definition: rational.h:60
#define FF_PROFILE_DNXHR_444
Definition: avcodec.h:1891
int buf_size
Definition: dnxhddec.c:57
void * priv_data
Definition: avcodec.h:558
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:466
static int dnxhd_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: dnxhddec.c:606
int len
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
AVCodecContext * avctx
Definition: dnxhddec.c:53
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:392
BlockDSPContext bdsp
Definition: dnxhddec.c:55
AVCodec ff_dnxhd_decoder
Definition: dnxhddec.c:719
const CIDEntry * cid_table
Definition: dnxhddec.c:68
#define av_freep(p)
#define av_always_inline
Definition: attributes.h:45
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:166
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:2489
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: packet.h:340
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:431
int last_dc[3]
Definition: dnxhddec.c:45
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
static int dnxhd_decode_dct_block_12_444(const DNXHDContext *ctx, RowContext *row, int n)
Definition: dnxhddec.c:471
int i
Definition: input.c:407
static av_cold int dnxhd_decode_init(AVCodecContext *avctx)
Definition: dnxhddec.c:93
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190