FFmpeg
proresdec.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2010-2011 Maxim Poliakovski
3  * Copyright (c) 2010-2011 Elvis Presley
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Known FOURCCs: 'apch' (HQ), 'apcn' (SD), 'apcs' (LT), 'apco' (Proxy), 'ap4h' (4444), 'ap4x' (4444 XQ)
25  */
26 
27 //#define DEBUG
28 
29 #include "config_components.h"
30 
31 #include "libavutil/internal.h"
32 #include "libavutil/mem.h"
33 #include "libavutil/mem_internal.h"
34 
35 #include "avcodec.h"
36 #include "codec_internal.h"
37 #include "decode.h"
38 #include "get_bits.h"
39 #include "hwaccel_internal.h"
40 #include "hwconfig.h"
41 #include "idctdsp.h"
42 #include "profiles.h"
43 #include "proresdec.h"
44 #include "proresdata.h"
45 #include "thread.h"
46 
47 #define ALPHA_SHIFT_16_TO_10(alpha_val) (alpha_val >> 6)
48 #define ALPHA_SHIFT_8_TO_10(alpha_val) ((alpha_val << 2) | (alpha_val >> 6))
49 #define ALPHA_SHIFT_16_TO_12(alpha_val) (alpha_val >> 4)
50 #define ALPHA_SHIFT_8_TO_12(alpha_val) ((alpha_val << 4) | (alpha_val >> 4))
51 
52 static void inline unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs,
53  const int num_bits, const int decode_precision) {
54  const int mask = (1 << num_bits) - 1;
55  int i, idx, val, alpha_val;
56 
57  idx = 0;
58  alpha_val = mask;
59  do {
60  do {
61  if (get_bits1(gb)) {
62  val = get_bits(gb, num_bits);
63  } else {
64  int sign;
65  val = get_bits(gb, num_bits == 16 ? 7 : 4);
66  sign = val & 1;
67  val = (val + 2) >> 1;
68  if (sign)
69  val = -val;
70  }
71  alpha_val = (alpha_val + val) & mask;
72  if (num_bits == 16) {
73  if (decode_precision == 10) {
74  dst[idx++] = ALPHA_SHIFT_16_TO_10(alpha_val);
75  } else { /* 12b */
76  dst[idx++] = ALPHA_SHIFT_16_TO_12(alpha_val);
77  }
78  } else {
79  if (decode_precision == 10) {
80  dst[idx++] = ALPHA_SHIFT_8_TO_10(alpha_val);
81  } else { /* 12b */
82  dst[idx++] = ALPHA_SHIFT_8_TO_12(alpha_val);
83  }
84  }
85  if (idx >= num_coeffs)
86  break;
87  } while (get_bits_left(gb)>0 && get_bits1(gb));
88  val = get_bits(gb, 4);
89  if (!val)
90  val = get_bits(gb, 11);
91  if (idx + val > num_coeffs)
92  val = num_coeffs - idx;
93  if (num_bits == 16) {
94  for (i = 0; i < val; i++) {
95  if (decode_precision == 10) {
96  dst[idx++] = ALPHA_SHIFT_16_TO_10(alpha_val);
97  } else { /* 12b */
98  dst[idx++] = ALPHA_SHIFT_16_TO_12(alpha_val);
99  }
100  }
101  } else {
102  for (i = 0; i < val; i++) {
103  if (decode_precision == 10) {
104  dst[idx++] = ALPHA_SHIFT_8_TO_10(alpha_val);
105  } else { /* 12b */
106  dst[idx++] = ALPHA_SHIFT_8_TO_12(alpha_val);
107  }
108  }
109  }
110  } while (idx < num_coeffs);
111 }
112 
113 static void unpack_alpha_10(GetBitContext *gb, uint16_t *dst, int num_coeffs,
114  const int num_bits)
115 {
116  if (num_bits == 16) {
117  unpack_alpha(gb, dst, num_coeffs, 16, 10);
118  } else { /* 8 bits alpha */
119  unpack_alpha(gb, dst, num_coeffs, 8, 10);
120  }
121 }
122 
123 static void unpack_alpha_12(GetBitContext *gb, uint16_t *dst, int num_coeffs,
124  const int num_bits)
125 {
126  if (num_bits == 16) {
127  unpack_alpha(gb, dst, num_coeffs, 16, 12);
128  } else { /* 8 bits alpha */
129  unpack_alpha(gb, dst, num_coeffs, 8, 12);
130  }
131 }
132 
133 static av_cold int decode_init(AVCodecContext *avctx)
134 {
135  ProresContext *ctx = avctx->priv_data;
136 
137  avctx->bits_per_raw_sample = 10;
138 
139  switch (avctx->codec_tag) {
140  case MKTAG('a','p','c','o'):
141  avctx->profile = AV_PROFILE_PRORES_PROXY;
142  break;
143  case MKTAG('a','p','c','s'):
144  avctx->profile = AV_PROFILE_PRORES_LT;
145  break;
146  case MKTAG('a','p','c','n'):
147  avctx->profile = AV_PROFILE_PRORES_STANDARD;
148  break;
149  case MKTAG('a','p','c','h'):
150  avctx->profile = AV_PROFILE_PRORES_HQ;
151  break;
152  case MKTAG('a','p','4','h'):
153  avctx->profile = AV_PROFILE_PRORES_4444;
154  avctx->bits_per_raw_sample = 12;
155  break;
156  case MKTAG('a','p','4','x'):
157  avctx->profile = AV_PROFILE_PRORES_XQ;
158  avctx->bits_per_raw_sample = 12;
159  break;
160  default:
161  avctx->profile = AV_PROFILE_UNKNOWN;
162  av_log(avctx, AV_LOG_WARNING, "Unknown prores profile %d\n", avctx->codec_tag);
163  }
164 
165  ctx->unpack_alpha = avctx->bits_per_raw_sample == 10 ?
166  unpack_alpha_10 : unpack_alpha_12;
167 
168  av_log(avctx, AV_LOG_DEBUG,
169  "Auto bitdepth precision. Use %db decoding based on codec tag.\n",
170  avctx->bits_per_raw_sample);
171 
172  ff_blockdsp_init(&ctx->bdsp);
173  ff_proresdsp_init(&ctx->prodsp, avctx->bits_per_raw_sample);
174 
175  ff_permute_scantable(ctx->progressive_scan, ff_prores_progressive_scan,
176  ctx->prodsp.idct_permutation);
177  ff_permute_scantable(ctx->interlaced_scan, ff_prores_interlaced_scan,
178  ctx->prodsp.idct_permutation);
179 
180  ctx->pix_fmt = AV_PIX_FMT_NONE;
181 
182  return 0;
183 }
184 
185 static int decode_frame_header(ProresContext *ctx, const uint8_t *buf,
186  const int data_size, AVCodecContext *avctx)
187 {
188  int hdr_size, width, height, flags, dimensions_changed = 0;
189  int version;
190  const uint8_t *ptr;
191  enum AVPixelFormat pix_fmt;
192  int old_frame_type = ctx->frame_type;
193 
194  hdr_size = AV_RB16(buf);
195  ff_dlog(avctx, "header size %d\n", hdr_size);
196  if (hdr_size > data_size) {
197  av_log(avctx, AV_LOG_ERROR, "error, wrong header size\n");
198  return AVERROR_INVALIDDATA;
199  }
200 
201  version = AV_RB16(buf + 2);
202  ff_dlog(avctx, "%.4s version %d\n", buf+4, version);
203  if (version > 1) {
204  av_log(avctx, AV_LOG_ERROR, "unsupported version: %d\n", version);
205  return AVERROR_PATCHWELCOME;
206  }
207 
208  width = AV_RB16(buf + 8);
209  height = AV_RB16(buf + 10);
210 
211  if (width != avctx->width || height != avctx->height) {
212  int ret;
213 
214  av_log(avctx, AV_LOG_WARNING, "picture resolution change: %dx%d -> %dx%d\n",
215  avctx->width, avctx->height, width, height);
216  if ((ret = ff_set_dimensions(avctx, width, height)) < 0)
217  return ret;
218  dimensions_changed = 1;
219  }
220 
221  ctx->frame_type = (buf[12] >> 2) & 3;
222  ctx->alpha_info = buf[17] & 0xf;
223 
224  if (ctx->alpha_info > 2) {
225  av_log(avctx, AV_LOG_ERROR, "Invalid alpha mode %d\n", ctx->alpha_info);
226  return AVERROR_INVALIDDATA;
227  }
228  if (avctx->skip_alpha) ctx->alpha_info = 0;
229 
230  ff_dlog(avctx, "frame type %d\n", ctx->frame_type);
231 
232  if (ctx->frame_type == 0) {
233  ctx->scan = ctx->progressive_scan; // permuted
234  } else {
235  ctx->scan = ctx->interlaced_scan; // permuted
236  ctx->frame->flags |= AV_FRAME_FLAG_INTERLACED;
237  if (ctx->frame_type == 1)
238  ctx->frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST;
239  }
240 
241  if (ctx->alpha_info) {
242  if (avctx->bits_per_raw_sample == 10) {
243  pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUVA444P10 : AV_PIX_FMT_YUVA422P10;
244  } else { /* 12b */
245  pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUVA444P12 : AV_PIX_FMT_YUVA422P12;
246  }
247  } else {
248  if (avctx->bits_per_raw_sample == 10) {
249  pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUV444P10 : AV_PIX_FMT_YUV422P10;
250  } else { /* 12b */
251  pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUV444P12 : AV_PIX_FMT_YUV422P12;
252  }
253  }
254 
255  if (pix_fmt != ctx->pix_fmt || dimensions_changed ||
256  ctx->frame_type != old_frame_type) {
257 #define HWACCEL_MAX (CONFIG_PRORES_VIDEOTOOLBOX_HWACCEL + CONFIG_PRORES_VULKAN_HWACCEL)
258 #if HWACCEL_MAX
259  enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
260  int ret;
261 
262  ctx->pix_fmt = pix_fmt;
263 
264 #if CONFIG_PRORES_VIDEOTOOLBOX_HWACCEL
265  *fmtp++ = AV_PIX_FMT_VIDEOTOOLBOX;
266 #endif
267 #if CONFIG_PRORES_VULKAN_HWACCEL
268  *fmtp++ = AV_PIX_FMT_VULKAN;
269 #endif
270  *fmtp++ = ctx->pix_fmt;
271  *fmtp = AV_PIX_FMT_NONE;
272 
273  if ((ret = ff_get_format(avctx, pix_fmts)) < 0)
274  return ret;
275 
276  avctx->pix_fmt = ret;
277 #else
278  avctx->pix_fmt = ctx->pix_fmt = pix_fmt;
279 #endif
280  }
281 
282  avctx->color_primaries = buf[14];
283  avctx->color_trc = buf[15];
284  avctx->colorspace = buf[16];
285  avctx->color_range = AVCOL_RANGE_MPEG;
286 
287  ptr = buf + 20;
288  flags = buf[19];
289  ff_dlog(avctx, "flags %x\n", flags);
290 
291  if (flags & 2) {
292  if(buf + data_size - ptr < 64) {
293  av_log(avctx, AV_LOG_ERROR, "Header truncated\n");
294  return AVERROR_INVALIDDATA;
295  }
296  ff_permute_scantable(ctx->qmat_luma, ctx->prodsp.idct_permutation, ptr);
297  ptr += 64;
298  } else {
299  memset(ctx->qmat_luma, 4, 64);
300  }
301 
302  if (flags & 1) {
303  if(buf + data_size - ptr < 64) {
304  av_log(avctx, AV_LOG_ERROR, "Header truncated\n");
305  return AVERROR_INVALIDDATA;
306  }
307  ff_permute_scantable(ctx->qmat_chroma, ctx->prodsp.idct_permutation, ptr);
308  } else {
309  memcpy(ctx->qmat_chroma, ctx->qmat_luma, 64);
310  }
311 
312  return hdr_size;
313 }
314 
315 static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size)
316 {
317  ProresContext *ctx = avctx->priv_data;
318  int i, hdr_size, slice_count;
319  unsigned pic_data_size;
320  int log2_slice_mb_width, log2_slice_mb_height;
321  int slice_mb_count, mb_x, mb_y;
322  const uint8_t *data_ptr, *index_ptr;
323 
324  hdr_size = buf[0] >> 3;
325  if (hdr_size < 8 || hdr_size > buf_size) {
326  av_log(avctx, AV_LOG_ERROR, "error, wrong picture header size\n");
327  return AVERROR_INVALIDDATA;
328  }
329 
330  pic_data_size = AV_RB32(buf + 1);
331  if (pic_data_size > buf_size) {
332  av_log(avctx, AV_LOG_ERROR, "error, wrong picture data size\n");
333  return AVERROR_INVALIDDATA;
334  }
335 
336  log2_slice_mb_width = buf[7] >> 4;
337  log2_slice_mb_height = buf[7] & 0xF;
338  if (log2_slice_mb_width > 3 || log2_slice_mb_height) {
339  av_log(avctx, AV_LOG_ERROR, "unsupported slice resolution: %dx%d\n",
340  1 << log2_slice_mb_width, 1 << log2_slice_mb_height);
341  return AVERROR_INVALIDDATA;
342  }
343 
344  ctx->slice_mb_width = 1 << log2_slice_mb_width;
345  ctx->slice_mb_height = 1 << log2_slice_mb_height;
346 
347  ctx->mb_width = (avctx->width + 15) >> 4;
348  if (ctx->frame_type)
349  ctx->mb_height = (avctx->height + 31) >> 5;
350  else
351  ctx->mb_height = (avctx->height + 15) >> 4;
352 
353  // QT ignores the written value
354  // slice_count = AV_RB16(buf + 5);
355  slice_count = ctx->mb_height * ((ctx->mb_width >> log2_slice_mb_width) +
356  av_popcount(ctx->mb_width & ctx->slice_mb_width - 1));
357 
358  if (ctx->slice_count != slice_count || !ctx->slices) {
359  av_freep(&ctx->slices);
360  ctx->slice_count = 0;
361  ctx->slices = av_calloc(slice_count, sizeof(*ctx->slices));
362  if (!ctx->slices)
363  return AVERROR(ENOMEM);
364  ctx->slice_count = slice_count;
365  }
366 
367  if (!slice_count)
368  return AVERROR(EINVAL);
369 
370  if (hdr_size + slice_count*2 > buf_size) {
371  av_log(avctx, AV_LOG_ERROR, "error, wrong slice count\n");
372  return AVERROR_INVALIDDATA;
373  }
374 
375  // parse slice information
376  index_ptr = buf + hdr_size;
377  data_ptr = index_ptr + slice_count*2;
378 
379  slice_mb_count = ctx->slice_mb_width;
380  mb_x = 0;
381  mb_y = 0;
382 
383  for (i = 0; i < slice_count; i++) {
384  SliceContext *slice = &ctx->slices[i];
385 
386  slice->data = data_ptr;
387  data_ptr += AV_RB16(index_ptr + i*2);
388 
389  while (ctx->mb_width - mb_x < slice_mb_count)
390  slice_mb_count >>= 1;
391 
392  slice->mb_x = mb_x;
393  slice->mb_y = mb_y;
394  slice->mb_count = slice_mb_count;
395  slice->data_size = data_ptr - slice->data;
396 
397  if (slice->data_size < 6) {
398  av_log(avctx, AV_LOG_ERROR, "error, wrong slice data size\n");
399  return AVERROR_INVALIDDATA;
400  }
401 
402  mb_x += slice_mb_count;
403  if (mb_x == ctx->mb_width) {
404  slice_mb_count = ctx->slice_mb_width;
405  mb_x = 0;
406  mb_y++;
407  }
408  if (data_ptr > buf + buf_size) {
409  av_log(avctx, AV_LOG_ERROR, "error, slice out of bounds\n");
410  return AVERROR_INVALIDDATA;
411  }
412  }
413 
414  if (mb_x || mb_y != ctx->mb_height) {
415  av_log(avctx, AV_LOG_ERROR, "error wrong mb count y %d h %d\n",
416  mb_y, ctx->mb_height);
417  return AVERROR_INVALIDDATA;
418  }
419 
420  return pic_data_size;
421 }
422 
423 #define DECODE_CODEWORD(val, codebook, SKIP) \
424  do { \
425  unsigned int rice_order, exp_order, switch_bits; \
426  unsigned int q, buf, bits; \
427  \
428  UPDATE_CACHE_32(re, gb); /* We really need 32 bits */ \
429  buf = GET_CACHE(re, gb); \
430  \
431  /* number of bits to switch between rice and exp golomb */ \
432  switch_bits = codebook & 3; \
433  rice_order = codebook >> 5; \
434  exp_order = (codebook >> 2) & 7; \
435  \
436  q = 31 - av_log2(buf); \
437  \
438  if (q > switch_bits) { /* exp golomb */ \
439  bits = exp_order - switch_bits + (q<<1); \
440  if (bits > 31) \
441  return AVERROR_INVALIDDATA; \
442  val = SHOW_UBITS(re, gb, bits) - (1 << exp_order) + \
443  ((switch_bits + 1) << rice_order); \
444  SKIP(re, gb, bits); \
445  } else if (rice_order) { \
446  SKIP_BITS(re, gb, q+1); \
447  val = (q << rice_order) + SHOW_UBITS(re, gb, rice_order); \
448  SKIP(re, gb, rice_order); \
449  } else { \
450  val = q; \
451  SKIP(re, gb, q+1); \
452  } \
453  } while (0)
454 
455 #define TOSIGNED(x) (((x) >> 1) ^ (-((x) & 1)))
456 
457 #define FIRST_DC_CB 0xB8
458 
459 static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
460 
461 static av_always_inline int decode_dc_coeffs(GetBitContext *gb, int16_t *out,
462  int blocks_per_slice)
463 {
464  int16_t prev_dc;
465  int code, i, sign;
466 
467  OPEN_READER(re, gb);
468 
469  DECODE_CODEWORD(code, FIRST_DC_CB, LAST_SKIP_BITS);
470  prev_dc = TOSIGNED(code);
471  out[0] = prev_dc;
472 
473  out += 64; // dc coeff for the next block
474 
475  code = 5;
476  sign = 0;
477  for (i = 1; i < blocks_per_slice; i++, out += 64) {
478  DECODE_CODEWORD(code, dc_codebook[FFMIN(code, 6U)], LAST_SKIP_BITS);
479  if(code) sign ^= -(code & 1);
480  else sign = 0;
481  prev_dc += (((code + 1) >> 1) ^ sign) - sign;
482  out[0] = prev_dc;
483  }
484  CLOSE_READER(re, gb);
485  return 0;
486 }
487 
488 // adaptive codebook switching lut according to previous run/level values
489 static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29, 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };
490 static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28, 0x28, 0x28, 0x28, 0x4C };
491 
492 static av_always_inline int decode_ac_coeffs(AVCodecContext *avctx, GetBitContext *gb,
493  int16_t *out, int blocks_per_slice)
494 {
495  const ProresContext *ctx = avctx->priv_data;
496  int block_mask, sign;
497  unsigned pos, run, level;
498  int max_coeffs, i, bits_left;
499  int log2_block_count = av_log2(blocks_per_slice);
500 
501  OPEN_READER(re, gb);
502  UPDATE_CACHE_32(re, gb);
503  run = 4;
504  level = 2;
505 
506  max_coeffs = 64 << log2_block_count;
507  block_mask = blocks_per_slice - 1;
508 
509  for (pos = block_mask;;) {
510  bits_left = gb->size_in_bits - re_index;
511  if (bits_left <= 0 || (bits_left < 32 && !SHOW_UBITS(re, gb, bits_left)))
512  break;
513 
514  DECODE_CODEWORD(run, run_to_cb[FFMIN(run, 15)], LAST_SKIP_BITS);
515  pos += run + 1;
516  if (pos >= max_coeffs) {
517  av_log(avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", pos, max_coeffs);
518  return AVERROR_INVALIDDATA;
519  }
520 
521  DECODE_CODEWORD(level, lev_to_cb[FFMIN(level, 9)], SKIP_BITS);
522  level += 1;
523 
524  i = pos >> log2_block_count;
525 
526  sign = SHOW_SBITS(re, gb, 1);
527  SKIP_BITS(re, gb, 1);
528  out[((pos & block_mask) << 6) + ctx->scan[i]] = ((level ^ sign) - sign);
529  }
530 
531  CLOSE_READER(re, gb);
532  return 0;
533 }
534 
535 static int decode_slice_luma(AVCodecContext *avctx, SliceContext *slice,
536  uint16_t *dst, int dst_stride,
537  const uint8_t *buf, unsigned buf_size,
538  const int16_t *qmat)
539 {
540  const ProresContext *ctx = avctx->priv_data;
541  LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);
542  int16_t *block;
543  GetBitContext gb;
544  int i, blocks_per_slice = slice->mb_count<<2;
545  int ret;
546 
547  for (i = 0; i < blocks_per_slice; i++)
548  ctx->bdsp.clear_block(blocks+(i<<6));
549 
550  init_get_bits(&gb, buf, buf_size << 3);
551 
552  if ((ret = decode_dc_coeffs(&gb, blocks, blocks_per_slice)) < 0)
553  return ret;
554  if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)
555  return ret;
556 
557  block = blocks;
558  for (i = 0; i < slice->mb_count; i++) {
559  ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat);
560  ctx->prodsp.idct_put(dst +8, dst_stride, block+(1<<6), qmat);
561  ctx->prodsp.idct_put(dst+4*dst_stride , dst_stride, block+(2<<6), qmat);
562  ctx->prodsp.idct_put(dst+4*dst_stride+8, dst_stride, block+(3<<6), qmat);
563  block += 4*64;
564  dst += 16;
565  }
566  return 0;
567 }
568 
569 static int decode_slice_chroma(AVCodecContext *avctx, SliceContext *slice,
570  uint16_t *dst, int dst_stride,
571  const uint8_t *buf, unsigned buf_size,
572  const int16_t *qmat, int log2_blocks_per_mb)
573 {
574  ProresContext *ctx = avctx->priv_data;
575  LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);
576  int16_t *block;
577  GetBitContext gb;
578  int i, j, blocks_per_slice = slice->mb_count << log2_blocks_per_mb;
579  int ret;
580 
581  for (i = 0; i < blocks_per_slice; i++)
582  ctx->bdsp.clear_block(blocks+(i<<6));
583 
584  /* Some encodes have empty chroma scans to simulate grayscale */
585  if (buf_size) {
586  init_get_bits(&gb, buf, buf_size << 3);
587 
588  if ((ret = decode_dc_coeffs(&gb, blocks, blocks_per_slice)) < 0)
589  return ret;
590  if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)
591  return ret;
592  }
593 
594  block = blocks;
595  for (i = 0; i < slice->mb_count; i++) {
596  for (j = 0; j < log2_blocks_per_mb; j++) {
597  ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat);
598  ctx->prodsp.idct_put(dst+4*dst_stride, dst_stride, block+(1<<6), qmat);
599  block += 2*64;
600  dst += 8;
601  }
602  }
603  return 0;
604 }
605 
606 /**
607  * Decode alpha slice plane.
608  */
609 static void decode_slice_alpha(const ProresContext *ctx,
610  uint16_t *dst, int dst_stride,
611  const uint8_t *buf, int buf_size,
612  int blocks_per_slice)
613 {
614  GetBitContext gb;
615  int i;
616  LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);
617  int16_t *block;
618 
619  for (i = 0; i < blocks_per_slice<<2; i++)
620  ctx->bdsp.clear_block(blocks+(i<<6));
621 
622  init_get_bits(&gb, buf, buf_size << 3);
623 
624  if (ctx->alpha_info == 2) {
625  ctx->unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 16);
626  } else {
627  ctx->unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 8);
628  }
629 
630  block = blocks;
631 
632  for (i = 0; i < 16; i++) {
633  memcpy(dst, block, 16 * blocks_per_slice * sizeof(*dst));
634  dst += dst_stride >> 1;
635  block += 16 * blocks_per_slice;
636  }
637 }
638 
639 static int decode_slice_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
640 {
641  const ProresContext *ctx = avctx->priv_data;
642  SliceContext *slice = &ctx->slices[jobnr];
643  const uint8_t *buf = slice->data;
644  AVFrame *pic = ctx->frame;
645  int i, hdr_size, qscale, log2_chroma_blocks_per_mb;
646  int luma_stride, chroma_stride;
647  int y_data_size, u_data_size, v_data_size, a_data_size, offset;
648  uint8_t *dest_y, *dest_u, *dest_v;
649  LOCAL_ALIGNED_16(int16_t, qmat_luma_scaled, [64]);
650  LOCAL_ALIGNED_16(int16_t, qmat_chroma_scaled,[64]);
651  int mb_x_shift;
652  int ret;
653 
654  slice->ret = -1;
655  //av_log(avctx, AV_LOG_INFO, "slice %d mb width %d mb x %d y %d\n",
656  // jobnr, slice->mb_count, slice->mb_x, slice->mb_y);
657 
658  // slice header
659  hdr_size = buf[0] >> 3;
660  qscale = av_clip(buf[1], 1, 224);
661  qscale = qscale > 128 ? qscale - 96 << 2: qscale;
662  y_data_size = AV_RB16(buf + 2);
663  u_data_size = AV_RB16(buf + 4);
664  v_data_size = slice->data_size - y_data_size - u_data_size - hdr_size;
665  if (hdr_size > 7) v_data_size = AV_RB16(buf + 6);
666  a_data_size = slice->data_size - y_data_size - u_data_size -
667  v_data_size - hdr_size;
668 
669  if (y_data_size < 0 || u_data_size < 0 || v_data_size < 0
670  || hdr_size+y_data_size+u_data_size+v_data_size > slice->data_size){
671  av_log(avctx, AV_LOG_ERROR, "invalid plane data size\n");
672  return AVERROR_INVALIDDATA;
673  }
674 
675  buf += hdr_size;
676 
677  for (i = 0; i < 64; i++) {
678  qmat_luma_scaled [i] = ctx->qmat_luma [i] * qscale;
679  qmat_chroma_scaled[i] = ctx->qmat_chroma[i] * qscale;
680  }
681 
682  if (ctx->frame_type == 0) {
683  luma_stride = pic->linesize[0];
684  chroma_stride = pic->linesize[1];
685  } else {
686  luma_stride = pic->linesize[0] << 1;
687  chroma_stride = pic->linesize[1] << 1;
688  }
689 
690  if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10 || avctx->pix_fmt == AV_PIX_FMT_YUVA444P10 ||
691  avctx->pix_fmt == AV_PIX_FMT_YUV444P12 || avctx->pix_fmt == AV_PIX_FMT_YUVA444P12) {
692  mb_x_shift = 5;
693  log2_chroma_blocks_per_mb = 2;
694  } else {
695  mb_x_shift = 4;
696  log2_chroma_blocks_per_mb = 1;
697  }
698 
699  offset = (slice->mb_y << 4) * luma_stride + (slice->mb_x << 5);
700  dest_y = pic->data[0] + offset;
701  dest_u = pic->data[1] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift);
702  dest_v = pic->data[2] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift);
703 
704  if (ctx->frame_type && ctx->first_field ^ !!(ctx->frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST)) {
705  dest_y += pic->linesize[0];
706  dest_u += pic->linesize[1];
707  dest_v += pic->linesize[2];
708  offset += pic->linesize[3];
709  }
710 
711  ret = decode_slice_luma(avctx, slice, (uint16_t*)dest_y, luma_stride,
712  buf, y_data_size, qmat_luma_scaled);
713  if (ret < 0)
714  return ret;
715 
716  if (!(avctx->flags & AV_CODEC_FLAG_GRAY)) {
717  ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_u, chroma_stride,
718  buf + y_data_size, u_data_size,
719  qmat_chroma_scaled, log2_chroma_blocks_per_mb);
720  if (ret < 0)
721  return ret;
722 
723  ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_v, chroma_stride,
724  buf + y_data_size + u_data_size, v_data_size,
725  qmat_chroma_scaled, log2_chroma_blocks_per_mb);
726  if (ret < 0)
727  return ret;
728  }
729 
730  /* decode alpha plane if available */
731  if (ctx->alpha_info && pic->data[3] && a_data_size) {
732  uint8_t *dest_a = pic->data[3] + offset;
733  decode_slice_alpha(ctx, (uint16_t*)dest_a, luma_stride,
734  buf + y_data_size + u_data_size + v_data_size,
735  a_data_size, slice->mb_count);
736  }
737 
738  slice->ret = 0;
739  return 0;
740 }
741 
742 static int decode_picture(AVCodecContext *avctx)
743 {
744  ProresContext *ctx = avctx->priv_data;
745  int i;
746  int error = 0;
747 
748  avctx->execute2(avctx, decode_slice_thread, NULL, NULL, ctx->slice_count);
749 
750  for (i = 0; i < ctx->slice_count; i++)
751  error += ctx->slices[i].ret < 0;
752 
753  if (error)
754  ctx->frame->decode_error_flags = FF_DECODE_ERROR_INVALID_BITSTREAM;
755  if (error < ctx->slice_count)
756  return 0;
757 
758  return ctx->slices[0].ret;
759 }
760 
761 static int decode_frame(AVCodecContext *avctx, AVFrame *frame,
762  int *got_frame, AVPacket *avpkt)
763 {
764  ProresContext *ctx = avctx->priv_data;
765  const uint8_t *buf = avpkt->data;
766  int buf_size = avpkt->size;
767  int frame_hdr_size, pic_size, ret;
768  int i;
769 
770  if (buf_size < 28 || AV_RL32(buf + 4) != AV_RL32("icpf")) {
771  av_log(avctx, AV_LOG_ERROR, "invalid frame header\n");
772  return AVERROR_INVALIDDATA;
773  }
774 
775  ctx->frame = frame;
776  ctx->first_field = 1;
777 
778  buf += 8;
779  buf_size -= 8;
780 
781  frame_hdr_size = decode_frame_header(ctx, buf, buf_size, avctx);
782  if (frame_hdr_size < 0)
783  return frame_hdr_size;
784 
785  if (avctx->skip_frame == AVDISCARD_ALL)
786  return 0;
787 
788  buf += frame_hdr_size;
789  buf_size -= frame_hdr_size;
790 
791  if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0)
792  return ret;
793 
794  av_refstruct_unref(&ctx->hwaccel_picture_private);
795 
796  if ((ret = ff_hwaccel_frame_priv_alloc(avctx, &ctx->hwaccel_picture_private)) < 0)
797  return ret;
798 
799  ff_thread_finish_setup(avctx);
800 
801  decode_picture:
802  pic_size = decode_picture_header(avctx, buf, buf_size);
803  if (pic_size < 0) {
804  av_log(avctx, AV_LOG_ERROR, "error decoding picture header\n");
805  return pic_size;
806  }
807 
808  if (HWACCEL_MAX && avctx->hwaccel) {
809  const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
810 
811  ret = hwaccel->start_frame(avctx, avpkt->buf, avpkt->data, avpkt->size);
812  if (ret < 0)
813  return ret;
814 
815  for (i = 0; i < ctx->slice_count; ++i) {
816  ret = hwaccel->decode_slice(avctx, ctx->slices[i].data, ctx->slices[i].data_size);
817  if (ret < 0)
818  return ret;
819  }
820 
821  ret = hwaccel->end_frame(avctx);
822  if (ret < 0)
823  return ret;
824  } else if ((ret = decode_picture(avctx)) < 0) {
825  av_log(avctx, AV_LOG_ERROR, "error decoding picture\n");
826  return ret;
827  }
828 
829  buf += pic_size;
830  buf_size -= pic_size;
831 
832  if (ctx->frame_type && buf_size > 0 && ctx->first_field) {
833  ctx->first_field = 0;
834  goto decode_picture;
835  }
836 
837  av_refstruct_unref(&ctx->hwaccel_picture_private);
838 
839  *got_frame = 1;
840 
841  return avpkt->size;
842 }
843 
844 static av_cold int decode_close(AVCodecContext *avctx)
845 {
846  ProresContext *ctx = avctx->priv_data;
847 
848  av_freep(&ctx->slices);
849  av_refstruct_unref(&ctx->hwaccel_picture_private);
850 
851  return 0;
852 }
853 
854 #if HAVE_THREADS
855 static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
856 {
857  ProresContext *csrc = src->priv_data;
858  ProresContext *cdst = dst->priv_data;
859 
860  cdst->pix_fmt = csrc->pix_fmt;
861  cdst->frame_type = csrc->frame_type;
862 
863  return 0;
864 }
865 #endif
866 
867 const FFCodec ff_prores_decoder = {
868  .p.name = "prores",
869  CODEC_LONG_NAME("Apple ProRes (iCodec Pro)"),
870  .p.type = AVMEDIA_TYPE_VIDEO,
871  .p.id = AV_CODEC_ID_PRORES,
872  .priv_data_size = sizeof(ProresContext),
873  .init = decode_init,
874  .close = decode_close,
875  FF_CODEC_DECODE_CB(decode_frame),
876  UPDATE_THREAD_CONTEXT(update_thread_context),
877  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,
878  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
879  .p.profiles = NULL_IF_CONFIG_SMALL(ff_prores_profiles),
880 #if HWACCEL_MAX
881  .hw_configs = (const AVCodecHWConfigInternal *const []) {
882 #if CONFIG_PRORES_VIDEOTOOLBOX_HWACCEL
883  HWACCEL_VIDEOTOOLBOX(prores),
884 #endif
885 #if CONFIG_PRORES_VULKAN_HWACCEL
886  HWACCEL_VULKAN(prores),
887 #endif
888  NULL
889  },
890 #endif
891 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
flags
const SwsFlags flags[]
Definition: swscale.c:61
hwconfig.h
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1405
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
level
uint8_t level
Definition: svq3.c:208
av_clip
#define av_clip
Definition: common.h:100
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:694
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:659
mem_internal.h
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1207
out
FILE * out
Definition: movenc.c:55
ff_prores_profiles
const AVProfile ff_prores_profiles[]
Definition: profiles.c:175
decode_frame_header
static int decode_frame_header(ProresContext *ctx, const uint8_t *buf, const int data_size, AVCodecContext *avctx)
Definition: proresdec.c:185
unpack_alpha_10
static void unpack_alpha_10(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits)
Definition: proresdec.c:113
mask
int mask
Definition: mediacodecdec_common.c:154
GetBitContext::size_in_bits
int size_in_bits
Definition: get_bits.h:112
HWACCEL_MAX
#define HWACCEL_MAX
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:652
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: proresdec.c:761
AVPacket::data
uint8_t * data
Definition: packet.h:588
decode_picture_header
static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size)
Definition: proresdec.c:315
ProresContext
Definition: proresdec.h:43
SliceContext::mb_x
unsigned mb_x
Definition: proresdec.h:36
FFCodec
Definition: codec_internal.h:127
av_popcount
#define av_popcount
Definition: common.h:154
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:91
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:591
ff_prores_progressive_scan
const uint8_t ff_prores_progressive_scan[64]
Definition: proresdata.c:25
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:517
thread.h
AV_PIX_FMT_VULKAN
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition: pixfmt.h:379
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:448
AV_PROFILE_PRORES_STANDARD
#define AV_PROFILE_PRORES_STANDARD
Definition: defs.h:183
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:655
ff_permute_scantable
av_cold void ff_permute_scantable(uint8_t dst[64], const uint8_t src[64], const uint8_t permutation[64])
Definition: idctdsp.c:30
close
static av_cold void close(AVCodecParserContext *s)
Definition: apv_parser.c:136
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:337
AV_PROFILE_PRORES_HQ
#define AV_PROFILE_PRORES_HQ
Definition: defs.h:184
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
FFHWAccel
Definition: hwaccel_internal.h:34
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1662
ProresContext::pix_fmt
enum AVPixelFormat pix_fmt
Definition: proresdec.h:63
GetBitContext
Definition: get_bits.h:109
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:488
proresdec.h
val
static double val(void *priv, double ch)
Definition: aeval.c:77
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:542
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:645
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
av_cold
#define av_cold
Definition: attributes.h:106
decode_slice_alpha
static void decode_slice_alpha(const ProresContext *ctx, uint16_t *dst, int dst_stride, const uint8_t *buf, int buf_size, int blocks_per_slice)
Decode alpha slice plane.
Definition: proresdec.c:609
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:189
dc_codebook
static const uint8_t dc_codebook[7]
Definition: proresdec.c:459
unpack_alpha_12
static void unpack_alpha_12(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits)
Definition: proresdec.c:123
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:347
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c)
Definition: blockdsp.c:58
ff_hwaccel_frame_priv_alloc
int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private)
Allocate a hwaccel frame private data if the provided avctx uses a hwaccel method that needs it.
Definition: decode.c:2278
SliceContext::data_size
unsigned data_size
Definition: proresdec.h:39
decode_close
static av_cold int decode_close(AVCodecContext *avctx)
Definition: proresdec.c:844
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1415
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:1038
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:248
decode_dc_coeffs
static av_always_inline int decode_dc_coeffs(GetBitContext *gb, int16_t *out, int blocks_per_slice)
Definition: proresdec.c:461
LOCAL_ALIGNED_16
#define LOCAL_ALIGNED_16(t, v,...)
Definition: mem_internal.h:130
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:296
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:594
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1553
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
ctx
AVFormatContext * ctx
Definition: movenc.c:49
decode.h
get_bits.h
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:229
decode_slice_thread
static int decode_slice_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
Definition: proresdec.c:639
ff_prores_interlaced_scan
const uint8_t ff_prores_interlaced_scan[64]
Definition: proresdata.c:36
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:332
arg
const char * arg
Definition: jacosubdec.c:65
if
if(ret)
Definition: filter_design.txt:179
decode_ac_coeffs
static av_always_inline int decode_ac_coeffs(AVCodecContext *avctx, GetBitContext *gb, int16_t *out, int blocks_per_slice)
Definition: proresdec.c:492
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:95
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:232
ALPHA_SHIFT_8_TO_10
#define ALPHA_SHIFT_8_TO_10(alpha_val)
Definition: proresdec.c:48
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:571
NULL
#define NULL
Definition: coverity.c:32
FF_DECODE_ERROR_INVALID_BITSTREAM
#define FF_DECODE_ERROR_INVALID_BITSTREAM
Definition: frame.h:715
bits_left
#define bits_left
Definition: bitstream.h:116
DECODE_CODEWORD
#define DECODE_CODEWORD(val, codebook, SKIP)
Definition: proresdec.c:423
LOCAL_ALIGNED_32
#define LOCAL_ALIGNED_32(t, v,...)
Definition: mem_internal.h:132
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
run
uint8_t run
Definition: svq3.c:207
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:669
hwaccel_internal.h
SliceContext::ret
int ret
Definition: proresdec.h:40
ALPHA_SHIFT_16_TO_10
#define ALPHA_SHIFT_16_TO_10(alpha_val)
Definition: proresdec.c:47
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:391
profiles.h
SliceContext::mb_y
unsigned mb_y
Definition: proresdec.h:37
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:235
UPDATE_THREAD_CONTEXT
#define UPDATE_THREAD_CONTEXT(func)
Definition: codec_internal.h:341
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:540
AV_PROFILE_PRORES_LT
#define AV_PROFILE_PRORES_LT
Definition: defs.h:182
lev_to_cb
static const uint8_t lev_to_cb[10]
Definition: proresdec.c:490
SliceContext
Definition: mss12.h:70
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:550
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
decode_slice_luma
static int decode_slice_luma(AVCodecContext *avctx, SliceContext *slice, uint16_t *dst, int dst_stride, const uint8_t *buf, unsigned buf_size, const int16_t *qmat)
Definition: proresdec.c:535
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:302
AVPacket::size
int size
Definition: packet.h:589
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
height
#define height
Definition: dsp.h:89
codec_internal.h
ff_proresdsp_init
av_cold void ff_proresdsp_init(ProresDSPContext *dsp, int bits_per_raw_sample)
Definition: proresdsp.c:140
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:544
SliceContext::mb_count
unsigned mb_count
Definition: proresdec.h:38
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
Definition: codec_internal.h:54
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:546
proresdata.h
AVCodecContext::skip_alpha
int skip_alpha
Skip processing alpha if supported by codec.
Definition: avcodec.h:1676
AVCodecHWConfigInternal
Definition: hwconfig.h:25
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:177
AV_PROFILE_PRORES_4444
#define AV_PROFILE_PRORES_4444
Definition: defs.h:185
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:99
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:592
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
version
version
Definition: libkvazaar.c:313
AV_PROFILE_PRORES_PROXY
#define AV_PROFILE_PRORES_PROXY
Definition: defs.h:181
av_refstruct_unref
void av_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
AV_PIX_FMT_VIDEOTOOLBOX
@ AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
Definition: pixfmt.h:305
TOSIGNED
#define TOSIGNED(x)
Definition: proresdec.c:455
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
internal.h
SliceContext::data
const uint8_t * data
Definition: proresdec.h:35
decode_slice_chroma
static int decode_slice_chroma(AVCodecContext *avctx, SliceContext *slice, uint16_t *dst, int dst_stride, const uint8_t *buf, unsigned buf_size, const int16_t *qmat, int log2_blocks_per_mb)
Definition: proresdec.c:569
FIRST_DC_CB
#define FIRST_DC_CB
Definition: proresdec.c:457
av_always_inline
#define av_always_inline
Definition: attributes.h:63
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
AVCodecContext::height
int height
Definition: avcodec.h:592
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:631
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:650
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:760
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
HWACCEL_VIDEOTOOLBOX
#define HWACCEL_VIDEOTOOLBOX(codec)
Definition: hwconfig.h:74
idctdsp.h
avcodec.h
ff_prores_decoder
const FFCodec ff_prores_decoder
Definition: proresdec.c:867
ALPHA_SHIFT_16_TO_12
#define ALPHA_SHIFT_16_TO_12(alpha_val)
Definition: proresdec.c:49
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:265
run_to_cb
static const uint8_t run_to_cb[16]
Definition: proresdec.c:489
hwaccel
static const char * hwaccel
Definition: ffplay.c:353
pos
unsigned int pos
Definition: spdifenc.c:414
ff_thread_finish_setup
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 ff_thread_finish_setup() afterwards. If some code can 't be moved
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
U
#define U(x)
Definition: vpx_arith.h:37
HWACCEL_VULKAN
#define HWACCEL_VULKAN(codec)
Definition: hwconfig.h:76
ProresContext::frame_type
int frame_type
0 = progressive, 1 = tff, 2 = bff
Definition: proresdec.h:48
AVCodecContext
main external API structure.
Definition: avcodec.h:431
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:247
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:593
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1618
ffhwaccel
static const FFHWAccel * ffhwaccel(const AVHWAccel *codec)
Definition: hwaccel_internal.h:168
update_thread_context
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 update_thread_context() run it in the next thread. Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities. There will be very little speed gain at this point but it should work. Use ff_thread_get_buffer()(or ff_progress_frame_get_buffer() in case you have inter-frame dependencies and use the ProgressFrame API) to allocate frame buffers. Call ff_progress_frame_report() 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
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
UPDATE_CACHE_32
#define UPDATE_CACHE_32(name, gb)
Definition: get_bits.h:214
mem.h
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:456
ALPHA_SHIFT_8_TO_12
#define ALPHA_SHIFT_8_TO_12(alpha_val)
Definition: proresdec.c:50
AVPacket
This structure stores compressed data.
Definition: packet.h:565
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
unpack_alpha
static void unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits, const int decode_precision)
Definition: proresdec.c:52
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:592
AV_PROFILE_PRORES_XQ
#define AV_PROFILE_PRORES_XQ
Definition: defs.h:186
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:472
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
decode_picture
static int decode_picture(AVCodecContext *avctx)
Definition: proresdec.c:742
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
width
#define width
Definition: dsp.h:89
AVCodecContext::execute2
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
Definition: avcodec.h:1610
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
src
#define src
Definition: vp8dsp.c:248
AV_CODEC_ID_PRORES
@ AV_CODEC_ID_PRORES
Definition: codec_id.h:200
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: proresdec.c:133
Generated on Sat Nov 29 2025 19:22:16 for FFmpeg by   doxygen 1.8.17