Commit | Line | Data |
---|---|---|
2ba45a60 DM |
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 | }; |