2 * Copyright (c) 2010-2011 Maxim Poliakovski
3 * Copyright (c) 2010-2011 Elvis Presley
5 * This file is part of FFmpeg.
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.
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.
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
24 * Known FOURCCs: 'apch' (HQ), 'apcn' (SD), 'apcs' (LT), 'acpo' (Proxy), 'ap4h' (4444)
29 #define LONG_BITSTREAM_READER
35 #include "simple_idct.h"
36 #include "proresdec.h"
37 #include "proresdata.h"
39 static void permute(uint8_t *dst
, const uint8_t *src
, const uint8_t permutation
[64])
42 for (i
= 0; i
< 64; i
++)
43 dst
[i
] = permutation
[src
[i
]];
46 static av_cold
int decode_init(AVCodecContext
*avctx
)
48 ProresContext
*ctx
= avctx
->priv_data
;
49 uint8_t idct_permutation
[64];
51 avctx
->bits_per_raw_sample
= 10;
53 ff_blockdsp_init(&ctx
->bdsp
, avctx
);
54 ff_proresdsp_init(&ctx
->prodsp
, avctx
);
56 ff_init_scantable_permutation(idct_permutation
,
57 ctx
->prodsp
.idct_permutation_type
);
59 permute(ctx
->progressive_scan
, ff_prores_progressive_scan
, idct_permutation
);
60 permute(ctx
->interlaced_scan
, ff_prores_interlaced_scan
, idct_permutation
);
65 static int decode_frame_header(ProresContext
*ctx
, const uint8_t *buf
,
66 const int data_size
, AVCodecContext
*avctx
)
68 int hdr_size
, width
, height
, flags
;
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
;
79 version
= AV_RB16(buf
+ 2);
80 av_dlog(avctx
, "%.4s version %d\n", buf
+4, version
);
82 av_log(avctx
, AV_LOG_ERROR
, "unsupported version: %d\n", version
);
83 return AVERROR_PATCHWELCOME
;
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
;
94 ctx
->frame_type
= (buf
[12] >> 2) & 3;
95 ctx
->alpha_info
= buf
[17] & 0xf;
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
;
101 if (avctx
->skip_alpha
) ctx
->alpha_info
= 0;
103 av_dlog(avctx
, "frame type %d\n", ctx
->frame_type
);
105 if (ctx
->frame_type
== 0) {
106 ctx
->scan
= ctx
->progressive_scan
; // permuted
108 ctx
->scan
= ctx
->interlaced_scan
; // permuted
109 ctx
->frame
->interlaced_frame
= 1;
110 ctx
->frame
->top_field_first
= ctx
->frame_type
== 1;
113 if (ctx
->alpha_info
) {
114 avctx
->pix_fmt
= (buf
[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUVA444P10
: AV_PIX_FMT_YUVA422P10
;
116 avctx
->pix_fmt
= (buf
[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUV444P10
: AV_PIX_FMT_YUV422P10
;
121 av_dlog(avctx
, "flags %x\n", flags
);
124 if(buf
+ data_size
- ptr
< 64) {
125 av_log(avctx
, AV_LOG_ERROR
, "Header truncated\n");
126 return AVERROR_INVALIDDATA
;
128 permute(ctx
->qmat_luma
, ctx
->prodsp
.idct_permutation
, ptr
);
131 memset(ctx
->qmat_luma
, 4, 64);
135 if(buf
+ data_size
- ptr
< 64) {
136 av_log(avctx
, AV_LOG_ERROR
, "Header truncated\n");
137 return AVERROR_INVALIDDATA
;
139 permute(ctx
->qmat_chroma
, ctx
->prodsp
.idct_permutation
, ptr
);
141 memset(ctx
->qmat_chroma
, 4, 64);
147 static int decode_picture_header(AVCodecContext
*avctx
, const uint8_t *buf
, const int buf_size
)
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
;
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
;
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
;
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
;
176 ctx
->mb_width
= (avctx
->width
+ 15) >> 4;
178 ctx
->mb_height
= (avctx
->height
+ 31) >> 5;
180 ctx
->mb_height
= (avctx
->height
+ 15) >> 4;
182 slice_count
= AV_RB16(buf
+ 5);
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
));
188 return AVERROR(ENOMEM
);
189 ctx
->slice_count
= slice_count
;
193 return AVERROR(EINVAL
);
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
;
200 // parse slice information
201 index_ptr
= buf
+ hdr_size
;
202 data_ptr
= index_ptr
+ slice_count
*2;
204 slice_mb_count
= 1 << log2_slice_mb_width
;
208 for (i
= 0; i
< slice_count
; i
++) {
209 SliceContext
*slice
= &ctx
->slices
[i
];
211 slice
->data
= data_ptr
;
212 data_ptr
+= AV_RB16(index_ptr
+ i
*2);
214 while (ctx
->mb_width
- mb_x
< slice_mb_count
)
215 slice_mb_count
>>= 1;
219 slice
->mb_count
= slice_mb_count
;
220 slice
->data_size
= data_ptr
- slice
->data
;
222 if (slice
->data_size
< 6) {
223 av_log(avctx
, AV_LOG_ERROR
, "error, wrong slice data size\n");
224 return AVERROR_INVALIDDATA
;
227 mb_x
+= slice_mb_count
;
228 if (mb_x
== ctx
->mb_width
) {
229 slice_mb_count
= 1 << log2_slice_mb_width
;
233 if (data_ptr
> buf
+ buf_size
) {
234 av_log(avctx
, AV_LOG_ERROR
, "error, slice out of bounds\n");
235 return AVERROR_INVALIDDATA
;
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
;
245 return pic_data_size
;
248 #define DECODE_CODEWORD(val, codebook) \
250 unsigned int rice_order, exp_order, switch_bits; \
251 unsigned int q, buf, bits; \
253 UPDATE_CACHE(re, gb); \
254 buf = GET_CACHE(re, gb); \
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; \
261 q = 31 - av_log2(buf); \
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); \
274 SKIP_BITS(re, gb, q+1); \
278 #define TOSIGNED(x) (((x) >> 1) ^ (-((x) & 1)))
280 #define FIRST_DC_CB 0xB8
282 static const uint8_t dc_codebook
[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
284 static av_always_inline
void decode_dc_coeffs(GetBitContext
*gb
, int16_t *out
,
285 int blocks_per_slice
)
292 DECODE_CODEWORD(code
, FIRST_DC_CB
);
293 prev_dc
= TOSIGNED(code
);
296 out
+= 64; // dc coeff for the next block
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);
304 prev_dc
+= (((code
+ 1) >> 1) ^ sign
) - sign
;
307 CLOSE_READER(re
, gb
);
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 };
314 static av_always_inline
int decode_ac_coeffs(AVCodecContext
*avctx
, GetBitContext
*gb
,
315 int16_t *out
, int blocks_per_slice
)
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
);
324 UPDATE_CACHE(re
, gb
); \
328 max_coeffs
= 64 << log2_block_count
;
329 block_mask
= blocks_per_slice
- 1;
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
)))
336 DECODE_CODEWORD(run
, run_to_cb
[FFMIN(run
, 15)]);
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
;
343 DECODE_CODEWORD(level
, lev_to_cb
[FFMIN(level
, 9)]);
346 i
= pos
>> log2_block_count
;
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
);
353 CLOSE_READER(re
, gb
);
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
,
362 ProresContext
*ctx
= avctx
->priv_data
;
363 LOCAL_ALIGNED_16(int16_t, blocks
, [8*4*64]);
366 int i
, blocks_per_slice
= slice
->mb_count
<<2;
369 for (i
= 0; i
< blocks_per_slice
; i
++)
370 ctx
->bdsp
.clear_block(blocks
+(i
<<6));
372 init_get_bits(&gb
, buf
, buf_size
<< 3);
374 decode_dc_coeffs(&gb
, blocks
, blocks_per_slice
);
375 if ((ret
= decode_ac_coeffs(avctx
, &gb
, blocks
, blocks_per_slice
)) < 0)
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
);
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
)
395 ProresContext
*ctx
= avctx
->priv_data
;
396 LOCAL_ALIGNED_16(int16_t, blocks
, [8*4*64]);
399 int i
, j
, blocks_per_slice
= slice
->mb_count
<< log2_blocks_per_mb
;
402 for (i
= 0; i
< blocks_per_slice
; i
++)
403 ctx
->bdsp
.clear_block(blocks
+(i
<<6));
405 init_get_bits(&gb
, buf
, buf_size
<< 3);
407 decode_dc_coeffs(&gb
, blocks
, blocks_per_slice
);
408 if ((ret
= decode_ac_coeffs(avctx
, &gb
, blocks
, blocks_per_slice
)) < 0)
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
);
423 static void unpack_alpha(GetBitContext
*gb
, uint16_t *dst
, int num_coeffs
,
426 const int mask
= (1 << num_bits
) - 1;
427 int i
, idx
, val
, alpha_val
;
434 val
= get_bits(gb
, num_bits
);
437 val
= get_bits(gb
, num_bits
== 16 ? 7 : 4);
439 val
= (val
+ 2) >> 1;
443 alpha_val
= (alpha_val
+ val
) & mask
;
444 if (num_bits
== 16) {
445 dst
[idx
++] = alpha_val
>> 6;
447 dst
[idx
++] = (alpha_val
<< 2) | (alpha_val
>> 6);
449 if (idx
>= num_coeffs
)
451 } while (get_bits_left(gb
)>0 && get_bits1(gb
));
452 val
= get_bits(gb
, 4);
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;
461 for (i
= 0; i
< val
; i
++)
462 dst
[idx
++] = (alpha_val
<< 2) | (alpha_val
>> 6);
465 } while (idx
< num_coeffs
);
469 * Decode alpha slice plane.
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
)
478 LOCAL_ALIGNED_16(int16_t, blocks
, [8*4*64]);
481 for (i
= 0; i
< blocks_per_slice
<<2; i
++)
482 ctx
->bdsp
.clear_block(blocks
+(i
<<6));
484 init_get_bits(&gb
, buf
, buf_size
<< 3);
486 if (ctx
->alpha_info
== 2) {
487 unpack_alpha(&gb
, blocks
, blocks_per_slice
* 4 * 64, 16);
489 unpack_alpha(&gb
, blocks
, blocks_per_slice
* 4 * 64, 8);
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
;
500 static int decode_slice_thread(AVCodecContext
*avctx
, void *arg
, int jobnr
, int threadnr
)
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];
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);
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
;
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
;
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
;
543 if (ctx
->frame_type
== 0) {
544 luma_stride
= pic
->linesize
[0];
545 chroma_stride
= pic
->linesize
[1];
547 luma_stride
= pic
->linesize
[0] << 1;
548 chroma_stride
= pic
->linesize
[1] << 1;
551 if (avctx
->pix_fmt
== AV_PIX_FMT_YUV444P10
|| avctx
->pix_fmt
== AV_PIX_FMT_YUVA444P10
) {
553 log2_chroma_blocks_per_mb
= 2;
556 log2_chroma_blocks_per_mb
= 1;
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);
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];
571 ret
= decode_slice_luma(avctx
, slice
, (uint16_t*)dest_y
, luma_stride
,
572 buf
, y_data_size
, qmat_luma_scaled
);
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
);
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
);
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
);
599 static int decode_picture(AVCodecContext
*avctx
)
601 ProresContext
*ctx
= avctx
->priv_data
;
604 avctx
->execute2(avctx
, decode_slice_thread
, NULL
, NULL
, ctx
->slice_count
);
606 for (i
= 0; i
< ctx
->slice_count
; i
++)
607 if (ctx
->slices
[i
].ret
< 0)
608 return ctx
->slices
[i
].ret
;
613 static int decode_frame(AVCodecContext
*avctx
, void *data
, int *got_frame
,
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
;
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
;
628 ctx
->frame
->pict_type
= AV_PICTURE_TYPE_I
;
629 ctx
->frame
->key_frame
= 1;
630 ctx
->first_field
= 1;
635 frame_hdr_size
= decode_frame_header(ctx
, buf
, buf_size
, avctx
);
636 if (frame_hdr_size
< 0)
637 return frame_hdr_size
;
639 buf
+= frame_hdr_size
;
640 buf_size
-= frame_hdr_size
;
642 if ((ret
= ff_get_buffer(avctx
, frame
, 0)) < 0)
646 pic_size
= decode_picture_header(avctx
, buf
, buf_size
);
648 av_log(avctx
, AV_LOG_ERROR
, "error decoding picture header\n");
652 if ((ret
= decode_picture(avctx
)) < 0) {
653 av_log(avctx
, AV_LOG_ERROR
, "error decoding picture\n");
658 buf_size
-= pic_size
;
660 if (ctx
->frame_type
&& buf_size
> 0 && ctx
->first_field
) {
661 ctx
->first_field
= 0;
670 static av_cold
int decode_close(AVCodecContext
*avctx
)
672 ProresContext
*ctx
= avctx
->priv_data
;
674 av_freep(&ctx
->slices
);
679 AVCodec ff_prores_decoder
= {
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
),
686 .close
= decode_close
,
687 .decode
= decode_frame
,
688 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_SLICE_THREADS
,