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), '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_internal.h"
35 
36 #include "avcodec.h"
37 #include "codec_internal.h"
38 #include "decode.h"
39 #include "get_bits.h"
40 #include "hwconfig.h"
41 #include "idctdsp.h"
42 #include "profiles.h"
43 #include "proresdec.h"
44 #include "proresdata.h"
45 #include "thread.h"
46 
47 static void permute(uint8_t *dst, const uint8_t *src, const uint8_t permutation[64])
48 {
49  int i;
50  for (i = 0; i < 64; i++)
51  dst[i] = permutation[src[i]];
52 }
53 
54 #define ALPHA_SHIFT_16_TO_10(alpha_val) (alpha_val >> 6)
55 #define ALPHA_SHIFT_8_TO_10(alpha_val) ((alpha_val << 2) | (alpha_val >> 6))
56 #define ALPHA_SHIFT_16_TO_12(alpha_val) (alpha_val >> 4)
57 #define ALPHA_SHIFT_8_TO_12(alpha_val) ((alpha_val << 4) | (alpha_val >> 4))
58 
59 static void inline unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs,
60  const int num_bits, const int decode_precision) {
61  const int mask = (1 << num_bits) - 1;
62  int i, idx, val, alpha_val;
63 
64  idx = 0;
65  alpha_val = mask;
66  do {
67  do {
68  if (get_bits1(gb)) {
69  val = get_bits(gb, num_bits);
70  } else {
71  int sign;
72  val = get_bits(gb, num_bits == 16 ? 7 : 4);
73  sign = val & 1;
74  val = (val + 2) >> 1;
75  if (sign)
76  val = -val;
77  }
78  alpha_val = (alpha_val + val) & mask;
79  if (num_bits == 16) {
80  if (decode_precision == 10) {
81  dst[idx++] = ALPHA_SHIFT_16_TO_10(alpha_val);
82  } else { /* 12b */
83  dst[idx++] = ALPHA_SHIFT_16_TO_12(alpha_val);
84  }
85  } else {
86  if (decode_precision == 10) {
87  dst[idx++] = ALPHA_SHIFT_8_TO_10(alpha_val);
88  } else { /* 12b */
89  dst[idx++] = ALPHA_SHIFT_8_TO_12(alpha_val);
90  }
91  }
92  if (idx >= num_coeffs)
93  break;
94  } while (get_bits_left(gb)>0 && get_bits1(gb));
95  val = get_bits(gb, 4);
96  if (!val)
97  val = get_bits(gb, 11);
98  if (idx + val > num_coeffs)
99  val = num_coeffs - idx;
100  if (num_bits == 16) {
101  for (i = 0; i < val; i++) {
102  if (decode_precision == 10) {
103  dst[idx++] = ALPHA_SHIFT_16_TO_10(alpha_val);
104  } else { /* 12b */
105  dst[idx++] = ALPHA_SHIFT_16_TO_12(alpha_val);
106  }
107  }
108  } else {
109  for (i = 0; i < val; i++) {
110  if (decode_precision == 10) {
111  dst[idx++] = ALPHA_SHIFT_8_TO_10(alpha_val);
112  } else { /* 12b */
113  dst[idx++] = ALPHA_SHIFT_8_TO_12(alpha_val);
114  }
115  }
116  }
117  } while (idx < num_coeffs);
118 }
119 
120 static void unpack_alpha_10(GetBitContext *gb, uint16_t *dst, int num_coeffs,
121  const int num_bits)
122 {
123  if (num_bits == 16) {
124  unpack_alpha(gb, dst, num_coeffs, 16, 10);
125  } else { /* 8 bits alpha */
126  unpack_alpha(gb, dst, num_coeffs, 8, 10);
127  }
128 }
129 
130 static void unpack_alpha_12(GetBitContext *gb, uint16_t *dst, int num_coeffs,
131  const int num_bits)
132 {
133  if (num_bits == 16) {
134  unpack_alpha(gb, dst, num_coeffs, 16, 12);
135  } else { /* 8 bits alpha */
136  unpack_alpha(gb, dst, num_coeffs, 8, 12);
137  }
138 }
139 
141 {
142  int ret = 0;
143  ProresContext *ctx = avctx->priv_data;
144  uint8_t idct_permutation[64];
145 
146  avctx->bits_per_raw_sample = 10;
147 
148  switch (avctx->codec_tag) {
149  case MKTAG('a','p','c','o'):
151  break;
152  case MKTAG('a','p','c','s'):
153  avctx->profile = FF_PROFILE_PRORES_LT;
154  break;
155  case MKTAG('a','p','c','n'):
157  break;
158  case MKTAG('a','p','c','h'):
159  avctx->profile = FF_PROFILE_PRORES_HQ;
160  break;
161  case MKTAG('a','p','4','h'):
163  avctx->bits_per_raw_sample = 12;
164  break;
165  case MKTAG('a','p','4','x'):
166  avctx->profile = FF_PROFILE_PRORES_XQ;
167  avctx->bits_per_raw_sample = 12;
168  break;
169  default:
170  avctx->profile = FF_PROFILE_UNKNOWN;
171  av_log(avctx, AV_LOG_WARNING, "Unknown prores profile %d\n", avctx->codec_tag);
172  }
173 
174  if (avctx->bits_per_raw_sample == 10) {
175  av_log(avctx, AV_LOG_DEBUG, "Auto bitdepth precision. Use 10b decoding based on codec tag.\n");
176  } else { /* 12b */
177  av_log(avctx, AV_LOG_DEBUG, "Auto bitdepth precision. Use 12b decoding based on codec tag.\n");
178  }
179 
180  ff_blockdsp_init(&ctx->bdsp);
181  ret = ff_proresdsp_init(&ctx->prodsp, avctx);
182  if (ret < 0) {
183  av_log(avctx, AV_LOG_ERROR, "Fail to init proresdsp for bits per raw sample %d\n", avctx->bits_per_raw_sample);
184  return ret;
185  }
186 
187  ff_init_scantable_permutation(idct_permutation,
188  ctx->prodsp.idct_permutation_type);
189 
190  permute(ctx->progressive_scan, ff_prores_progressive_scan, idct_permutation);
191  permute(ctx->interlaced_scan, ff_prores_interlaced_scan, idct_permutation);
192 
193  ctx->pix_fmt = AV_PIX_FMT_NONE;
194 
195  if (avctx->bits_per_raw_sample == 10){
196  ctx->unpack_alpha = unpack_alpha_10;
197  } else if (avctx->bits_per_raw_sample == 12){
198  ctx->unpack_alpha = unpack_alpha_12;
199  } else {
200  av_log(avctx, AV_LOG_ERROR, "Fail to set unpack_alpha for bits per raw sample %d\n", avctx->bits_per_raw_sample);
201  return AVERROR_BUG;
202  }
203  return ret;
204 }
205 
206 static int decode_frame_header(ProresContext *ctx, const uint8_t *buf,
207  const int data_size, AVCodecContext *avctx)
208 {
209  int hdr_size, width, height, flags;
210  int version;
211  const uint8_t *ptr;
212  enum AVPixelFormat pix_fmt;
213 
214  hdr_size = AV_RB16(buf);
215  ff_dlog(avctx, "header size %d\n", hdr_size);
216  if (hdr_size > data_size) {
217  av_log(avctx, AV_LOG_ERROR, "error, wrong header size\n");
218  return AVERROR_INVALIDDATA;
219  }
220 
221  version = AV_RB16(buf + 2);
222  ff_dlog(avctx, "%.4s version %d\n", buf+4, version);
223  if (version > 1) {
224  av_log(avctx, AV_LOG_ERROR, "unsupported version: %d\n", version);
225  return AVERROR_PATCHWELCOME;
226  }
227 
228  width = AV_RB16(buf + 8);
229  height = AV_RB16(buf + 10);
230 
231  if (width != avctx->width || height != avctx->height) {
232  int ret;
233 
234  av_log(avctx, AV_LOG_WARNING, "picture resolution change: %dx%d -> %dx%d\n",
235  avctx->width, avctx->height, width, height);
236  if ((ret = ff_set_dimensions(avctx, width, height)) < 0)
237  return ret;
238  }
239 
240  ctx->frame_type = (buf[12] >> 2) & 3;
241  ctx->alpha_info = buf[17] & 0xf;
242 
243  if (ctx->alpha_info > 2) {
244  av_log(avctx, AV_LOG_ERROR, "Invalid alpha mode %d\n", ctx->alpha_info);
245  return AVERROR_INVALIDDATA;
246  }
247  if (avctx->skip_alpha) ctx->alpha_info = 0;
248 
249  ff_dlog(avctx, "frame type %d\n", ctx->frame_type);
250 
251  if (ctx->frame_type == 0) {
252  ctx->scan = ctx->progressive_scan; // permuted
253  } else {
254  ctx->scan = ctx->interlaced_scan; // permuted
255  ctx->frame->interlaced_frame = 1;
256  ctx->frame->top_field_first = ctx->frame_type == 1;
257  }
258 
259  if (ctx->alpha_info) {
260  if (avctx->bits_per_raw_sample == 10) {
261  pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUVA444P10 : AV_PIX_FMT_YUVA422P10;
262  } else { /* 12b */
263  pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUVA444P12 : AV_PIX_FMT_YUVA422P12;
264  }
265  } else {
266  if (avctx->bits_per_raw_sample == 10) {
267  pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUV444P10 : AV_PIX_FMT_YUV422P10;
268  } else { /* 12b */
269  pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUV444P12 : AV_PIX_FMT_YUV422P12;
270  }
271  }
272 
273  if (pix_fmt != ctx->pix_fmt) {
274 #define HWACCEL_MAX (CONFIG_PRORES_VIDEOTOOLBOX_HWACCEL)
275  enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
276  int ret;
277 
278  ctx->pix_fmt = pix_fmt;
279 
280 #if CONFIG_PRORES_VIDEOTOOLBOX_HWACCEL
281  *fmtp++ = AV_PIX_FMT_VIDEOTOOLBOX;
282 #endif
283  *fmtp++ = ctx->pix_fmt;
284  *fmtp = AV_PIX_FMT_NONE;
285 
286  if ((ret = ff_thread_get_format(avctx, pix_fmts)) < 0)
287  return ret;
288 
289  avctx->pix_fmt = ret;
290  }
291 
292  avctx->color_primaries = buf[14];
293  avctx->color_trc = buf[15];
294  avctx->colorspace = buf[16];
295  avctx->color_range = AVCOL_RANGE_MPEG;
296 
297  ptr = buf + 20;
298  flags = buf[19];
299  ff_dlog(avctx, "flags %x\n", flags);
300 
301  if (flags & 2) {
302  if(buf + data_size - ptr < 64) {
303  av_log(avctx, AV_LOG_ERROR, "Header truncated\n");
304  return AVERROR_INVALIDDATA;
305  }
306  permute(ctx->qmat_luma, ctx->prodsp.idct_permutation, ptr);
307  ptr += 64;
308  } else {
309  memset(ctx->qmat_luma, 4, 64);
310  }
311 
312  if (flags & 1) {
313  if(buf + data_size - ptr < 64) {
314  av_log(avctx, AV_LOG_ERROR, "Header truncated\n");
315  return AVERROR_INVALIDDATA;
316  }
317  permute(ctx->qmat_chroma, ctx->prodsp.idct_permutation, ptr);
318  } else {
319  memcpy(ctx->qmat_chroma, ctx->qmat_luma, 64);
320  }
321 
322  return hdr_size;
323 }
324 
325 static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size)
326 {
327  ProresContext *ctx = avctx->priv_data;
328  int i, hdr_size, slice_count;
329  unsigned pic_data_size;
330  int log2_slice_mb_width, log2_slice_mb_height;
331  int slice_mb_count, mb_x, mb_y;
332  const uint8_t *data_ptr, *index_ptr;
333 
334  hdr_size = buf[0] >> 3;
335  if (hdr_size < 8 || hdr_size > buf_size) {
336  av_log(avctx, AV_LOG_ERROR, "error, wrong picture header size\n");
337  return AVERROR_INVALIDDATA;
338  }
339 
340  pic_data_size = AV_RB32(buf + 1);
341  if (pic_data_size > buf_size) {
342  av_log(avctx, AV_LOG_ERROR, "error, wrong picture data size\n");
343  return AVERROR_INVALIDDATA;
344  }
345 
346  log2_slice_mb_width = buf[7] >> 4;
347  log2_slice_mb_height = buf[7] & 0xF;
348  if (log2_slice_mb_width > 3 || log2_slice_mb_height) {
349  av_log(avctx, AV_LOG_ERROR, "unsupported slice resolution: %dx%d\n",
350  1 << log2_slice_mb_width, 1 << log2_slice_mb_height);
351  return AVERROR_INVALIDDATA;
352  }
353 
354  ctx->mb_width = (avctx->width + 15) >> 4;
355  if (ctx->frame_type)
356  ctx->mb_height = (avctx->height + 31) >> 5;
357  else
358  ctx->mb_height = (avctx->height + 15) >> 4;
359 
360  // QT ignores the written value
361  // slice_count = AV_RB16(buf + 5);
362  slice_count = ctx->mb_height * ((ctx->mb_width >> log2_slice_mb_width) +
363  av_popcount(ctx->mb_width & (1 << log2_slice_mb_width) - 1));
364 
365  if (ctx->slice_count != slice_count || !ctx->slices) {
366  av_freep(&ctx->slices);
367  ctx->slice_count = 0;
368  ctx->slices = av_calloc(slice_count, sizeof(*ctx->slices));
369  if (!ctx->slices)
370  return AVERROR(ENOMEM);
371  ctx->slice_count = slice_count;
372  }
373 
374  if (!slice_count)
375  return AVERROR(EINVAL);
376 
377  if (hdr_size + slice_count*2 > buf_size) {
378  av_log(avctx, AV_LOG_ERROR, "error, wrong slice count\n");
379  return AVERROR_INVALIDDATA;
380  }
381 
382  // parse slice information
383  index_ptr = buf + hdr_size;
384  data_ptr = index_ptr + slice_count*2;
385 
386  slice_mb_count = 1 << log2_slice_mb_width;
387  mb_x = 0;
388  mb_y = 0;
389 
390  for (i = 0; i < slice_count; i++) {
391  SliceContext *slice = &ctx->slices[i];
392 
393  slice->data = data_ptr;
394  data_ptr += AV_RB16(index_ptr + i*2);
395 
396  while (ctx->mb_width - mb_x < slice_mb_count)
397  slice_mb_count >>= 1;
398 
399  slice->mb_x = mb_x;
400  slice->mb_y = mb_y;
401  slice->mb_count = slice_mb_count;
402  slice->data_size = data_ptr - slice->data;
403 
404  if (slice->data_size < 6) {
405  av_log(avctx, AV_LOG_ERROR, "error, wrong slice data size\n");
406  return AVERROR_INVALIDDATA;
407  }
408 
409  mb_x += slice_mb_count;
410  if (mb_x == ctx->mb_width) {
411  slice_mb_count = 1 << log2_slice_mb_width;
412  mb_x = 0;
413  mb_y++;
414  }
415  if (data_ptr > buf + buf_size) {
416  av_log(avctx, AV_LOG_ERROR, "error, slice out of bounds\n");
417  return AVERROR_INVALIDDATA;
418  }
419  }
420 
421  if (mb_x || mb_y != ctx->mb_height) {
422  av_log(avctx, AV_LOG_ERROR, "error wrong mb count y %d h %d\n",
423  mb_y, ctx->mb_height);
424  return AVERROR_INVALIDDATA;
425  }
426 
427  return pic_data_size;
428 }
429 
430 #define DECODE_CODEWORD(val, codebook, SKIP) \
431  do { \
432  unsigned int rice_order, exp_order, switch_bits; \
433  unsigned int q, buf, bits; \
434  \
435  UPDATE_CACHE(re, gb); \
436  buf = GET_CACHE(re, gb); \
437  \
438  /* number of bits to switch between rice and exp golomb */ \
439  switch_bits = codebook & 3; \
440  rice_order = codebook >> 5; \
441  exp_order = (codebook >> 2) & 7; \
442  \
443  q = 31 - av_log2(buf); \
444  \
445  if (q > switch_bits) { /* exp golomb */ \
446  bits = exp_order - switch_bits + (q<<1); \
447  if (bits > FFMIN(MIN_CACHE_BITS, 31)) \
448  return AVERROR_INVALIDDATA; \
449  val = SHOW_UBITS(re, gb, bits) - (1 << exp_order) + \
450  ((switch_bits + 1) << rice_order); \
451  SKIP(re, gb, bits); \
452  } else if (rice_order) { \
453  SKIP_BITS(re, gb, q+1); \
454  val = (q << rice_order) + SHOW_UBITS(re, gb, rice_order); \
455  SKIP(re, gb, rice_order); \
456  } else { \
457  val = q; \
458  SKIP(re, gb, q+1); \
459  } \
460  } while (0)
461 
462 #define TOSIGNED(x) (((x) >> 1) ^ (-((x) & 1)))
463 
464 #define FIRST_DC_CB 0xB8
465 
466 static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
467 
469  int blocks_per_slice)
470 {
471  int16_t prev_dc;
472  int code, i, sign;
473 
474  OPEN_READER(re, gb);
475 
477  prev_dc = TOSIGNED(code);
478  out[0] = prev_dc;
479 
480  out += 64; // dc coeff for the next block
481 
482  code = 5;
483  sign = 0;
484  for (i = 1; i < blocks_per_slice; i++, out += 64) {
486  if(code) sign ^= -(code & 1);
487  else sign = 0;
488  prev_dc += (((code + 1) >> 1) ^ sign) - sign;
489  out[0] = prev_dc;
490  }
491  CLOSE_READER(re, gb);
492  return 0;
493 }
494 
495 // adaptive codebook switching lut according to previous run/level values
496 static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29, 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };
497 static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28, 0x28, 0x28, 0x28, 0x4C };
498 
500  int16_t *out, int blocks_per_slice)
501 {
502  const ProresContext *ctx = avctx->priv_data;
503  int block_mask, sign;
504  unsigned pos, run, level;
505  int max_coeffs, i, bits_left;
506  int log2_block_count = av_log2(blocks_per_slice);
507 
508  OPEN_READER(re, gb);
509  UPDATE_CACHE(re, gb); \
510  run = 4;
511  level = 2;
512 
513  max_coeffs = 64 << log2_block_count;
514  block_mask = blocks_per_slice - 1;
515 
516  for (pos = block_mask;;) {
517  bits_left = gb->size_in_bits - re_index;
518  if (!bits_left || (bits_left < 32 && !SHOW_UBITS(re, gb, bits_left)))
519  break;
520 
522  pos += run + 1;
523  if (pos >= max_coeffs) {
524  av_log(avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", pos, max_coeffs);
525  return AVERROR_INVALIDDATA;
526  }
527 
529  level += 1;
530 
531  i = pos >> log2_block_count;
532 
533  sign = SHOW_SBITS(re, gb, 1);
534  SKIP_BITS(re, gb, 1);
535  out[((pos & block_mask) << 6) + ctx->scan[i]] = ((level ^ sign) - sign);
536  }
537 
538  CLOSE_READER(re, gb);
539  return 0;
540 }
541 
543  uint16_t *dst, int dst_stride,
544  const uint8_t *buf, unsigned buf_size,
545  const int16_t *qmat)
546 {
547  const ProresContext *ctx = avctx->priv_data;
548  LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);
549  int16_t *block;
550  GetBitContext gb;
551  int i, blocks_per_slice = slice->mb_count<<2;
552  int ret;
553 
554  for (i = 0; i < blocks_per_slice; i++)
555  ctx->bdsp.clear_block(blocks+(i<<6));
556 
557  init_get_bits(&gb, buf, buf_size << 3);
558 
559  if ((ret = decode_dc_coeffs(&gb, blocks, blocks_per_slice)) < 0)
560  return ret;
561  if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)
562  return ret;
563 
564  block = blocks;
565  for (i = 0; i < slice->mb_count; i++) {
566  ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat);
567  ctx->prodsp.idct_put(dst +8, dst_stride, block+(1<<6), qmat);
568  ctx->prodsp.idct_put(dst+4*dst_stride , dst_stride, block+(2<<6), qmat);
569  ctx->prodsp.idct_put(dst+4*dst_stride+8, dst_stride, block+(3<<6), qmat);
570  block += 4*64;
571  dst += 16;
572  }
573  return 0;
574 }
575 
577  uint16_t *dst, int dst_stride,
578  const uint8_t *buf, unsigned buf_size,
579  const int16_t *qmat, int log2_blocks_per_mb)
580 {
581  ProresContext *ctx = avctx->priv_data;
582  LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);
583  int16_t *block;
584  GetBitContext gb;
585  int i, j, blocks_per_slice = slice->mb_count << log2_blocks_per_mb;
586  int ret;
587 
588  for (i = 0; i < blocks_per_slice; i++)
589  ctx->bdsp.clear_block(blocks+(i<<6));
590 
591  init_get_bits(&gb, buf, buf_size << 3);
592 
593  if ((ret = decode_dc_coeffs(&gb, blocks, blocks_per_slice)) < 0)
594  return ret;
595  if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)
596  return ret;
597 
598  block = blocks;
599  for (i = 0; i < slice->mb_count; i++) {
600  for (j = 0; j < log2_blocks_per_mb; j++) {
601  ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat);
602  ctx->prodsp.idct_put(dst+4*dst_stride, dst_stride, block+(1<<6), qmat);
603  block += 2*64;
604  dst += 8;
605  }
606  }
607  return 0;
608 }
609 
610 /**
611  * Decode alpha slice plane.
612  */
614  uint16_t *dst, int dst_stride,
615  const uint8_t *buf, int buf_size,
616  int blocks_per_slice)
617 {
618  GetBitContext gb;
619  int i;
620  LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);
621  int16_t *block;
622 
623  for (i = 0; i < blocks_per_slice<<2; i++)
624  ctx->bdsp.clear_block(blocks+(i<<6));
625 
626  init_get_bits(&gb, buf, buf_size << 3);
627 
628  if (ctx->alpha_info == 2) {
629  ctx->unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 16);
630  } else {
631  ctx->unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 8);
632  }
633 
634  block = blocks;
635 
636  for (i = 0; i < 16; i++) {
637  memcpy(dst, block, 16 * blocks_per_slice * sizeof(*dst));
638  dst += dst_stride >> 1;
639  block += 16 * blocks_per_slice;
640  }
641 }
642 
643 static int decode_slice_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
644 {
645  const ProresContext *ctx = avctx->priv_data;
646  SliceContext *slice = &ctx->slices[jobnr];
647  const uint8_t *buf = slice->data;
648  AVFrame *pic = ctx->frame;
649  int i, hdr_size, qscale, log2_chroma_blocks_per_mb;
650  int luma_stride, chroma_stride;
651  int y_data_size, u_data_size, v_data_size, a_data_size, offset;
652  uint8_t *dest_y, *dest_u, *dest_v;
653  LOCAL_ALIGNED_16(int16_t, qmat_luma_scaled, [64]);
654  LOCAL_ALIGNED_16(int16_t, qmat_chroma_scaled,[64]);
655  int mb_x_shift;
656  int ret;
657  uint16_t val_no_chroma;
658 
659  slice->ret = -1;
660  //av_log(avctx, AV_LOG_INFO, "slice %d mb width %d mb x %d y %d\n",
661  // jobnr, slice->mb_count, slice->mb_x, slice->mb_y);
662 
663  // slice header
664  hdr_size = buf[0] >> 3;
665  qscale = av_clip(buf[1], 1, 224);
666  qscale = qscale > 128 ? qscale - 96 << 2: qscale;
667  y_data_size = AV_RB16(buf + 2);
668  u_data_size = AV_RB16(buf + 4);
669  v_data_size = slice->data_size - y_data_size - u_data_size - hdr_size;
670  if (hdr_size > 7) v_data_size = AV_RB16(buf + 6);
671  a_data_size = slice->data_size - y_data_size - u_data_size -
672  v_data_size - hdr_size;
673 
674  if (y_data_size < 0 || u_data_size < 0 || v_data_size < 0
675  || hdr_size+y_data_size+u_data_size+v_data_size > slice->data_size){
676  av_log(avctx, AV_LOG_ERROR, "invalid plane data size\n");
677  return AVERROR_INVALIDDATA;
678  }
679 
680  buf += hdr_size;
681 
682  for (i = 0; i < 64; i++) {
683  qmat_luma_scaled [i] = ctx->qmat_luma [i] * qscale;
684  qmat_chroma_scaled[i] = ctx->qmat_chroma[i] * qscale;
685  }
686 
687  if (ctx->frame_type == 0) {
688  luma_stride = pic->linesize[0];
689  chroma_stride = pic->linesize[1];
690  } else {
691  luma_stride = pic->linesize[0] << 1;
692  chroma_stride = pic->linesize[1] << 1;
693  }
694 
695  if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10 || avctx->pix_fmt == AV_PIX_FMT_YUVA444P10 ||
697  mb_x_shift = 5;
698  log2_chroma_blocks_per_mb = 2;
699  } else {
700  mb_x_shift = 4;
701  log2_chroma_blocks_per_mb = 1;
702  }
703 
704  offset = (slice->mb_y << 4) * luma_stride + (slice->mb_x << 5);
705  dest_y = pic->data[0] + offset;
706  dest_u = pic->data[1] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift);
707  dest_v = pic->data[2] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift);
708 
709  if (ctx->frame_type && ctx->first_field ^ ctx->frame->top_field_first) {
710  dest_y += pic->linesize[0];
711  dest_u += pic->linesize[1];
712  dest_v += pic->linesize[2];
713  offset += pic->linesize[3];
714  }
715 
716  ret = decode_slice_luma(avctx, slice, (uint16_t*)dest_y, luma_stride,
717  buf, y_data_size, qmat_luma_scaled);
718  if (ret < 0)
719  return ret;
720 
721  if (!(avctx->flags & AV_CODEC_FLAG_GRAY) && (u_data_size + v_data_size) > 0) {
722  ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_u, chroma_stride,
723  buf + y_data_size, u_data_size,
724  qmat_chroma_scaled, log2_chroma_blocks_per_mb);
725  if (ret < 0)
726  return ret;
727 
728  ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_v, chroma_stride,
729  buf + y_data_size + u_data_size, v_data_size,
730  qmat_chroma_scaled, log2_chroma_blocks_per_mb);
731  if (ret < 0)
732  return ret;
733  }
734  else {
735  size_t mb_max_x = slice->mb_count << (mb_x_shift - 1);
736  size_t i, j;
737  if (avctx->bits_per_raw_sample == 10) {
738  val_no_chroma = 511;
739  } else { /* 12b */
740  val_no_chroma = 511 * 4;
741  }
742  for (i = 0; i < 16; ++i)
743  for (j = 0; j < mb_max_x; ++j) {
744  *(uint16_t*)(dest_u + (i * chroma_stride) + (j << 1)) = val_no_chroma;
745  *(uint16_t*)(dest_v + (i * chroma_stride) + (j << 1)) = val_no_chroma;
746  }
747  }
748 
749  /* decode alpha plane if available */
750  if (ctx->alpha_info && pic->data[3] && a_data_size) {
751  uint8_t *dest_a = pic->data[3] + offset;
752  decode_slice_alpha(ctx, (uint16_t*)dest_a, luma_stride,
753  buf + y_data_size + u_data_size + v_data_size,
754  a_data_size, slice->mb_count);
755  }
756 
757  slice->ret = 0;
758  return 0;
759 }
760 
761 static int decode_picture(AVCodecContext *avctx)
762 {
763  ProresContext *ctx = avctx->priv_data;
764  int i;
765  int error = 0;
766 
767  avctx->execute2(avctx, decode_slice_thread, NULL, NULL, ctx->slice_count);
768 
769  for (i = 0; i < ctx->slice_count; i++)
770  error += ctx->slices[i].ret < 0;
771 
772  if (error)
773  ctx->frame->decode_error_flags = FF_DECODE_ERROR_INVALID_BITSTREAM;
774  if (error < ctx->slice_count)
775  return 0;
776 
777  return ctx->slices[0].ret;
778 }
779 
781  int *got_frame, AVPacket *avpkt)
782 {
783  ProresContext *ctx = avctx->priv_data;
784  const uint8_t *buf = avpkt->data;
785  int buf_size = avpkt->size;
786  int frame_hdr_size, pic_size, ret;
787 
788  if (buf_size < 28 || AV_RL32(buf + 4) != AV_RL32("icpf")) {
789  av_log(avctx, AV_LOG_ERROR, "invalid frame header\n");
790  return AVERROR_INVALIDDATA;
791  }
792 
793  ctx->frame = frame;
794  ctx->frame->pict_type = AV_PICTURE_TYPE_I;
795  ctx->frame->key_frame = 1;
796  ctx->first_field = 1;
797 
798  buf += 8;
799  buf_size -= 8;
800 
801  frame_hdr_size = decode_frame_header(ctx, buf, buf_size, avctx);
802  if (frame_hdr_size < 0)
803  return frame_hdr_size;
804 
805  buf += frame_hdr_size;
806  buf_size -= frame_hdr_size;
807 
808  if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0)
809  return ret;
810  ff_thread_finish_setup(avctx);
811 
812  if (avctx->hwaccel) {
813  ret = avctx->hwaccel->start_frame(avctx, NULL, 0);
814  if (ret < 0)
815  return ret;
816  ret = avctx->hwaccel->decode_slice(avctx, avpkt->data, avpkt->size);
817  if (ret < 0)
818  return ret;
819  ret = avctx->hwaccel->end_frame(avctx);
820  if (ret < 0)
821  return ret;
822  goto finish;
823  }
824 
826  pic_size = decode_picture_header(avctx, buf, buf_size);
827  if (pic_size < 0) {
828  av_log(avctx, AV_LOG_ERROR, "error decoding picture header\n");
829  return pic_size;
830  }
831 
832  if ((ret = decode_picture(avctx)) < 0) {
833  av_log(avctx, AV_LOG_ERROR, "error decoding picture\n");
834  return ret;
835  }
836 
837  buf += pic_size;
838  buf_size -= pic_size;
839 
840  if (ctx->frame_type && buf_size > 0 && ctx->first_field) {
841  ctx->first_field = 0;
842  goto decode_picture;
843  }
844 
845 finish:
846  *got_frame = 1;
847 
848  return avpkt->size;
849 }
850 
852 {
853  ProresContext *ctx = avctx->priv_data;
854 
855  av_freep(&ctx->slices);
856 
857  return 0;
858 }
859 
860 #if HAVE_THREADS
862 {
863  ProresContext *csrc = src->priv_data;
864  ProresContext *cdst = dst->priv_data;
865 
866  cdst->pix_fmt = csrc->pix_fmt;
867 
868  return 0;
869 }
870 #endif
871 
873  .p.name = "prores",
874  CODEC_LONG_NAME("Apple ProRes (iCodec Pro)"),
875  .p.type = AVMEDIA_TYPE_VIDEO,
876  .p.id = AV_CODEC_ID_PRORES,
877  .priv_data_size = sizeof(ProresContext),
878  .init = decode_init,
879  .close = decode_close,
884  .hw_configs = (const AVCodecHWConfigInternal *const []) {
885 #if CONFIG_PRORES_VIDEOTOOLBOX_HWACCEL
886  HWACCEL_VIDEOTOOLBOX(prores),
887 #endif
888  NULL
889  },
890 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
hwconfig.h
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1369
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
DECODE_CODEWORD
#define DECODE_CODEWORD(val, codebook, SKIP)
Definition: proresdec2.c:430
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
FF_PROFILE_PRORES_XQ
#define FF_PROFILE_PRORES_XQ
Definition: avcodec.h:1663
level
uint8_t level
Definition: svq3.c:204
av_clip
#define av_clip
Definition: common.h:95
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
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:975
mem_internal.h
out
FILE * out
Definition: movenc.c:54
ff_prores_profiles
const AVProfile ff_prores_profiles[]
Definition: profiles.c:159
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:325
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:968
AVPacket::data
uint8_t * data
Definition: packet.h:374
ProresContext
Definition: proresdec.h:38
TOSIGNED
#define TOSIGNED(x)
Definition: proresdec2.c:462
SliceContext::mb_x
unsigned mb_x
Definition: proresdec.h:31
FFCodec
Definition: codec_internal.h:119
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
av_popcount
#define av_popcount
Definition: common.h:149
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:91
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:497
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:649
thread.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
finish
static void finish(void)
Definition: movenc.c:342
ProresContext::pix_fmt
enum AVPixelFormat pix_fmt
Definition: proresdec.h:55
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:478
proresdec.h
val
static double val(void *priv, double ch)
Definition: aeval.c:77
FF_PROFILE_PRORES_LT
#define FF_PROFILE_PRORES_LT
Definition: avcodec.h:1659
ALPHA_SHIFT_8_TO_10
#define ALPHA_SHIFT_8_TO_10(alpha_val)
Definition: proresdec2.c:55
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:462
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:59
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:961
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
ff_prores_decoder
const FFCodec ff_prores_decoder
Definition: proresdec2.c:872
FIRST_DC_CB
#define FIRST_DC_CB
Definition: proresdec2.c:464
mask
static const uint16_t mask[17]
Definition: lzw.c:38
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
decode_picture_header
static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size)
Definition: proresdec2.c:325
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:298
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c)
Definition: blockdsp.c:58
SliceContext::data_size
unsigned data_size
Definition: proresdec.h:34
decode_picture
static int decode_picture(AVCodecContext *avctx)
Definition: proresdec2.c:761
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
permute
static void permute(uint8_t *dst, const uint8_t *src, const uint8_t permutation[64])
Definition: proresdec2.c:47
LOCAL_ALIGNED_16
#define LOCAL_ALIGNED_16(t, v,...)
Definition: mem_internal.h:131
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1551
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:296
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:500
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1451
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:48
decode.h
get_bits.h
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:41
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
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
arg
const char * arg
Definition: jacosubdec.c:67
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:113
NULL
#define NULL
Definition: coverity.c:32
FF_DECODE_ERROR_INVALID_BITSTREAM
#define FF_DECODE_ERROR_INVALID_BITSTREAM
Definition: frame.h:635
LOCAL_ALIGNED_32
#define LOCAL_ALIGNED_32(t, v,...)
Definition: mem_internal.h:137
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
run
uint8_t run
Definition: svq3.c:203
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:982
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:499
SliceContext::ret
int ret
Definition: proresdec.h:35
AVHWAccel::end_frame
int(* end_frame)(AVCodecContext *avctx)
Called at the end of each frame or field picture.
Definition: avcodec.h:2170
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:496
profiles.h
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
UPDATE_THREAD_CONTEXT
#define UPDATE_THREAD_CONTEXT(func)
Definition: codec_internal.h:273
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:460
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:576
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:542
dc_codebook
static const uint8_t dc_codebook[7]
Definition: proresdec2.c:466
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
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
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:259
AVPacket::size
int size
Definition: packet.h:375
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:115
FF_PROFILE_PRORES_HQ
#define FF_PROFILE_PRORES_HQ
Definition: avcodec.h:1661
codec_internal.h
FF_PROFILE_PRORES_STANDARD
#define FF_PROFILE_PRORES_STANDARD
Definition: avcodec.h:1660
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:464
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:56
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:466
proresdata.h
ALPHA_SHIFT_8_TO_12
#define ALPHA_SHIFT_8_TO_12(alpha_val)
Definition: proresdec2.c:57
AVCodecContext::skip_alpha
int skip_alpha
Skip processing alpha if supported by codec.
Definition: avcodec.h:1799
decode_close
static av_cold int decode_close(AVCodecContext *avctx)
Definition: proresdec2.c:851
AVCodecHWConfigInternal
Definition: hwconfig.h:29
decode_frame_header
static int decode_frame_header(ProresContext *ctx, const uint8_t *buf, const int data_size, AVCodecContext *avctx)
Definition: proresdec2.c:206
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
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:117
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:498
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:313
AV_PIX_FMT_VIDEOTOOLBOX
@ AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
Definition: pixfmt.h:302
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
AVHWAccel::decode_slice
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
Definition: avcodec.h:2159
internal.h
SliceContext::data
const uint8_t * data
Definition: proresdec.h:30
HWACCEL_MAX
#define HWACCEL_MAX
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: proresdec2.c:780
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: proresdec2.c:613
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
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. If there are inter-frame dependencies
AVCodecContext::height
int height
Definition: avcodec.h:571
lev_to_cb
static const uint8_t lev_to_cb[10]
Definition: proresdec2.c:497
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:644
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
HWACCEL_VIDEOTOOLBOX
#define HWACCEL_VIDEOTOOLBOX(codec)
Definition: hwconfig.h:77
idctdsp.h
avcodec.h
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
FF_PROFILE_PRORES_4444
#define FF_PROFILE_PRORES_4444
Definition: avcodec.h:1662
FF_PROFILE_PRORES_PROXY
#define FF_PROFILE_PRORES_PROXY
Definition: avcodec.h:1658
unpack_alpha_10
static void unpack_alpha_10(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits)
Definition: proresdec2.c:120
pos
unsigned int pos
Definition: spdifenc.c:412
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:398
ALPHA_SHIFT_16_TO_10
#define ALPHA_SHIFT_16_TO_10(alpha_val)
Definition: proresdec2.c:54
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:499
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1550
ff_thread_get_format
FF_DISABLE_DEPRECATION_WARNINGS enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
Definition: pthread_frame.c:1042
decode_dc_coeffs
static av_always_inline int decode_dc_coeffs(GetBitContext *gb, int16_t *out, int blocks_per_slice)
Definition: proresdec2.c:468
AVHWAccel::start_frame
int(* start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Called at the beginning of each frame or field picture.
Definition: avcodec.h:2132
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
decode_slice_thread
static int decode_slice_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
Definition: proresdec2.c:643
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
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: proresdec2.c:140
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:423
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
unpack_alpha_12
static void unpack_alpha_12(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits)
Definition: proresdec2.c:130
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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:370
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
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:1536
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
re
float re
Definition: fft.c:79