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/avassert.h"
24 #include "libavutil/intfloat.h"
25 #include "libavutil/intreadwrite.h"
26 #include "libavutil/mem_internal.h"
27 #include "libavutil/mem.h"
29 #include "libavutil/rational.h"
30 
31 #define CACHED_BITSTREAM_READER !ARCH_X86_32
32 
33 #include "config_components.h"
34 #include "avcodec.h"
35 #include "bytestream.h"
36 #include "codec_internal.h"
37 #include "decode.h"
38 #include "get_bits.h"
39 #include "idctdsp.h"
40 #include "proresdata.h"
41 #include "thread.h"
42 #include "hwconfig.h"
43 #include "hwaccel_internal.h"
44 
45 #include "prores_raw.h"
46 
48 {
49  ProResRAWContext *s = avctx->priv_data;
50 
51  /* The codec outputs linear data, with the transfer function of the
52  * camera and any adjustments built into an 8-point linearization curve */
53  avctx->bits_per_raw_sample = 16;
54  avctx->color_trc = AVCOL_TRC_LINEAR;
57 
58  s->pix_fmt = AV_PIX_FMT_NONE;
59 
60  ff_blockdsp_init(&s->bdsp);
61  /* Coefficients and the iDCT are 12-bit, the linearization curve then
62  * expands the result to the 16-bit linear output range. */
63  ff_proresdsp_init(&s->prodsp, 12);
64 
65  ff_permute_scantable(s->scan, ff_prores_interlaced_scan, s->prodsp.idct_permutation);
66 
67  return 0;
68 }
69 
70 static uint16_t get_value(GetBitContext *gb, int16_t codebook)
71 {
72  const int16_t switch_bits = codebook >> 8;
73  const int16_t rice_order = codebook & 0xf;
74  const int16_t exp_order = (codebook >> 4) & 0xf;
75  int16_t q, bits;
76 
77  uint32_t b = show_bits_long(gb, 32);
78  if (!b)
79  return 0;
80  q = ff_clz(b);
81 
82  if (b & 0x80000000) {
83  skip_bits_long(gb, 1 + rice_order);
84  return (b & 0x7FFFFFFF) >> (31 - rice_order);
85  }
86 
87  if (q <= switch_bits) {
88  skip_bits_long(gb, 1 + rice_order + q);
89  return (q << rice_order) +
90  (((b << (q + 1)) >> 1) >> (31 - rice_order));
91  }
92 
93  bits = exp_order + (q << 1) - switch_bits;
94  if (bits > 32)
95  return 0; // we do not return a negative error code so that we dont produce out of range values on errors
96  skip_bits_long(gb, bits);
97  return (b >> (32 - bits)) +
98  ((switch_bits + 1) << rice_order) -
99  (1 << exp_order);
100 }
101 
102 #define TODCCODEBOOK(x) ((x + 1) >> 1)
103 
104 #define DC_CB_MAX 12
105 const uint8_t ff_prores_raw_dc_cb[DC_CB_MAX + 1] = {
106  0x010, 0x021, 0x032, 0x033, 0x033, 0x033, 0x044, 0x044, 0x044, 0x044, 0x044, 0x044, 0x076,
107 };
108 
109 #define AC_CB_MAX 94
110 const int16_t ff_prores_raw_ac_cb[AC_CB_MAX + 1] = {
111  0x000, 0x211, 0x111, 0x111, 0x222, 0x222, 0x222, 0x122, 0x122, 0x122,
112  0x233, 0x233, 0x233, 0x233, 0x233, 0x233, 0x233, 0x233, 0x133, 0x133,
113  0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244,
114  0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244, 0x244,
115  0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355,
116  0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355,
117  0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355,
118  0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x355, 0x166,
119 };
120 
121 #define RN_CB_MAX 27
122 const int16_t ff_prores_raw_rn_cb[RN_CB_MAX + 1] = {
123  0x200, 0x100, 0x000, 0x000, 0x211, 0x211, 0x111, 0x111, 0x011, 0x011, 0x021, 0x021, 0x222, 0x022,
124  0x022, 0x022, 0x022, 0x022, 0x022, 0x022, 0x022, 0x022, 0x022, 0x022, 0x022, 0x032, 0x032, 0x044
125 };
126 
127 #define LN_CB_MAX 14
128 const int16_t ff_prores_raw_ln_cb[LN_CB_MAX + 1] = {
129  0x100, 0x111, 0x222, 0x222, 0x122, 0x122, 0x433, 0x433, 0x233, 0x233, 0x233, 0x233, 0x233, 0x233, 0x033,
130 };
131 
133  AVFrame *frame, const uint8_t *data, int size,
134  int component, int16_t *qmat)
135 {
136  int ret;
137  ProResRAWContext *s = avctx->priv_data;
138  const ptrdiff_t linesize = frame->linesize[0] >> 1;
139  uint16_t *dst = (uint16_t *)(frame->data[0] + tile->y*frame->linesize[0] + 2*tile->x);
140 
141  int idx;
142  const int log2_nb_blocks = tile->log2_nb_blocks;
143  const int nb_blocks = 1 << log2_nb_blocks;
144  const int block_mask = nb_blocks - 1;
145  const int nb_codes = 64 * nb_blocks;
146 
147  LOCAL_ALIGNED_32(int32_t, block, [64*16]);
148 
149  int16_t sign = 0;
150  int16_t dc_add = 0;
151  int16_t dc_codebook;
152 
153  uint16_t ac, rn, ln;
154  int16_t ac_codebook = 49;
155  int16_t rn_codebook = 0;
156  int16_t ln_codebook = 66;
157 
158  const uint8_t *scan = s->scan;
159  GetBitContext gb;
160 
161  if (component > 1)
162  dst += linesize;
163  dst += component & 1;
164 
165  if ((ret = init_get_bits8(&gb, data, size)) < 0)
166  return ret;
167 
168  memset(block, 0, nb_blocks * 64 * sizeof(*block));
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, s->lin_curve);
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;
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 #if CONFIG_PRORES_RAW_VIDEOTOOLBOX_HWACCEL
323 #endif
324  pix_fmt,
326  };
327 
328  return ff_get_format(avctx, pix_fmts);
329 }
330 
331 static int decode_frame(AVCodecContext *avctx,
332  AVFrame *frame, int *got_frame_ptr,
333  AVPacket *avpkt)
334 {
335  ProResRAWContext *s = avctx->priv_data;
336  int ret, dimensions_changed = 0, old_version = s->version;
337  DECLARE_ALIGNED(32, uint8_t, qmat)[64];
338  memset(qmat, 1, 64);
339 
340  if (avctx->skip_frame >= AVDISCARD_ALL)
341  return avpkt->size;
342 
343  switch (avctx->codec_tag) {
344  case 0:
345  break;
346  case MKTAG('a','p','r','n'):
348  break;
349  case MKTAG('a','p','r','h'):
351  break;
352  default:
353  avpriv_request_sample(avctx, "Profile %d", avctx->codec_tag);
354  return AVERROR_PATCHWELCOME;
355  break;
356  }
357 
358  GetByteContext gb;
359  bytestream2_init(&gb, avpkt->data, avpkt->size);
360  if (bytestream2_get_be32(&gb) != avpkt->size)
361  return AVERROR_INVALIDDATA;
362 
363  /* ProRes RAW frame */
364  if (bytestream2_get_be32(&gb) != MKBETAG('p','r','r','f'))
365  return AVERROR_INVALIDDATA;
366 
367  int header_len = bytestream2_get_be16(&gb);
368  if (header_len < 62 || bytestream2_get_bytes_left(&gb) < header_len - 2)
369  return AVERROR_INVALIDDATA;
370 
371  GetByteContext gb_hdr;
372  bytestream2_init(&gb_hdr, gb.buffer, header_len - 2);
373  bytestream2_skip(&gb, header_len - 2);
374 
375  bytestream2_skip(&gb_hdr, 1); /* 1 reserved byte */
376  s->version = bytestream2_get_byte(&gb_hdr);
377  if (s->version > 1) {
378  avpriv_request_sample(avctx, "Version %d", s->version);
379  return AVERROR_PATCHWELCOME;
380  }
381 
382  /* Vendor header (e.g. "peac" for Panasonic or "atm0" for Atmos) */
383  bytestream2_skip(&gb_hdr, 4);
384 
385  /* Width and height must always be even */
386  int w = bytestream2_get_be16(&gb_hdr);
387  int h = bytestream2_get_be16(&gb_hdr);
388  if ((w & 1) || (h & 1))
389  return AVERROR_INVALIDDATA;
390 
391  if (w != avctx->width || h != avctx->height) {
392  av_log(avctx, AV_LOG_WARNING, "picture resolution change: %ix%i -> %ix%i\n",
393  avctx->width, avctx->height, w, h);
394  if ((ret = ff_set_dimensions(avctx, w, h)) < 0)
395  return ret;
396  dimensions_changed = 1;
397  }
398 
399  avctx->coded_width = FFALIGN(w, 16);
400  avctx->coded_height = FFALIGN(h, 16);
401 
403  if (pix_fmt != s->pix_fmt || dimensions_changed ||
404  s->version != old_version) {
405  s->pix_fmt = pix_fmt;
406 
407  ret = get_pixel_format(avctx, pix_fmt);
408  if (ret < 0)
409  return ret;
410 
411  avctx->pix_fmt = ret;
412  }
413 
414  /* RecommendedCrop: pixel margins to discard after debayer. Order is
415  * left/right/top/bottom */
416  uint8_t crop_l = bytestream2_get_byte(&gb_hdr);
417  uint8_t crop_r = bytestream2_get_byte(&gb_hdr);
418  uint8_t crop_t = bytestream2_get_byte(&gb_hdr);
419  uint8_t crop_b = bytestream2_get_byte(&gb_hdr);
420 
421  /* BayerPattern: 0=RGGB, 1/2/3 = alternates */
422  int bayer_pattern = bytestream2_get_be16(&gb_hdr) & 0x3;
423  if (bayer_pattern != 0) {
424  avpriv_request_sample(avctx, "Bayer pattern %d", bayer_pattern);
425  return AVERROR_PATCHWELCOME;
426  }
427 
428  /* senselValueRange: black_level is hardcoded to 0x100,
429  * white_level = senselValueRange + 0x100 */
430  uint16_t black_level = 0x100;
431  uint16_t white_level = bytestream2_get_be16(&gb_hdr) + 0x100;
432 
433  float wb_red = av_int2float(bytestream2_get_be32(&gb_hdr)); /* WhiteBalanceRedFactor */
434  float wb_blue = av_int2float(bytestream2_get_be32(&gb_hdr)); /* WhiteBalanceBlueFactor */
435 
436  /* ColorMatrix (3x3 float, camera RGB -> CIE 1931 XYZ D65, row-major) */
437  float color_matrix[3][3];
438  for (int r = 0; r < 3; r++)
439  for (int c = 0; c < 3; c++)
440  color_matrix[r][c] = av_int2float(bytestream2_get_be32(&gb_hdr));
441 
442  float gain = av_int2float(bytestream2_get_be32(&gb_hdr)); /* GainFactor (post-matrix mult) */
443  uint16_t wb_cct = bytestream2_get_be16(&gb_hdr); /* WhiteBalanceCCT (Kelvin, informational) */
444 
445  /* Flags */
446  int flags = bytestream2_get_be16(&gb_hdr);
447  int align = (flags >> 1) & 0x7;
448  if (align > 4) {
449  av_log(avctx, AV_LOG_ERROR,
450  "Invalid tile alignment %d (max 4)\n", align);
451  return AVERROR_INVALIDDATA;
452  }
453 
454  /* Quantization matrix */
455  if (flags & 1)
456  bytestream2_get_buffer(&gb_hdr, qmat, 64);
457 
458  if ((flags >> 4) & 1) {
459  /* 8-poing 16-bit control points, defining the combined linearization
460  * curve (inv. transfer fn + encoder-defined shaping) */
461  for (int i = 0; i < 8; i++)
462  s->lin_curve[i] = bytestream2_get_be16(&gb_hdr);
463  } else {
464  /* default curve: ptwos */
465  static const uint16_t default_lin_curve[8] =
466  { 0, 512, 1024, 2048, 4096, 8192, 16384, 32768 };
467  memcpy(s->lin_curve, default_lin_curve, sizeof(s->lin_curve));
468  }
469 
470  ff_permute_scantable(s->qmat, s->prodsp.idct_permutation, qmat);
471 
472  int tw16 = (w + 15) >> 4;
473  s->nb_tw = (tw16 >> align) + av_popcount(~(-1 * (1 << align)) & tw16);
474  s->nb_th = (h + 15) >> 4;
475  s->nb_tiles = s->nb_tw * s->nb_th;
476  av_log(avctx, AV_LOG_DEBUG, "%dx%d | nb_tiles: %d\n", s->nb_tw, s->nb_th, s->nb_tiles);
477 
478  s->th = 16;
479 
480  av_fast_mallocz(&s->tiles, &s->tiles_size, s->nb_tiles * sizeof(*s->tiles));
481  if (!s->tiles)
482  return AVERROR(ENOMEM);
483 
484  if (bytestream2_get_bytes_left(&gb) < s->nb_tiles * 2)
485  return AVERROR_INVALIDDATA;
486 
487  /* First tile that extends past the right edge gets halved in width,
488  * next one gets quartered, and so on */
489  int offset = bytestream2_tell(&gb) + s->nb_tiles * 2;
490  int n = 0;
491  for (int ty = 0; ty < s->nb_th; ty++) {
492  unsigned tx = 0;
493  int rem = tw16;
494  for (int e = align; rem > 0; e--) {
495  int unit = 1 << e;
496  while (unit <= rem) {
497  TileContext *tile = &s->tiles[n++];
498  int size = bytestream2_get_be16(&gb);
499 
500  if (offset >= avpkt->size)
501  return AVERROR_INVALIDDATA;
502  if (size >= avpkt->size)
503  return AVERROR_INVALIDDATA;
504  if (offset > avpkt->size - size)
505  return AVERROR_INVALIDDATA;
506 
507  bytestream2_init(&tile->gb, avpkt->data + offset, size);
508  tile->x = tx * 16;
509  tile->y = ty * s->th;
510  tile->log2_nb_blocks = e;
511  offset += size;
512 
513  tx += unit;
514  rem -= unit;
515  }
516  }
517  }
518  av_assert1(n == s->nb_tiles);
519 
520  /**
521  * Any data between last tile and frame end is vendor-specific metadata:
522  * [psim record] 4 be32 size + "psim" + pascal string + payload
523  * <more records, if any>, or:
524  * [eomd] 4 be32 size=8 + "eomd" fourcc (end of metadata)
525  * [padding] zero-fill to next-frame alignment
526  *
527  * Known records (feel free to extend):
528  * com.panasonic.Semi-Pro.optical_correction (IEEE doubles):
529  * R - radial polynomial? + padding: [ k0, k1, k2, k3, pad0, pad1 ]
530  * G, B: same
531  * Trailer: optical center in normalized frame coords: [ x, y ]
532  */
533 
534  ret = ff_thread_get_buffer(avctx, frame, 0);
535  if (ret < 0)
536  return ret;
537 
538  s->frame = frame;
539 
540  /* Start */
541  if (avctx->hwaccel) {
542  const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
543 
544  ret = ff_hwaccel_frame_priv_alloc(avctx, &s->hwaccel_picture_private);
545  if (ret < 0)
546  return ret;
547 
548  ret = hwaccel->start_frame(avctx, avpkt->buf, avpkt->data, avpkt->size);
549  if (ret < 0)
550  return ret;
551 
552  for (int n = 0; n < s->nb_tiles; n++) {
553  TileContext *tile = &s->tiles[n];
554  ret = hwaccel->decode_slice(avctx, tile->gb.buffer,
555  tile->gb.buffer_end - tile->gb.buffer);
556  if (ret < 0)
557  return ret;
558  }
559 
560  ret = hwaccel->end_frame(avctx);
561  if (ret < 0)
562  return ret;
563 
564  av_refstruct_unref(&s->hwaccel_picture_private);
565  } else {
566  avctx->execute2(avctx, decode_tiles, frame, NULL, s->nb_tiles);
567  }
568 
569  frame->pict_type = AV_PICTURE_TYPE_I;
570  frame->flags |= AV_FRAME_FLAG_KEY;
571  frame->crop_left = crop_l;
572  frame->crop_right = crop_r;
573  frame->crop_top = crop_t;
574  frame->crop_bottom = crop_b;
575 
577  if (!rcp)
578  return AVERROR(ENOMEM);
580  rcp->black_level = av_make_q(black_level, 65535);
581  rcp->white_level = av_make_q(white_level, 65535);
582  rcp->wb_cct = wb_cct;
583 
585  pr->wb_red = av_d2q(wb_red, INT_MAX);
586  pr->wb_blue = av_d2q(wb_blue, INT_MAX);
587  pr->gain = av_d2q(gain, INT_MAX);
588  for (int r = 0; r < 3; r++)
589  for (int c = 0; c < 3; c++)
590  pr->color_matrix[r][c] = av_d2q(color_matrix[r][c], INT_MAX);
591 
592  *got_frame_ptr = 1;
593 
594  return avpkt->size;
595 }
596 
598 {
599  ProResRAWContext *s = avctx->priv_data;
600  av_refstruct_unref(&s->hwaccel_picture_private);
601  av_freep(&s->tiles);
602  return 0;
603 }
604 
605 #if HAVE_THREADS
607 {
608  ProResRAWContext *rsrc = src->priv_data;
609  ProResRAWContext *rdst = dst->priv_data;
610 
611  rdst->pix_fmt = rsrc->pix_fmt;
612  rdst->version = rsrc->version;
613 
614  return 0;
615 }
616 #endif
617 
619  .p.name = "prores_raw",
620  CODEC_LONG_NAME("Apple ProRes RAW"),
621  .p.type = AVMEDIA_TYPE_VIDEO,
622  .p.id = AV_CODEC_ID_PRORES_RAW,
623  .priv_data_size = sizeof(ProResRAWContext),
624  .init = decode_init,
625  .close = decode_end,
628  .p.capabilities = AV_CODEC_CAP_DR1 |
631  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
633  .hw_configs = (const AVCodecHWConfigInternal *const []) {
634 #if CONFIG_PRORES_RAW_VULKAN_HWACCEL
635  HWACCEL_VULKAN(prores_raw),
636 #endif
637 #if CONFIG_PRORES_RAW_VIDEOTOOLBOX_HWACCEL
638  HWACCEL_VIDEOTOOLBOX(prores_raw),
639 #endif
640  NULL
641  },
642 };
flags
const SwsFlags flags[]
Definition: swscale.c:85
hwconfig.h
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1423
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:43
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:688
r
const char * r
Definition: vf_curves.c:127
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
AVRawColorParams::wb_cct
uint32_t wb_cct
Color temperature in Kelvin from with the camera's white balance.
Definition: raw_color_params.h:121
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:671
mem_internal.h
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: prores_raw.c:597
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1223
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
AVCOL_TRC_LINEAR
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
Definition: pixfmt.h:675
rational.h
av_cold
#define av_cold
Definition: attributes.h:119
ff_clz
#define ff_clz
Definition: intmath.h:141
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:466
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:664
AVPacket::data
uint8_t * data
Definition: packet.h:603
b
#define b
Definition: input.c:43
data
const char data[16]
Definition: mxf.c:149
FFCodec
Definition: codec_internal.h:127
ProResRAWContext::version
int version
Definition: prores_raw.h:53
AC_CB_MAX
#define AC_CB_MAX
Definition: prores_raw.c:109
av_popcount
#define av_popcount
Definition: common.h:154
intfloat.h
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
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:128
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
AVRawColorParams::prores_raw
AVProResRawColorParams prores_raw
Definition: raw_color_params.h:127
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:1680
av_int2float
static av_always_inline float av_int2float(uint32_t i)
Reinterpret a 32-bit integer as a float.
Definition: intfloat.h:40
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:619
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:47
TODCCODEBOOK
#define TODCCODEBOOK(x)
Definition: prores_raw.c:102
avassert.h
ff_prores_raw_decoder
const FFCodec ff_prores_raw_decoder
Definition: prores_raw.c:618
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:657
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
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:681
raw_color_params.h
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:2330
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:1044
ff_prores_raw_rn_cb
const int16_t ff_prores_raw_rn_cb[RN_CB_MAX+1]
Definition: prores_raw.c:122
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:1571
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
fail
#define fail
Definition: test.h:478
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:586
av_raw_color_params_create_side_data
AVRawColorParams * av_raw_color_params_create_side_data(AVFrame *frame)
Allocate and add an AVRawColorParams structure to an existing AVFrame as AV_FRAME_DATA_RAW_COLOR_PARA...
Definition: raw_color_params.c:36
ff_prores_raw_dc_cb
const uint8_t ff_prores_raw_dc_cb[DC_CB_MAX+1]
Definition: prores_raw.c:105
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:39
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
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVProResRawColorParams
ProRes RAW per-frame color transform, parsed from the prrf frame header.
Definition: raw_color_params.h:56
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:579
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:604
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:331
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:176
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
size
int size
Definition: twinvq_data.h:10344
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
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:55
AVRawColorParams
Per-frame color information for a RAW camera codec.
Definition: raw_color_params.h:100
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:49
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
AVProResRawColorParams::color_matrix
AVRational color_matrix[3][3]
3x3 row-major color matrix from camera RGB to linear-light CIE 1931 XYZ relative to the D65 illuminan...
Definition: raw_color_params.h:73
AV_PIX_FMT_VIDEOTOOLBOX
@ AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
Definition: pixfmt.h:305
LN_CB_MAX
#define LN_CB_MAX
Definition: prores_raw.c:127
bytestream2_size
static av_always_inline int bytestream2_size(const GetByteContext *g)
Definition: bytestream.h:202
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:58
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_d2q
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
AVRawColorParams::type
enum AVRawColorParamsType type
Selects which member of codec is valid.
Definition: raw_color_params.h:104
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
AVProResRawColorParams::wb_blue
AVRational wb_blue
White balance multiplier for the blue channel, applied pre-debayer.
Definition: raw_color_params.h:66
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:703
AVCodecContext::height
int height
Definition: avcodec.h:604
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:643
HWACCEL_VIDEOTOOLBOX
#define HWACCEL_VIDEOTOOLBOX(codec)
Definition: hwconfig.h:74
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:70
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:132
AVCodecContext
main external API structure.
Definition: avcodec.h:443
RN_CB_MAX
#define RN_CB_MAX
Definition: prores_raw.c:121
AVRawColorParams::black_level
AVRational black_level
Lowest valid raw sample code (sensor black point)
Definition: raw_color_params.h:109
AVRawColorParams::codec
union AVRawColorParams::@548 codec
Additional codec-specific fields.
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1636
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:619
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
AVProResRawColorParams::wb_red
AVRational wb_red
White balance multiplier for the red channel, applied pre-debayer.
Definition: raw_color_params.h:60
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:468
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:278
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:580
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:470
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:110
AVRawColorParams::white_level
AVRational white_level
Highest valid raw sample code (sensor white point)
Definition: raw_color_params.h:114
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:604
int32_t
int32_t
Definition: audioconvert.c:56
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:104
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:1628
src
#define src
Definition: vp8dsp.c:248
codebook
static const unsigned codebook[256][2]
Definition: cfhdenc.c:41
AVProResRawColorParams::gain
AVRational gain
Post-matrix scene-linear scaling factor.
Definition: raw_color_params.h:80
decode_tile
static int decode_tile(AVCodecContext *avctx, TileContext *tile, AVFrame *frame)
Definition: prores_raw.c:249
AV_RAW_COLOR_PARAMS_PRORES_RAW
@ AV_RAW_COLOR_PARAMS_PRORES_RAW
The union is valid when interpreted as AVProResRawColorParams (codec.prores_raw).
Definition: raw_color_params.h:37