2 * Apple ProRes compatible decoder
4 * Copyright (c) 2010-2011 Maxim Poliakovski
6 * This file is part of Libav.
8 * Libav is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * Libav is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with Libav; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * This is a decoder for Apple ProRes 422 SD/HQ/LT/Proxy and ProRes 4444.
26 * It is used for storing and editing high definition video data in Apple's Final Cut Pro.
28 * @see http://wiki.multimedia.cx/index.php?title=Apple_ProRes
31 #define LONG_BITSTREAM_READER // some ProRes vlc codes require up to 28 bits to be read at once
35 #include "libavutil/intmath.h"
38 #include "proresdata.h"
39 #include "proresdsp.h"
43 const uint8_t *index
; ///< pointers to the data of this slice
47 int prev_slice_sf
; ///< scalefactor of the previous decoded slice
48 DECLARE_ALIGNED(16, DCTELEM
, blocks
)[8 * 4 * 64];
49 DECLARE_ALIGNED(16, int16_t, qmat_luma_scaled
)[64];
50 DECLARE_ALIGNED(16, int16_t, qmat_chroma_scaled
)[64];
57 int scantable_type
; ///< -1 = uninitialized, 0 = progressive, 1/2 = interlaced
59 int frame_type
; ///< 0 = progressive, 1 = top-field first, 2 = bottom-field first
60 int pic_format
; ///< 2 = 422, 3 = 444
61 uint8_t qmat_luma
[64]; ///< dequantization matrix for luma
62 uint8_t qmat_chroma
[64]; ///< dequantization matrix for chroma
63 int qmat_changed
; ///< 1 - global quantization matrices changed
64 int total_slices
; ///< total number of slices in a picture
65 ProresThreadData
*slice_data
;
69 int num_chroma_blocks
; ///< number of chrominance blocks in a macroblock
72 int slice_width_factor
;
73 int slice_height_factor
;
80 static av_cold
int decode_init(AVCodecContext
*avctx
)
82 ProresContext
*ctx
= avctx
->priv_data
;
84 ctx
->total_slices
= 0;
85 ctx
->slice_data
= NULL
;
87 avctx
->bits_per_raw_sample
= PRORES_BITS_PER_SAMPLE
;
88 ff_proresdsp_init(&ctx
->dsp
);
90 avctx
->coded_frame
= &ctx
->picture
;
91 avcodec_get_frame_defaults(&ctx
->picture
);
92 ctx
->picture
.type
= AV_PICTURE_TYPE_I
;
93 ctx
->picture
.key_frame
= 1;
95 ctx
->scantable_type
= -1; // set scantable type to uninitialized
96 memset(ctx
->qmat_luma
, 4, 64);
97 memset(ctx
->qmat_chroma
, 4, 64);
103 static int decode_frame_header(ProresContext
*ctx
, const uint8_t *buf
,
104 const int data_size
, AVCodecContext
*avctx
)
106 int hdr_size
, version
, width
, height
, flags
;
109 hdr_size
= AV_RB16(buf
);
110 if (hdr_size
> data_size
) {
111 av_log(avctx
, AV_LOG_ERROR
, "frame data too small\n");
112 return AVERROR_INVALIDDATA
;
115 version
= AV_RB16(buf
+ 2);
117 av_log(avctx
, AV_LOG_ERROR
,
118 "unsupported header version: %d\n", version
);
119 return AVERROR_INVALIDDATA
;
122 width
= AV_RB16(buf
+ 8);
123 height
= AV_RB16(buf
+ 10);
124 if (width
!= avctx
->width
|| height
!= avctx
->height
) {
125 av_log(avctx
, AV_LOG_ERROR
,
126 "picture dimension changed: old: %d x %d, new: %d x %d\n",
127 avctx
->width
, avctx
->height
, width
, height
);
128 return AVERROR_INVALIDDATA
;
131 ctx
->frame_type
= (buf
[12] >> 2) & 3;
132 if (ctx
->frame_type
> 2) {
133 av_log(avctx
, AV_LOG_ERROR
,
134 "unsupported frame type: %d\n", ctx
->frame_type
);
135 return AVERROR_INVALIDDATA
;
138 ctx
->chroma_factor
= (buf
[12] >> 6) & 3;
139 ctx
->mb_chroma_factor
= ctx
->chroma_factor
+ 2;
140 ctx
->num_chroma_blocks
= (1 << ctx
->chroma_factor
) >> 1;
141 switch (ctx
->chroma_factor
) {
143 avctx
->pix_fmt
= AV_PIX_FMT_YUV422P10
;
146 avctx
->pix_fmt
= AV_PIX_FMT_YUV444P10
;
149 av_log(avctx
, AV_LOG_ERROR
,
150 "unsupported picture format: %d\n", ctx
->pic_format
);
151 return AVERROR_INVALIDDATA
;
154 if (ctx
->scantable_type
!= ctx
->frame_type
) {
155 if (!ctx
->frame_type
)
156 ff_init_scantable(ctx
->dsp
.idct_permutation
, &ctx
->scantable
,
157 ff_prores_progressive_scan
);
159 ff_init_scantable(ctx
->dsp
.idct_permutation
, &ctx
->scantable
,
160 ff_prores_interlaced_scan
);
161 ctx
->scantable_type
= ctx
->frame_type
;
164 if (ctx
->frame_type
) { /* if interlaced */
165 ctx
->picture
.interlaced_frame
= 1;
166 ctx
->picture
.top_field_first
= ctx
->frame_type
& 1;
169 avctx
->color_primaries
= buf
[14];
170 avctx
->color_trc
= buf
[15];
171 avctx
->colorspace
= buf
[16];
173 ctx
->alpha_info
= buf
[17] & 0xf;
175 av_log_missing_feature(avctx
, "Alpha channel", 0);
177 ctx
->qmat_changed
= 0;
181 if (ptr
- buf
> hdr_size
- 64) {
182 av_log(avctx
, AV_LOG_ERROR
, "header data too small\n");
183 return AVERROR_INVALIDDATA
;
185 if (memcmp(ctx
->qmat_luma
, ptr
, 64)) {
186 memcpy(ctx
->qmat_luma
, ptr
, 64);
187 ctx
->qmat_changed
= 1;
191 memset(ctx
->qmat_luma
, 4, 64);
192 ctx
->qmat_changed
= 1;
196 if (ptr
- buf
> hdr_size
- 64) {
197 av_log(avctx
, AV_LOG_ERROR
, "header data too small\n");
200 if (memcmp(ctx
->qmat_chroma
, ptr
, 64)) {
201 memcpy(ctx
->qmat_chroma
, ptr
, 64);
202 ctx
->qmat_changed
= 1;
205 memset(ctx
->qmat_chroma
, 4, 64);
206 ctx
->qmat_changed
= 1;
213 static int decode_picture_header(ProresContext
*ctx
, const uint8_t *buf
,
214 const int data_size
, AVCodecContext
*avctx
)
216 int i
, hdr_size
, pic_data_size
, num_slices
;
217 int slice_width_factor
, slice_height_factor
;
218 int remainder
, num_x_slices
;
219 const uint8_t *data_ptr
, *index_ptr
;
221 hdr_size
= data_size
> 0 ? buf
[0] >> 3 : 0;
222 if (hdr_size
< 8 || hdr_size
> data_size
) {
223 av_log(avctx
, AV_LOG_ERROR
, "picture header too small\n");
224 return AVERROR_INVALIDDATA
;
227 pic_data_size
= AV_RB32(buf
+ 1);
228 if (pic_data_size
> data_size
) {
229 av_log(avctx
, AV_LOG_ERROR
, "picture data too small\n");
230 return AVERROR_INVALIDDATA
;
233 slice_width_factor
= buf
[7] >> 4;
234 slice_height_factor
= buf
[7] & 0xF;
235 if (slice_width_factor
> 3 || slice_height_factor
) {
236 av_log(avctx
, AV_LOG_ERROR
,
237 "unsupported slice dimension: %d x %d\n",
238 1 << slice_width_factor
, 1 << slice_height_factor
);
239 return AVERROR_INVALIDDATA
;
242 ctx
->slice_width_factor
= slice_width_factor
;
243 ctx
->slice_height_factor
= slice_height_factor
;
245 ctx
->num_x_mbs
= (avctx
->width
+ 15) >> 4;
246 ctx
->num_y_mbs
= (avctx
->height
+
247 (1 << (4 + ctx
->picture
.interlaced_frame
)) - 1) >>
248 (4 + ctx
->picture
.interlaced_frame
);
250 remainder
= ctx
->num_x_mbs
& ((1 << slice_width_factor
) - 1);
251 num_x_slices
= (ctx
->num_x_mbs
>> slice_width_factor
) + (remainder
& 1) +
252 ((remainder
>> 1) & 1) + ((remainder
>> 2) & 1);
254 num_slices
= num_x_slices
* ctx
->num_y_mbs
;
255 if (num_slices
!= AV_RB16(buf
+ 5)) {
256 av_log(avctx
, AV_LOG_ERROR
, "invalid number of slices\n");
257 return AVERROR_INVALIDDATA
;
260 if (ctx
->total_slices
!= num_slices
) {
261 av_freep(&ctx
->slice_data
);
262 ctx
->slice_data
= av_malloc((num_slices
+ 1) * sizeof(ctx
->slice_data
[0]));
263 if (!ctx
->slice_data
)
264 return AVERROR(ENOMEM
);
265 ctx
->total_slices
= num_slices
;
268 if (hdr_size
+ num_slices
* 2 > data_size
) {
269 av_log(avctx
, AV_LOG_ERROR
, "slice table too small\n");
270 return AVERROR_INVALIDDATA
;
273 /* parse slice table allowing quick access to the slice data */
274 index_ptr
= buf
+ hdr_size
;
275 data_ptr
= index_ptr
+ num_slices
* 2;
277 for (i
= 0; i
< num_slices
; i
++) {
278 ctx
->slice_data
[i
].index
= data_ptr
;
279 ctx
->slice_data
[i
].prev_slice_sf
= 0;
280 data_ptr
+= AV_RB16(index_ptr
+ i
* 2);
282 ctx
->slice_data
[i
].index
= data_ptr
;
283 ctx
->slice_data
[i
].prev_slice_sf
= 0;
285 if (data_ptr
> buf
+ data_size
) {
286 av_log(avctx
, AV_LOG_ERROR
, "out of slice data\n");
290 return pic_data_size
;
295 * Read an unsigned rice/exp golomb codeword.
297 static inline int decode_vlc_codeword(GetBitContext
*gb
, unsigned codebook
)
299 unsigned int rice_order
, exp_order
, switch_bits
;
300 unsigned int buf
, code
;
301 int log
, prefix_len
, len
;
304 UPDATE_CACHE(re
, gb
);
305 buf
= GET_CACHE(re
, gb
);
307 /* number of prefix bits to switch between Rice and expGolomb */
308 switch_bits
= (codebook
& 3) + 1;
309 rice_order
= codebook
>> 5; /* rice code order */
310 exp_order
= (codebook
>> 2) & 7; /* exp golomb code order */
312 log
= 31 - av_log2(buf
); /* count prefix bits (zeroes) */
314 if (log
< switch_bits
) { /* ok, we got a rice code */
316 /* shortcut for faster decoding of rice codes without remainder */
318 LAST_SKIP_BITS(re
, gb
, log
+ 1);
320 prefix_len
= log
+ 1;
321 code
= (log
<< rice_order
) + NEG_USR32(buf
<< prefix_len
, rice_order
);
322 LAST_SKIP_BITS(re
, gb
, prefix_len
+ rice_order
);
324 } else { /* otherwise we got a exp golomb code */
325 len
= (log
<< 1) - switch_bits
+ exp_order
+ 1;
326 code
= NEG_USR32(buf
, len
) - (1 << exp_order
) + (switch_bits
<< rice_order
);
327 LAST_SKIP_BITS(re
, gb
, len
);
330 CLOSE_READER(re
, gb
);
335 #define LSB2SIGN(x) (-((x) & 1))
336 #define TOSIGNED(x) (((x) >> 1) ^ LSB2SIGN(x))
339 * Decode DC coefficients for all blocks in a slice.
341 static inline void decode_dc_coeffs(GetBitContext
*gb
, DCTELEM
*out
,
349 code
= decode_vlc_codeword(gb
, FIRST_DC_CB
);
350 out
[0] = prev_dc
= TOSIGNED(code
);
352 out
+= 64; /* move to the DC coeff of the next block */
355 for (i
= 1; i
< nblocks
; i
++, out
+= 64) {
356 code
= decode_vlc_codeword(gb
, ff_prores_dc_codebook
[FFMIN(FFABS(delta
), 3)]);
358 sign
= -(((delta
>> 15) & 1) ^ (code
& 1));
359 delta
= (((code
+ 1) >> 1) ^ sign
) - sign
;
367 * Decode AC coefficients for all blocks in a slice.
369 static inline void decode_ac_coeffs(GetBitContext
*gb
, DCTELEM
*out
,
370 int blocks_per_slice
,
371 int plane_size_factor
,
374 int pos
, block_mask
, run
, level
, sign
, run_cb_index
, lev_cb_index
;
375 int max_coeffs
, bits_left
;
377 /* set initial prediction values */
381 max_coeffs
= blocks_per_slice
<< 6;
382 block_mask
= blocks_per_slice
- 1;
384 for (pos
= blocks_per_slice
- 1; pos
< max_coeffs
;) {
385 run_cb_index
= ff_prores_run_to_cb_index
[FFMIN(run
, 15)];
386 lev_cb_index
= ff_prores_lev_to_cb_index
[FFMIN(level
, 9)];
388 bits_left
= get_bits_left(gb
);
389 if (bits_left
<= 0 || (bits_left
<= 8 && !show_bits(gb
, bits_left
)))
392 run
= decode_vlc_codeword(gb
, ff_prores_ac_codebook
[run_cb_index
]);
394 bits_left
= get_bits_left(gb
);
395 if (bits_left
<= 0 || (bits_left
<= 8 && !show_bits(gb
, bits_left
)))
398 level
= decode_vlc_codeword(gb
, ff_prores_ac_codebook
[lev_cb_index
]) + 1;
401 if (pos
>= max_coeffs
)
404 sign
= get_sbits(gb
, 1);
405 out
[((pos
& block_mask
) << 6) + scan
[pos
>> plane_size_factor
]] =
406 (level
^ sign
) - sign
;
412 * Decode a slice plane (luma or chroma).
414 static void decode_slice_plane(ProresContext
*ctx
, ProresThreadData
*td
,
416 int data_size
, uint16_t *out_ptr
,
417 int linesize
, int mbs_per_slice
,
418 int blocks_per_mb
, int plane_size_factor
,
419 const int16_t *qmat
, int is_chroma
)
423 int mb_num
, blocks_per_slice
;
425 blocks_per_slice
= mbs_per_slice
* blocks_per_mb
;
427 memset(td
->blocks
, 0, 8 * 4 * 64 * sizeof(*td
->blocks
));
429 init_get_bits(&gb
, buf
, data_size
<< 3);
431 decode_dc_coeffs(&gb
, td
->blocks
, blocks_per_slice
);
433 decode_ac_coeffs(&gb
, td
->blocks
, blocks_per_slice
,
434 plane_size_factor
, ctx
->scantable
.permutated
);
436 /* inverse quantization, inverse transform and output */
437 block_ptr
= td
->blocks
;
440 for (mb_num
= 0; mb_num
< mbs_per_slice
; mb_num
++, out_ptr
+= blocks_per_mb
* 4) {
441 ctx
->dsp
.idct_put(out_ptr
, linesize
, block_ptr
, qmat
);
443 if (blocks_per_mb
> 2) {
444 ctx
->dsp
.idct_put(out_ptr
+ 8, linesize
, block_ptr
, qmat
);
447 ctx
->dsp
.idct_put(out_ptr
+ linesize
* 4, linesize
, block_ptr
, qmat
);
449 if (blocks_per_mb
> 2) {
450 ctx
->dsp
.idct_put(out_ptr
+ linesize
* 4 + 8, linesize
, block_ptr
, qmat
);
455 for (mb_num
= 0; mb_num
< mbs_per_slice
; mb_num
++, out_ptr
+= blocks_per_mb
* 4) {
456 ctx
->dsp
.idct_put(out_ptr
, linesize
, block_ptr
, qmat
);
458 ctx
->dsp
.idct_put(out_ptr
+ linesize
* 4, linesize
, block_ptr
, qmat
);
460 if (blocks_per_mb
> 2) {
461 ctx
->dsp
.idct_put(out_ptr
+ 8, linesize
, block_ptr
, qmat
);
463 ctx
->dsp
.idct_put(out_ptr
+ linesize
* 4 + 8, linesize
, block_ptr
, qmat
);
471 static int decode_slice(AVCodecContext
*avctx
, void *tdata
)
473 ProresThreadData
*td
= tdata
;
474 ProresContext
*ctx
= avctx
->priv_data
;
475 int mb_x_pos
= td
->x_pos
;
476 int mb_y_pos
= td
->y_pos
;
477 int pic_num
= ctx
->pic_num
;
478 int slice_num
= td
->slice_num
;
479 int mbs_per_slice
= td
->slice_width
;
481 uint8_t *y_data
, *u_data
, *v_data
;
482 AVFrame
*pic
= avctx
->coded_frame
;
483 int i
, sf
, slice_width_factor
;
484 int slice_data_size
, hdr_size
, y_data_size
, u_data_size
, v_data_size
;
485 int y_linesize
, u_linesize
, v_linesize
;
487 buf
= ctx
->slice_data
[slice_num
].index
;
488 slice_data_size
= ctx
->slice_data
[slice_num
+ 1].index
- buf
;
490 slice_width_factor
= av_log2(mbs_per_slice
);
492 y_data
= pic
->data
[0];
493 u_data
= pic
->data
[1];
494 v_data
= pic
->data
[2];
495 y_linesize
= pic
->linesize
[0];
496 u_linesize
= pic
->linesize
[1];
497 v_linesize
= pic
->linesize
[2];
499 if (pic
->interlaced_frame
) {
500 if (!(pic_num
^ pic
->top_field_first
)) {
501 y_data
+= y_linesize
;
502 u_data
+= u_linesize
;
503 v_data
+= v_linesize
;
510 if (slice_data_size
< 6) {
511 av_log(avctx
, AV_LOG_ERROR
, "slice data too small\n");
512 return AVERROR_INVALIDDATA
;
515 /* parse slice header */
516 hdr_size
= buf
[0] >> 3;
517 y_data_size
= AV_RB16(buf
+ 2);
518 u_data_size
= AV_RB16(buf
+ 4);
519 v_data_size
= hdr_size
> 7 ? AV_RB16(buf
+ 6) :
520 slice_data_size
- y_data_size
- u_data_size
- hdr_size
;
522 if (hdr_size
+ y_data_size
+ u_data_size
+ v_data_size
> slice_data_size
||
523 v_data_size
< 0 || hdr_size
< 6) {
524 av_log(avctx
, AV_LOG_ERROR
, "invalid data size\n");
525 return AVERROR_INVALIDDATA
;
528 sf
= av_clip(buf
[1], 1, 224);
529 sf
= sf
> 128 ? (sf
- 96) << 2 : sf
;
531 /* scale quantization matrixes according with slice's scale factor */
532 /* TODO: this can be SIMD-optimized a lot */
533 if (ctx
->qmat_changed
|| sf
!= td
->prev_slice_sf
) {
534 td
->prev_slice_sf
= sf
;
535 for (i
= 0; i
< 64; i
++) {
536 td
->qmat_luma_scaled
[ctx
->dsp
.idct_permutation
[i
]] = ctx
->qmat_luma
[i
] * sf
;
537 td
->qmat_chroma_scaled
[ctx
->dsp
.idct_permutation
[i
]] = ctx
->qmat_chroma
[i
] * sf
;
541 /* decode luma plane */
542 decode_slice_plane(ctx
, td
, buf
+ hdr_size
, y_data_size
,
543 (uint16_t*) (y_data
+ (mb_y_pos
<< 4) * y_linesize
+
544 (mb_x_pos
<< 5)), y_linesize
,
545 mbs_per_slice
, 4, slice_width_factor
+ 2,
546 td
->qmat_luma_scaled
, 0);
548 /* decode U chroma plane */
549 decode_slice_plane(ctx
, td
, buf
+ hdr_size
+ y_data_size
, u_data_size
,
550 (uint16_t*) (u_data
+ (mb_y_pos
<< 4) * u_linesize
+
551 (mb_x_pos
<< ctx
->mb_chroma_factor
)),
552 u_linesize
, mbs_per_slice
, ctx
->num_chroma_blocks
,
553 slice_width_factor
+ ctx
->chroma_factor
- 1,
554 td
->qmat_chroma_scaled
, 1);
556 /* decode V chroma plane */
557 decode_slice_plane(ctx
, td
, buf
+ hdr_size
+ y_data_size
+ u_data_size
,
559 (uint16_t*) (v_data
+ (mb_y_pos
<< 4) * v_linesize
+
560 (mb_x_pos
<< ctx
->mb_chroma_factor
)),
561 v_linesize
, mbs_per_slice
, ctx
->num_chroma_blocks
,
562 slice_width_factor
+ ctx
->chroma_factor
- 1,
563 td
->qmat_chroma_scaled
, 1);
569 static int decode_picture(ProresContext
*ctx
, int pic_num
,
570 AVCodecContext
*avctx
)
572 int slice_num
, slice_width
, x_pos
, y_pos
;
576 ctx
->pic_num
= pic_num
;
577 for (y_pos
= 0; y_pos
< ctx
->num_y_mbs
; y_pos
++) {
578 slice_width
= 1 << ctx
->slice_width_factor
;
580 for (x_pos
= 0; x_pos
< ctx
->num_x_mbs
&& slice_width
;
581 x_pos
+= slice_width
) {
582 while (ctx
->num_x_mbs
- x_pos
< slice_width
)
585 ctx
->slice_data
[slice_num
].slice_num
= slice_num
;
586 ctx
->slice_data
[slice_num
].x_pos
= x_pos
;
587 ctx
->slice_data
[slice_num
].y_pos
= y_pos
;
588 ctx
->slice_data
[slice_num
].slice_width
= slice_width
;
594 return avctx
->execute(avctx
, decode_slice
,
595 ctx
->slice_data
, NULL
, slice_num
,
596 sizeof(ctx
->slice_data
[0]));
600 #define MOVE_DATA_PTR(nbytes) buf += (nbytes); buf_size -= (nbytes)
602 static int decode_frame(AVCodecContext
*avctx
, void *data
, int *got_frame
,
605 ProresContext
*ctx
= avctx
->priv_data
;
606 AVFrame
*picture
= avctx
->coded_frame
;
607 const uint8_t *buf
= avpkt
->data
;
608 int buf_size
= avpkt
->size
;
609 int frame_hdr_size
, pic_num
, pic_data_size
;
611 /* check frame atom container */
612 if (buf_size
< 28 || buf_size
< AV_RB32(buf
) ||
613 AV_RB32(buf
+ 4) != FRAME_ID
) {
614 av_log(avctx
, AV_LOG_ERROR
, "invalid frame\n");
615 return AVERROR_INVALIDDATA
;
620 frame_hdr_size
= decode_frame_header(ctx
, buf
, buf_size
, avctx
);
621 if (frame_hdr_size
< 0)
622 return AVERROR_INVALIDDATA
;
624 MOVE_DATA_PTR(frame_hdr_size
);
626 if (picture
->data
[0])
627 avctx
->release_buffer(avctx
, picture
);
629 picture
->reference
= 0;
630 if (ff_get_buffer(avctx
, picture
) < 0)
633 for (pic_num
= 0; ctx
->picture
.interlaced_frame
- pic_num
+ 1; pic_num
++) {
634 pic_data_size
= decode_picture_header(ctx
, buf
, buf_size
, avctx
);
635 if (pic_data_size
< 0)
636 return AVERROR_INVALIDDATA
;
638 if (decode_picture(ctx
, pic_num
, avctx
))
641 MOVE_DATA_PTR(pic_data_size
);
645 *(AVFrame
*) data
= *avctx
->coded_frame
;
651 static av_cold
int decode_close(AVCodecContext
*avctx
)
653 ProresContext
*ctx
= avctx
->priv_data
;
655 if (ctx
->picture
.data
[0])
656 avctx
->release_buffer(avctx
, &ctx
->picture
);
658 av_freep(&ctx
->slice_data
);
664 AVCodec ff_prores_decoder
= {
666 .type
= AVMEDIA_TYPE_VIDEO
,
667 .id
= AV_CODEC_ID_PRORES
,
668 .priv_data_size
= sizeof(ProresContext
),
670 .close
= decode_close
,
671 .decode
= decode_frame
,
672 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_SLICE_THREADS
,
673 .long_name
= NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)")