FFmpeg
prores_raw.c
Go to the documentation of this file.
1 /*
2  * ProRes RAW decoder
3  * Copyright (c) 2023-2025 Paul B Mahol
4  * Copyright (c) 2025 Lynne
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "libavutil/intreadwrite.h"
24 #include "libavutil/mem_internal.h"
25 #include "libavutil/mem.h"
26 
27 #define CACHED_BITSTREAM_READER !ARCH_X86_32
28 
29 #include "config_components.h"
30 #include "avcodec.h"
31 #include "bytestream.h"
32 #include "codec_internal.h"
33 #include "decode.h"
34 #include "get_bits.h"
35 #include "idctdsp.h"
36 #include "proresdata.h"
37 #include "thread.h"
38 #include "hwconfig.h"
39 #include "hwaccel_internal.h"
40 
41 #include "prores_raw.h"
42 
44 {
45  ProResRAWContext *s = avctx->priv_data;
46  uint8_t idct_permutation[64];
47 
48  avctx->bits_per_raw_sample = 12;
52 
53  s->pix_fmt = AV_PIX_FMT_NONE;
54 
55  ff_blockdsp_init(&s->bdsp);
56  ff_proresdsp_init(&s->prodsp, avctx->bits_per_raw_sample);
57 
58  ff_init_scantable_permutation(idct_permutation,
59  s->prodsp.idct_permutation_type);
60 
61  ff_permute_scantable(s->scan, ff_prores_interlaced_scan, idct_permutation);
62 
63  return 0;
64 }
65 
66 static int16_t get_value(GetBitContext *gb, int16_t codebook)
67 {
68  const int16_t switch_bits = codebook >> 8;
69  const int16_t rice_order = codebook & 0xf;
70  const int16_t exp_order = (codebook >> 4) & 0xf;
71  int16_t q, bits;
72 
73  uint32_t b = show_bits_long(gb, 32);
74  if (!b)
75  return 0;
76  q = ff_clz(b);
77 
78  if (b & 0x80000000) {
79  skip_bits_long(gb, 1 + rice_order);
80  return (b & 0x7FFFFFFF) >> (31 - rice_order);
81  }
82 
83  if (q <= switch_bits) {
84  skip_bits_long(gb, 1 + rice_order + q);
85  return (q << rice_order) +
86  (((b << (q + 1)) >> 1) >> (31 - rice_order));
87  }
88 
89  bits = exp_order + (q << 1) - switch_bits;
90  skip_bits_long(gb, bits);
91  return (b >> (32 - bits)) +
92  ((switch_bits + 1) << rice_order) -
93  (1 << exp_order);
94 }
95 
96 #define TODCCODEBOOK(x) ((x + 1) >> 1)
97 
98 static const uint8_t align_tile_w[16] = {
99  0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
100 };
101 
102 #define DC_CB_MAX 12
103 const uint8_t ff_prores_raw_dc_cb[DC_CB_MAX + 1] = {
104  16, 33, 50, 51, 51, 51, 68, 68, 68, 68, 68, 68, 118,
105 };
106 
107 #define AC_CB_MAX 94
108 const int16_t ff_prores_raw_ac_cb[AC_CB_MAX + 1] = {
109  0, 529, 273, 273, 546, 546, 546, 290, 290, 290, 563, 563,
110  563, 563, 563, 563, 563, 563, 307, 307, 580, 580, 580, 580,
111  580, 580, 580, 580, 580, 580, 580, 580, 580, 580, 580, 580,
112  580, 580, 580, 580, 580, 580, 853, 853, 853, 853, 853, 853,
113  853, 853, 853, 853, 853, 853, 853, 853, 853, 853, 853, 853,
114  853, 853, 853, 853, 853, 853, 853, 853, 853, 853, 853, 853,
115  853, 853, 853, 853, 853, 853, 853, 853, 853, 853, 853, 853,
116  853, 853, 853, 853, 853, 853, 853, 853, 853, 853, 358
117 };
118 
119 #define RN_CB_MAX 27
120 const int16_t ff_prores_raw_rn_cb[RN_CB_MAX + 1] = {
121  512, 256, 0, 0, 529, 529, 273, 273, 17, 17, 33, 33, 546,
122  34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 50, 50, 68,
123 };
124 
125 #define LN_CB_MAX 14
126 const int16_t ff_prores_raw_ln_cb[LN_CB_MAX + 1] = {
127  256, 273, 546, 546, 290, 290, 1075, 1075, 563, 563, 563, 563, 563, 563, 51
128 };
129 
131  AVFrame *frame, const uint8_t *data, int size,
132  int component, int16_t *qmat)
133 {
134  int ret;
135  ProResRAWContext *s = avctx->priv_data;
136  const ptrdiff_t linesize = frame->linesize[0] >> 1;
137  uint16_t *dst = (uint16_t *)(frame->data[0] + tile->y*frame->linesize[0] + 2*tile->x);
138 
139  int idx;
140  const int w = FFMIN(s->tw, avctx->width - tile->x) / 2;
141  const int nb_blocks = w / 8;
142  const int log2_nb_blocks = 31 - ff_clz(nb_blocks);
143  const int block_mask = (1 << log2_nb_blocks) - 1;
144  const int nb_codes = 64 * nb_blocks;
145 
146  LOCAL_ALIGNED_32(int16_t, block, [64*16]);
147 
148  int16_t sign = 0;
149  int16_t dc_add = 0;
150  int16_t dc_codebook;
151 
152  int16_t ac, rn, ln;
153  int16_t ac_codebook = 49;
154  int16_t rn_codebook = 0;
155  int16_t ln_codebook = 66;
156 
157  const uint8_t *scan = s->scan;
158  GetBitContext gb;
159 
160  if (component > 1)
161  dst += linesize;
162  dst += component & 1;
163 
164  if ((ret = init_get_bits8(&gb, data, size)) < 0)
165  return ret;
166 
167  for (int n = 0; n < nb_blocks; n++)
168  s->bdsp.clear_block(block + n*64);
169 
170  /* Special handling for first block */
171  int dc = get_value(&gb, 700);
172  int prev_dc = (dc >> 1) ^ -(dc & 1);
173  block[0] = (((dc&1) + (dc>>1) ^ -(int)(dc & 1)) + (dc & 1)) + 1;
174 
175  for (int n = 1; n < nb_blocks; n++) {
176  if (get_bits_left(&gb) <= 0)
177  break;
178 
179  if ((n & 15) == 1)
180  dc_codebook = 100;
181  else
183 
184  dc = get_value(&gb, dc_codebook);
185 
186  sign = sign ^ dc & 1;
187  dc_add = (-sign ^ TODCCODEBOOK(dc)) + sign;
188  sign = dc_add < 0;
189  prev_dc += dc_add;
190 
191  block[n*64] = prev_dc + 1;
192  }
193 
194  for (int n = nb_blocks; n <= nb_codes;) {
195  if (get_bits_left(&gb) <= 0)
196  break;
197 
198  ln = get_value(&gb, ln_codebook);
199 
200  for (int i = 0; i < ln; i++) {
201  if (get_bits_left(&gb) <= 0)
202  break;
203 
204  if ((n + i) >= nb_codes)
205  break;
206 
207  ac = get_value(&gb, ac_codebook);
208  ac_codebook = ff_prores_raw_ac_cb[FFMIN(ac, AC_CB_MAX)];
209  sign = -get_bits1(&gb);
210 
211  idx = scan[(n + i) >> log2_nb_blocks] + (((n + i) & block_mask) << 6);
212  block[idx] = ((ac + 1) ^ sign) - sign;
213  }
214 
215  n += ln;
216  if (n >= nb_codes)
217  break;
218 
219  rn = get_value(&gb, rn_codebook);
220  rn_codebook = ff_prores_raw_rn_cb[FFMIN(rn, RN_CB_MAX)];
221 
222  n += rn + 1;
223  if (n >= nb_codes)
224  break;
225 
226  if (get_bits_left(&gb) <= 0)
227  break;
228 
229  ac = get_value(&gb, ac_codebook);
230  sign = -get_bits1(&gb);
231 
232  idx = scan[n >> log2_nb_blocks] + ((n & block_mask) << 6);
233  block[idx] = ((ac + 1) ^ sign) - sign;
234 
235  ac_codebook = ff_prores_raw_ac_cb[FFMIN(ac, AC_CB_MAX)];
236  ln_codebook = ff_prores_raw_ln_cb[FFMIN(ac, LN_CB_MAX)];
237 
238  n++;
239  }
240 
241  for (int n = 0; n < nb_blocks; n++) {
242  uint16_t *ptr = dst + n*16;
243  s->prodsp.idct_put_bayer(ptr, linesize, block + n*64, qmat);
244  }
245 
246  return 0;
247 }
248 
250  AVFrame *frame)
251 {
252  int ret;
253  ProResRAWContext *s = avctx->priv_data;
254 
255  GetByteContext *gb = &tile->gb;
256  LOCAL_ALIGNED_32(int16_t, qmat, [64]);
257 
258  if (tile->x >= avctx->width)
259  return 0;
260 
261  /* Tile header */
262  int header_len = bytestream2_get_byteu(gb) >> 3;
263  int16_t scale = bytestream2_get_byteu(gb);
264 
265  int size[4];
266  size[0] = bytestream2_get_be16(gb);
267  size[1] = bytestream2_get_be16(gb);
268  size[2] = bytestream2_get_be16(gb);
269  size[3] = bytestream2_size(gb) - size[0] - size[1] - size[2] - header_len;
270  if (size[3] < 0)
271  return AVERROR_INVALIDDATA;
272 
273  for (int i = 0; i < 64; i++)
274  qmat[i] = s->qmat[i] * scale >> 1;
275 
276  const uint8_t *comp_start = gb->buffer_start + header_len;
277 
278  ret = decode_comp(avctx, tile, frame, comp_start,
279  size[0], 2, qmat);
280  if (ret < 0)
281  goto fail;
282 
283  ret = decode_comp(avctx, tile, frame, comp_start + size[0],
284  size[1], 1, qmat);
285  if (ret < 0)
286  goto fail;
287 
288  ret = decode_comp(avctx, tile, frame, comp_start + size[0] + size[1],
289  size[2], 3, qmat);
290  if (ret < 0)
291  goto fail;
292 
293  ret = decode_comp(avctx, tile, frame, comp_start + size[0] + size[1] + size[2],
294  size[3], 0, qmat);
295  if (ret < 0)
296  goto fail;
297 
298  return 0;
299 fail:
300  av_log(avctx, AV_LOG_ERROR, "tile %d/%d decoding error\n", tile->x, tile->y);
301  return ret;
302 }
303 
304 static int decode_tiles(AVCodecContext *avctx, void *arg,
305  int n, int thread_nb)
306 {
307  ProResRAWContext *s = avctx->priv_data;
308  TileContext *tile = &s->tiles[n];
309  AVFrame *frame = arg;
310 
311  return decode_tile(avctx, tile, frame);
312 }
313 
315  enum AVPixelFormat pix_fmt)
316 {
317  enum AVPixelFormat pix_fmts[] = {
318 #if CONFIG_PRORES_RAW_VULKAN_HWACCEL
320 #endif
321  pix_fmt,
323  };
324 
325  return ff_get_format(avctx, pix_fmts);
326 }
327 
328 static int decode_frame(AVCodecContext *avctx,
329  AVFrame *frame, int *got_frame_ptr,
330  AVPacket *avpkt)
331 {
332  int ret;
333  ProResRAWContext *s = avctx->priv_data;
334  DECLARE_ALIGNED(32, uint8_t, qmat)[64];
335  memset(qmat, 1, 64);
336 
337  switch (avctx->codec_tag) {
338  case 0:
339  break;
340  case MKTAG('a','p','r','n'):
342  break;
343  case MKTAG('a','p','r','h'):
345  break;
346  default:
347  avpriv_request_sample(avctx, "Profile %d", avctx->codec_tag);
348  return AVERROR_PATCHWELCOME;
349  break;
350  }
351 
352  GetByteContext gb;
353  bytestream2_init(&gb, avpkt->data, avpkt->size);
354  if (bytestream2_get_be32(&gb) != avpkt->size)
355  return AVERROR_INVALIDDATA;
356 
357  /* ProRes RAW frame */
358  if (bytestream2_get_be32(&gb) != MKBETAG('p','r','r','f'))
359  return AVERROR_INVALIDDATA;
360 
361  int header_len = bytestream2_get_be16(&gb);
362  if (header_len < 62)
363  return AVERROR_INVALIDDATA;
364 
365  GetByteContext gb_hdr;
366  bytestream2_init(&gb_hdr, gb.buffer, header_len - 2);
367  bytestream2_skip(&gb, header_len - 2);
368 
369  bytestream2_skip(&gb_hdr, 1);
370  s->version = bytestream2_get_byte(&gb_hdr);
371  if (s->version > 1) {
372  avpriv_request_sample(avctx, "Version %d", s->version);
373  return AVERROR_PATCHWELCOME;
374  }
375 
376  /* Vendor header (e.g. "peac" for Panasonic or "atm0" for Atmos) */
377  bytestream2_skip(&gb_hdr, 4);
378 
379  /* Width and height must always be even */
380  int w = bytestream2_get_be16(&gb_hdr);
381  int h = bytestream2_get_be16(&gb_hdr);
382  if ((w & 1) || (h & 1))
383  return AVERROR_INVALIDDATA;
384 
385  if (w != avctx->width || h != avctx->height) {
386  av_log(avctx, AV_LOG_WARNING, "picture resolution change: %ix%i -> %ix%i\n",
387  avctx->width, avctx->height, w, h);
388  if ((ret = ff_set_dimensions(avctx, w, h)) < 0)
389  return ret;
390  }
391 
392  avctx->coded_width = FFALIGN(w, 16);
393  avctx->coded_height = FFALIGN(h, 16);
394 
396  if (pix_fmt != s->pix_fmt) {
397  s->pix_fmt = pix_fmt;
398 
399  ret = get_pixel_format(avctx, pix_fmt);
400  if (ret < 0)
401  return ret;
402 
403  avctx->pix_fmt = ret;
404  }
405 
406  bytestream2_skip(&gb_hdr, 1 * 4);
407  bytestream2_skip(&gb_hdr, 2); /* & 0x3 */
408  bytestream2_skip(&gb_hdr, 2);
409  bytestream2_skip(&gb_hdr, 4);
410  bytestream2_skip(&gb_hdr, 4);
411  bytestream2_skip(&gb_hdr, 4 * 3 * 3);
412  bytestream2_skip(&gb_hdr, 4);
413  bytestream2_skip(&gb_hdr, 2);
414 
415  /* Flags */
416  int flags = bytestream2_get_be16(&gb_hdr);
417  int align = (flags >> 1) & 0x7;
418 
419  /* Quantization matrix */
420  if (flags & 1)
421  bytestream2_get_buffer(&gb_hdr, qmat, 64);
422 
423  if ((flags >> 4) & 1) {
424  bytestream2_skip(&gb_hdr, 2);
425  bytestream2_skip(&gb_hdr, 2 * 7);
426  }
427 
428  ff_permute_scantable(s->qmat, s->prodsp.idct_permutation, qmat);
429 
430  s->nb_tw = (w + 15) >> 4;
431  s->nb_th = (h + 15) >> 4;
432  s->nb_tw = (s->nb_tw >> align) + align_tile_w[~(-1 * (1 << align)) & s->nb_tw];
433  s->nb_tiles = s->nb_tw * s->nb_th;
434  av_log(avctx, AV_LOG_DEBUG, "%dx%d | nb_tiles: %d\n", s->nb_tw, s->nb_th, s->nb_tiles);
435 
436  s->tw = s->version == 0 ? 128 : 256;
437  s->th = 16;
438  av_log(avctx, AV_LOG_DEBUG, "tile_size: %dx%d\n", s->tw, s->th);
439 
440  av_fast_mallocz(&s->tiles, &s->tiles_size, s->nb_tiles * sizeof(*s->tiles));
441  if (!s->tiles)
442  return AVERROR(ENOMEM);
443 
444  if (bytestream2_get_bytes_left(&gb) < s->nb_tiles * 2)
445  return AVERROR_INVALIDDATA;
446 
447  /* Read tile data offsets */
448  int offset = bytestream2_tell(&gb) + s->nb_tiles * 2;
449  for (int n = 0; n < s->nb_tiles; n++) {
450  TileContext *tile = &s->tiles[n];
451 
452  int size = bytestream2_get_be16(&gb);
453  if (offset >= avpkt->size)
454  return AVERROR_INVALIDDATA;
455  if (size >= avpkt->size)
456  return AVERROR_INVALIDDATA;
457  if (offset > avpkt->size - size)
458  return AVERROR_INVALIDDATA;
459 
460  bytestream2_init(&tile->gb, avpkt->data + offset, size);
461 
462  tile->y = (n / s->nb_tw) * s->th;
463  tile->x = (n % s->nb_tw) * s->tw;
464 
465  offset += size;
466  }
467 
468  ret = ff_thread_get_buffer(avctx, frame, 0);
469  if (ret < 0)
470  return ret;
471 
472  s->frame = frame;
473 
474  /* Start */
475  if (avctx->hwaccel) {
476  const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
477 
478  ret = ff_hwaccel_frame_priv_alloc(avctx, &s->hwaccel_picture_private);
479  if (ret < 0)
480  return ret;
481 
482  ret = hwaccel->start_frame(avctx, avpkt->buf, avpkt->data, avpkt->size);
483  if (ret < 0)
484  return ret;
485 
486  for (int n = 0; n < s->nb_tiles; n++) {
487  TileContext *tile = &s->tiles[n];
488  ret = hwaccel->decode_slice(avctx, tile->gb.buffer,
489  tile->gb.buffer_end - tile->gb.buffer);
490  if (ret < 0)
491  return ret;
492  }
493 
494  ret = hwaccel->end_frame(avctx);
495  if (ret < 0)
496  return ret;
497 
498  av_refstruct_unref(&s->hwaccel_picture_private);
499  } else {
500  avctx->execute2(avctx, decode_tiles, frame, NULL, s->nb_tiles);
501  }
502 
503  frame->pict_type = AV_PICTURE_TYPE_I;
504  frame->flags |= AV_FRAME_FLAG_KEY;
505 
506  *got_frame_ptr = 1;
507 
508  return avpkt->size;
509 }
510 
512 {
513  ProResRAWContext *s = avctx->priv_data;
514  av_refstruct_unref(&s->hwaccel_picture_private);
515  av_freep(&s->tiles);
516  return 0;
517 }
518 
519 #if HAVE_THREADS
521 {
522  ProResRAWContext *rsrc = src->priv_data;
523  ProResRAWContext *rdst = dst->priv_data;
524 
525  rdst->pix_fmt = rsrc->pix_fmt;
526 
527  return 0;
528 }
529 #endif
530 
532  .p.name = "prores_raw",
533  CODEC_LONG_NAME("Apple ProRes RAW"),
534  .p.type = AVMEDIA_TYPE_VIDEO,
535  .p.id = AV_CODEC_ID_PRORES_RAW,
536  .priv_data_size = sizeof(ProResRAWContext),
537  .init = decode_init,
538  .close = decode_end,
541  .p.capabilities = AV_CODEC_CAP_DR1 |
544  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
546  .hw_configs = (const AVCodecHWConfigInternal *const []) {
547 #if CONFIG_PRORES_RAW_VULKAN_HWACCEL
548  HWACCEL_VULKAN(prores_raw),
549 #endif
550  NULL
551  },
552 };
flags
const SwsFlags flags[]
Definition: swscale.c:61
hwconfig.h
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1405
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:276
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
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:493
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:689
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
GetByteContext::buffer_start
const uint8_t * buffer_start
Definition: bytestream.h:34
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(const GetByteContext *g)
Definition: bytestream.h:158
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:659
mem_internal.h
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: prores_raw.c:511
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1203
GetByteContext
Definition: bytestream.h:33
bytestream2_tell
static av_always_inline int bytestream2_tell(const GetByteContext *g)
Definition: bytestream.h:192
decode_tiles
static int decode_tiles(AVCodecContext *avctx, void *arg, int n, int thread_nb)
Definition: prores_raw.c:304
ff_clz
#define ff_clz
Definition: intmath.h:141
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
w
uint8_t w
Definition: llviddspenc.c:38
AVPacket::data
uint8_t * data
Definition: packet.h:558
b
#define b
Definition: input.c:42
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:664
data
const char data[16]
Definition: mxf.c:149
FFCodec
Definition: codec_internal.h:127
AC_CB_MAX
#define AC_CB_MAX
Definition: prores_raw.c:107
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
ff_prores_raw_ln_cb
const int16_t ff_prores_raw_ln_cb[LN_CB_MAX+1]
Definition: prores_raw.c:126
thread.h
AV_PROFILE_PRORES_RAW_HQ
#define AV_PROFILE_PRORES_RAW_HQ
Definition: defs.h:189
AV_PIX_FMT_VULKAN
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition: pixfmt.h:379
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:135
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
FFHWAccel
Definition: hwaccel_internal.h:34
fail
#define fail()
Definition: checkasm.h:202
GetBitContext
Definition: get_bits.h:109
AV_PROFILE_PRORES_RAW
#define AV_PROFILE_PRORES_RAW
Definition: defs.h:188
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:607
AV_CODEC_ID_PRORES_RAW
@ AV_CODEC_ID_PRORES_RAW
Definition: codec_id.h:333
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: prores_raw.c:43
TODCCODEBOOK
#define TODCCODEBOOK(x)
Definition: prores_raw.c:96
align_tile_w
static const uint8_t align_tile_w[16]
Definition: prores_raw.c:98
ff_prores_raw_decoder
const FFCodec ff_prores_raw_decoder
Definition: prores_raw.c:531
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:100
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:539
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:642
dc_codebook
static const uint8_t dc_codebook[7]
Definition: proresdec.c:450
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:346
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:2266
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
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:1037
ff_prores_raw_rn_cb
const int16_t ff_prores_raw_rn_cb[RN_CB_MAX+1]
Definition: prores_raw.c:120
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
prores_raw.h
bits
uint8_t bits
Definition: vp3data.h:128
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:298
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
decode.h
get_bits.h
ff_prores_interlaced_scan
const uint8_t ff_prores_interlaced_scan[64]
Definition: proresdata.c:36
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:639
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:331
arg
const char * arg
Definition: jacosubdec.c:67
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:95
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:541
ff_prores_raw_dc_cb
const uint8_t ff_prores_raw_dc_cb[DC_CB_MAX+1]
Definition: prores_raw.c:103
NULL
#define NULL
Definition: coverity.c:32
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
hwaccel_internal.h
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:278
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:386
av_fast_mallocz
void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size)
Allocate and clear a buffer, reusing the given one if large enough.
Definition: mem.c:562
ProResRAWContext
Definition: prores_raw.h:38
bytestream2_get_buffer
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:267
UPDATE_THREAD_CONTEXT
#define UPDATE_THREAD_CONTEXT(func)
Definition: codec_internal.h:340
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
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
AVPacket::size
int size
Definition: packet.h:559
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
codec_internal.h
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: prores_raw.c:328
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:104
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
size
int size
Definition: twinvq_data.h:10344
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
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
proresdata.h
AVCodecHWConfigInternal
Definition: hwconfig.h:25
align
static const uint8_t *BS_FUNC() align(BSCTX *bc)
Skip bits to a byte boundary.
Definition: bitstream_template.h:419
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:99
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
get_pixel_format
static enum AVPixelFormat get_pixel_format(AVCodecContext *avctx, enum AVPixelFormat pix_fmt)
Definition: prores_raw.c:314
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:622
ProResRAWContext::pix_fmt
enum AVPixelFormat pix_fmt
Definition: prores_raw.h:48
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
LN_CB_MAX
#define LN_CB_MAX
Definition: prores_raw.c:125
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
bytestream2_size
static av_always_inline int bytestream2_size(const GetByteContext *g)
Definition: bytestream.h:202
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
get_value
static int16_t get_value(GetBitContext *gb, int16_t codebook)
Definition: prores_raw.c:66
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:693
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
idctdsp.h
avcodec.h
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
tile
static int FUNC() tile(CodedBitstreamContext *ctx, RWContext *rw, APVRawTile *current, int tile_idx, uint32_t tile_size)
Definition: cbs_apv_syntax_template.c:224
hwaccel
static const char * hwaccel
Definition: ffplay.c:353
HWACCEL_VULKAN
#define HWACCEL_VULKAN(codec)
Definition: hwconfig.h:76
decode_comp
static int decode_comp(AVCodecContext *avctx, TileContext *tile, AVFrame *frame, const uint8_t *data, int size, int component, int16_t *qmat)
Definition: prores_raw.c:130
AVCodecContext
main external API structure.
Definition: avcodec.h:431
RN_CB_MAX
#define RN_CB_MAX
Definition: prores_raw.c:119
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
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
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:607
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
mem.h
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
ff_init_scantable_permutation
av_cold void ff_init_scantable_permutation(uint8_t *idct_permutation, enum idct_permutation_type perm_type)
Definition: idctdsp.c:39
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:456
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:273
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:535
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
ff_prores_raw_ac_cb
const int16_t ff_prores_raw_ac_cb[AC_CB_MAX+1]
Definition: prores_raw.c:108
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:592
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
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
DC_CB_MAX
#define DC_CB_MAX
Definition: prores_raw.c:102
TileContext
Definition: prores_raw.h:33
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
h
h
Definition: vp9dsp_template.c:2070
AV_PIX_FMT_BAYER_RGGB16
#define AV_PIX_FMT_BAYER_RGGB16
Definition: pixfmt.h:572
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
src
#define src
Definition: vp8dsp.c:248
codebook
static const unsigned codebook[256][2]
Definition: cfhdenc.c:41
decode_tile
static int decode_tile(AVCodecContext *avctx, TileContext *tile, AVFrame *frame)
Definition: prores_raw.c:249