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 
47  avctx->bits_per_raw_sample = 12;
51 
52  s->pix_fmt = AV_PIX_FMT_NONE;
53 
54  ff_blockdsp_init(&s->bdsp);
55  ff_proresdsp_init(&s->prodsp, avctx->bits_per_raw_sample);
56 
57  ff_permute_scantable(s->scan, ff_prores_interlaced_scan, s->prodsp.idct_permutation);
58 
59  return 0;
60 }
61 
62 static uint16_t get_value(GetBitContext *gb, int16_t codebook)
63 {
64  const int16_t switch_bits = codebook >> 8;
65  const int16_t rice_order = codebook & 0xf;
66  const int16_t exp_order = (codebook >> 4) & 0xf;
67  int16_t q, bits;
68 
69  uint32_t b = show_bits_long(gb, 32);
70  if (!b)
71  return 0;
72  q = ff_clz(b);
73 
74  if (b & 0x80000000) {
75  skip_bits_long(gb, 1 + rice_order);
76  return (b & 0x7FFFFFFF) >> (31 - rice_order);
77  }
78 
79  if (q <= switch_bits) {
80  skip_bits_long(gb, 1 + rice_order + q);
81  return (q << rice_order) +
82  (((b << (q + 1)) >> 1) >> (31 - rice_order));
83  }
84 
85  bits = exp_order + (q << 1) - switch_bits;
86  if (bits > 32)
87  return 0; // we do not return a negative error code so that we dont produce out of range values on errors
88  skip_bits_long(gb, bits);
89  return (b >> (32 - bits)) +
90  ((switch_bits + 1) << rice_order) -
91  (1 << exp_order);
92 }
93 
94 #define TODCCODEBOOK(x) ((x + 1) >> 1)
95 
96 #define DC_CB_MAX 12
97 const uint8_t ff_prores_raw_dc_cb[DC_CB_MAX + 1] = {
98  0x010, 0x021, 0x032, 0x033, 0x033, 0x033, 0x044, 0x044, 0x044, 0x044, 0x044, 0x044, 0x076,
99 };
100 
101 #define AC_CB_MAX 94
102 const int16_t ff_prores_raw_ac_cb[AC_CB_MAX + 1] = {
103  0x000, 0x211, 0x111, 0x111, 0x222, 0x222, 0x222, 0x122, 0x122, 0x122,
104  0x233, 0x233, 0x233, 0x233, 0x233, 0x233, 0x233, 0x233, 0x133, 0x133,
105  0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244,
106  0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244,
107  0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355,
108  0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355,
109  0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355,
110  0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x166,
111 };
112 
113 #define RN_CB_MAX 27
114 const int16_t ff_prores_raw_rn_cb[RN_CB_MAX + 1] = {
115  0x200, 0x100, 0x000, 0x000, 0x211, 0x211, 0x111, 0x111, 0x011, 0x011, 0x021, 0x021, 0x222, 0x022,
116  0x022, 0x022, 0x022, 0x022, 0x022, 0x022, 0x022, 0x022, 0x022, 0x022, 0x022, 0x032, 0x032, 0x044
117 };
118 
119 #define LN_CB_MAX 14
120 const int16_t ff_prores_raw_ln_cb[LN_CB_MAX + 1] = {
121  0x100, 0x111, 0x222, 0x222, 0x122, 0x122, 0x433, 0x433, 0x233, 0x233, 0x233, 0x233, 0x233, 0x233, 0x033,
122 };
123 
125  AVFrame *frame, const uint8_t *data, int size,
126  int component, int16_t *qmat)
127 {
128  int ret;
129  ProResRAWContext *s = avctx->priv_data;
130  const ptrdiff_t linesize = frame->linesize[0] >> 1;
131  uint16_t *dst = (uint16_t *)(frame->data[0] + tile->y*frame->linesize[0] + 2*tile->x);
132 
133  int idx;
134  const int w = FFMIN(s->tw, avctx->width - tile->x) / 2;
135  const int nb_blocks = w / 8;
136  const int log2_nb_blocks = 31 - ff_clz(nb_blocks);
137  const int block_mask = (1 << log2_nb_blocks) - 1;
138  const int nb_codes = 64 * nb_blocks;
139 
140  LOCAL_ALIGNED_32(int16_t, block, [64*16]);
141 
142  int16_t sign = 0;
143  int16_t dc_add = 0;
144  int16_t dc_codebook;
145 
146  uint16_t ac, rn, ln;
147  int16_t ac_codebook = 49;
148  int16_t rn_codebook = 0;
149  int16_t ln_codebook = 66;
150 
151  const uint8_t *scan = s->scan;
152  GetBitContext gb;
153 
154  if (component > 1)
155  dst += linesize;
156  dst += component & 1;
157 
158  if ((ret = init_get_bits8(&gb, data, size)) < 0)
159  return ret;
160 
161  for (int n = 0; n < nb_blocks; n++)
162  s->bdsp.clear_block(block + n*64);
163 
164  /* Special handling for first block */
165  int dc = get_value(&gb, 700);
166  int prev_dc = (dc >> 1) ^ -(dc & 1);
167  block[0] = (((dc&1) + (dc>>1) ^ -(int)(dc & 1)) + (dc & 1)) + 1;
168 
169  for (int n = 1; n < nb_blocks; n++) {
170  if (get_bits_left(&gb) <= 0)
171  break;
172 
173  if ((n & 15) == 1)
174  dc_codebook = 100;
175  else
177 
178  dc = get_value(&gb, dc_codebook);
179 
180  sign = sign ^ dc & 1;
181  dc_add = (-sign ^ TODCCODEBOOK(dc)) + sign;
182  sign = dc_add < 0;
183  prev_dc += dc_add;
184 
185  block[n*64] = prev_dc + 1;
186  }
187 
188  for (int n = nb_blocks; n <= nb_codes;) {
189  if (get_bits_left(&gb) <= 0)
190  break;
191 
192  ln = get_value(&gb, ln_codebook);
193 
194  for (int i = 0; i < ln; i++) {
195  if (get_bits_left(&gb) <= 0)
196  break;
197 
198  if ((n + i) >= nb_codes)
199  break;
200 
201  ac = get_value(&gb, ac_codebook);
202  ac_codebook = ff_prores_raw_ac_cb[FFMIN(ac, AC_CB_MAX)];
203  sign = -get_bits1(&gb);
204 
205  idx = scan[(n + i) >> log2_nb_blocks] + (((n + i) & block_mask) << 6);
206  block[idx] = ((ac + 1) ^ sign) - sign;
207  }
208 
209  n += ln;
210  if (n >= nb_codes)
211  break;
212 
213  rn = get_value(&gb, rn_codebook);
214  rn_codebook = ff_prores_raw_rn_cb[FFMIN(rn, RN_CB_MAX)];
215 
216  n += rn + 1;
217  if (n >= nb_codes)
218  break;
219 
220  if (get_bits_left(&gb) <= 0)
221  break;
222 
223  ac = get_value(&gb, ac_codebook);
224  sign = -get_bits1(&gb);
225 
226  idx = scan[n >> log2_nb_blocks] + ((n & block_mask) << 6);
227  block[idx] = ((ac + 1) ^ sign) - sign;
228 
229  ac_codebook = ff_prores_raw_ac_cb[FFMIN(ac, AC_CB_MAX)];
230  ln_codebook = ff_prores_raw_ln_cb[FFMIN(ac, LN_CB_MAX)];
231 
232  n++;
233  }
234 
235  for (int n = 0; n < nb_blocks; n++) {
236  uint16_t *ptr = dst + n*16;
237  s->prodsp.idct_put_bayer(ptr, linesize, block + n*64, qmat);
238  }
239 
240  return 0;
241 }
242 
244  AVFrame *frame)
245 {
246  int ret;
247  ProResRAWContext *s = avctx->priv_data;
248 
249  GetByteContext *gb = &tile->gb;
250  LOCAL_ALIGNED_32(int16_t, qmat, [64]);
251 
252  if (tile->x >= avctx->width)
253  return 0;
254 
255  /* Tile header */
256  int header_len = bytestream2_get_byteu(gb) >> 3;
257  int16_t scale = bytestream2_get_byteu(gb);
258 
259  int size[4];
260  size[0] = bytestream2_get_be16(gb);
261  size[1] = bytestream2_get_be16(gb);
262  size[2] = bytestream2_get_be16(gb);
263  size[3] = bytestream2_size(gb) - size[0] - size[1] - size[2] - header_len;
264  if (size[3] < 0)
265  return AVERROR_INVALIDDATA;
266 
267  for (int i = 0; i < 64; i++)
268  qmat[i] = s->qmat[i] * scale >> 1;
269 
270  const uint8_t *comp_start = gb->buffer_start + header_len;
271 
272  ret = decode_comp(avctx, tile, frame, comp_start,
273  size[0], 2, qmat);
274  if (ret < 0)
275  goto fail;
276 
277  ret = decode_comp(avctx, tile, frame, comp_start + size[0],
278  size[1], 1, qmat);
279  if (ret < 0)
280  goto fail;
281 
282  ret = decode_comp(avctx, tile, frame, comp_start + size[0] + size[1],
283  size[2], 3, qmat);
284  if (ret < 0)
285  goto fail;
286 
287  ret = decode_comp(avctx, tile, frame, comp_start + size[0] + size[1] + size[2],
288  size[3], 0, qmat);
289  if (ret < 0)
290  goto fail;
291 
292  return 0;
293 fail:
294  av_log(avctx, AV_LOG_ERROR, "tile %d/%d decoding error\n", tile->x, tile->y);
295  return ret;
296 }
297 
298 static int decode_tiles(AVCodecContext *avctx, void *arg,
299  int n, int thread_nb)
300 {
301  ProResRAWContext *s = avctx->priv_data;
302  TileContext *tile = &s->tiles[n];
303  AVFrame *frame = arg;
304 
305  return decode_tile(avctx, tile, frame);
306 }
307 
309  enum AVPixelFormat pix_fmt)
310 {
311  enum AVPixelFormat pix_fmts[] = {
312 #if CONFIG_PRORES_RAW_VULKAN_HWACCEL
314 #endif
315  pix_fmt,
317  };
318 
319  return ff_get_format(avctx, pix_fmts);
320 }
321 
322 static int decode_frame(AVCodecContext *avctx,
323  AVFrame *frame, int *got_frame_ptr,
324  AVPacket *avpkt)
325 {
326  ProResRAWContext *s = avctx->priv_data;
327  int ret, dimensions_changed = 0, old_version = s->version;
328  DECLARE_ALIGNED(32, uint8_t, qmat)[64];
329  memset(qmat, 1, 64);
330 
331  if (avctx->skip_frame >= AVDISCARD_ALL)
332  return avpkt->size;
333 
334  switch (avctx->codec_tag) {
335  case 0:
336  break;
337  case MKTAG('a','p','r','n'):
339  break;
340  case MKTAG('a','p','r','h'):
342  break;
343  default:
344  avpriv_request_sample(avctx, "Profile %d", avctx->codec_tag);
345  return AVERROR_PATCHWELCOME;
346  break;
347  }
348 
349  GetByteContext gb;
350  bytestream2_init(&gb, avpkt->data, avpkt->size);
351  if (bytestream2_get_be32(&gb) != avpkt->size)
352  return AVERROR_INVALIDDATA;
353 
354  /* ProRes RAW frame */
355  if (bytestream2_get_be32(&gb) != MKBETAG('p','r','r','f'))
356  return AVERROR_INVALIDDATA;
357 
358  int header_len = bytestream2_get_be16(&gb);
359  if (header_len < 62 || bytestream2_get_bytes_left(&gb) < header_len - 2)
360  return AVERROR_INVALIDDATA;
361 
362  GetByteContext gb_hdr;
363  bytestream2_init(&gb_hdr, gb.buffer, header_len - 2);
364  bytestream2_skip(&gb, header_len - 2);
365 
366  bytestream2_skip(&gb_hdr, 1);
367  s->version = bytestream2_get_byte(&gb_hdr);
368  if (s->version > 1) {
369  avpriv_request_sample(avctx, "Version %d", s->version);
370  return AVERROR_PATCHWELCOME;
371  }
372 
373  /* Vendor header (e.g. "peac" for Panasonic or "atm0" for Atmos) */
374  bytestream2_skip(&gb_hdr, 4);
375 
376  /* Width and height must always be even */
377  int w = bytestream2_get_be16(&gb_hdr);
378  int h = bytestream2_get_be16(&gb_hdr);
379  if ((w & 1) || (h & 1))
380  return AVERROR_INVALIDDATA;
381 
382  if (w != avctx->width || h != avctx->height) {
383  av_log(avctx, AV_LOG_WARNING, "picture resolution change: %ix%i -> %ix%i\n",
384  avctx->width, avctx->height, w, h);
385  if ((ret = ff_set_dimensions(avctx, w, h)) < 0)
386  return ret;
387  dimensions_changed = 1;
388  }
389 
390  avctx->coded_width = FFALIGN(w, 16);
391  avctx->coded_height = FFALIGN(h, 16);
392 
394  if (pix_fmt != s->pix_fmt || dimensions_changed ||
395  s->version != old_version) {
396  s->pix_fmt = pix_fmt;
397 
398  ret = get_pixel_format(avctx, pix_fmt);
399  if (ret < 0)
400  return ret;
401 
402  avctx->pix_fmt = ret;
403  }
404 
405  bytestream2_skip(&gb_hdr, 1 * 4);
406  bytestream2_skip(&gb_hdr, 2); /* & 0x3 */
407  bytestream2_skip(&gb_hdr, 2);
408  bytestream2_skip(&gb_hdr, 4);
409  bytestream2_skip(&gb_hdr, 4);
410  bytestream2_skip(&gb_hdr, 4 * 3 * 3);
411  bytestream2_skip(&gb_hdr, 4);
412  bytestream2_skip(&gb_hdr, 2);
413 
414  /* Flags */
415  int flags = bytestream2_get_be16(&gb_hdr);
416  int align = (flags >> 1) & 0x7;
417 
418  /* Quantization matrix */
419  if (flags & 1)
420  bytestream2_get_buffer(&gb_hdr, qmat, 64);
421 
422  if ((flags >> 4) & 1) {
423  bytestream2_skip(&gb_hdr, 2);
424  bytestream2_skip(&gb_hdr, 2 * 7);
425  }
426 
427  ff_permute_scantable(s->qmat, s->prodsp.idct_permutation, qmat);
428 
429  s->nb_tw = (w + 15) >> 4;
430  s->nb_th = (h + 15) >> 4;
431  s->nb_tw = (s->nb_tw >> align) + av_popcount(~(-1 * (1 << align)) & s->nb_tw);
432  s->nb_tiles = s->nb_tw * s->nb_th;
433  av_log(avctx, AV_LOG_DEBUG, "%dx%d | nb_tiles: %d\n", s->nb_tw, s->nb_th, s->nb_tiles);
434 
435  s->tw = s->version == 0 ? 128 : 256;
436  s->th = 16;
437  av_log(avctx, AV_LOG_DEBUG, "tile_size: %dx%d\n", s->tw, s->th);
438 
439  av_fast_mallocz(&s->tiles, &s->tiles_size, s->nb_tiles * sizeof(*s->tiles));
440  if (!s->tiles)
441  return AVERROR(ENOMEM);
442 
443  if (bytestream2_get_bytes_left(&gb) < s->nb_tiles * 2)
444  return AVERROR_INVALIDDATA;
445 
446  /* Read tile data offsets */
447  int offset = bytestream2_tell(&gb) + s->nb_tiles * 2;
448  for (int n = 0; n < s->nb_tiles; n++) {
449  TileContext *tile = &s->tiles[n];
450 
451  int size = bytestream2_get_be16(&gb);
452  if (offset >= avpkt->size)
453  return AVERROR_INVALIDDATA;
454  if (size >= avpkt->size)
455  return AVERROR_INVALIDDATA;
456  if (offset > avpkt->size - size)
457  return AVERROR_INVALIDDATA;
458 
459  bytestream2_init(&tile->gb, avpkt->data + offset, size);
460 
461  tile->y = (n / s->nb_tw) * s->th;
462  tile->x = (n % s->nb_tw) * s->tw;
463 
464  offset += size;
465  }
466 
467  ret = ff_thread_get_buffer(avctx, frame, 0);
468  if (ret < 0)
469  return ret;
470 
471  s->frame = frame;
472 
473  /* Start */
474  if (avctx->hwaccel) {
475  const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
476 
477  ret = ff_hwaccel_frame_priv_alloc(avctx, &s->hwaccel_picture_private);
478  if (ret < 0)
479  return ret;
480 
481  ret = hwaccel->start_frame(avctx, avpkt->buf, avpkt->data, avpkt->size);
482  if (ret < 0)
483  return ret;
484 
485  for (int n = 0; n < s->nb_tiles; n++) {
486  TileContext *tile = &s->tiles[n];
487  ret = hwaccel->decode_slice(avctx, tile->gb.buffer,
488  tile->gb.buffer_end - tile->gb.buffer);
489  if (ret < 0)
490  return ret;
491  }
492 
493  ret = hwaccel->end_frame(avctx);
494  if (ret < 0)
495  return ret;
496 
497  av_refstruct_unref(&s->hwaccel_picture_private);
498  } else {
499  avctx->execute2(avctx, decode_tiles, frame, NULL, s->nb_tiles);
500  }
501 
502  frame->pict_type = AV_PICTURE_TYPE_I;
503  frame->flags |= AV_FRAME_FLAG_KEY;
504 
505  *got_frame_ptr = 1;
506 
507  return avpkt->size;
508 }
509 
511 {
512  ProResRAWContext *s = avctx->priv_data;
513  av_refstruct_unref(&s->hwaccel_picture_private);
514  av_freep(&s->tiles);
515  return 0;
516 }
517 
518 #if HAVE_THREADS
520 {
521  ProResRAWContext *rsrc = src->priv_data;
522  ProResRAWContext *rdst = dst->priv_data;
523 
524  rdst->pix_fmt = rsrc->pix_fmt;
525  rdst->version = rsrc->version;
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:1413
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:280
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:498
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
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:667
mem_internal.h
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: prores_raw.c:510
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1208
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:298
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:660
AVPacket::data
uint8_t * data
Definition: packet.h:588
b
#define b
Definition: input.c:42
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:669
data
const char data[16]
Definition: mxf.c:149
FFCodec
Definition: codec_internal.h:127
ProResRAWContext::version
int version
Definition: prores_raw.h:52
AC_CB_MAX
#define AC_CB_MAX
Definition: prores_raw.c:101
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
ff_prores_raw_ln_cb
const int16_t ff_prores_raw_ln_cb[LN_CB_MAX+1]
Definition: prores_raw.c:120
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:197
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
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1670
fail
#define fail()
Definition: checkasm.h:217
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:615
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:94
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:653
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
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:544
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:459
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:2279
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:1043
ff_prores_raw_rn_cb
const int16_t ff_prores_raw_rn_cb[RN_CB_MAX+1]
Definition: prores_raw.c:114
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:296
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1561
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:332
arg
const char * arg
Definition: jacosubdec.c:65
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
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:571
ff_prores_raw_dc_cb
const uint8_t ff_prores_raw_dc_cb[DC_CB_MAX+1]
Definition: prores_raw.c:97
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:391
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:341
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
AVPacket::size
int size
Definition: packet.h:589
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:322
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:308
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:119
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
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:703
AVCodecContext::height
int height
Definition: avcodec.h:600
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:639
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:356
get_value
static uint16_t get_value(GetBitContext *gb, int16_t codebook)
Definition: prores_raw.c:62
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:124
AVCodecContext
main external API structure.
Definition: avcodec.h:439
RN_CB_MAX
#define RN_CB_MAX
Definition: prores_raw.c:113
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1626
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:615
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
mem.h
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
w
uint8_t w
Definition: llvidencdsp.c:39
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:464
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:565
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:466
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:102
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:600
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:96
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:1618
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:243