FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 "avcodec.h"
32 #include "get_bits.h"
33 #include "idctdsp.h"
34 #include "internal.h"
35 #include "simple_idct.h"
36 #include "proresdec.h"
37 #include "proresdata.h"
38 
39 static void permute(uint8_t *dst, const uint8_t *src, const uint8_t permutation[64])
40 {
41  int i;
42  for (i = 0; i < 64; i++)
43  dst[i] = permutation[src[i]];
44 }
45 
46 static av_cold int decode_init(AVCodecContext *avctx)
47 {
48  ProresContext *ctx = avctx->priv_data;
49  uint8_t idct_permutation[64];
50 
51  avctx->bits_per_raw_sample = 10;
52 
53  ff_blockdsp_init(&ctx->bdsp, avctx);
54  ff_proresdsp_init(&ctx->prodsp, avctx);
55 
56  ff_init_scantable_permutation(idct_permutation,
57  ctx->prodsp.idct_permutation_type);
58 
59  permute(ctx->progressive_scan, ff_prores_progressive_scan, idct_permutation);
60  permute(ctx->interlaced_scan, ff_prores_interlaced_scan, idct_permutation);
61 
62  return 0;
63 }
64 
65 static int decode_frame_header(ProresContext *ctx, const uint8_t *buf,
66  const int data_size, AVCodecContext *avctx)
67 {
68  int hdr_size, width, height, flags;
69  int version;
70  const uint8_t *ptr;
71 
72  hdr_size = AV_RB16(buf);
73  av_dlog(avctx, "header size %d\n", hdr_size);
74  if (hdr_size > data_size) {
75  av_log(avctx, AV_LOG_ERROR, "error, wrong header size\n");
76  return AVERROR_INVALIDDATA;
77  }
78 
79  version = AV_RB16(buf + 2);
80  av_dlog(avctx, "%.4s version %d\n", buf+4, version);
81  if (version > 1) {
82  av_log(avctx, AV_LOG_ERROR, "unsupported version: %d\n", version);
83  return AVERROR_PATCHWELCOME;
84  }
85 
86  width = AV_RB16(buf + 8);
87  height = AV_RB16(buf + 10);
88  if (width != avctx->width || height != avctx->height) {
89  av_log(avctx, AV_LOG_ERROR, "picture resolution change: %dx%d -> %dx%d\n",
90  avctx->width, avctx->height, width, height);
91  return AVERROR_PATCHWELCOME;
92  }
93 
94  ctx->frame_type = (buf[12] >> 2) & 3;
95  ctx->alpha_info = buf[17] & 0xf;
96 
97  if (ctx->alpha_info > 2) {
98  av_log(avctx, AV_LOG_ERROR, "Invalid alpha mode %d\n", ctx->alpha_info);
99  return AVERROR_INVALIDDATA;
100  }
101  if (avctx->skip_alpha) ctx->alpha_info = 0;
102 
103  av_dlog(avctx, "frame type %d\n", ctx->frame_type);
104 
105  if (ctx->frame_type == 0) {
106  ctx->scan = ctx->progressive_scan; // permuted
107  } else {
108  ctx->scan = ctx->interlaced_scan; // permuted
109  ctx->frame->interlaced_frame = 1;
110  ctx->frame->top_field_first = ctx->frame_type == 1;
111  }
112 
113  if (ctx->alpha_info) {
114  avctx->pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUVA444P10 : AV_PIX_FMT_YUVA422P10;
115  } else {
116  avctx->pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUV444P10 : AV_PIX_FMT_YUV422P10;
117  }
118 
119  ptr = buf + 20;
120  flags = buf[19];
121  av_dlog(avctx, "flags %x\n", flags);
122 
123  if (flags & 2) {
124  if(buf + data_size - ptr < 64) {
125  av_log(avctx, AV_LOG_ERROR, "Header truncated\n");
126  return AVERROR_INVALIDDATA;
127  }
128  permute(ctx->qmat_luma, ctx->prodsp.idct_permutation, ptr);
129  ptr += 64;
130  } else {
131  memset(ctx->qmat_luma, 4, 64);
132  }
133 
134  if (flags & 1) {
135  if(buf + data_size - ptr < 64) {
136  av_log(avctx, AV_LOG_ERROR, "Header truncated\n");
137  return AVERROR_INVALIDDATA;
138  }
139  permute(ctx->qmat_chroma, ctx->prodsp.idct_permutation, ptr);
140  } else {
141  memset(ctx->qmat_chroma, 4, 64);
142  }
143 
144  return hdr_size;
145 }
146 
147 static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size)
148 {
149  ProresContext *ctx = avctx->priv_data;
150  int i, hdr_size, slice_count;
151  unsigned pic_data_size;
152  int log2_slice_mb_width, log2_slice_mb_height;
153  int slice_mb_count, mb_x, mb_y;
154  const uint8_t *data_ptr, *index_ptr;
155 
156  hdr_size = buf[0] >> 3;
157  if (hdr_size < 8 || hdr_size > buf_size) {
158  av_log(avctx, AV_LOG_ERROR, "error, wrong picture header size\n");
159  return AVERROR_INVALIDDATA;
160  }
161 
162  pic_data_size = AV_RB32(buf + 1);
163  if (pic_data_size > buf_size) {
164  av_log(avctx, AV_LOG_ERROR, "error, wrong picture data size\n");
165  return AVERROR_INVALIDDATA;
166  }
167 
168  log2_slice_mb_width = buf[7] >> 4;
169  log2_slice_mb_height = buf[7] & 0xF;
170  if (log2_slice_mb_width > 3 || log2_slice_mb_height) {
171  av_log(avctx, AV_LOG_ERROR, "unsupported slice resolution: %dx%d\n",
172  1 << log2_slice_mb_width, 1 << log2_slice_mb_height);
173  return AVERROR_INVALIDDATA;
174  }
175 
176  ctx->mb_width = (avctx->width + 15) >> 4;
177  if (ctx->frame_type)
178  ctx->mb_height = (avctx->height + 31) >> 5;
179  else
180  ctx->mb_height = (avctx->height + 15) >> 4;
181 
182  slice_count = AV_RB16(buf + 5);
183 
184  if (ctx->slice_count != slice_count || !ctx->slices) {
185  av_freep(&ctx->slices);
186  ctx->slices = av_mallocz_array(slice_count, sizeof(*ctx->slices));
187  if (!ctx->slices)
188  return AVERROR(ENOMEM);
189  ctx->slice_count = slice_count;
190  }
191 
192  if (!slice_count)
193  return AVERROR(EINVAL);
194 
195  if (hdr_size + slice_count*2 > buf_size) {
196  av_log(avctx, AV_LOG_ERROR, "error, wrong slice count\n");
197  return AVERROR_INVALIDDATA;
198  }
199 
200  // parse slice information
201  index_ptr = buf + hdr_size;
202  data_ptr = index_ptr + slice_count*2;
203 
204  slice_mb_count = 1 << log2_slice_mb_width;
205  mb_x = 0;
206  mb_y = 0;
207 
208  for (i = 0; i < slice_count; i++) {
209  SliceContext *slice = &ctx->slices[i];
210 
211  slice->data = data_ptr;
212  data_ptr += AV_RB16(index_ptr + i*2);
213 
214  while (ctx->mb_width - mb_x < slice_mb_count)
215  slice_mb_count >>= 1;
216 
217  slice->mb_x = mb_x;
218  slice->mb_y = mb_y;
219  slice->mb_count = slice_mb_count;
220  slice->data_size = data_ptr - slice->data;
221 
222  if (slice->data_size < 6) {
223  av_log(avctx, AV_LOG_ERROR, "error, wrong slice data size\n");
224  return AVERROR_INVALIDDATA;
225  }
226 
227  mb_x += slice_mb_count;
228  if (mb_x == ctx->mb_width) {
229  slice_mb_count = 1 << log2_slice_mb_width;
230  mb_x = 0;
231  mb_y++;
232  }
233  if (data_ptr > buf + buf_size) {
234  av_log(avctx, AV_LOG_ERROR, "error, slice out of bounds\n");
235  return AVERROR_INVALIDDATA;
236  }
237  }
238 
239  if (mb_x || mb_y != ctx->mb_height) {
240  av_log(avctx, AV_LOG_ERROR, "error wrong mb count y %d h %d\n",
241  mb_y, ctx->mb_height);
242  return AVERROR_INVALIDDATA;
243  }
244 
245  return pic_data_size;
246 }
247 
248 #define DECODE_CODEWORD(val, codebook) \
249  do { \
250  unsigned int rice_order, exp_order, switch_bits; \
251  unsigned int q, buf, bits; \
252  \
253  UPDATE_CACHE(re, gb); \
254  buf = GET_CACHE(re, gb); \
255  \
256  /* number of bits to switch between rice and exp golomb */ \
257  switch_bits = codebook & 3; \
258  rice_order = codebook >> 5; \
259  exp_order = (codebook >> 2) & 7; \
260  \
261  q = 31 - av_log2(buf); \
262  \
263  if (q > switch_bits) { /* exp golomb */ \
264  bits = exp_order - switch_bits + (q<<1); \
265  val = SHOW_UBITS(re, gb, bits) - (1 << exp_order) + \
266  ((switch_bits + 1) << rice_order); \
267  SKIP_BITS(re, gb, bits); \
268  } else if (rice_order) { \
269  SKIP_BITS(re, gb, q+1); \
270  val = (q << rice_order) + SHOW_UBITS(re, gb, rice_order); \
271  SKIP_BITS(re, gb, rice_order); \
272  } else { \
273  val = q; \
274  SKIP_BITS(re, gb, q+1); \
275  } \
276  } while (0)
277 
278 #define TOSIGNED(x) (((x) >> 1) ^ (-((x) & 1)))
279 
280 #define FIRST_DC_CB 0xB8
281 
282 static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
283 
284 static av_always_inline void decode_dc_coeffs(GetBitContext *gb, int16_t *out,
285  int blocks_per_slice)
286 {
287  int16_t prev_dc;
288  int code, i, sign;
289 
290  OPEN_READER(re, gb);
291 
292  DECODE_CODEWORD(code, FIRST_DC_CB);
293  prev_dc = TOSIGNED(code);
294  out[0] = prev_dc;
295 
296  out += 64; // dc coeff for the next block
297 
298  code = 5;
299  sign = 0;
300  for (i = 1; i < blocks_per_slice; i++, out += 64) {
301  DECODE_CODEWORD(code, dc_codebook[FFMIN(code, 6U)]);
302  if(code) sign ^= -(code & 1);
303  else sign = 0;
304  prev_dc += (((code + 1) >> 1) ^ sign) - sign;
305  out[0] = prev_dc;
306  }
307  CLOSE_READER(re, gb);
308 }
309 
310 // adaptive codebook switching lut according to previous run/level values
311 static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29, 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };
312 static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28, 0x28, 0x28, 0x28, 0x4C };
313 
314 static av_always_inline int decode_ac_coeffs(AVCodecContext *avctx, GetBitContext *gb,
315  int16_t *out, int blocks_per_slice)
316 {
317  ProresContext *ctx = avctx->priv_data;
318  int block_mask, sign;
319  unsigned pos, run, level;
320  int max_coeffs, i, bits_left;
321  int log2_block_count = av_log2(blocks_per_slice);
322 
323  OPEN_READER(re, gb);
324  UPDATE_CACHE(re, gb); \
325  run = 4;
326  level = 2;
327 
328  max_coeffs = 64 << log2_block_count;
329  block_mask = blocks_per_slice - 1;
330 
331  for (pos = block_mask;;) {
332  bits_left = gb->size_in_bits - re_index;
333  if (!bits_left || (bits_left < 32 && !SHOW_UBITS(re, gb, bits_left)))
334  break;
335 
336  DECODE_CODEWORD(run, run_to_cb[FFMIN(run, 15)]);
337  pos += run + 1;
338  if (pos >= max_coeffs) {
339  av_log(avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", pos, max_coeffs);
340  return AVERROR_INVALIDDATA;
341  }
342 
343  DECODE_CODEWORD(level, lev_to_cb[FFMIN(level, 9)]);
344  level += 1;
345 
346  i = pos >> log2_block_count;
347 
348  sign = SHOW_SBITS(re, gb, 1);
349  SKIP_BITS(re, gb, 1);
350  out[((pos & block_mask) << 6) + ctx->scan[i]] = ((level ^ sign) - sign);
351  }
352 
353  CLOSE_READER(re, gb);
354  return 0;
355 }
356 
357 static int decode_slice_luma(AVCodecContext *avctx, SliceContext *slice,
358  uint16_t *dst, int dst_stride,
359  const uint8_t *buf, unsigned buf_size,
360  const int16_t *qmat)
361 {
362  ProresContext *ctx = avctx->priv_data;
363  LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]);
364  int16_t *block;
365  GetBitContext gb;
366  int i, blocks_per_slice = slice->mb_count<<2;
367  int ret;
368 
369  for (i = 0; i < blocks_per_slice; i++)
370  ctx->bdsp.clear_block(blocks+(i<<6));
371 
372  init_get_bits(&gb, buf, buf_size << 3);
373 
374  decode_dc_coeffs(&gb, blocks, blocks_per_slice);
375  if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)
376  return ret;
377 
378  block = blocks;
379  for (i = 0; i < slice->mb_count; i++) {
380  ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat);
381  ctx->prodsp.idct_put(dst +8, dst_stride, block+(1<<6), qmat);
382  ctx->prodsp.idct_put(dst+4*dst_stride , dst_stride, block+(2<<6), qmat);
383  ctx->prodsp.idct_put(dst+4*dst_stride+8, dst_stride, block+(3<<6), qmat);
384  block += 4*64;
385  dst += 16;
386  }
387  return 0;
388 }
389 
390 static int decode_slice_chroma(AVCodecContext *avctx, SliceContext *slice,
391  uint16_t *dst, int dst_stride,
392  const uint8_t *buf, unsigned buf_size,
393  const int16_t *qmat, int log2_blocks_per_mb)
394 {
395  ProresContext *ctx = avctx->priv_data;
396  LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]);
397  int16_t *block;
398  GetBitContext gb;
399  int i, j, blocks_per_slice = slice->mb_count << log2_blocks_per_mb;
400  int ret;
401 
402  for (i = 0; i < blocks_per_slice; i++)
403  ctx->bdsp.clear_block(blocks+(i<<6));
404 
405  init_get_bits(&gb, buf, buf_size << 3);
406 
407  decode_dc_coeffs(&gb, blocks, blocks_per_slice);
408  if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)
409  return ret;
410 
411  block = blocks;
412  for (i = 0; i < slice->mb_count; i++) {
413  for (j = 0; j < log2_blocks_per_mb; j++) {
414  ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat);
415  ctx->prodsp.idct_put(dst+4*dst_stride, dst_stride, block+(1<<6), qmat);
416  block += 2*64;
417  dst += 8;
418  }
419  }
420  return 0;
421 }
422 
423 static void unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs,
424  const int num_bits)
425 {
426  const int mask = (1 << num_bits) - 1;
427  int i, idx, val, alpha_val;
428 
429  idx = 0;
430  alpha_val = mask;
431  do {
432  do {
433  if (get_bits1(gb)) {
434  val = get_bits(gb, num_bits);
435  } else {
436  int sign;
437  val = get_bits(gb, num_bits == 16 ? 7 : 4);
438  sign = val & 1;
439  val = (val + 2) >> 1;
440  if (sign)
441  val = -val;
442  }
443  alpha_val = (alpha_val + val) & mask;
444  if (num_bits == 16) {
445  dst[idx++] = alpha_val >> 6;
446  } else {
447  dst[idx++] = (alpha_val << 2) | (alpha_val >> 6);
448  }
449  if (idx >= num_coeffs)
450  break;
451  } while (get_bits_left(gb)>0 && get_bits1(gb));
452  val = get_bits(gb, 4);
453  if (!val)
454  val = get_bits(gb, 11);
455  if (idx + val > num_coeffs)
456  val = num_coeffs - idx;
457  if (num_bits == 16) {
458  for (i = 0; i < val; i++)
459  dst[idx++] = alpha_val >> 6;
460  } else {
461  for (i = 0; i < val; i++)
462  dst[idx++] = (alpha_val << 2) | (alpha_val >> 6);
463 
464  }
465  } while (idx < num_coeffs);
466 }
467 
468 /**
469  * Decode alpha slice plane.
470  */
471 static void decode_slice_alpha(ProresContext *ctx,
472  uint16_t *dst, int dst_stride,
473  const uint8_t *buf, int buf_size,
474  int blocks_per_slice)
475 {
476  GetBitContext gb;
477  int i;
478  LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]);
479  int16_t *block;
480 
481  for (i = 0; i < blocks_per_slice<<2; i++)
482  ctx->bdsp.clear_block(blocks+(i<<6));
483 
484  init_get_bits(&gb, buf, buf_size << 3);
485 
486  if (ctx->alpha_info == 2) {
487  unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 16);
488  } else {
489  unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 8);
490  }
491 
492  block = blocks;
493  for (i = 0; i < 16; i++) {
494  memcpy(dst, block, 16 * blocks_per_slice * sizeof(*dst));
495  dst += dst_stride >> 1;
496  block += 16 * blocks_per_slice;
497  }
498 }
499 
500 static int decode_slice_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
501 {
502  ProresContext *ctx = avctx->priv_data;
503  SliceContext *slice = &ctx->slices[jobnr];
504  const uint8_t *buf = slice->data;
505  AVFrame *pic = ctx->frame;
506  int i, hdr_size, qscale, log2_chroma_blocks_per_mb;
507  int luma_stride, chroma_stride;
508  int y_data_size, u_data_size, v_data_size, a_data_size;
509  uint8_t *dest_y, *dest_u, *dest_v, *dest_a;
510  int16_t qmat_luma_scaled[64];
511  int16_t qmat_chroma_scaled[64];
512  int mb_x_shift;
513  int ret;
514 
515  slice->ret = -1;
516  //av_log(avctx, AV_LOG_INFO, "slice %d mb width %d mb x %d y %d\n",
517  // jobnr, slice->mb_count, slice->mb_x, slice->mb_y);
518 
519  // slice header
520  hdr_size = buf[0] >> 3;
521  qscale = av_clip(buf[1], 1, 224);
522  qscale = qscale > 128 ? qscale - 96 << 2: qscale;
523  y_data_size = AV_RB16(buf + 2);
524  u_data_size = AV_RB16(buf + 4);
525  v_data_size = slice->data_size - y_data_size - u_data_size - hdr_size;
526  if (hdr_size > 7) v_data_size = AV_RB16(buf + 6);
527  a_data_size = slice->data_size - y_data_size - u_data_size -
528  v_data_size - hdr_size;
529 
530  if (y_data_size < 0 || u_data_size < 0 || v_data_size < 0
531  || hdr_size+y_data_size+u_data_size+v_data_size > slice->data_size){
532  av_log(avctx, AV_LOG_ERROR, "invalid plane data size\n");
533  return AVERROR_INVALIDDATA;
534  }
535 
536  buf += hdr_size;
537 
538  for (i = 0; i < 64; i++) {
539  qmat_luma_scaled [i] = ctx->qmat_luma [i] * qscale;
540  qmat_chroma_scaled[i] = ctx->qmat_chroma[i] * qscale;
541  }
542 
543  if (ctx->frame_type == 0) {
544  luma_stride = pic->linesize[0];
545  chroma_stride = pic->linesize[1];
546  } else {
547  luma_stride = pic->linesize[0] << 1;
548  chroma_stride = pic->linesize[1] << 1;
549  }
550 
551  if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10 || avctx->pix_fmt == AV_PIX_FMT_YUVA444P10) {
552  mb_x_shift = 5;
553  log2_chroma_blocks_per_mb = 2;
554  } else {
555  mb_x_shift = 4;
556  log2_chroma_blocks_per_mb = 1;
557  }
558 
559  dest_y = pic->data[0] + (slice->mb_y << 4) * luma_stride + (slice->mb_x << 5);
560  dest_u = pic->data[1] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift);
561  dest_v = pic->data[2] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift);
562  dest_a = pic->data[3] + (slice->mb_y << 4) * luma_stride + (slice->mb_x << 5);
563 
564  if (ctx->frame_type && ctx->first_field ^ ctx->frame->top_field_first) {
565  dest_y += pic->linesize[0];
566  dest_u += pic->linesize[1];
567  dest_v += pic->linesize[2];
568  dest_a += pic->linesize[3];
569  }
570 
571  ret = decode_slice_luma(avctx, slice, (uint16_t*)dest_y, luma_stride,
572  buf, y_data_size, qmat_luma_scaled);
573  if (ret < 0)
574  return ret;
575 
576  if (!(avctx->flags & CODEC_FLAG_GRAY)) {
577  ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_u, chroma_stride,
578  buf + y_data_size, u_data_size,
579  qmat_chroma_scaled, log2_chroma_blocks_per_mb);
580  if (ret < 0)
581  return ret;
582 
583  ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_v, chroma_stride,
584  buf + y_data_size + u_data_size, v_data_size,
585  qmat_chroma_scaled, log2_chroma_blocks_per_mb);
586  if (ret < 0)
587  return ret;
588  }
589  /* decode alpha plane if available */
590  if (ctx->alpha_info && pic->data[3] && a_data_size)
591  decode_slice_alpha(ctx, (uint16_t*)dest_a, luma_stride,
592  buf + y_data_size + u_data_size + v_data_size,
593  a_data_size, slice->mb_count);
594 
595  slice->ret = 0;
596  return 0;
597 }
598 
599 static int decode_picture(AVCodecContext *avctx)
600 {
601  ProresContext *ctx = avctx->priv_data;
602  int i;
603 
604  avctx->execute2(avctx, decode_slice_thread, NULL, NULL, ctx->slice_count);
605 
606  for (i = 0; i < ctx->slice_count; i++)
607  if (ctx->slices[i].ret < 0)
608  return ctx->slices[i].ret;
609 
610  return 0;
611 }
612 
613 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
614  AVPacket *avpkt)
615 {
616  ProresContext *ctx = avctx->priv_data;
617  AVFrame *frame = data;
618  const uint8_t *buf = avpkt->data;
619  int buf_size = avpkt->size;
620  int frame_hdr_size, pic_size, ret;
621 
622  if (buf_size < 28 || AV_RL32(buf + 4) != AV_RL32("icpf")) {
623  av_log(avctx, AV_LOG_ERROR, "invalid frame header\n");
624  return AVERROR_INVALIDDATA;
625  }
626 
627  ctx->frame = frame;
628  ctx->frame->pict_type = AV_PICTURE_TYPE_I;
629  ctx->frame->key_frame = 1;
630  ctx->first_field = 1;
631 
632  buf += 8;
633  buf_size -= 8;
634 
635  frame_hdr_size = decode_frame_header(ctx, buf, buf_size, avctx);
636  if (frame_hdr_size < 0)
637  return frame_hdr_size;
638 
639  buf += frame_hdr_size;
640  buf_size -= frame_hdr_size;
641 
642  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
643  return ret;
644 
645  decode_picture:
646  pic_size = decode_picture_header(avctx, buf, buf_size);
647  if (pic_size < 0) {
648  av_log(avctx, AV_LOG_ERROR, "error decoding picture header\n");
649  return pic_size;
650  }
651 
652  if ((ret = decode_picture(avctx)) < 0) {
653  av_log(avctx, AV_LOG_ERROR, "error decoding picture\n");
654  return ret;
655  }
656 
657  buf += pic_size;
658  buf_size -= pic_size;
659 
660  if (ctx->frame_type && buf_size > 0 && ctx->first_field) {
661  ctx->first_field = 0;
662  goto decode_picture;
663  }
664 
665  *got_frame = 1;
666 
667  return avpkt->size;
668 }
669 
670 static av_cold int decode_close(AVCodecContext *avctx)
671 {
672  ProresContext *ctx = avctx->priv_data;
673 
674  av_freep(&ctx->slices);
675 
676  return 0;
677 }
678 
679 AVCodec ff_prores_decoder = {
680  .name = "prores",
681  .long_name = NULL_IF_CONFIG_SMALL("ProRes"),
682  .type = AVMEDIA_TYPE_VIDEO,
683  .id = AV_CODEC_ID_PRORES,
684  .priv_data_size = sizeof(ProresContext),
685  .init = decode_init,
686  .close = decode_close,
687  .decode = decode_frame,
688  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
689 };
Generated on Sun Mar 8 2015 02:34:58 for FFmpeg by   doxygen 1.8.2