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 39static 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 46static 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_dsputil_init(&ctx->dsp, avctx); 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 66static 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 av_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 av_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 av_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 av_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 148static 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 slice_count = AV_RB16(buf + 5); 184 185 if (ctx->slice_count != slice_count || !ctx->slices) { 186 av_freep(&ctx->slices); 187 ctx->slices = av_mallocz_array(slice_count, sizeof(*ctx->slices)); 188 if (!ctx->slices) 189 return AVERROR(ENOMEM); 190 ctx->slice_count = slice_count; 191 } 192 193 if (!slice_count) 194 return AVERROR(EINVAL); 195 196 if (hdr_size + slice_count*2 > buf_size) { 197 av_log(avctx, AV_LOG_ERROR, "error, wrong slice count\n"); 198 return AVERROR_INVALIDDATA; 199 } 200 201 // parse slice information 202 index_ptr = buf + hdr_size; 203 data_ptr = index_ptr + slice_count*2; 204 205 slice_mb_count = 1 << log2_slice_mb_width; 206 mb_x = 0; 207 mb_y = 0; 208 209 for (i = 0; i < slice_count; i++) { 210 SliceContext *slice = &ctx->slices[i]; 211 212 slice->data = data_ptr; 213 data_ptr += AV_RB16(index_ptr + i*2); 214 215 while (ctx->mb_width - mb_x < slice_mb_count) 216 slice_mb_count >>= 1; 217 218 slice->mb_x = mb_x; 219 slice->mb_y = mb_y; 220 slice->mb_count = slice_mb_count; 221 slice->data_size = data_ptr - slice->data; 222 223 if (slice->data_size < 6) { 224 av_log(avctx, AV_LOG_ERROR, "error, wrong slice data size\n"); 225 return AVERROR_INVALIDDATA; 226 } 227 228 mb_x += slice_mb_count; 229 if (mb_x == ctx->mb_width) { 230 slice_mb_count = 1 << log2_slice_mb_width; 231 mb_x = 0; 232 mb_y++; 233 } 234 if (data_ptr > buf + buf_size) { 235 av_log(avctx, AV_LOG_ERROR, "error, slice out of bounds\n"); 236 return AVERROR_INVALIDDATA; 237 } 238 } 239 240 if (mb_x || mb_y != ctx->mb_height) { 241 av_log(avctx, AV_LOG_ERROR, "error wrong mb count y %d h %d\n", 242 mb_y, ctx->mb_height); 243 return AVERROR_INVALIDDATA; 244 } 245 246 return pic_data_size; 247} 248 249#define DECODE_CODEWORD(val, codebook) \ 250 do { \ 251 unsigned int rice_order, exp_order, switch_bits; \ 252 unsigned int q, buf, bits; \ 253 \ 254 UPDATE_CACHE(re, gb); \ 255 buf = GET_CACHE(re, gb); \ 256 \ 257 /* number of bits to switch between rice and exp golomb */ \ 258 switch_bits = codebook & 3; \ 259 rice_order = codebook >> 5; \ 260 exp_order = (codebook >> 2) & 7; \ 261 \ 262 q = 31 - av_log2(buf); \ 263 \ 264 if (q > switch_bits) { /* exp golomb */ \ 265 bits = exp_order - switch_bits + (q<<1); \ 266 val = SHOW_UBITS(re, gb, bits) - (1 << exp_order) + \ 267 ((switch_bits + 1) << rice_order); \ 268 SKIP_BITS(re, gb, bits); \ 269 } else if (rice_order) { \ 270 SKIP_BITS(re, gb, q+1); \ 271 val = (q << rice_order) + SHOW_UBITS(re, gb, rice_order); \ 272 SKIP_BITS(re, gb, rice_order); \ 273 } else { \ 274 val = q; \ 275 SKIP_BITS(re, gb, q+1); \ 276 } \ 277 } while (0) 278 279#define TOSIGNED(x) (((x) >> 1) ^ (-((x) & 1))) 280 281#define FIRST_DC_CB 0xB8 282 283static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70}; 284 285static av_always_inline void decode_dc_coeffs(GetBitContext *gb, int16_t *out, 286 int blocks_per_slice) 287{ 288 int16_t prev_dc; 289 int code, i, sign; 290 291 OPEN_READER(re, gb); 292 293 DECODE_CODEWORD(code, FIRST_DC_CB); 294 prev_dc = TOSIGNED(code); 295 out[0] = prev_dc; 296 297 out += 64; // dc coeff for the next block 298 299 code = 5; 300 sign = 0; 301 for (i = 1; i < blocks_per_slice; i++, out += 64) { 302 DECODE_CODEWORD(code, dc_codebook[FFMIN(code, 6U)]); 303 if(code) sign ^= -(code & 1); 304 else sign = 0; 305 prev_dc += (((code + 1) >> 1) ^ sign) - sign; 306 out[0] = prev_dc; 307 } 308 CLOSE_READER(re, gb); 309} 310 311// adaptive codebook switching lut according to previous run/level values 312static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29, 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C }; 313static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28, 0x28, 0x28, 0x28, 0x4C }; 314 315static av_always_inline int decode_ac_coeffs(AVCodecContext *avctx, GetBitContext *gb, 316 int16_t *out, int blocks_per_slice) 317{ 318 ProresContext *ctx = avctx->priv_data; 319 int block_mask, sign; 320 unsigned pos, run, level; 321 int max_coeffs, i, bits_left; 322 int log2_block_count = av_log2(blocks_per_slice); 323 324 OPEN_READER(re, gb); 325 UPDATE_CACHE(re, gb); \ 326 run = 4; 327 level = 2; 328 329 max_coeffs = 64 << log2_block_count; 330 block_mask = blocks_per_slice - 1; 331 332 for (pos = block_mask;;) { 333 bits_left = gb->size_in_bits - re_index; 334 if (!bits_left || (bits_left < 32 && !SHOW_UBITS(re, gb, bits_left))) 335 break; 336 337 DECODE_CODEWORD(run, run_to_cb[FFMIN(run, 15)]); 338 pos += run + 1; 339 if (pos >= max_coeffs) { 340 av_log(avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", pos, max_coeffs); 341 return AVERROR_INVALIDDATA; 342 } 343 344 DECODE_CODEWORD(level, lev_to_cb[FFMIN(level, 9)]); 345 level += 1; 346 347 i = pos >> log2_block_count; 348 349 sign = SHOW_SBITS(re, gb, 1); 350 SKIP_BITS(re, gb, 1); 351 out[((pos & block_mask) << 6) + ctx->scan[i]] = ((level ^ sign) - sign); 352 } 353 354 CLOSE_READER(re, gb); 355 return 0; 356} 357 358static int decode_slice_luma(AVCodecContext *avctx, SliceContext *slice, 359 uint16_t *dst, int dst_stride, 360 const uint8_t *buf, unsigned buf_size, 361 const int16_t *qmat) 362{ 363 ProresContext *ctx = avctx->priv_data; 364 LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]); 365 int16_t *block; 366 GetBitContext gb; 367 int i, blocks_per_slice = slice->mb_count<<2; 368 int ret; 369 370 for (i = 0; i < blocks_per_slice; i++) 371 ctx->bdsp.clear_block(blocks+(i<<6)); 372 373 init_get_bits(&gb, buf, buf_size << 3); 374 375 decode_dc_coeffs(&gb, blocks, blocks_per_slice); 376 if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0) 377 return ret; 378 379 block = blocks; 380 for (i = 0; i < slice->mb_count; i++) { 381 ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat); 382 ctx->prodsp.idct_put(dst +8, dst_stride, block+(1<<6), qmat); 383 ctx->prodsp.idct_put(dst+4*dst_stride , dst_stride, block+(2<<6), qmat); 384 ctx->prodsp.idct_put(dst+4*dst_stride+8, dst_stride, block+(3<<6), qmat); 385 block += 4*64; 386 dst += 16; 387 } 388 return 0; 389} 390 391static int decode_slice_chroma(AVCodecContext *avctx, SliceContext *slice, 392 uint16_t *dst, int dst_stride, 393 const uint8_t *buf, unsigned buf_size, 394 const int16_t *qmat, int log2_blocks_per_mb) 395{ 396 ProresContext *ctx = avctx->priv_data; 397 LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]); 398 int16_t *block; 399 GetBitContext gb; 400 int i, j, blocks_per_slice = slice->mb_count << log2_blocks_per_mb; 401 int ret; 402 403 for (i = 0; i < blocks_per_slice; i++) 404 ctx->bdsp.clear_block(blocks+(i<<6)); 405 406 init_get_bits(&gb, buf, buf_size << 3); 407 408 decode_dc_coeffs(&gb, blocks, blocks_per_slice); 409 if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0) 410 return ret; 411 412 block = blocks; 413 for (i = 0; i < slice->mb_count; i++) { 414 for (j = 0; j < log2_blocks_per_mb; j++) { 415 ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat); 416 ctx->prodsp.idct_put(dst+4*dst_stride, dst_stride, block+(1<<6), qmat); 417 block += 2*64; 418 dst += 8; 419 } 420 } 421 return 0; 422} 423 424static void unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs, 425 const int num_bits) 426{ 427 const int mask = (1 << num_bits) - 1; 428 int i, idx, val, alpha_val; 429 430 idx = 0; 431 alpha_val = mask; 432 do { 433 do { 434 if (get_bits1(gb)) { 435 val = get_bits(gb, num_bits); 436 } else { 437 int sign; 438 val = get_bits(gb, num_bits == 16 ? 7 : 4); 439 sign = val & 1; 440 val = (val + 2) >> 1; 441 if (sign) 442 val = -val; 443 } 444 alpha_val = (alpha_val + val) & mask; 445 if (num_bits == 16) { 446 dst[idx++] = alpha_val >> 6; 447 } else { 448 dst[idx++] = (alpha_val << 2) | (alpha_val >> 6); 449 } 450 if (idx >= num_coeffs) 451 break; 452 } while (get_bits_left(gb)>0 && get_bits1(gb)); 453 val = get_bits(gb, 4); 454 if (!val) 455 val = get_bits(gb, 11); 456 if (idx + val > num_coeffs) 457 val = num_coeffs - idx; 458 if (num_bits == 16) { 459 for (i = 0; i < val; i++) 460 dst[idx++] = alpha_val >> 6; 461 } else { 462 for (i = 0; i < val; i++) 463 dst[idx++] = (alpha_val << 2) | (alpha_val >> 6); 464 465 } 466 } while (idx < num_coeffs); 467} 468 469/** 470 * Decode alpha slice plane. 471 */ 472static void decode_slice_alpha(ProresContext *ctx, 473 uint16_t *dst, int dst_stride, 474 const uint8_t *buf, int buf_size, 475 int blocks_per_slice) 476{ 477 GetBitContext gb; 478 int i; 479 LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]); 480 int16_t *block; 481 482 for (i = 0; i < blocks_per_slice<<2; i++) 483 ctx->bdsp.clear_block(blocks+(i<<6)); 484 485 init_get_bits(&gb, buf, buf_size << 3); 486 487 if (ctx->alpha_info == 2) { 488 unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 16); 489 } else { 490 unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 8); 491 } 492 493 block = blocks; 494 for (i = 0; i < 16; i++) { 495 memcpy(dst, block, 16 * blocks_per_slice * sizeof(*dst)); 496 dst += dst_stride >> 1; 497 block += 16 * blocks_per_slice; 498 } 499} 500 501static int decode_slice_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr) 502{ 503 ProresContext *ctx = avctx->priv_data; 504 SliceContext *slice = &ctx->slices[jobnr]; 505 const uint8_t *buf = slice->data; 506 AVFrame *pic = ctx->frame; 507 int i, hdr_size, qscale, log2_chroma_blocks_per_mb; 508 int luma_stride, chroma_stride; 509 int y_data_size, u_data_size, v_data_size, a_data_size; 510 uint8_t *dest_y, *dest_u, *dest_v, *dest_a; 511 int16_t qmat_luma_scaled[64]; 512 int16_t qmat_chroma_scaled[64]; 513 int mb_x_shift; 514 int ret; 515 516 slice->ret = -1; 517 //av_log(avctx, AV_LOG_INFO, "slice %d mb width %d mb x %d y %d\n", 518 // jobnr, slice->mb_count, slice->mb_x, slice->mb_y); 519 520 // slice header 521 hdr_size = buf[0] >> 3; 522 qscale = av_clip(buf[1], 1, 224); 523 qscale = qscale > 128 ? qscale - 96 << 2: qscale; 524 y_data_size = AV_RB16(buf + 2); 525 u_data_size = AV_RB16(buf + 4); 526 v_data_size = slice->data_size - y_data_size - u_data_size - hdr_size; 527 if (hdr_size > 7) v_data_size = AV_RB16(buf + 6); 528 a_data_size = slice->data_size - y_data_size - u_data_size - 529 v_data_size - hdr_size; 530 531 if (y_data_size < 0 || u_data_size < 0 || v_data_size < 0 532 || hdr_size+y_data_size+u_data_size+v_data_size > slice->data_size){ 533 av_log(avctx, AV_LOG_ERROR, "invalid plane data size\n"); 534 return AVERROR_INVALIDDATA; 535 } 536 537 buf += hdr_size; 538 539 for (i = 0; i < 64; i++) { 540 qmat_luma_scaled [i] = ctx->qmat_luma [i] * qscale; 541 qmat_chroma_scaled[i] = ctx->qmat_chroma[i] * qscale; 542 } 543 544 if (ctx->frame_type == 0) { 545 luma_stride = pic->linesize[0]; 546 chroma_stride = pic->linesize[1]; 547 } else { 548 luma_stride = pic->linesize[0] << 1; 549 chroma_stride = pic->linesize[1] << 1; 550 } 551 552 if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10 || avctx->pix_fmt == AV_PIX_FMT_YUVA444P10) { 553 mb_x_shift = 5; 554 log2_chroma_blocks_per_mb = 2; 555 } else { 556 mb_x_shift = 4; 557 log2_chroma_blocks_per_mb = 1; 558 } 559 560 dest_y = pic->data[0] + (slice->mb_y << 4) * luma_stride + (slice->mb_x << 5); 561 dest_u = pic->data[1] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift); 562 dest_v = pic->data[2] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift); 563 dest_a = pic->data[3] + (slice->mb_y << 4) * luma_stride + (slice->mb_x << 5); 564 565 if (ctx->frame_type && ctx->first_field ^ ctx->frame->top_field_first) { 566 dest_y += pic->linesize[0]; 567 dest_u += pic->linesize[1]; 568 dest_v += pic->linesize[2]; 569 dest_a += pic->linesize[3]; 570 } 571 572 ret = decode_slice_luma(avctx, slice, (uint16_t*)dest_y, luma_stride, 573 buf, y_data_size, qmat_luma_scaled); 574 if (ret < 0) 575 return ret; 576 577 if (!(avctx->flags & CODEC_FLAG_GRAY)) { 578 ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_u, chroma_stride, 579 buf + y_data_size, u_data_size, 580 qmat_chroma_scaled, log2_chroma_blocks_per_mb); 581 if (ret < 0) 582 return ret; 583 584 ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_v, chroma_stride, 585 buf + y_data_size + u_data_size, v_data_size, 586 qmat_chroma_scaled, log2_chroma_blocks_per_mb); 587 if (ret < 0) 588 return ret; 589 } 590 /* decode alpha plane if available */ 591 if (ctx->alpha_info && pic->data[3] && a_data_size) 592 decode_slice_alpha(ctx, (uint16_t*)dest_a, luma_stride, 593 buf + y_data_size + u_data_size + v_data_size, 594 a_data_size, slice->mb_count); 595 596 slice->ret = 0; 597 return 0; 598} 599 600static int decode_picture(AVCodecContext *avctx) 601{ 602 ProresContext *ctx = avctx->priv_data; 603 int i; 604 605 avctx->execute2(avctx, decode_slice_thread, NULL, NULL, ctx->slice_count); 606 607 for (i = 0; i < ctx->slice_count; i++) 608 if (ctx->slices[i].ret < 0) 609 return ctx->slices[i].ret; 610 611 return 0; 612} 613 614static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, 615 AVPacket *avpkt) 616{ 617 ProresContext *ctx = avctx->priv_data; 618 AVFrame *frame = data; 619 const uint8_t *buf = avpkt->data; 620 int buf_size = avpkt->size; 621 int frame_hdr_size, pic_size, ret; 622 623 if (buf_size < 28 || AV_RL32(buf + 4) != AV_RL32("icpf")) { 624 av_log(avctx, AV_LOG_ERROR, "invalid frame header\n"); 625 return AVERROR_INVALIDDATA; 626 } 627 628 ctx->frame = frame; 629 ctx->frame->pict_type = AV_PICTURE_TYPE_I; 630 ctx->frame->key_frame = 1; 631 ctx->first_field = 1; 632 633 buf += 8; 634 buf_size -= 8; 635 636 frame_hdr_size = decode_frame_header(ctx, buf, buf_size, avctx); 637 if (frame_hdr_size < 0) 638 return frame_hdr_size; 639 640 buf += frame_hdr_size; 641 buf_size -= frame_hdr_size; 642 643 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) 644 return ret; 645 646 decode_picture: 647 pic_size = decode_picture_header(avctx, buf, buf_size); 648 if (pic_size < 0) { 649 av_log(avctx, AV_LOG_ERROR, "error decoding picture header\n"); 650 return pic_size; 651 } 652 653 if ((ret = decode_picture(avctx)) < 0) { 654 av_log(avctx, AV_LOG_ERROR, "error decoding picture\n"); 655 return ret; 656 } 657 658 buf += pic_size; 659 buf_size -= pic_size; 660 661 if (ctx->frame_type && buf_size > 0 && ctx->first_field) { 662 ctx->first_field = 0; 663 goto decode_picture; 664 } 665 666 *got_frame = 1; 667 668 return avpkt->size; 669} 670 671static av_cold int decode_close(AVCodecContext *avctx) 672{ 673 ProresContext *ctx = avctx->priv_data; 674 675 av_freep(&ctx->slices); 676 677 return 0; 678} 679 680AVCodec ff_prores_decoder = { 681 .name = "prores", 682 .long_name = NULL_IF_CONFIG_SMALL("ProRes"), 683 .type = AVMEDIA_TYPE_VIDEO, 684 .id = AV_CODEC_ID_PRORES, 685 .priv_data_size = sizeof(ProresContext), 686 .init = decode_init, 687 .close = decode_close, 688 .decode = decode_frame, 689 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS, 690}; 691