path: root/libavcodec/proresdec2.c (plain)
blob: ff46bcfde0d723431e16a69d48d2d7a68e142d10

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