2 * Apple ProRes compatible decoder
4 * Copyright (c) 2010-2011 Maxim Poliakovski
6 * This file is part of FFmpeg.
8 * FFmpeg 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 * FFmpeg 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 FFmpeg; 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"
39 #include "proresdata.h"
40 #include "proresdsp.h"
44 const uint8_t *index
; ///< pointers to the data of this slice
48 int prev_slice_sf
; ///< scalefactor of the previous decoded slice
49 DECLARE_ALIGNED(16, int16_t, blocks
)[8 * 4 * 64];
50 DECLARE_ALIGNED(16, int16_t, qmat_luma_scaled
)[64];
51 DECLARE_ALIGNED(16, int16_t, qmat_chroma_scaled
)[64];
58 int scantable_type
; ///< -1 = uninitialized, 0 = progressive, 1/2 = interlaced
60 int frame_type
; ///< 0 = progressive, 1 = top-field first, 2 = bottom-field first
61 int pic_format
; ///< 2 = 422, 3 = 444
62 uint8_t qmat_luma
[64]; ///< dequantization matrix for luma
63 uint8_t qmat_chroma
[64]; ///< dequantization matrix for chroma
64 int qmat_changed
; ///< 1 - global quantization matrices changed
65 int total_slices
; ///< total number of slices in a picture
66 ProresThreadData
*slice_data
;
70 int num_chroma_blocks
; ///< number of chrominance blocks in a macroblock
73 int slice_width_factor
;
74 int slice_height_factor
;
81 static av_cold
int decode_init(AVCodecContext
*avctx
)
83 ProresContext
*ctx
= avctx
->priv_data
;
85 ctx
->total_slices
= 0;
86 ctx
->slice_data
= NULL
;
88 avctx
->bits_per_raw_sample
= PRORES_BITS_PER_SAMPLE
;
89 ff_proresdsp_init(&ctx
->dsp
, avctx
);
91 ctx
->scantable_type
= -1; // set scantable type to uninitialized
92 memset(ctx
->qmat_luma
, 4, 64);
93 memset(ctx
->qmat_chroma
, 4, 64);
99 static int decode_frame_header(ProresContext
*ctx
, const uint8_t *buf
,
100 const int data_size
, AVCodecContext
*avctx
)
102 int hdr_size
, version
, width
, height
, flags
;
105 hdr_size
= AV_RB16(buf
);
106 if (hdr_size
> data_size
) {
107 av_log(avctx
, AV_LOG_ERROR
, "frame data too small\n");
108 return AVERROR_INVALIDDATA
;
111 version
= AV_RB16(buf
+ 2);
113 av_log(avctx
, AV_LOG_ERROR
,
114 "unsupported header version: %d\n", version
);
115 return AVERROR_INVALIDDATA
;
118 width
= AV_RB16(buf
+ 8);
119 height
= AV_RB16(buf
+ 10);
120 if (width
!= avctx
->width
|| height
!= avctx
->height
) {
121 av_log(avctx
, AV_LOG_ERROR
,
122 "picture dimension changed: old: %d x %d, new: %d x %d\n",
123 avctx
->width
, avctx
->height
, width
, height
);
124 return AVERROR_INVALIDDATA
;
127 ctx
->frame_type
= (buf
[12] >> 2) & 3;
128 if (ctx
->frame_type
> 2) {
129 av_log(avctx
, AV_LOG_ERROR
,
130 "unsupported frame type: %d\n", ctx
->frame_type
);
131 return AVERROR_INVALIDDATA
;
134 ctx
->chroma_factor
= (buf
[12] >> 6) & 3;
135 ctx
->mb_chroma_factor
= ctx
->chroma_factor
+ 2;
136 ctx
->num_chroma_blocks
= (1 << ctx
->chroma_factor
) >> 1;
137 ctx
->alpha_info
= buf
[17] & 0xf;
139 if (ctx
->alpha_info
> 2) {
140 av_log(avctx
, AV_LOG_ERROR
, "Invalid alpha mode %d\n", ctx
->alpha_info
);
141 return AVERROR_INVALIDDATA
;
143 if (avctx
->skip_alpha
) ctx
->alpha_info
= 0;
145 switch (ctx
->chroma_factor
) {
147 avctx
->pix_fmt
= ctx
->alpha_info
? AV_PIX_FMT_YUVA422P10
148 : AV_PIX_FMT_YUV422P10
;
151 avctx
->pix_fmt
= ctx
->alpha_info
? AV_PIX_FMT_YUVA444P10
152 : AV_PIX_FMT_YUV444P10
;
155 av_log(avctx
, AV_LOG_ERROR
,
156 "unsupported picture format: %d\n", ctx
->pic_format
);
157 return AVERROR_INVALIDDATA
;
160 if (ctx
->scantable_type
!= ctx
->frame_type
) {
161 if (!ctx
->frame_type
)
162 ff_init_scantable(ctx
->dsp
.idct_permutation
, &ctx
->scantable
,
163 ff_prores_progressive_scan
);
165 ff_init_scantable(ctx
->dsp
.idct_permutation
, &ctx
->scantable
,
166 ff_prores_interlaced_scan
);
167 ctx
->scantable_type
= ctx
->frame_type
;
170 if (ctx
->frame_type
) { /* if interlaced */
171 ctx
->frame
->interlaced_frame
= 1;
172 ctx
->frame
->top_field_first
= ctx
->frame_type
& 1;
174 ctx
->frame
->interlaced_frame
= 0;
177 avctx
->color_primaries
= buf
[14];
178 avctx
->color_trc
= buf
[15];
179 avctx
->colorspace
= buf
[16];
181 ctx
->qmat_changed
= 0;
185 if (ptr
- buf
> hdr_size
- 64) {
186 av_log(avctx
, AV_LOG_ERROR
, "header data too small\n");
187 return AVERROR_INVALIDDATA
;
189 if (memcmp(ctx
->qmat_luma
, ptr
, 64)) {
190 memcpy(ctx
->qmat_luma
, ptr
, 64);
191 ctx
->qmat_changed
= 1;
195 memset(ctx
->qmat_luma
, 4, 64);
196 ctx
->qmat_changed
= 1;
200 if (ptr
- buf
> hdr_size
- 64) {
201 av_log(avctx
, AV_LOG_ERROR
, "header data too small\n");
204 if (memcmp(ctx
->qmat_chroma
, ptr
, 64)) {
205 memcpy(ctx
->qmat_chroma
, ptr
, 64);
206 ctx
->qmat_changed
= 1;
209 memset(ctx
->qmat_chroma
, 4, 64);
210 ctx
->qmat_changed
= 1;
217 static int decode_picture_header(ProresContext
*ctx
, const uint8_t *buf
,
218 const int data_size
, AVCodecContext
*avctx
)
220 int i
, hdr_size
, pic_data_size
, num_slices
;
221 int slice_width_factor
, slice_height_factor
;
222 int remainder
, num_x_slices
;
223 const uint8_t *data_ptr
, *index_ptr
;
225 hdr_size
= data_size
> 0 ? buf
[0] >> 3 : 0;
226 if (hdr_size
< 8 || hdr_size
> data_size
) {
227 av_log(avctx
, AV_LOG_ERROR
, "picture header too small\n");
228 return AVERROR_INVALIDDATA
;
231 pic_data_size
= AV_RB32(buf
+ 1);
232 if (pic_data_size
> data_size
) {
233 av_log(avctx
, AV_LOG_ERROR
, "picture data too small\n");
234 return AVERROR_INVALIDDATA
;
237 slice_width_factor
= buf
[7] >> 4;
238 slice_height_factor
= buf
[7] & 0xF;
239 if (slice_width_factor
> 3 || slice_height_factor
) {
240 av_log(avctx
, AV_LOG_ERROR
,
241 "unsupported slice dimension: %d x %d\n",
242 1 << slice_width_factor
, 1 << slice_height_factor
);
243 return AVERROR_INVALIDDATA
;
246 ctx
->slice_width_factor
= slice_width_factor
;
247 ctx
->slice_height_factor
= slice_height_factor
;
249 ctx
->num_x_mbs
= (avctx
->width
+ 15) >> 4;
250 ctx
->num_y_mbs
= (avctx
->height
+
251 (1 << (4 + ctx
->frame
->interlaced_frame
)) - 1) >>
252 (4 + ctx
->frame
->interlaced_frame
);
254 remainder
= ctx
->num_x_mbs
& ((1 << slice_width_factor
) - 1);
255 num_x_slices
= (ctx
->num_x_mbs
>> slice_width_factor
) + (remainder
& 1) +
256 ((remainder
>> 1) & 1) + ((remainder
>> 2) & 1);
258 num_slices
= num_x_slices
* ctx
->num_y_mbs
;
259 if (num_slices
!= AV_RB16(buf
+ 5)) {
260 av_log(avctx
, AV_LOG_ERROR
, "invalid number of slices\n");
261 return AVERROR_INVALIDDATA
;
264 if (ctx
->total_slices
!= num_slices
) {
265 av_freep(&ctx
->slice_data
);
266 ctx
->slice_data
= av_malloc((num_slices
+ 1) * sizeof(ctx
->slice_data
[0]));
267 if (!ctx
->slice_data
)
268 return AVERROR(ENOMEM
);
269 ctx
->total_slices
= num_slices
;
272 if (hdr_size
+ num_slices
* 2 > data_size
) {
273 av_log(avctx
, AV_LOG_ERROR
, "slice table too small\n");
274 return AVERROR_INVALIDDATA
;
277 /* parse slice table allowing quick access to the slice data */
278 index_ptr
= buf
+ hdr_size
;
279 data_ptr
= index_ptr
+ num_slices
* 2;
281 for (i
= 0; i
< num_slices
; i
++) {
282 ctx
->slice_data
[i
].index
= data_ptr
;
283 ctx
->slice_data
[i
].prev_slice_sf
= 0;
284 data_ptr
+= AV_RB16(index_ptr
+ i
* 2);
286 ctx
->slice_data
[i
].index
= data_ptr
;
287 ctx
->slice_data
[i
].prev_slice_sf
= 0;
289 if (data_ptr
> buf
+ data_size
) {
290 av_log(avctx
, AV_LOG_ERROR
, "out of slice data\n");
294 return pic_data_size
;
299 * Read an unsigned rice/exp golomb codeword.
301 static inline int decode_vlc_codeword(GetBitContext
*gb
, unsigned codebook
)
303 unsigned int rice_order
, exp_order
, switch_bits
;
304 unsigned int buf
, code
;
305 int log
, prefix_len
, len
;
308 UPDATE_CACHE(re
, gb
);
309 buf
= GET_CACHE(re
, gb
);
311 /* number of prefix bits to switch between Rice and expGolomb */
312 switch_bits
= (codebook
& 3) + 1;
313 rice_order
= codebook
>> 5; /* rice code order */
314 exp_order
= (codebook
>> 2) & 7; /* exp golomb code order */
316 log
= 31 - av_log2(buf
); /* count prefix bits (zeroes) */
318 if (log
< switch_bits
) { /* ok, we got a rice code */
320 /* shortcut for faster decoding of rice codes without remainder */
322 LAST_SKIP_BITS(re
, gb
, log
+ 1);
324 prefix_len
= log
+ 1;
325 code
= (log
<< rice_order
) + NEG_USR32(buf
<< prefix_len
, rice_order
);
326 LAST_SKIP_BITS(re
, gb
, prefix_len
+ rice_order
);
328 } else { /* otherwise we got a exp golomb code */
329 len
= (log
<< 1) - switch_bits
+ exp_order
+ 1;
330 code
= NEG_USR32(buf
, len
) - (1 << exp_order
) + (switch_bits
<< rice_order
);
331 LAST_SKIP_BITS(re
, gb
, len
);
334 CLOSE_READER(re
, gb
);
339 #define LSB2SIGN(x) (-((x) & 1))
340 #define TOSIGNED(x) (((x) >> 1) ^ LSB2SIGN(x))
343 * Decode DC coefficients for all blocks in a slice.
345 static inline void decode_dc_coeffs(GetBitContext
*gb
, int16_t *out
,
353 code
= decode_vlc_codeword(gb
, FIRST_DC_CB
);
354 out
[0] = prev_dc
= TOSIGNED(code
);
356 out
+= 64; /* move to the DC coeff of the next block */
359 for (i
= 1; i
< nblocks
; i
++, out
+= 64) {
360 code
= decode_vlc_codeword(gb
, ff_prores_dc_codebook
[FFMIN(FFABS(delta
), 3)]);
362 sign
= -(((delta
>> 15) & 1) ^ (code
& 1));
363 delta
= (((code
+ 1) >> 1) ^ sign
) - sign
;
371 * Decode AC coefficients for all blocks in a slice.
373 static inline int decode_ac_coeffs(GetBitContext
*gb
, int16_t *out
,
374 int blocks_per_slice
,
375 int plane_size_factor
,
378 int pos
, block_mask
, run
, level
, sign
, run_cb_index
, lev_cb_index
;
379 int max_coeffs
, bits_left
;
381 /* set initial prediction values */
385 max_coeffs
= blocks_per_slice
<< 6;
386 block_mask
= blocks_per_slice
- 1;
388 for (pos
= blocks_per_slice
- 1; pos
< max_coeffs
;) {
389 run_cb_index
= ff_prores_run_to_cb_index
[FFMIN(run
, 15)];
390 lev_cb_index
= ff_prores_lev_to_cb_index
[FFMIN(level
, 9)];
392 bits_left
= get_bits_left(gb
);
393 if (bits_left
<= 0 || (bits_left
<= 8 && !show_bits(gb
, bits_left
)))
396 run
= decode_vlc_codeword(gb
, ff_prores_ac_codebook
[run_cb_index
]);
398 return AVERROR_INVALIDDATA
;
400 bits_left
= get_bits_left(gb
);
401 if (bits_left
<= 0 || (bits_left
<= 8 && !show_bits(gb
, bits_left
)))
402 return AVERROR_INVALIDDATA
;
404 level
= decode_vlc_codeword(gb
, ff_prores_ac_codebook
[lev_cb_index
]) + 1;
406 return AVERROR_INVALIDDATA
;
409 if (pos
>= max_coeffs
)
412 sign
= get_sbits(gb
, 1);
413 out
[((pos
& block_mask
) << 6) + scan
[pos
>> plane_size_factor
]] =
414 (level
^ sign
) - sign
;
422 * Decode a slice plane (luma or chroma).
424 static int decode_slice_plane(ProresContext
*ctx
, ProresThreadData
*td
,
426 int data_size
, uint16_t *out_ptr
,
427 int linesize
, int mbs_per_slice
,
428 int blocks_per_mb
, int plane_size_factor
,
429 const int16_t *qmat
, int is_chroma
)
433 int mb_num
, blocks_per_slice
, ret
;
435 blocks_per_slice
= mbs_per_slice
* blocks_per_mb
;
437 memset(td
->blocks
, 0, 8 * 4 * 64 * sizeof(*td
->blocks
));
439 init_get_bits(&gb
, buf
, data_size
<< 3);
441 decode_dc_coeffs(&gb
, td
->blocks
, blocks_per_slice
);
443 ret
= decode_ac_coeffs(&gb
, td
->blocks
, blocks_per_slice
,
444 plane_size_factor
, ctx
->scantable
.permutated
);
448 /* inverse quantization, inverse transform and output */
449 block_ptr
= td
->blocks
;
452 for (mb_num
= 0; mb_num
< mbs_per_slice
; mb_num
++, out_ptr
+= blocks_per_mb
* 4) {
453 ctx
->dsp
.idct_put(out_ptr
, linesize
, block_ptr
, qmat
);
455 if (blocks_per_mb
> 2) {
456 ctx
->dsp
.idct_put(out_ptr
+ 8, linesize
, block_ptr
, qmat
);
459 ctx
->dsp
.idct_put(out_ptr
+ linesize
* 4, linesize
, block_ptr
, qmat
);
461 if (blocks_per_mb
> 2) {
462 ctx
->dsp
.idct_put(out_ptr
+ linesize
* 4 + 8, linesize
, block_ptr
, qmat
);
467 for (mb_num
= 0; mb_num
< mbs_per_slice
; mb_num
++, out_ptr
+= blocks_per_mb
* 4) {
468 ctx
->dsp
.idct_put(out_ptr
, linesize
, block_ptr
, qmat
);
470 ctx
->dsp
.idct_put(out_ptr
+ linesize
* 4, linesize
, block_ptr
, qmat
);
472 if (blocks_per_mb
> 2) {
473 ctx
->dsp
.idct_put(out_ptr
+ 8, linesize
, block_ptr
, qmat
);
475 ctx
->dsp
.idct_put(out_ptr
+ linesize
* 4 + 8, linesize
, block_ptr
, qmat
);
484 static void unpack_alpha(GetBitContext
*gb
, uint16_t *dst
, int num_coeffs
,
487 const int mask
= (1 << num_bits
) - 1;
488 int i
, idx
, val
, alpha_val
;
495 val
= get_bits(gb
, num_bits
);
498 val
= get_bits(gb
, num_bits
== 16 ? 7 : 4);
500 val
= (val
+ 2) >> 1;
504 alpha_val
= (alpha_val
+ val
) & mask
;
506 dst
[idx
++] = alpha_val
>> 6;
508 dst
[idx
++] = (alpha_val
<< 2) | (alpha_val
>> 6);
509 if (idx
>= num_coeffs
) {
512 } while (get_bits1(gb
));
513 val
= get_bits(gb
, 4);
515 val
= get_bits(gb
, 11);
516 if (idx
+ val
> num_coeffs
)
517 val
= num_coeffs
- idx
;
519 for (i
= 0; i
< val
; i
++)
520 dst
[idx
++] = alpha_val
>> 6;
522 for (i
= 0; i
< val
; i
++)
523 dst
[idx
++] = (alpha_val
<< 2) | (alpha_val
>> 6);
524 } while (idx
< num_coeffs
);
528 * Decode alpha slice plane.
530 static void decode_alpha_plane(ProresContext
*ctx
, ProresThreadData
*td
,
531 const uint8_t *buf
, int data_size
,
532 uint16_t *out_ptr
, int linesize
,
539 memset(td
->blocks
, 0, 8 * 4 * 64 * sizeof(*td
->blocks
));
541 init_get_bits(&gb
, buf
, data_size
<< 3);
543 if (ctx
->alpha_info
== 2)
544 unpack_alpha(&gb
, td
->blocks
, mbs_per_slice
* 4 * 64, 16);
546 unpack_alpha(&gb
, td
->blocks
, mbs_per_slice
* 4 * 64, 8);
548 block_ptr
= td
->blocks
;
550 for (i
= 0; i
< 16; i
++) {
551 memcpy(out_ptr
, block_ptr
, 16 * mbs_per_slice
* sizeof(*out_ptr
));
552 out_ptr
+= linesize
>> 1;
553 block_ptr
+= 16 * mbs_per_slice
;
557 static int decode_slice(AVCodecContext
*avctx
, void *tdata
)
559 ProresThreadData
*td
= tdata
;
560 ProresContext
*ctx
= avctx
->priv_data
;
561 int mb_x_pos
= td
->x_pos
;
562 int mb_y_pos
= td
->y_pos
;
563 int pic_num
= ctx
->pic_num
;
564 int slice_num
= td
->slice_num
;
565 int mbs_per_slice
= td
->slice_width
;
567 uint8_t *y_data
, *u_data
, *v_data
, *a_data
;
568 AVFrame
*pic
= ctx
->frame
;
569 int i
, sf
, slice_width_factor
;
570 int slice_data_size
, hdr_size
;
571 int y_data_size
, u_data_size
, v_data_size
, a_data_size
;
572 int y_linesize
, u_linesize
, v_linesize
, a_linesize
;
576 buf
= ctx
->slice_data
[slice_num
].index
;
577 slice_data_size
= ctx
->slice_data
[slice_num
+ 1].index
- buf
;
579 slice_width_factor
= av_log2(mbs_per_slice
);
581 y_data
= pic
->data
[0];
582 u_data
= pic
->data
[1];
583 v_data
= pic
->data
[2];
584 a_data
= pic
->data
[3];
585 y_linesize
= pic
->linesize
[0];
586 u_linesize
= pic
->linesize
[1];
587 v_linesize
= pic
->linesize
[2];
588 a_linesize
= pic
->linesize
[3];
590 if (pic
->interlaced_frame
) {
591 if (!(pic_num
^ pic
->top_field_first
)) {
592 y_data
+= y_linesize
;
593 u_data
+= u_linesize
;
594 v_data
+= v_linesize
;
596 a_data
+= a_linesize
;
603 y_data
+= (mb_y_pos
<< 4) * y_linesize
+ (mb_x_pos
<< 5);
604 u_data
+= (mb_y_pos
<< 4) * u_linesize
+ (mb_x_pos
<< ctx
->mb_chroma_factor
);
605 v_data
+= (mb_y_pos
<< 4) * v_linesize
+ (mb_x_pos
<< ctx
->mb_chroma_factor
);
607 a_data
+= (mb_y_pos
<< 4) * a_linesize
+ (mb_x_pos
<< 5);
609 if (slice_data_size
< 6) {
610 av_log(avctx
, AV_LOG_ERROR
, "slice data too small\n");
611 return AVERROR_INVALIDDATA
;
614 /* parse slice header */
615 hdr_size
= buf
[0] >> 3;
617 y_data_size
= AV_RB16(buf
+ 2);
618 coff
[1] = coff
[0] + y_data_size
;
619 u_data_size
= AV_RB16(buf
+ 4);
620 coff
[2] = coff
[1] + u_data_size
;
621 v_data_size
= hdr_size
> 7 ? AV_RB16(buf
+ 6) : slice_data_size
- coff
[2];
622 coff
[3] = coff
[2] + v_data_size
;
623 a_data_size
= ctx
->alpha_info
? slice_data_size
- coff
[3] : 0;
625 /* if V or alpha component size is negative that means that previous
626 component sizes are too large */
627 if (v_data_size
< 0 || a_data_size
< 0 || hdr_size
< 6) {
628 av_log(avctx
, AV_LOG_ERROR
, "invalid data size\n");
629 return AVERROR_INVALIDDATA
;
632 sf
= av_clip(buf
[1], 1, 224);
633 sf
= sf
> 128 ? (sf
- 96) << 2 : sf
;
635 /* scale quantization matrixes according with slice's scale factor */
636 /* TODO: this can be SIMD-optimized a lot */
637 if (ctx
->qmat_changed
|| sf
!= td
->prev_slice_sf
) {
638 td
->prev_slice_sf
= sf
;
639 for (i
= 0; i
< 64; i
++) {
640 td
->qmat_luma_scaled
[ctx
->dsp
.idct_permutation
[i
]] = ctx
->qmat_luma
[i
] * sf
;
641 td
->qmat_chroma_scaled
[ctx
->dsp
.idct_permutation
[i
]] = ctx
->qmat_chroma
[i
] * sf
;
645 /* decode luma plane */
646 ret
= decode_slice_plane(ctx
, td
, buf
+ coff
[0], y_data_size
,
647 (uint16_t*) y_data
, y_linesize
,
648 mbs_per_slice
, 4, slice_width_factor
+ 2,
649 td
->qmat_luma_scaled
, 0);
654 /* decode U chroma plane */
655 ret
= decode_slice_plane(ctx
, td
, buf
+ coff
[1], u_data_size
,
656 (uint16_t*) u_data
, u_linesize
,
657 mbs_per_slice
, ctx
->num_chroma_blocks
,
658 slice_width_factor
+ ctx
->chroma_factor
- 1,
659 td
->qmat_chroma_scaled
, 1);
663 /* decode V chroma plane */
664 ret
= decode_slice_plane(ctx
, td
, buf
+ coff
[2], v_data_size
,
665 (uint16_t*) v_data
, v_linesize
,
666 mbs_per_slice
, ctx
->num_chroma_blocks
,
667 slice_width_factor
+ ctx
->chroma_factor
- 1,
668 td
->qmat_chroma_scaled
, 1);
672 /* decode alpha plane if available */
673 if (a_data
&& a_data_size
)
674 decode_alpha_plane(ctx
, td
, buf
+ coff
[3], a_data_size
,
675 (uint16_t*) a_data
, a_linesize
,
682 static int decode_picture(ProresContext
*ctx
, int pic_num
,
683 AVCodecContext
*avctx
)
685 int slice_num
, slice_width
, x_pos
, y_pos
;
689 ctx
->pic_num
= pic_num
;
690 for (y_pos
= 0; y_pos
< ctx
->num_y_mbs
; y_pos
++) {
691 slice_width
= 1 << ctx
->slice_width_factor
;
693 for (x_pos
= 0; x_pos
< ctx
->num_x_mbs
&& slice_width
;
694 x_pos
+= slice_width
) {
695 while (ctx
->num_x_mbs
- x_pos
< slice_width
)
698 ctx
->slice_data
[slice_num
].slice_num
= slice_num
;
699 ctx
->slice_data
[slice_num
].x_pos
= x_pos
;
700 ctx
->slice_data
[slice_num
].y_pos
= y_pos
;
701 ctx
->slice_data
[slice_num
].slice_width
= slice_width
;
707 return avctx
->execute(avctx
, decode_slice
,
708 ctx
->slice_data
, NULL
, slice_num
,
709 sizeof(ctx
->slice_data
[0]));
713 #define MOVE_DATA_PTR(nbytes) buf += (nbytes); buf_size -= (nbytes)
715 static int decode_frame(AVCodecContext
*avctx
, void *data
, int *got_frame
,
718 ProresContext
*ctx
= avctx
->priv_data
;
719 const uint8_t *buf
= avpkt
->data
;
720 int buf_size
= avpkt
->size
;
721 int frame_hdr_size
, pic_num
, pic_data_size
;
724 ctx
->frame
->pict_type
= AV_PICTURE_TYPE_I
;
725 ctx
->frame
->key_frame
= 1;
727 /* check frame atom container */
728 if (buf_size
< 28 || buf_size
< AV_RB32(buf
) ||
729 AV_RB32(buf
+ 4) != FRAME_ID
) {
730 av_log(avctx
, AV_LOG_ERROR
, "invalid frame\n");
731 return AVERROR_INVALIDDATA
;
736 frame_hdr_size
= decode_frame_header(ctx
, buf
, buf_size
, avctx
);
737 if (frame_hdr_size
< 0)
738 return AVERROR_INVALIDDATA
;
740 MOVE_DATA_PTR(frame_hdr_size
);
742 if (ff_get_buffer(avctx
, ctx
->frame
, 0) < 0)
745 for (pic_num
= 0; ctx
->frame
->interlaced_frame
- pic_num
+ 1; pic_num
++) {
746 pic_data_size
= decode_picture_header(ctx
, buf
, buf_size
, avctx
);
747 if (pic_data_size
< 0)
748 return AVERROR_INVALIDDATA
;
750 if (decode_picture(ctx
, pic_num
, avctx
))
753 MOVE_DATA_PTR(pic_data_size
);
763 static av_cold
int decode_close(AVCodecContext
*avctx
)
765 ProresContext
*ctx
= avctx
->priv_data
;
767 av_freep(&ctx
->slice_data
);
773 AVCodec ff_prores_lgpl_decoder
= {
774 .name
= "prores_lgpl",
775 .long_name
= NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"),
776 .type
= AVMEDIA_TYPE_VIDEO
,
777 .id
= AV_CODEC_ID_PRORES
,
778 .priv_data_size
= sizeof(ProresContext
),
780 .close
= decode_close
,
781 .decode
= decode_frame
,
782 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_SLICE_THREADS
,