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,
183  ctx->prodsp.idct_permutation_type);
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){
189  ctx->unpack_alpha = unpack_alpha_10;
190  } else if (avctx->bits_per_raw_sample == 12){
191  ctx->unpack_alpha = unpack_alpha_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 
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)
744  ctx->frame->decode_error_flags = FF_DECODE_ERROR_INVALID_BITSTREAM;
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;
767  ctx->frame->pict_type = AV_PICTURE_TYPE_I;
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 
811 {
812  ProresContext *ctx = avctx->priv_data;
813 
814  av_freep(&ctx->slices);
815 
816  return 0;
817 }
818 
820  .name = "prores",
821  .long_name = NULL_IF_CONFIG_SMALL("ProRes (iCodec Pro)"),
822  .type = AVMEDIA_TYPE_VIDEO,
823  .id = AV_CODEC_ID_PRORES,
824  .priv_data_size = sizeof(ProresContext),
825  .init = decode_init,
826  .close = decode_close,
827  .decode = decode_frame,
830 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:29
AVCodec
AVCodec.
Definition: codec.h:190
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
DECODE_CODEWORD
#define DECODE_CODEWORD(val, codebook, SKIP)
Definition: proresdec2.c:403
FF_PROFILE_PRORES_XQ
#define FF_PROFILE_PRORES_XQ
Definition: avcodec.h:1969
level
uint8_t level
Definition: svq3.c:210
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1154
out
FILE * out
Definition: movenc.c:54
ff_prores_profiles
const AVProfile ff_prores_profiles[]
Definition: profiles.c:153
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:406
ff_proresdsp_init
av_cold int ff_proresdsp_init(ProresDSPContext *dsp, AVCodecContext *avctx)
Definition: proresdsp.c:79
GetBitContext::size_in_bits
int size_in_bits
Definition: get_bits.h:68
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1147
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:355
data
const char data[16]
Definition: mxf.c:91
ProresContext
Definition: proresdec.h:38
TOSIGNED
#define TOSIGNED(x)
Definition: proresdec2.c:435
SliceContext::mb_x
unsigned mb_x
Definition: proresdec.h:31
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:435
ff_prores_progressive_scan
const uint8_t ff_prores_progressive_scan[64]
Definition: proresdata.c:25
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
thread.h
ThreadFrame::f
AVFrame * f
Definition: thread.h:35
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:314
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
U
#define U(x)
Definition: vp56_arith.h:37
GetBitContext
Definition: get_bits.h:61
ff_thread_get_buffer
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 so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() 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::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
proresdec.h
val
static double val(void *priv, double ch)
Definition: aeval.c:76
FF_PROFILE_PRORES_LT
#define FF_PROFILE_PRORES_LT
Definition: avcodec.h:1965
ALPHA_SHIFT_8_TO_10
#define ALPHA_SHIFT_8_TO_10(alpha_val)
Definition: proresdec2.c:50
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:400
unpack_alpha
static void unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits, const int decode_precision)
Definition: proresdec2.c:54
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1140
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold
#define av_cold
Definition: attributes.h:90
FIRST_DC_CB
#define FIRST_DC_CB
Definition: proresdec2.c:437
mask
static const uint16_t mask[17]
Definition: lzw.c:38
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
decode_picture_header
static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size)
Definition: proresdec2.c:298
width
#define width
SliceContext::data_size
unsigned data_size
Definition: proresdec.h:34
decode_picture
static int decode_picture(AVCodecContext *avctx)
Definition: proresdec2.c:732
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
permute
static void permute(uint8_t *dst, const uint8_t *src, const uint8_t permutation[64])
Definition: proresdec2.c:42
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1860
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:438
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1757
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
ctx
AVFormatContext * ctx
Definition: movenc.c:48
get_bits.h
simple_idct.h
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:193
ff_prores_interlaced_scan
const uint8_t ff_prores_interlaced_scan[64]
Definition: proresdata.c:36
arg
const char * arg
Definition: jacosubdec.c:66
if
if(ret)
Definition: filter_design.txt:179
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
NULL
#define NULL
Definition: coverity.c:32
FF_DECODE_ERROR_INVALID_BITSTREAM
#define FF_DECODE_ERROR_INVALID_BITSTREAM
Definition: frame.h:596
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
run
uint8_t run
Definition: svq3.c:209
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1161
decode_ac_coeffs
static av_always_inline int decode_ac_coeffs(AVCodecContext *avctx, GetBitContext *gb, int16_t *out, int blocks_per_slice)
Definition: proresdec2.c:472
SliceContext::ret
int ret
Definition: proresdec.h:35
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
run_to_cb
static const uint8_t run_to_cb[16]
Definition: proresdec2.c:469
profiles.h
src
#define src
Definition: vp8dsp.c:254
SliceContext::mb_y
unsigned mb_y
Definition: proresdec.h:32
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:398
decode_slice_chroma
static int decode_slice_chroma(AVCodecContext *avctx, SliceContext *slice, uint16_t *dst, int dst_stride, const uint8_t *buf, unsigned buf_size, const int16_t *qmat, int log2_blocks_per_mb)
Definition: proresdec2.c:549
SliceContext
Definition: mss12.h:70
decode_slice_luma
static int decode_slice_luma(AVCodecContext *avctx, SliceContext *slice, uint16_t *dst, int dst_stride, const uint8_t *buf, unsigned buf_size, const int16_t *qmat)
Definition: proresdec2.c:515
dc_codebook
static const uint8_t dc_codebook[7]
Definition: proresdec2.c:439
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
AVPacket::size
int size
Definition: packet.h:356
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
FF_PROFILE_PRORES_HQ
#define FF_PROFILE_PRORES_HQ
Definition: avcodec.h:1967
FF_PROFILE_PRORES_STANDARD
#define FF_PROFILE_PRORES_STANDARD
Definition: avcodec.h:1966
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:402
SliceContext::mb_count
unsigned mb_count
Definition: proresdec.h:33
ALPHA_SHIFT_16_TO_12
#define ALPHA_SHIFT_16_TO_12(alpha_val)
Definition: proresdec2.c:51
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:92
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:404
proresdata.h
ALPHA_SHIFT_8_TO_12
#define ALPHA_SHIFT_8_TO_12(alpha_val)
Definition: proresdec2.c:52
AVCodecContext::skip_alpha
int skip_alpha
Skip processing alpha if supported by codec.
Definition: avcodec.h:2142
decode_close
static av_cold int decode_close(AVCodecContext *avctx)
Definition: proresdec2.c:810
decode_frame_header
static int decode_frame_header(ProresContext *ctx, const uint8_t *buf, const int data_size, AVCodecContext *avctx)
Definition: proresdec2.c:199
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
height
#define height
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:110
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:436
version
version
Definition: libkvazaar.c:292
ff_init_scantable_permutation
av_cold void ff_init_scantable_permutation(uint8_t *idct_permutation, enum idct_permutation_type perm_type)
Definition: idctdsp.c:50
decode_slice_alpha
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
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
internal.h
SliceContext::data
const uint8_t * data
Definition: proresdec.h:30
av_always_inline
#define av_always_inline
Definition: attributes.h:49
uint8_t
uint8_t
Definition: audio_convert.c:194
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
AVCodecContext::height
int height
Definition: avcodec.h:699
lev_to_cb
static const uint8_t lev_to_cb[10]
Definition: proresdec2.c:470
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:534
idctdsp.h
avcodec.h
ret
ret
Definition: filter_design.txt:187
ff_prores_decoder
AVCodec ff_prores_decoder
Definition: proresdec2.c:819
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:264
FF_PROFILE_PRORES_4444
#define FF_PROFILE_PRORES_4444
Definition: avcodec.h:1968
FF_PROFILE_PRORES_PROXY
#define FF_PROFILE_PRORES_PROXY
Definition: avcodec.h:1964
unpack_alpha_10
static void unpack_alpha_10(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits)
Definition: proresdec2.c:115
pos
unsigned int pos
Definition: spdifenc.c:412
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:88
AVCodecContext
main external API structure.
Definition: avcodec.h:526
ALPHA_SHIFT_16_TO_10
#define ALPHA_SHIFT_16_TO_10(alpha_val)
Definition: proresdec2.c:49
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: proresdec2.c:751
ThreadFrame
Definition: thread.h:34
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:437
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1859
decode_dc_coeffs
static av_always_inline int decode_dc_coeffs(GetBitContext *gb, int16_t *out, int blocks_per_slice)
Definition: proresdec2.c:441
profiles
static const AVProfile profiles[]
Definition: libfdk-aacenc.c:428
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:104
decode_slice_thread
static int decode_slice_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
Definition: proresdec2.c:616
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: proresdec2.c:135
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:551
LOCAL_ALIGNED_16
#define LOCAL_ALIGNED_16(t, v,...)
Definition: internal.h:131
AVPacket
This structure stores compressed data.
Definition: packet.h:332
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
unpack_alpha_12
static void unpack_alpha_12(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits)
Definition: proresdec2.c:125
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:699
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:331
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:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
LOCAL_ALIGNED_32
#define LOCAL_ALIGNED_32(t, v,...)
Definition: internal.h:137
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
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:1845
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AV_CODEC_ID_PRORES
@ AV_CODEC_ID_PRORES
Definition: codec_id.h:197
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:94
re
float re
Definition: fft.c:82