git.sesse.net Git - ffmpeg/blob - libavcodec/proresdec2.c

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