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