FFmpeg
proresdec.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), 'apco' (Proxy), 'ap4h' (4444), 'ap4x' (4444 XQ)
25  */
26 
27 //#define DEBUG
28 
29 #define LONG_BITSTREAM_READER
30 
31 #include "config_components.h"
32 
33 #include "libavutil/internal.h"
34 #include "libavutil/mem.h"
35 #include "libavutil/mem_internal.h"
36 
37 #include "avcodec.h"
38 #include "codec_internal.h"
39 #include "decode.h"
40 #include "get_bits.h"
41 #include "hwaccel_internal.h"
42 #include "hwconfig.h"
43 #include "idctdsp.h"
44 #include "profiles.h"
45 #include "proresdec.h"
46 #include "proresdata.h"
47 #include "thread.h"
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 = AV_PROFILE_PRORES_LT;
149  break;
150  case MKTAG('a','p','c','n'):
152  break;
153  case MKTAG('a','p','c','h'):
154  avctx->profile = AV_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 = AV_PROFILE_PRORES_XQ;
162  avctx->bits_per_raw_sample = 12;
163  break;
164  default:
165  avctx->profile = AV_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);
176  ret = ff_proresdsp_init(&ctx->prodsp, avctx->bits_per_raw_sample);
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  ff_permute_scantable(ctx->progressive_scan, ff_prores_progressive_scan, idct_permutation);
186  ff_permute_scantable(ctx->interlaced_scan, ff_prores_interlaced_scan, idct_permutation);
187 
188  ctx->pix_fmt = AV_PIX_FMT_NONE;
189 
190  if (avctx->bits_per_raw_sample == 10){
191  ctx->unpack_alpha = unpack_alpha_10;
192  } else if (avctx->bits_per_raw_sample == 12){
193  ctx->unpack_alpha = unpack_alpha_12;
194  } else {
195  av_log(avctx, AV_LOG_ERROR, "Fail to set unpack_alpha for bits per raw sample %d\n", avctx->bits_per_raw_sample);
196  return AVERROR_BUG;
197  }
198  return ret;
199 }
200 
201 static int decode_frame_header(ProresContext *ctx, const uint8_t *buf,
202  const int data_size, AVCodecContext *avctx)
203 {
204  int hdr_size, width, height, flags;
205  int version;
206  const uint8_t *ptr;
207  enum AVPixelFormat pix_fmt;
208 
209  hdr_size = AV_RB16(buf);
210  ff_dlog(avctx, "header size %d\n", hdr_size);
211  if (hdr_size > data_size) {
212  av_log(avctx, AV_LOG_ERROR, "error, wrong header size\n");
213  return AVERROR_INVALIDDATA;
214  }
215 
216  version = AV_RB16(buf + 2);
217  ff_dlog(avctx, "%.4s version %d\n", buf+4, version);
218  if (version > 1) {
219  av_log(avctx, AV_LOG_ERROR, "unsupported version: %d\n", version);
220  return AVERROR_PATCHWELCOME;
221  }
222 
223  width = AV_RB16(buf + 8);
224  height = AV_RB16(buf + 10);
225 
226  if (width != avctx->width || height != avctx->height) {
227  int ret;
228 
229  av_log(avctx, AV_LOG_WARNING, "picture resolution change: %dx%d -> %dx%d\n",
230  avctx->width, avctx->height, width, height);
231  if ((ret = ff_set_dimensions(avctx, width, height)) < 0)
232  return ret;
233  }
234 
235  ctx->frame_type = (buf[12] >> 2) & 3;
236  ctx->alpha_info = buf[17] & 0xf;
237 
238  if (ctx->alpha_info > 2) {
239  av_log(avctx, AV_LOG_ERROR, "Invalid alpha mode %d\n", ctx->alpha_info);
240  return AVERROR_INVALIDDATA;
241  }
242  if (avctx->skip_alpha) ctx->alpha_info = 0;
243 
244  ff_dlog(avctx, "frame type %d\n", ctx->frame_type);
245 
246  if (ctx->frame_type == 0) {
247  ctx->scan = ctx->progressive_scan; // permuted
248  } else {
249  ctx->scan = ctx->interlaced_scan; // permuted
251  if (ctx->frame_type == 1)
253  }
254 
255  if (ctx->alpha_info) {
256  if (avctx->bits_per_raw_sample == 10) {
257  pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUVA444P10 : AV_PIX_FMT_YUVA422P10;
258  } else { /* 12b */
259  pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUVA444P12 : AV_PIX_FMT_YUVA422P12;
260  }
261  } else {
262  if (avctx->bits_per_raw_sample == 10) {
263  pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUV444P10 : AV_PIX_FMT_YUV422P10;
264  } else { /* 12b */
265  pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUV444P12 : AV_PIX_FMT_YUV422P12;
266  }
267  }
268 
269  if (pix_fmt != ctx->pix_fmt) {
270 #define HWACCEL_MAX (CONFIG_PRORES_VIDEOTOOLBOX_HWACCEL)
271  enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
272  int ret;
273 
274  ctx->pix_fmt = pix_fmt;
275 
276 #if CONFIG_PRORES_VIDEOTOOLBOX_HWACCEL
277  *fmtp++ = AV_PIX_FMT_VIDEOTOOLBOX;
278 #endif
279  *fmtp++ = ctx->pix_fmt;
280  *fmtp = AV_PIX_FMT_NONE;
281 
282  if ((ret = ff_get_format(avctx, pix_fmts)) < 0)
283  return ret;
284 
285  avctx->pix_fmt = ret;
286  }
287 
288  ctx->frame->color_primaries = buf[14];
289  ctx->frame->color_trc = buf[15];
290  ctx->frame->colorspace = buf[16];
291  ctx->frame->color_range = AVCOL_RANGE_MPEG;
292 
293  ptr = buf + 20;
294  flags = buf[19];
295  ff_dlog(avctx, "flags %x\n", flags);
296 
297  if (flags & 2) {
298  if(buf + data_size - ptr < 64) {
299  av_log(avctx, AV_LOG_ERROR, "Header truncated\n");
300  return AVERROR_INVALIDDATA;
301  }
302  ff_permute_scantable(ctx->qmat_luma, ctx->prodsp.idct_permutation, ptr);
303  ptr += 64;
304  } else {
305  memset(ctx->qmat_luma, 4, 64);
306  }
307 
308  if (flags & 1) {
309  if(buf + data_size - ptr < 64) {
310  av_log(avctx, AV_LOG_ERROR, "Header truncated\n");
311  return AVERROR_INVALIDDATA;
312  }
313  ff_permute_scantable(ctx->qmat_chroma, ctx->prodsp.idct_permutation, ptr);
314  } else {
315  memcpy(ctx->qmat_chroma, ctx->qmat_luma, 64);
316  }
317 
318  return hdr_size;
319 }
320 
321 static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size)
322 {
323  ProresContext *ctx = avctx->priv_data;
324  int i, hdr_size, slice_count;
325  unsigned pic_data_size;
326  int log2_slice_mb_width, log2_slice_mb_height;
327  int slice_mb_count, mb_x, mb_y;
328  const uint8_t *data_ptr, *index_ptr;
329 
330  hdr_size = buf[0] >> 3;
331  if (hdr_size < 8 || hdr_size > buf_size) {
332  av_log(avctx, AV_LOG_ERROR, "error, wrong picture header size\n");
333  return AVERROR_INVALIDDATA;
334  }
335 
336  pic_data_size = AV_RB32(buf + 1);
337  if (pic_data_size > buf_size) {
338  av_log(avctx, AV_LOG_ERROR, "error, wrong picture data size\n");
339  return AVERROR_INVALIDDATA;
340  }
341 
342  log2_slice_mb_width = buf[7] >> 4;
343  log2_slice_mb_height = buf[7] & 0xF;
344  if (log2_slice_mb_width > 3 || log2_slice_mb_height) {
345  av_log(avctx, AV_LOG_ERROR, "unsupported slice resolution: %dx%d\n",
346  1 << log2_slice_mb_width, 1 << log2_slice_mb_height);
347  return AVERROR_INVALIDDATA;
348  }
349 
350  ctx->mb_width = (avctx->width + 15) >> 4;
351  if (ctx->frame_type)
352  ctx->mb_height = (avctx->height + 31) >> 5;
353  else
354  ctx->mb_height = (avctx->height + 15) >> 4;
355 
356  // QT ignores the written value
357  // slice_count = AV_RB16(buf + 5);
358  slice_count = ctx->mb_height * ((ctx->mb_width >> log2_slice_mb_width) +
359  av_popcount(ctx->mb_width & (1 << log2_slice_mb_width) - 1));
360 
361  if (ctx->slice_count != slice_count || !ctx->slices) {
362  av_freep(&ctx->slices);
363  ctx->slice_count = 0;
364  ctx->slices = av_calloc(slice_count, sizeof(*ctx->slices));
365  if (!ctx->slices)
366  return AVERROR(ENOMEM);
367  ctx->slice_count = slice_count;
368  }
369 
370  if (!slice_count)
371  return AVERROR(EINVAL);
372 
373  if (hdr_size + slice_count*2 > buf_size) {
374  av_log(avctx, AV_LOG_ERROR, "error, wrong slice count\n");
375  return AVERROR_INVALIDDATA;
376  }
377 
378  // parse slice information
379  index_ptr = buf + hdr_size;
380  data_ptr = index_ptr + slice_count*2;
381 
382  slice_mb_count = 1 << log2_slice_mb_width;
383  mb_x = 0;
384  mb_y = 0;
385 
386  for (i = 0; i < slice_count; i++) {
387  SliceContext *slice = &ctx->slices[i];
388 
389  slice->data = data_ptr;
390  data_ptr += AV_RB16(index_ptr + i*2);
391 
392  while (ctx->mb_width - mb_x < slice_mb_count)
393  slice_mb_count >>= 1;
394 
395  slice->mb_x = mb_x;
396  slice->mb_y = mb_y;
397  slice->mb_count = slice_mb_count;
398  slice->data_size = data_ptr - slice->data;
399 
400  if (slice->data_size < 6) {
401  av_log(avctx, AV_LOG_ERROR, "error, wrong slice data size\n");
402  return AVERROR_INVALIDDATA;
403  }
404 
405  mb_x += slice_mb_count;
406  if (mb_x == ctx->mb_width) {
407  slice_mb_count = 1 << log2_slice_mb_width;
408  mb_x = 0;
409  mb_y++;
410  }
411  if (data_ptr > buf + buf_size) {
412  av_log(avctx, AV_LOG_ERROR, "error, slice out of bounds\n");
413  return AVERROR_INVALIDDATA;
414  }
415  }
416 
417  if (mb_x || mb_y != ctx->mb_height) {
418  av_log(avctx, AV_LOG_ERROR, "error wrong mb count y %d h %d\n",
419  mb_y, ctx->mb_height);
420  return AVERROR_INVALIDDATA;
421  }
422 
423  return pic_data_size;
424 }
425 
426 #define DECODE_CODEWORD(val, codebook, SKIP) \
427  do { \
428  unsigned int rice_order, exp_order, switch_bits; \
429  unsigned int q, buf, bits; \
430  \
431  UPDATE_CACHE(re, gb); \
432  buf = GET_CACHE(re, gb); \
433  \
434  /* number of bits to switch between rice and exp golomb */ \
435  switch_bits = codebook & 3; \
436  rice_order = codebook >> 5; \
437  exp_order = (codebook >> 2) & 7; \
438  \
439  q = 31 - av_log2(buf); \
440  \
441  if (q > switch_bits) { /* exp golomb */ \
442  bits = exp_order - switch_bits + (q<<1); \
443  if (bits > FFMIN(MIN_CACHE_BITS, 31)) \
444  return AVERROR_INVALIDDATA; \
445  val = SHOW_UBITS(re, gb, bits) - (1 << exp_order) + \
446  ((switch_bits + 1) << rice_order); \
447  SKIP(re, gb, bits); \
448  } else if (rice_order) { \
449  SKIP_BITS(re, gb, q+1); \
450  val = (q << rice_order) + SHOW_UBITS(re, gb, rice_order); \
451  SKIP(re, gb, rice_order); \
452  } else { \
453  val = q; \
454  SKIP(re, gb, q+1); \
455  } \
456  } while (0)
457 
458 #define TOSIGNED(x) (((x) >> 1) ^ (-((x) & 1)))
459 
460 #define FIRST_DC_CB 0xB8
461 
462 static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
463 
465  int blocks_per_slice)
466 {
467  int16_t prev_dc;
468  int code, i, sign;
469 
470  OPEN_READER(re, gb);
471 
473  prev_dc = TOSIGNED(code);
474  out[0] = prev_dc;
475 
476  out += 64; // dc coeff for the next block
477 
478  code = 5;
479  sign = 0;
480  for (i = 1; i < blocks_per_slice; i++, out += 64) {
482  if(code) sign ^= -(code & 1);
483  else sign = 0;
484  prev_dc += (((code + 1) >> 1) ^ sign) - sign;
485  out[0] = prev_dc;
486  }
487  CLOSE_READER(re, gb);
488  return 0;
489 }
490 
491 // adaptive codebook switching lut according to previous run/level values
492 static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29, 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };
493 static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28, 0x28, 0x28, 0x28, 0x4C };
494 
496  int16_t *out, int blocks_per_slice)
497 {
498  const ProresContext *ctx = avctx->priv_data;
499  int block_mask, sign;
500  unsigned pos, run, level;
501  int max_coeffs, i, bits_left;
502  int log2_block_count = av_log2(blocks_per_slice);
503 
504  OPEN_READER(re, gb);
505  UPDATE_CACHE(re, gb); \
506  run = 4;
507  level = 2;
508 
509  max_coeffs = 64 << log2_block_count;
510  block_mask = blocks_per_slice - 1;
511 
512  for (pos = block_mask;;) {
513  bits_left = gb->size_in_bits - re_index;
514  if (!bits_left || (bits_left < 32 && !SHOW_UBITS(re, gb, bits_left)))
515  break;
516 
518  pos += run + 1;
519  if (pos >= max_coeffs) {
520  av_log(avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", pos, max_coeffs);
521  return AVERROR_INVALIDDATA;
522  }
523 
525  level += 1;
526 
527  i = pos >> log2_block_count;
528 
529  sign = SHOW_SBITS(re, gb, 1);
530  SKIP_BITS(re, gb, 1);
531  out[((pos & block_mask) << 6) + ctx->scan[i]] = ((level ^ sign) - sign);
532  }
533 
534  CLOSE_READER(re, gb);
535  return 0;
536 }
537 
539  uint16_t *dst, int dst_stride,
540  const uint8_t *buf, unsigned buf_size,
541  const int16_t *qmat)
542 {
543  const ProresContext *ctx = avctx->priv_data;
544  LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);
545  int16_t *block;
546  GetBitContext gb;
547  int i, blocks_per_slice = slice->mb_count<<2;
548  int ret;
549 
550  for (i = 0; i < blocks_per_slice; i++)
551  ctx->bdsp.clear_block(blocks+(i<<6));
552 
553  init_get_bits(&gb, buf, buf_size << 3);
554 
555  if ((ret = decode_dc_coeffs(&gb, blocks, blocks_per_slice)) < 0)
556  return ret;
557  if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)
558  return ret;
559 
560  block = blocks;
561  for (i = 0; i < slice->mb_count; i++) {
562  ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat);
563  ctx->prodsp.idct_put(dst +8, dst_stride, block+(1<<6), qmat);
564  ctx->prodsp.idct_put(dst+4*dst_stride , dst_stride, block+(2<<6), qmat);
565  ctx->prodsp.idct_put(dst+4*dst_stride+8, dst_stride, block+(3<<6), qmat);
566  block += 4*64;
567  dst += 16;
568  }
569  return 0;
570 }
571 
573  uint16_t *dst, int dst_stride,
574  const uint8_t *buf, unsigned buf_size,
575  const int16_t *qmat, int log2_blocks_per_mb)
576 {
577  ProresContext *ctx = avctx->priv_data;
578  LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);
579  int16_t *block;
580  GetBitContext gb;
581  int i, j, blocks_per_slice = slice->mb_count << log2_blocks_per_mb;
582  int ret;
583 
584  for (i = 0; i < blocks_per_slice; i++)
585  ctx->bdsp.clear_block(blocks+(i<<6));
586 
587  init_get_bits(&gb, buf, buf_size << 3);
588 
589  if ((ret = decode_dc_coeffs(&gb, blocks, blocks_per_slice)) < 0)
590  return ret;
591  if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)
592  return ret;
593 
594  block = blocks;
595  for (i = 0; i < slice->mb_count; i++) {
596  for (j = 0; j < log2_blocks_per_mb; j++) {
597  ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat);
598  ctx->prodsp.idct_put(dst+4*dst_stride, dst_stride, block+(1<<6), qmat);
599  block += 2*64;
600  dst += 8;
601  }
602  }
603  return 0;
604 }
605 
606 /**
607  * Decode alpha slice plane.
608  */
610  uint16_t *dst, int dst_stride,
611  const uint8_t *buf, int buf_size,
612  int blocks_per_slice)
613 {
614  GetBitContext gb;
615  int i;
616  LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);
617  int16_t *block;
618 
619  for (i = 0; i < blocks_per_slice<<2; i++)
620  ctx->bdsp.clear_block(blocks+(i<<6));
621 
622  init_get_bits(&gb, buf, buf_size << 3);
623 
624  if (ctx->alpha_info == 2) {
625  ctx->unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 16);
626  } else {
627  ctx->unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 8);
628  }
629 
630  block = blocks;
631 
632  for (i = 0; i < 16; i++) {
633  memcpy(dst, block, 16 * blocks_per_slice * sizeof(*dst));
634  dst += dst_stride >> 1;
635  block += 16 * blocks_per_slice;
636  }
637 }
638 
639 static int decode_slice_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
640 {
641  const ProresContext *ctx = avctx->priv_data;
642  SliceContext *slice = &ctx->slices[jobnr];
643  const uint8_t *buf = slice->data;
644  AVFrame *pic = ctx->frame;
645  int i, hdr_size, qscale, log2_chroma_blocks_per_mb;
646  int luma_stride, chroma_stride;
647  int y_data_size, u_data_size, v_data_size, a_data_size, offset;
648  uint8_t *dest_y, *dest_u, *dest_v;
649  LOCAL_ALIGNED_16(int16_t, qmat_luma_scaled, [64]);
650  LOCAL_ALIGNED_16(int16_t, qmat_chroma_scaled,[64]);
651  int mb_x_shift;
652  int ret;
653  uint16_t val_no_chroma;
654 
655  slice->ret = -1;
656  //av_log(avctx, AV_LOG_INFO, "slice %d mb width %d mb x %d y %d\n",
657  // jobnr, slice->mb_count, slice->mb_x, slice->mb_y);
658 
659  // slice header
660  hdr_size = buf[0] >> 3;
661  qscale = av_clip(buf[1], 1, 224);
662  qscale = qscale > 128 ? qscale - 96 << 2: qscale;
663  y_data_size = AV_RB16(buf + 2);
664  u_data_size = AV_RB16(buf + 4);
665  v_data_size = slice->data_size - y_data_size - u_data_size - hdr_size;
666  if (hdr_size > 7) v_data_size = AV_RB16(buf + 6);
667  a_data_size = slice->data_size - y_data_size - u_data_size -
668  v_data_size - hdr_size;
669 
670  if (y_data_size < 0 || u_data_size < 0 || v_data_size < 0
671  || hdr_size+y_data_size+u_data_size+v_data_size > slice->data_size){
672  av_log(avctx, AV_LOG_ERROR, "invalid plane data size\n");
673  return AVERROR_INVALIDDATA;
674  }
675 
676  buf += hdr_size;
677 
678  for (i = 0; i < 64; i++) {
679  qmat_luma_scaled [i] = ctx->qmat_luma [i] * qscale;
680  qmat_chroma_scaled[i] = ctx->qmat_chroma[i] * qscale;
681  }
682 
683  if (ctx->frame_type == 0) {
684  luma_stride = pic->linesize[0];
685  chroma_stride = pic->linesize[1];
686  } else {
687  luma_stride = pic->linesize[0] << 1;
688  chroma_stride = pic->linesize[1] << 1;
689  }
690 
691  if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10 || avctx->pix_fmt == AV_PIX_FMT_YUVA444P10 ||
693  mb_x_shift = 5;
694  log2_chroma_blocks_per_mb = 2;
695  } else {
696  mb_x_shift = 4;
697  log2_chroma_blocks_per_mb = 1;
698  }
699 
700  offset = (slice->mb_y << 4) * luma_stride + (slice->mb_x << 5);
701  dest_y = pic->data[0] + offset;
702  dest_u = pic->data[1] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift);
703  dest_v = pic->data[2] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift);
704 
705  if (ctx->frame_type && ctx->first_field ^ !!(ctx->frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST)) {
706  dest_y += pic->linesize[0];
707  dest_u += pic->linesize[1];
708  dest_v += pic->linesize[2];
709  offset += pic->linesize[3];
710  }
711 
712  ret = decode_slice_luma(avctx, slice, (uint16_t*)dest_y, luma_stride,
713  buf, y_data_size, qmat_luma_scaled);
714  if (ret < 0)
715  return ret;
716 
717  if (!(avctx->flags & AV_CODEC_FLAG_GRAY) && (u_data_size + v_data_size) > 0) {
718  ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_u, chroma_stride,
719  buf + y_data_size, u_data_size,
720  qmat_chroma_scaled, log2_chroma_blocks_per_mb);
721  if (ret < 0)
722  return ret;
723 
724  ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_v, chroma_stride,
725  buf + y_data_size + u_data_size, v_data_size,
726  qmat_chroma_scaled, log2_chroma_blocks_per_mb);
727  if (ret < 0)
728  return ret;
729  }
730  else {
731  size_t mb_max_x = slice->mb_count << (mb_x_shift - 1);
732  size_t i, j;
733  if (avctx->bits_per_raw_sample == 10) {
734  val_no_chroma = 511;
735  } else { /* 12b */
736  val_no_chroma = 511 * 4;
737  }
738  for (i = 0; i < 16; ++i)
739  for (j = 0; j < mb_max_x; ++j) {
740  *(uint16_t*)(dest_u + (i * chroma_stride) + (j << 1)) = val_no_chroma;
741  *(uint16_t*)(dest_v + (i * chroma_stride) + (j << 1)) = val_no_chroma;
742  }
743  }
744 
745  /* decode alpha plane if available */
746  if (ctx->alpha_info && pic->data[3] && a_data_size) {
747  uint8_t *dest_a = pic->data[3] + offset;
748  decode_slice_alpha(ctx, (uint16_t*)dest_a, luma_stride,
749  buf + y_data_size + u_data_size + v_data_size,
750  a_data_size, slice->mb_count);
751  }
752 
753  slice->ret = 0;
754  return 0;
755 }
756 
757 static int decode_picture(AVCodecContext *avctx)
758 {
759  ProresContext *ctx = avctx->priv_data;
760  int i;
761  int error = 0;
762 
763  avctx->execute2(avctx, decode_slice_thread, NULL, NULL, ctx->slice_count);
764 
765  for (i = 0; i < ctx->slice_count; i++)
766  error += ctx->slices[i].ret < 0;
767 
768  if (error)
769  ctx->frame->decode_error_flags = FF_DECODE_ERROR_INVALID_BITSTREAM;
770  if (error < ctx->slice_count)
771  return 0;
772 
773  return ctx->slices[0].ret;
774 }
775 
777  int *got_frame, AVPacket *avpkt)
778 {
779  ProresContext *ctx = avctx->priv_data;
780  const uint8_t *buf = avpkt->data;
781  int buf_size = avpkt->size;
782  int frame_hdr_size, pic_size, ret;
783 
784  if (buf_size < 28 || AV_RL32(buf + 4) != AV_RL32("icpf")) {
785  av_log(avctx, AV_LOG_ERROR, "invalid frame header\n");
786  return AVERROR_INVALIDDATA;
787  }
788 
789  ctx->frame = frame;
790  ctx->first_field = 1;
791 
792  buf += 8;
793  buf_size -= 8;
794 
795  frame_hdr_size = decode_frame_header(ctx, buf, buf_size, avctx);
796  if (frame_hdr_size < 0)
797  return frame_hdr_size;
798 
799  buf += frame_hdr_size;
800  buf_size -= frame_hdr_size;
801 
802  if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0)
803  return ret;
804  ff_thread_finish_setup(avctx);
805 
806  if (avctx->hwaccel) {
807  const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
808  ret = hwaccel->start_frame(avctx, NULL, 0);
809  if (ret < 0)
810  return ret;
811  ret = hwaccel->decode_slice(avctx, avpkt->data, avpkt->size);
812  if (ret < 0)
813  return ret;
814  ret = hwaccel->end_frame(avctx);
815  if (ret < 0)
816  return ret;
817  goto finish;
818  }
819 
821  pic_size = decode_picture_header(avctx, buf, buf_size);
822  if (pic_size < 0) {
823  av_log(avctx, AV_LOG_ERROR, "error decoding picture header\n");
824  return pic_size;
825  }
826 
827  if ((ret = decode_picture(avctx)) < 0) {
828  av_log(avctx, AV_LOG_ERROR, "error decoding picture\n");
829  return ret;
830  }
831 
832  buf += pic_size;
833  buf_size -= pic_size;
834 
835  if (ctx->frame_type && buf_size > 0 && ctx->first_field) {
836  ctx->first_field = 0;
837  goto decode_picture;
838  }
839 
840 finish:
841  *got_frame = 1;
842 
843  return avpkt->size;
844 }
845 
847 {
848  ProresContext *ctx = avctx->priv_data;
849 
850  av_freep(&ctx->slices);
851 
852  return 0;
853 }
854 
855 #if HAVE_THREADS
857 {
858  ProresContext *csrc = src->priv_data;
859  ProresContext *cdst = dst->priv_data;
860 
861  cdst->pix_fmt = csrc->pix_fmt;
862 
863  return 0;
864 }
865 #endif
866 
868  .p.name = "prores",
869  CODEC_LONG_NAME("Apple ProRes (iCodec Pro)"),
870  .p.type = AVMEDIA_TYPE_VIDEO,
871  .p.id = AV_CODEC_ID_PRORES,
872  .priv_data_size = sizeof(ProresContext),
873  .init = decode_init,
874  .close = decode_close,
879  .hw_configs = (const AVCodecHWConfigInternal *const []) {
880 #if CONFIG_PRORES_VIDEOTOOLBOX_HWACCEL
881  HWACCEL_VIDEOTOOLBOX(prores),
882 #endif
883  NULL
884  },
885 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
hwconfig.h
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1427
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
level
uint8_t level
Definition: svq3.c:205
av_clip
#define av_clip
Definition: common.h:100
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
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
mem_internal.h
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1241
out
FILE * out
Definition: movenc.c:55
ff_prores_profiles
const AVProfile ff_prores_profiles[]
Definition: profiles.c:174
decode_frame_header
static int decode_frame_header(ProresContext *ctx, const uint8_t *buf, const int data_size, AVCodecContext *avctx)
Definition: proresdec.c:201
unpack_alpha_10
static void unpack_alpha_10(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits)
Definition: proresdec.c:115
GetBitContext::size_in_bits
int size_in_bits
Definition: get_bits.h:111
HWACCEL_MAX
#define HWACCEL_MAX
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: proresdec.c:776
AVPacket::data
uint8_t * data
Definition: packet.h:520
decode_picture_header
static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size)
Definition: proresdec.c:321
ProresContext
Definition: proresdec.h:43
SliceContext::mb_x
unsigned mb_x
Definition: proresdec.h:36
FFCodec
Definition: codec_internal.h:126
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:225
av_popcount
#define av_popcount
Definition: common.h:154
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:94
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:517
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:514
thread.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:395
AV_PROFILE_PRORES_STANDARD
#define AV_PROFILE_PRORES_STANDARD
Definition: defs.h:182
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:638
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
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
AV_PROFILE_PRORES_HQ
#define AV_PROFILE_PRORES_HQ
Definition: defs.h:183
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
finish
static void finish(void)
Definition: movenc.c:373
FFHWAccel
Definition: hwaccel_internal.h:34
ProresContext::pix_fmt
enum AVPixelFormat pix_fmt
Definition: proresdec.h:60
GetBitContext
Definition: get_bits.h:108
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
proresdec.h
val
static double val(void *priv, double ch)
Definition: aeval.c:78
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:481
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
decode_slice_alpha
static void decode_slice_alpha(const ProresContext *ctx, uint16_t *dst, int dst_stride, const uint8_t *buf, int buf_size, int blocks_per_slice)
Decode alpha slice plane.
Definition: proresdec.c:609
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
mask
static const uint16_t mask[17]
Definition: lzw.c:38
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:188
dc_codebook
static const uint8_t dc_codebook[7]
Definition: proresdec.c:462
unpack_alpha_12
static void unpack_alpha_12(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits)
Definition: proresdec.c:125
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:286
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c)
Definition: blockdsp.c:58
SliceContext::data_size
unsigned data_size
Definition: proresdec.h:39
decode_close
static av_cold int decode_close(AVCodecContext *avctx)
Definition: proresdec.c:846
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1406
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:986
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:260
decode_dc_coeffs
static av_always_inline int decode_dc_coeffs(GetBitContext *gb, int16_t *out, int blocks_per_slice)
Definition: proresdec.c:464
LOCAL_ALIGNED_16
#define LOCAL_ALIGNED_16(t, v,...)
Definition: mem_internal.h:150
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:304
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:520
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1575
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:49
decode.h
get_bits.h
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:241
decode_slice_thread
static int decode_slice_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
Definition: proresdec.c:639
ff_prores_interlaced_scan
const uint8_t ff_prores_interlaced_scan[64]
Definition: proresdata.c:36
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
arg
const char * arg
Definition: jacosubdec.c:67
if
if(ret)
Definition: filter_design.txt:179
decode_ac_coeffs
static av_always_inline int decode_ac_coeffs(AVCodecContext *avctx, GetBitContext *gb, int16_t *out, int blocks_per_slice)
Definition: proresdec.c:495
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:110
ALPHA_SHIFT_8_TO_10
#define ALPHA_SHIFT_8_TO_10(alpha_val)
Definition: proresdec.c:50
ff_proresdsp_init
av_cold int ff_proresdsp_init(ProresDSPContext *dsp, int bits_per_raw_sample)
Definition: proresdsp.c:79
NULL
#define NULL
Definition: coverity.c:32
FF_DECODE_ERROR_INVALID_BITSTREAM
#define FF_DECODE_ERROR_INVALID_BITSTREAM
Definition: frame.h:702
bits_left
#define bits_left
Definition: bitstream.h:114
DECODE_CODEWORD
#define DECODE_CODEWORD(val, codebook, SKIP)
Definition: proresdec.c:426
LOCAL_ALIGNED_32
#define LOCAL_ALIGNED_32(t, v,...)
Definition: mem_internal.h:156
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
run
uint8_t run
Definition: svq3.c:204
hwaccel_internal.h
SliceContext::ret
int ret
Definition: proresdec.h:40
ALPHA_SHIFT_16_TO_10
#define ALPHA_SHIFT_16_TO_10(alpha_val)
Definition: proresdec.c:49
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
profiles.h
SliceContext::mb_y
unsigned mb_y
Definition: proresdec.h:37
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:247
UPDATE_THREAD_CONTEXT
#define UPDATE_THREAD_CONTEXT(func)
Definition: codec_internal.h:280
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:479
AV_PROFILE_PRORES_LT
#define AV_PROFILE_PRORES_LT
Definition: defs.h:181
lev_to_cb
static const uint8_t lev_to_cb[10]
Definition: proresdec.c:493
SliceContext
Definition: mss12.h:70
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
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
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: proresdec.c:538
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:322
AVPacket::size
int size
Definition: packet.h:521
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:94
codec_internal.h
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:483
SliceContext::mb_count
unsigned mb_count
Definition: proresdec.h:38
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:96
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:485
proresdata.h
AVCodecContext::skip_alpha
int skip_alpha
Skip processing alpha if supported by codec.
Definition: avcodec.h:1834
AVCodecHWConfigInternal
Definition: hwconfig.h:25
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:177
AV_PROFILE_PRORES_4444
#define AV_PROFILE_PRORES_4444
Definition: defs.h:184
height
#define height
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:114
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:518
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
version
version
Definition: libkvazaar.c:321
AV_PROFILE_PRORES_PROXY
#define AV_PROFILE_PRORES_PROXY
Definition: defs.h:180
AV_PIX_FMT_VIDEOTOOLBOX
@ AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
Definition: pixfmt.h:305
TOSIGNED
#define TOSIGNED(x)
Definition: proresdec.c:458
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
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:35
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: proresdec.c:572
FIRST_DC_CB
#define FIRST_DC_CB
Definition: proresdec.c:460
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:633
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:669
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
HWACCEL_VIDEOTOOLBOX
#define HWACCEL_VIDEOTOOLBOX(codec)
Definition: hwconfig.h:74
idctdsp.h
avcodec.h
ff_prores_decoder
const FFCodec ff_prores_decoder
Definition: proresdec.c:867
ALPHA_SHIFT_16_TO_12
#define ALPHA_SHIFT_16_TO_12(alpha_val)
Definition: proresdec.c:51
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:264
run_to_cb
static const uint8_t run_to_cb[16]
Definition: proresdec.c:492
hwaccel
static const char * hwaccel
Definition: ffplay.c:353
pos
unsigned int pos
Definition: spdifenc.c:414
ff_thread_finish_setup
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 ff_thread_finish_setup() afterwards. If some code can 't be moved
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
U
#define U(x)
Definition: vpx_arith.h:37
AVCodecContext
main external API structure.
Definition: avcodec.h:445
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:259
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:519
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1640
ffhwaccel
static const FFHWAccel * ffhwaccel(const AVHWAccel *codec)
Definition: hwaccel_internal.h:166
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
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
ff_init_scantable_permutation
av_cold void ff_init_scantable_permutation(uint8_t *idct_permutation, enum idct_permutation_type perm_type)
Definition: idctdsp.c:39
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:470
ALPHA_SHIFT_8_TO_12
#define ALPHA_SHIFT_8_TO_12(alpha_val)
Definition: proresdec.c:52
AVPacket
This structure stores compressed data.
Definition: packet.h:497
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
unpack_alpha
static void unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits, const int decode_precision)
Definition: proresdec.c:54
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
AV_PROFILE_PRORES_XQ
#define AV_PROFILE_PRORES_XQ
Definition: defs.h:185
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:419
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
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
decode_picture
static int decode_picture(AVCodecContext *avctx)
Definition: proresdec.c:757
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
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:1632
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AV_CODEC_ID_PRORES
@ AV_CODEC_ID_PRORES
Definition: codec_id.h:200
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:98
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: proresdec.c:135