FFmpeg
proresdec2.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2010-2011 Maxim Poliakovski
3  * Copyright (c) 2010-2011 Elvis Presley
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Known FOURCCs: 'apch' (HQ), 'apcn' (SD), 'apcs' (LT), 'acpo' (Proxy), 'ap4h' (4444)
25  */
26 
27 //#define DEBUG
28 
29 #define LONG_BITSTREAM_READER
30 
31 #include "libavutil/internal.h"
32 #include "avcodec.h"
33 #include "get_bits.h"
34 #include "idctdsp.h"
35 #include "internal.h"
36 #include "profiles.h"
37 #include "simple_idct.h"
38 #include "proresdec.h"
39 #include "proresdata.h"
40 #include "thread.h"
41 
42 static void permute(uint8_t *dst, const uint8_t *src, const uint8_t permutation[64])
43 {
44  int i;
45  for (i = 0; i < 64; i++)
46  dst[i] = permutation[src[i]];
47 }
48 
49 #define ALPHA_SHIFT_16_TO_10(alpha_val) (alpha_val >> 6)
50 #define ALPHA_SHIFT_8_TO_10(alpha_val) ((alpha_val << 2) | (alpha_val >> 6))
51 #define ALPHA_SHIFT_16_TO_12(alpha_val) (alpha_val >> 4)
52 #define ALPHA_SHIFT_8_TO_12(alpha_val) ((alpha_val << 4) | (alpha_val >> 4))
53 
54 static void inline unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs,
55  const int num_bits, const int decode_precision) {
56  const int mask = (1 << num_bits) - 1;
57  int i, idx, val, alpha_val;
58 
59  idx = 0;
60  alpha_val = mask;
61  do {
62  do {
63  if (get_bits1(gb)) {
64  val = get_bits(gb, num_bits);
65  } else {
66  int sign;
67  val = get_bits(gb, num_bits == 16 ? 7 : 4);
68  sign = val & 1;
69  val = (val + 2) >> 1;
70  if (sign)
71  val = -val;
72  }
73  alpha_val = (alpha_val + val) & mask;
74  if (num_bits == 16) {
75  if (decode_precision == 10) {
76  dst[idx++] = ALPHA_SHIFT_16_TO_10(alpha_val);
77  } else { /* 12b */
78  dst[idx++] = ALPHA_SHIFT_16_TO_12(alpha_val);
79  }
80  } else {
81  if (decode_precision == 10) {
82  dst[idx++] = ALPHA_SHIFT_8_TO_10(alpha_val);
83  } else { /* 12b */
84  dst[idx++] = ALPHA_SHIFT_8_TO_12(alpha_val);
85  }
86  }
87  if (idx >= num_coeffs)
88  break;
89  } while (get_bits_left(gb)>0 && get_bits1(gb));
90  val = get_bits(gb, 4);
91  if (!val)
92  val = get_bits(gb, 11);
93  if (idx + val > num_coeffs)
94  val = num_coeffs - idx;
95  if (num_bits == 16) {
96  for (i = 0; i < val; i++) {
97  if (decode_precision == 10) {
98  dst[idx++] = ALPHA_SHIFT_16_TO_10(alpha_val);
99  } else { /* 12b */
100  dst[idx++] = ALPHA_SHIFT_16_TO_12(alpha_val);
101  }
102  }
103  } else {
104  for (i = 0; i < val; i++) {
105  if (decode_precision == 10) {
106  dst[idx++] = ALPHA_SHIFT_8_TO_10(alpha_val);
107  } else { /* 12b */
108  dst[idx++] = ALPHA_SHIFT_8_TO_12(alpha_val);
109  }
110  }
111  }
112  } while (idx < num_coeffs);
113 }
114 
115 static void unpack_alpha_10(GetBitContext *gb, uint16_t *dst, int num_coeffs,
116  const int num_bits)
117 {
118  if (num_bits == 16) {
119  unpack_alpha(gb, dst, num_coeffs, 16, 10);
120  } else { /* 8 bits alpha */
121  unpack_alpha(gb, dst, num_coeffs, 8, 10);
122  }
123 }
124 
125 static void unpack_alpha_12(GetBitContext *gb, uint16_t *dst, int num_coeffs,
126  const int num_bits)
127 {
128  if (num_bits == 16) {
129  unpack_alpha(gb, dst, num_coeffs, 16, 12);
130  } else { /* 8 bits alpha */
131  unpack_alpha(gb, dst, num_coeffs, 8, 12);
132  }
133 }
134 
136 {
137  int ret = 0;
138  ProresContext *ctx = avctx->priv_data;
139  uint8_t idct_permutation[64];
140 
141  avctx->bits_per_raw_sample = 10;
142 
143  switch (avctx->codec_tag) {
144  case MKTAG('a','p','c','o'):
146  break;
147  case MKTAG('a','p','c','s'):
148  avctx->profile = FF_PROFILE_PRORES_LT;
149  break;
150  case MKTAG('a','p','c','n'):
152  break;
153  case MKTAG('a','p','c','h'):
154  avctx->profile = FF_PROFILE_PRORES_HQ;
155  break;
156  case MKTAG('a','p','4','h'):
158  avctx->bits_per_raw_sample = 12;
159  break;
160  case MKTAG('a','p','4','x'):
161  avctx->profile = FF_PROFILE_PRORES_XQ;
162  avctx->bits_per_raw_sample = 12;
163  break;
164  default:
165  avctx->profile = FF_PROFILE_UNKNOWN;
166  av_log(avctx, AV_LOG_WARNING, "Unknown prores profile %d\n", avctx->codec_tag);
167  }
168 
169  if (avctx->bits_per_raw_sample == 10) {
170  av_log(avctx, AV_LOG_DEBUG, "Auto bitdepth precision. Use 10b decoding based on codec tag.\n");
171  } else { /* 12b */
172  av_log(avctx, AV_LOG_DEBUG, "Auto bitdepth precision. Use 12b decoding based on codec tag.\n");
173  }
174 
175  ff_blockdsp_init(&ctx->bdsp, avctx);
176  ret = ff_proresdsp_init(&ctx->prodsp, avctx);
177  if (ret < 0) {
178  av_log(avctx, AV_LOG_ERROR, "Fail to init proresdsp for bits per raw sample %d\n", avctx->bits_per_raw_sample);
179  return ret;
180  }
181 
182  ff_init_scantable_permutation(idct_permutation,
184 
185  permute(ctx->progressive_scan, ff_prores_progressive_scan, idct_permutation);
186  permute(ctx->interlaced_scan, ff_prores_interlaced_scan, idct_permutation);
187 
188  if (avctx->bits_per_raw_sample == 10){
190  } else if (avctx->bits_per_raw_sample == 12){
192  } else {
193  av_log(avctx, AV_LOG_ERROR, "Fail to set unpack_alpha for bits per raw sample %d\n", avctx->bits_per_raw_sample);
194  return AVERROR_BUG;
195  }
196  return ret;
197 }
198 
200  const int data_size, AVCodecContext *avctx)
201 {
202  int hdr_size, width, height, flags;
203  int version;
204  const uint8_t *ptr;
205 
206  hdr_size = AV_RB16(buf);
207  ff_dlog(avctx, "header size %d\n", hdr_size);
208  if (hdr_size > data_size) {
209  av_log(avctx, AV_LOG_ERROR, "error, wrong header size\n");
210  return AVERROR_INVALIDDATA;
211  }
212 
213  version = AV_RB16(buf + 2);
214  ff_dlog(avctx, "%.4s version %d\n", buf+4, version);
215  if (version > 1) {
216  av_log(avctx, AV_LOG_ERROR, "unsupported version: %d\n", version);
217  return AVERROR_PATCHWELCOME;
218  }
219 
220  width = AV_RB16(buf + 8);
221  height = AV_RB16(buf + 10);
222 
223  if (width != avctx->width || height != avctx->height) {
224  int ret;
225 
226  av_log(avctx, AV_LOG_WARNING, "picture resolution change: %dx%d -> %dx%d\n",
227  avctx->width, avctx->height, width, height);
228  if ((ret = ff_set_dimensions(avctx, width, height)) < 0)
229  return ret;
230  }
231 
232  ctx->frame_type = (buf[12] >> 2) & 3;
233  ctx->alpha_info = buf[17] & 0xf;
234 
235  if (ctx->alpha_info > 2) {
236  av_log(avctx, AV_LOG_ERROR, "Invalid alpha mode %d\n", ctx->alpha_info);
237  return AVERROR_INVALIDDATA;
238  }
239  if (avctx->skip_alpha) ctx->alpha_info = 0;
240 
241  ff_dlog(avctx, "frame type %d\n", ctx->frame_type);
242 
243  if (ctx->frame_type == 0) {
244  ctx->scan = ctx->progressive_scan; // permuted
245  } else {
246  ctx->scan = ctx->interlaced_scan; // permuted
247  ctx->frame->interlaced_frame = 1;
248  ctx->frame->top_field_first = ctx->frame_type == 1;
249  }
250 
251  if (ctx->alpha_info) {
252  if (avctx->bits_per_raw_sample == 10) {
253  avctx->pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUVA444P10 : AV_PIX_FMT_YUVA422P10;
254  } else { /* 12b */
255  avctx->pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUVA444P12 : AV_PIX_FMT_YUVA422P12;
256  }
257  } else {
258  if (avctx->bits_per_raw_sample == 10) {
259  avctx->pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUV444P10 : AV_PIX_FMT_YUV422P10;
260  } else { /* 12b */
261  avctx->pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUV444P12 : AV_PIX_FMT_YUV422P12;
262  }
263  }
264 
265  avctx->color_primaries = buf[14];
266  avctx->color_trc = buf[15];
267  avctx->colorspace = buf[16];
268  avctx->color_range = AVCOL_RANGE_MPEG;
269 
270  ptr = buf + 20;
271  flags = buf[19];
272  ff_dlog(avctx, "flags %x\n", flags);
273 
274  if (flags & 2) {
275  if(buf + data_size - ptr < 64) {
276  av_log(avctx, AV_LOG_ERROR, "Header truncated\n");
277  return AVERROR_INVALIDDATA;
278  }
279  permute(ctx->qmat_luma, ctx->prodsp.idct_permutation, ptr);
280  ptr += 64;
281  } else {
282  memset(ctx->qmat_luma, 4, 64);
283  }
284 
285  if (flags & 1) {
286  if(buf + data_size - ptr < 64) {
287  av_log(avctx, AV_LOG_ERROR, "Header truncated\n");
288  return AVERROR_INVALIDDATA;
289  }
290  permute(ctx->qmat_chroma, ctx->prodsp.idct_permutation, ptr);
291  } else {
292  memset(ctx->qmat_chroma, 4, 64);
293  }
294 
295  return hdr_size;
296 }
297 
298 static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size)
299 {
300  ProresContext *ctx = avctx->priv_data;
301  int i, hdr_size, slice_count;
302  unsigned pic_data_size;
303  int log2_slice_mb_width, log2_slice_mb_height;
304  int slice_mb_count, mb_x, mb_y;
305  const uint8_t *data_ptr, *index_ptr;
306 
307  hdr_size = buf[0] >> 3;
308  if (hdr_size < 8 || hdr_size > buf_size) {
309  av_log(avctx, AV_LOG_ERROR, "error, wrong picture header size\n");
310  return AVERROR_INVALIDDATA;
311  }
312 
313  pic_data_size = AV_RB32(buf + 1);
314  if (pic_data_size > buf_size) {
315  av_log(avctx, AV_LOG_ERROR, "error, wrong picture data size\n");
316  return AVERROR_INVALIDDATA;
317  }
318 
319  log2_slice_mb_width = buf[7] >> 4;
320  log2_slice_mb_height = buf[7] & 0xF;
321  if (log2_slice_mb_width > 3 || log2_slice_mb_height) {
322  av_log(avctx, AV_LOG_ERROR, "unsupported slice resolution: %dx%d\n",
323  1 << log2_slice_mb_width, 1 << log2_slice_mb_height);
324  return AVERROR_INVALIDDATA;
325  }
326 
327  ctx->mb_width = (avctx->width + 15) >> 4;
328  if (ctx->frame_type)
329  ctx->mb_height = (avctx->height + 31) >> 5;
330  else
331  ctx->mb_height = (avctx->height + 15) >> 4;
332 
333  // QT ignores the written value
334  // slice_count = AV_RB16(buf + 5);
335  slice_count = ctx->mb_height * ((ctx->mb_width >> log2_slice_mb_width) +
336  av_popcount(ctx->mb_width & (1 << log2_slice_mb_width) - 1));
337 
338  if (ctx->slice_count != slice_count || !ctx->slices) {
339  av_freep(&ctx->slices);
340  ctx->slice_count = 0;
341  ctx->slices = av_mallocz_array(slice_count, sizeof(*ctx->slices));
342  if (!ctx->slices)
343  return AVERROR(ENOMEM);
344  ctx->slice_count = slice_count;
345  }
346 
347  if (!slice_count)
348  return AVERROR(EINVAL);
349 
350  if (hdr_size + slice_count*2 > buf_size) {
351  av_log(avctx, AV_LOG_ERROR, "error, wrong slice count\n");
352  return AVERROR_INVALIDDATA;
353  }
354 
355  // parse slice information
356  index_ptr = buf + hdr_size;
357  data_ptr = index_ptr + slice_count*2;
358 
359  slice_mb_count = 1 << log2_slice_mb_width;
360  mb_x = 0;
361  mb_y = 0;
362 
363  for (i = 0; i < slice_count; i++) {
364  SliceContext *slice = &ctx->slices[i];
365 
366  slice->data = data_ptr;
367  data_ptr += AV_RB16(index_ptr + i*2);
368 
369  while (ctx->mb_width - mb_x < slice_mb_count)
370  slice_mb_count >>= 1;
371 
372  slice->mb_x = mb_x;
373  slice->mb_y = mb_y;
374  slice->mb_count = slice_mb_count;
375  slice->data_size = data_ptr - slice->data;
376 
377  if (slice->data_size < 6) {
378  av_log(avctx, AV_LOG_ERROR, "error, wrong slice data size\n");
379  return AVERROR_INVALIDDATA;
380  }
381 
382  mb_x += slice_mb_count;
383  if (mb_x == ctx->mb_width) {
384  slice_mb_count = 1 << log2_slice_mb_width;
385  mb_x = 0;
386  mb_y++;
387  }
388  if (data_ptr > buf + buf_size) {
389  av_log(avctx, AV_LOG_ERROR, "error, slice out of bounds\n");
390  return AVERROR_INVALIDDATA;
391  }
392  }
393 
394  if (mb_x || mb_y != ctx->mb_height) {
395  av_log(avctx, AV_LOG_ERROR, "error wrong mb count y %d h %d\n",
396  mb_y, ctx->mb_height);
397  return AVERROR_INVALIDDATA;
398  }
399 
400  return pic_data_size;
401 }
402 
403 #define DECODE_CODEWORD(val, codebook, SKIP) \
404  do { \
405  unsigned int rice_order, exp_order, switch_bits; \
406  unsigned int q, buf, bits; \
407  \
408  UPDATE_CACHE(re, gb); \
409  buf = GET_CACHE(re, gb); \
410  \
411  /* number of bits to switch between rice and exp golomb */ \
412  switch_bits = codebook & 3; \
413  rice_order = codebook >> 5; \
414  exp_order = (codebook >> 2) & 7; \
415  \
416  q = 31 - av_log2(buf); \
417  \
418  if (q > switch_bits) { /* exp golomb */ \
419  bits = exp_order - switch_bits + (q<<1); \
420  if (bits > FFMIN(MIN_CACHE_BITS, 31)) \
421  return AVERROR_INVALIDDATA; \
422  val = SHOW_UBITS(re, gb, bits) - (1 << exp_order) + \
423  ((switch_bits + 1) << rice_order); \
424  SKIP(re, gb, bits); \
425  } else if (rice_order) { \
426  SKIP_BITS(re, gb, q+1); \
427  val = (q << rice_order) + SHOW_UBITS(re, gb, rice_order); \
428  SKIP(re, gb, rice_order); \
429  } else { \
430  val = q; \
431  SKIP(re, gb, q+1); \
432  } \
433  } while (0)
434 
435 #define TOSIGNED(x) (((x) >> 1) ^ (-((x) & 1)))
436 
437 #define FIRST_DC_CB 0xB8
438 
439 static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
440 
442  int blocks_per_slice)
443 {
444  int16_t prev_dc;
445  int code, i, sign;
446 
447  OPEN_READER(re, gb);
448 
450  prev_dc = TOSIGNED(code);
451  out[0] = prev_dc;
452 
453  out += 64; // dc coeff for the next block
454 
455  code = 5;
456  sign = 0;
457  for (i = 1; i < blocks_per_slice; i++, out += 64) {
459  if(code) sign ^= -(code & 1);
460  else sign = 0;
461  prev_dc += (((code + 1) >> 1) ^ sign) - sign;
462  out[0] = prev_dc;
463  }
464  CLOSE_READER(re, gb);
465  return 0;
466 }
467 
468 // adaptive codebook switching lut according to previous run/level values
469 static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29, 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };
470 static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28, 0x28, 0x28, 0x28, 0x4C };
471 
473  int16_t *out, int blocks_per_slice)
474 {
475  ProresContext *ctx = avctx->priv_data;
476  int block_mask, sign;
477  unsigned pos, run, level;
478  int max_coeffs, i, bits_left;
479  int log2_block_count = av_log2(blocks_per_slice);
480 
481  OPEN_READER(re, gb);
482  UPDATE_CACHE(re, gb); \
483  run = 4;
484  level = 2;
485 
486  max_coeffs = 64 << log2_block_count;
487  block_mask = blocks_per_slice - 1;
488 
489  for (pos = block_mask;;) {
490  bits_left = gb->size_in_bits - re_index;
491  if (!bits_left || (bits_left < 32 && !SHOW_UBITS(re, gb, bits_left)))
492  break;
493 
495  pos += run + 1;
496  if (pos >= max_coeffs) {
497  av_log(avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", pos, max_coeffs);
498  return AVERROR_INVALIDDATA;
499  }
500 
501  DECODE_CODEWORD(level, lev_to_cb[FFMIN(level, 9)], SKIP_BITS);
502  level += 1;
503 
504  i = pos >> log2_block_count;
505 
506  sign = SHOW_SBITS(re, gb, 1);
507  SKIP_BITS(re, gb, 1);
508  out[((pos & block_mask) << 6) + ctx->scan[i]] = ((level ^ sign) - sign);
509  }
510 
511  CLOSE_READER(re, gb);
512  return 0;
513 }
514 
516  uint16_t *dst, int dst_stride,
517  const uint8_t *buf, unsigned buf_size,
518  const int16_t *qmat)
519 {
520  ProresContext *ctx = avctx->priv_data;
521  LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);
522  int16_t *block;
523  GetBitContext gb;
524  int i, blocks_per_slice = slice->mb_count<<2;
525  int ret;
526 
527  for (i = 0; i < blocks_per_slice; i++)
528  ctx->bdsp.clear_block(blocks+(i<<6));
529 
530  init_get_bits(&gb, buf, buf_size << 3);
531 
532  if ((ret = decode_dc_coeffs(&gb, blocks, blocks_per_slice)) < 0)
533  return ret;
534  if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)
535  return ret;
536 
537  block = blocks;
538  for (i = 0; i < slice->mb_count; i++) {
539  ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat);
540  ctx->prodsp.idct_put(dst +8, dst_stride, block+(1<<6), qmat);
541  ctx->prodsp.idct_put(dst+4*dst_stride , dst_stride, block+(2<<6), qmat);
542  ctx->prodsp.idct_put(dst+4*dst_stride+8, dst_stride, block+(3<<6), qmat);
543  block += 4*64;
544  dst += 16;
545  }
546  return 0;
547 }
548 
550  uint16_t *dst, int dst_stride,
551  const uint8_t *buf, unsigned buf_size,
552  const int16_t *qmat, int log2_blocks_per_mb)
553 {
554  ProresContext *ctx = avctx->priv_data;
555  LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);
556  int16_t *block;
557  GetBitContext gb;
558  int i, j, blocks_per_slice = slice->mb_count << log2_blocks_per_mb;
559  int ret;
560 
561  for (i = 0; i < blocks_per_slice; i++)
562  ctx->bdsp.clear_block(blocks+(i<<6));
563 
564  init_get_bits(&gb, buf, buf_size << 3);
565 
566  if ((ret = decode_dc_coeffs(&gb, blocks, blocks_per_slice)) < 0)
567  return ret;
568  if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)
569  return ret;
570 
571  block = blocks;
572  for (i = 0; i < slice->mb_count; i++) {
573  for (j = 0; j < log2_blocks_per_mb; j++) {
574  ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat);
575  ctx->prodsp.idct_put(dst+4*dst_stride, dst_stride, block+(1<<6), qmat);
576  block += 2*64;
577  dst += 8;
578  }
579  }
580  return 0;
581 }
582 
583 /**
584  * Decode alpha slice plane.
585  */
587  uint16_t *dst, int dst_stride,
588  const uint8_t *buf, int buf_size,
589  int blocks_per_slice)
590 {
591  GetBitContext gb;
592  int i;
593  LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);
594  int16_t *block;
595 
596  for (i = 0; i < blocks_per_slice<<2; i++)
597  ctx->bdsp.clear_block(blocks+(i<<6));
598 
599  init_get_bits(&gb, buf, buf_size << 3);
600 
601  if (ctx->alpha_info == 2) {
602  ctx->unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 16);
603  } else {
604  ctx->unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 8);
605  }
606 
607  block = blocks;
608 
609  for (i = 0; i < 16; i++) {
610  memcpy(dst, block, 16 * blocks_per_slice * sizeof(*dst));
611  dst += dst_stride >> 1;
612  block += 16 * blocks_per_slice;
613  }
614 }
615 
616 static int decode_slice_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
617 {
618  ProresContext *ctx = avctx->priv_data;
619  SliceContext *slice = &ctx->slices[jobnr];
620  const uint8_t *buf = slice->data;
621  AVFrame *pic = ctx->frame;
622  int i, hdr_size, qscale, log2_chroma_blocks_per_mb;
623  int luma_stride, chroma_stride;
624  int y_data_size, u_data_size, v_data_size, a_data_size;
625  uint8_t *dest_y, *dest_u, *dest_v, *dest_a;
626  LOCAL_ALIGNED_16(int16_t, qmat_luma_scaled, [64]);
627  LOCAL_ALIGNED_16(int16_t, qmat_chroma_scaled,[64]);
628  int mb_x_shift;
629  int ret;
630  uint16_t val_no_chroma;
631 
632  slice->ret = -1;
633  //av_log(avctx, AV_LOG_INFO, "slice %d mb width %d mb x %d y %d\n",
634  // jobnr, slice->mb_count, slice->mb_x, slice->mb_y);
635 
636  // slice header
637  hdr_size = buf[0] >> 3;
638  qscale = av_clip(buf[1], 1, 224);
639  qscale = qscale > 128 ? qscale - 96 << 2: qscale;
640  y_data_size = AV_RB16(buf + 2);
641  u_data_size = AV_RB16(buf + 4);
642  v_data_size = slice->data_size - y_data_size - u_data_size - hdr_size;
643  if (hdr_size > 7) v_data_size = AV_RB16(buf + 6);
644  a_data_size = slice->data_size - y_data_size - u_data_size -
645  v_data_size - hdr_size;
646 
647  if (y_data_size < 0 || u_data_size < 0 || v_data_size < 0
648  || hdr_size+y_data_size+u_data_size+v_data_size > slice->data_size){
649  av_log(avctx, AV_LOG_ERROR, "invalid plane data size\n");
650  return AVERROR_INVALIDDATA;
651  }
652 
653  buf += hdr_size;
654 
655  for (i = 0; i < 64; i++) {
656  qmat_luma_scaled [i] = ctx->qmat_luma [i] * qscale;
657  qmat_chroma_scaled[i] = ctx->qmat_chroma[i] * qscale;
658  }
659 
660  if (ctx->frame_type == 0) {
661  luma_stride = pic->linesize[0];
662  chroma_stride = pic->linesize[1];
663  } else {
664  luma_stride = pic->linesize[0] << 1;
665  chroma_stride = pic->linesize[1] << 1;
666  }
667 
668  if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10 || avctx->pix_fmt == AV_PIX_FMT_YUVA444P10 ||
670  mb_x_shift = 5;
671  log2_chroma_blocks_per_mb = 2;
672  } else {
673  mb_x_shift = 4;
674  log2_chroma_blocks_per_mb = 1;
675  }
676 
677  dest_y = pic->data[0] + (slice->mb_y << 4) * luma_stride + (slice->mb_x << 5);
678  dest_u = pic->data[1] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift);
679  dest_v = pic->data[2] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift);
680  dest_a = pic->data[3] + (slice->mb_y << 4) * luma_stride + (slice->mb_x << 5);
681 
682  if (ctx->frame_type && ctx->first_field ^ ctx->frame->top_field_first) {
683  dest_y += pic->linesize[0];
684  dest_u += pic->linesize[1];
685  dest_v += pic->linesize[2];
686  dest_a += pic->linesize[3];
687  }
688 
689  ret = decode_slice_luma(avctx, slice, (uint16_t*)dest_y, luma_stride,
690  buf, y_data_size, qmat_luma_scaled);
691  if (ret < 0)
692  return ret;
693 
694  if (!(avctx->flags & AV_CODEC_FLAG_GRAY) && (u_data_size + v_data_size) > 0) {
695  ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_u, chroma_stride,
696  buf + y_data_size, u_data_size,
697  qmat_chroma_scaled, log2_chroma_blocks_per_mb);
698  if (ret < 0)
699  return ret;
700 
701  ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_v, chroma_stride,
702  buf + y_data_size + u_data_size, v_data_size,
703  qmat_chroma_scaled, log2_chroma_blocks_per_mb);
704  if (ret < 0)
705  return ret;
706  }
707  else {
708  size_t mb_max_x = slice->mb_count << (mb_x_shift - 1);
709  size_t i, j;
710  if (avctx->bits_per_raw_sample == 10) {
711  val_no_chroma = 511;
712  } else { /* 12b */
713  val_no_chroma = 511 * 4;
714  }
715  for (i = 0; i < 16; ++i)
716  for (j = 0; j < mb_max_x; ++j) {
717  *(uint16_t*)(dest_u + (i * chroma_stride) + (j << 1)) = val_no_chroma;
718  *(uint16_t*)(dest_v + (i * chroma_stride) + (j << 1)) = val_no_chroma;
719  }
720  }
721 
722  /* decode alpha plane if available */
723  if (ctx->alpha_info && pic->data[3] && a_data_size)
724  decode_slice_alpha(ctx, (uint16_t*)dest_a, luma_stride,
725  buf + y_data_size + u_data_size + v_data_size,
726  a_data_size, slice->mb_count);
727 
728  slice->ret = 0;
729  return 0;
730 }
731 
732 static int decode_picture(AVCodecContext *avctx)
733 {
734  ProresContext *ctx = avctx->priv_data;
735  int i;
736  int error = 0;
737 
738  avctx->execute2(avctx, decode_slice_thread, NULL, NULL, ctx->slice_count);
739 
740  for (i = 0; i < ctx->slice_count; i++)
741  error += ctx->slices[i].ret < 0;
742 
743  if (error)
745  if (error < ctx->slice_count)
746  return 0;
747 
748  return ctx->slices[0].ret;
749 }
750 
751 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
752  AVPacket *avpkt)
753 {
754  ProresContext *ctx = avctx->priv_data;
755  ThreadFrame tframe = { .f = data };
756  AVFrame *frame = data;
757  const uint8_t *buf = avpkt->data;
758  int buf_size = avpkt->size;
759  int frame_hdr_size, pic_size, ret;
760 
761  if (buf_size < 28 || AV_RL32(buf + 4) != AV_RL32("icpf")) {
762  av_log(avctx, AV_LOG_ERROR, "invalid frame header\n");
763  return AVERROR_INVALIDDATA;
764  }
765 
766  ctx->frame = frame;
768  ctx->frame->key_frame = 1;
769  ctx->first_field = 1;
770 
771  buf += 8;
772  buf_size -= 8;
773 
774  frame_hdr_size = decode_frame_header(ctx, buf, buf_size, avctx);
775  if (frame_hdr_size < 0)
776  return frame_hdr_size;
777 
778  buf += frame_hdr_size;
779  buf_size -= frame_hdr_size;
780 
782  pic_size = decode_picture_header(avctx, buf, buf_size);
783  if (pic_size < 0) {
784  av_log(avctx, AV_LOG_ERROR, "error decoding picture header\n");
785  return pic_size;
786  }
787 
788  if (ctx->first_field)
789  if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
790  return ret;
791 
792  if ((ret = decode_picture(avctx)) < 0) {
793  av_log(avctx, AV_LOG_ERROR, "error decoding picture\n");
794  return ret;
795  }
796 
797  buf += pic_size;
798  buf_size -= pic_size;
799 
800  if (ctx->frame_type && buf_size > 0 && ctx->first_field) {
801  ctx->first_field = 0;
802  goto decode_picture;
803  }
804 
805  *got_frame = 1;
806 
807  return avpkt->size;
808 }
809 
810 #if HAVE_THREADS
811 static int decode_init_thread_copy(AVCodecContext *avctx)
812 {
813  ProresContext *ctx = avctx->priv_data;
814 
815  ctx->slices = NULL;
816 
817  return 0;
818 }
819 #endif
820 
822 {
823  ProresContext *ctx = avctx->priv_data;
824 
825  av_freep(&ctx->slices);
826 
827  return 0;
828 }
829 
831  .name = "prores",
832  .long_name = NULL_IF_CONFIG_SMALL("ProRes (iCodec Pro)"),
833  .type = AVMEDIA_TYPE_VIDEO,
834  .id = AV_CODEC_ID_PRORES,
835  .priv_data_size = sizeof(ProresContext),
836  .init = decode_init,
837  .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
838  .close = decode_close,
839  .decode = decode_frame,
842 };
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:863
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int first_field
Definition: proresdec.h:52
uint8_t qmat_luma[64]
Definition: proresdec.h:43
float re
Definition: fft.c:82
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:425
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AVFrame * f
Definition: thread.h:35
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:104
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static int decode_slice_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
Definition: proresdec2.c:616
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have add an init_thread_copy() which re-allocates them for other threads.Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities.There will be very little speed gain at this point but it should work.If there are inter-frame dependencies
void(* clear_block)(int16_t *block)
Definition: blockdsp.h:36
static int decode_slice_luma(AVCodecContext *avctx, SliceContext *slice, uint16_t *dst, int dst_stride, const uint8_t *buf, unsigned buf_size, const int16_t *qmat)
Definition: proresdec2.c:515
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2200
int size
Definition: avcodec.h:1478
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
#define ALPHA_SHIFT_16_TO_12(alpha_val)
Definition: proresdec2.c:51
int av_log2(unsigned v)
Definition: intmath.c:26
const uint8_t * scan
Definition: proresdec.h:51
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
#define FF_PROFILE_PRORES_LT
Definition: avcodec.h:3004
BlockDSPContext bdsp
Definition: proresdec.h:39
unsigned mb_height
height of the current picture in mb
Definition: proresdec.h:48
int version
Definition: avisynth_c.h:858
int idct_permutation_type
Definition: proresdsp.h:31
uint8_t run
Definition: svq3.c:206
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2796
unsigned mb_y
Definition: proresdec.h:32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:87
#define src
Definition: vp8dsp.c:254
int profile
profile
Definition: avcodec.h:2898
AVCodec.
Definition: avcodec.h:3481
#define FF_PROFILE_PRORES_XQ
Definition: avcodec.h:3008
unsigned data_size
Definition: proresdec.h:34
AVFrame * frame
Definition: proresdec.h:41
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:82
static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size)
Definition: proresdec2.c:298
Multithreading support functions.
static av_cold int decode_init(AVCodecContext *avctx)
Definition: proresdec2.c:135
unsigned mb_count
Definition: proresdec.h:33
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
#define ALPHA_SHIFT_8_TO_12(alpha_val)
Definition: proresdec2.c:52
static void unpack_alpha_12(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits)
Definition: proresdec2.c:125
AVCodec ff_prores_decoder
Definition: proresdec2.c:830
#define height
uint8_t * data
Definition: avcodec.h:1477
#define ff_dlog(a,...)
bitstream reader API header.
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:442
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:392
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:883
const AVProfile ff_prores_profiles[]
Definition: profiles.c:154
#define av_log(a,...)
int slice_count
number of slices in the current picture
Definition: proresdec.h:46
SliceContext * slices
Definition: proresdec.h:45
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
unsigned mb_width
width of the current picture in mb
Definition: proresdec.h:47
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
ProresDSPContext prodsp
Definition: proresdec.h:40
static void unpack_alpha_10(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits)
Definition: proresdec2.c:115
static const uint16_t mask[17]
Definition: lzw.c:38
const uint8_t * data
Definition: proresdec.h:30
int skip_alpha
Skip processing alpha if supported by codec.
Definition: avcodec.h:3178
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1645
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:390
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1037
unsigned mb_x
Definition: proresdec.h:31
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:193
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:225
common internal API header
static void unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits, const int decode_precision)
Definition: proresdec2.c:54
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#define FFMIN(a, b)
Definition: common.h:96
av_cold void ff_init_scantable_permutation(uint8_t *idct_permutation, enum idct_permutation_type perm_type)
Definition: idctdsp.c:50
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:428
#define width
int width
picture width / height.
Definition: avcodec.h:1738
#define FF_PROFILE_PRORES_STANDARD
Definition: avcodec.h:3005
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2899
uint8_t idct_permutation[64]
Definition: proresdsp.h:32
int size_in_bits
Definition: get_bits.h:68
AVFormatContext * ctx
Definition: movenc.c:48
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2179
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
static const uint8_t lev_to_cb[10]
Definition: proresdec2.c:470
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:426
uint8_t interlaced_scan[64]
Definition: proresdec.h:50
#define ALPHA_SHIFT_16_TO_10(alpha_val)
Definition: proresdec2.c:49
static void error(const char *err)
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
int alpha_info
Definition: proresdec.h:53
if(ret)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1041
#define FF_PROFILE_PRORES_4444
Definition: avcodec.h:3007
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:2884
const uint8_t ff_prores_interlaced_scan[64]
Definition: proresdata.c:36
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
main external API structure.
Definition: avcodec.h:1565
const uint8_t ff_prores_progressive_scan[64]
Definition: proresdata.c:25
static void permute(uint8_t *dst, const uint8_t *src, const uint8_t permutation[64])
Definition: proresdec2.c:42
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:1590
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
void * buf
Definition: avisynth_c.h:766
static av_always_inline int decode_ac_coeffs(AVCodecContext *avctx, GetBitContext *gb, int16_t *out, int blocks_per_slice)
Definition: proresdec2.c:472
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static int decode_slice_chroma(AVCodecContext *avctx, SliceContext *slice, uint16_t *dst, int dst_stride, const uint8_t *buf, unsigned buf_size, const int16_t *qmat, int log2_blocks_per_mb)
Definition: proresdec2.c:549
static const uint8_t run_to_cb[16]
Definition: proresdec2.c:469
uint8_t progressive_scan[64]
Definition: proresdec.h:49
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2193
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2186
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
#define TOSIGNED(x)
Definition: proresdec2.c:435
#define FF_PROFILE_PRORES_HQ
Definition: avcodec.h:3006
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: proresdec2.c:751
#define DECODE_CODEWORD(val, codebook, SKIP)
Definition: proresdec2.c:403
#define FF_DECODE_ERROR_INVALID_BITSTREAM
Definition: frame.h:591
int decode_error_flags
decode error flags of the frame, set to a combination of FF_DECODE_ERROR_xxx flags if the decoder pro...
Definition: frame.h:590
#define flags(name, subs,...)
Definition: cbs_av1.c:561
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:388
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:394
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
uint8_t level
Definition: svq3.c:207
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:521
#define LOCAL_ALIGNED_32(t, v,...)
Definition: internal.h:137
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
#define FIRST_DC_CB
Definition: proresdec2.c:437
common internal api header.
static const uint8_t dc_codebook[7]
Definition: proresdec2.c:439
void * priv_data
Definition: avcodec.h:1592
#define ALPHA_SHIFT_8_TO_10(alpha_val)
Definition: proresdec2.c:50
uint8_t qmat_chroma[64]
Definition: proresdec.h:44
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:447
simple idct header.
av_cold int ff_proresdsp_init(ProresDSPContext *dsp, AVCodecContext *avctx)
Definition: proresdsp.c:79
void(* unpack_alpha)(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits)
Definition: proresdec.h:54
static void decode_slice_alpha(ProresContext *ctx, uint16_t *dst, int dst_stride, const uint8_t *buf, int buf_size, int blocks_per_slice)
Decode alpha slice plane.
Definition: proresdec2.c:586
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
static int decode_frame_header(ProresContext *ctx, const uint8_t *buf, const int data_size, AVCodecContext *avctx)
Definition: proresdec2.c:199
static av_always_inline int decode_dc_coeffs(GetBitContext *gb, int16_t *out, int blocks_per_slice)
Definition: proresdec2.c:441
#define FF_PROFILE_PRORES_PROXY
Definition: avcodec.h:3003
static av_cold int decode_close(AVCodecContext *avctx)
Definition: proresdec2.c:821
FILE * out
Definition: movenc.c:54
#define LOCAL_ALIGNED_16(t, v,...)
Definition: internal.h:131
#define av_freep(p)
#define av_always_inline
Definition: attributes.h:39
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
int frame_type
0 = progressive, 1 = tff, 2 = bff
Definition: proresdec.h:42
#define MKTAG(a, b, c, d)
Definition: common.h:366
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1454
static int decode_picture(AVCodecContext *avctx)
Definition: proresdec2.c:732
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
void(* idct_put)(uint16_t *out, ptrdiff_t linesize, int16_t *block, const int16_t *qmat)
Definition: proresdsp.h:33
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:427
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191