Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Apple ProRes compatible decoder
  3.  *
  4.  * Copyright (c) 2010-2011 Maxim Poliakovski
  5.  *
  6.  * This file is part of FFmpeg.
  7.  *
  8.  * FFmpeg is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Lesser General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2.1 of the License, or (at your option) any later version.
  12.  *
  13.  * FFmpeg is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Lesser General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Lesser General Public
  19.  * License along with FFmpeg; if not, write to the Free Software
  20.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21.  */
  22.  
  23. /**
  24.  * @file
  25.  * This is a decoder for Apple ProRes 422 SD/HQ/LT/Proxy and ProRes 4444.
  26.  * It is used for storing and editing high definition video data in Apple's Final Cut Pro.
  27.  *
  28.  * @see http://wiki.multimedia.cx/index.php?title=Apple_ProRes
  29.  */
  30.  
  31. #define LONG_BITSTREAM_READER // some ProRes vlc codes require up to 28 bits to be read at once
  32.  
  33. #include <stdint.h>
  34.  
  35. #include "libavutil/intmath.h"
  36. #include "avcodec.h"
  37. #include "dsputil.h"
  38. #include "internal.h"
  39. #include "proresdata.h"
  40. #include "proresdsp.h"
  41. #include "get_bits.h"
  42.  
  43. typedef struct {
  44.     const uint8_t *index;            ///< pointers to the data of this slice
  45.     int slice_num;
  46.     int x_pos, y_pos;
  47.     int slice_width;
  48.     int prev_slice_sf;               ///< scalefactor of the previous decoded slice
  49.     DECLARE_ALIGNED(16, int16_t, blocks)[8 * 4 * 64];
  50.     DECLARE_ALIGNED(16, int16_t, qmat_luma_scaled)[64];
  51.     DECLARE_ALIGNED(16, int16_t, qmat_chroma_scaled)[64];
  52. } ProresThreadData;
  53.  
  54. typedef struct {
  55.     ProresDSPContext dsp;
  56.     AVFrame    *frame;
  57.     ScanTable  scantable;
  58.     int        scantable_type;           ///< -1 = uninitialized, 0 = progressive, 1/2 = interlaced
  59.  
  60.     int        frame_type;               ///< 0 = progressive, 1 = top-field first, 2 = bottom-field first
  61.     int        pic_format;               ///< 2 = 422, 3 = 444
  62.     uint8_t    qmat_luma[64];            ///< dequantization matrix for luma
  63.     uint8_t    qmat_chroma[64];          ///< dequantization matrix for chroma
  64.     int        qmat_changed;             ///< 1 - global quantization matrices changed
  65.     int        total_slices;            ///< total number of slices in a picture
  66.     ProresThreadData *slice_data;
  67.     int        pic_num;
  68.     int        chroma_factor;
  69.     int        mb_chroma_factor;
  70.     int        num_chroma_blocks;       ///< number of chrominance blocks in a macroblock
  71.     int        num_x_slices;
  72.     int        num_y_slices;
  73.     int        slice_width_factor;
  74.     int        slice_height_factor;
  75.     int        num_x_mbs;
  76.     int        num_y_mbs;
  77.     int        alpha_info;
  78. } ProresContext;
  79.  
  80.  
  81. static av_cold int decode_init(AVCodecContext *avctx)
  82. {
  83.     ProresContext *ctx = avctx->priv_data;
  84.  
  85.     ctx->total_slices     = 0;
  86.     ctx->slice_data       = NULL;
  87.  
  88.     avctx->bits_per_raw_sample = PRORES_BITS_PER_SAMPLE;
  89.     ff_proresdsp_init(&ctx->dsp, avctx);
  90.  
  91.     ctx->scantable_type = -1;   // set scantable type to uninitialized
  92.     memset(ctx->qmat_luma, 4, 64);
  93.     memset(ctx->qmat_chroma, 4, 64);
  94.  
  95.     return 0;
  96. }
  97.  
  98.  
  99. static int decode_frame_header(ProresContext *ctx, const uint8_t *buf,
  100.                                const int data_size, AVCodecContext *avctx)
  101. {
  102.     int hdr_size, version, width, height, flags;
  103.     const uint8_t *ptr;
  104.  
  105.     hdr_size = AV_RB16(buf);
  106.     if (hdr_size > data_size) {
  107.         av_log(avctx, AV_LOG_ERROR, "frame data too small\n");
  108.         return AVERROR_INVALIDDATA;
  109.     }
  110.  
  111.     version = AV_RB16(buf + 2);
  112.     if (version >= 2) {
  113.         av_log(avctx, AV_LOG_ERROR,
  114.                "unsupported header version: %d\n", version);
  115.         return AVERROR_INVALIDDATA;
  116.     }
  117.  
  118.     width  = AV_RB16(buf + 8);
  119.     height = AV_RB16(buf + 10);
  120.     if (width != avctx->width || height != avctx->height) {
  121.         av_log(avctx, AV_LOG_ERROR,
  122.                "picture dimension changed: old: %d x %d, new: %d x %d\n",
  123.                avctx->width, avctx->height, width, height);
  124.         return AVERROR_INVALIDDATA;
  125.     }
  126.  
  127.     ctx->frame_type = (buf[12] >> 2) & 3;
  128.     if (ctx->frame_type > 2) {
  129.         av_log(avctx, AV_LOG_ERROR,
  130.                "unsupported frame type: %d\n", ctx->frame_type);
  131.         return AVERROR_INVALIDDATA;
  132.     }
  133.  
  134.     ctx->chroma_factor     = (buf[12] >> 6) & 3;
  135.     ctx->mb_chroma_factor  = ctx->chroma_factor + 2;
  136.     ctx->num_chroma_blocks = (1 << ctx->chroma_factor) >> 1;
  137.     ctx->alpha_info        = buf[17] & 0xf;
  138.  
  139.     if (ctx->alpha_info > 2) {
  140.         av_log(avctx, AV_LOG_ERROR, "Invalid alpha mode %d\n", ctx->alpha_info);
  141.         return AVERROR_INVALIDDATA;
  142.     }
  143.     if (avctx->skip_alpha) ctx->alpha_info = 0;
  144.  
  145.     switch (ctx->chroma_factor) {
  146.     case 2:
  147.         avctx->pix_fmt = ctx->alpha_info ? AV_PIX_FMT_YUVA422P10
  148.                                          : AV_PIX_FMT_YUV422P10;
  149.         break;
  150.     case 3:
  151.         avctx->pix_fmt = ctx->alpha_info ? AV_PIX_FMT_YUVA444P10
  152.                                          : AV_PIX_FMT_YUV444P10;
  153.         break;
  154.     default:
  155.         av_log(avctx, AV_LOG_ERROR,
  156.                "unsupported picture format: %d\n", ctx->pic_format);
  157.         return AVERROR_INVALIDDATA;
  158.     }
  159.  
  160.     if (ctx->scantable_type != ctx->frame_type) {
  161.         if (!ctx->frame_type)
  162.             ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable,
  163.                               ff_prores_progressive_scan);
  164.         else
  165.             ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable,
  166.                               ff_prores_interlaced_scan);
  167.         ctx->scantable_type = ctx->frame_type;
  168.     }
  169.  
  170.     if (ctx->frame_type) {      /* if interlaced */
  171.         ctx->frame->interlaced_frame = 1;
  172.         ctx->frame->top_field_first  = ctx->frame_type & 1;
  173.     } else {
  174.         ctx->frame->interlaced_frame = 0;
  175.     }
  176.  
  177.     avctx->color_primaries = buf[14];
  178.     avctx->color_trc       = buf[15];
  179.     avctx->colorspace      = buf[16];
  180.  
  181.     ctx->qmat_changed = 0;
  182.     ptr   = buf + 20;
  183.     flags = buf[19];
  184.     if (flags & 2) {
  185.         if (ptr - buf > hdr_size - 64) {
  186.             av_log(avctx, AV_LOG_ERROR, "header data too small\n");
  187.             return AVERROR_INVALIDDATA;
  188.         }
  189.         if (memcmp(ctx->qmat_luma, ptr, 64)) {
  190.             memcpy(ctx->qmat_luma, ptr, 64);
  191.             ctx->qmat_changed = 1;
  192.         }
  193.         ptr += 64;
  194.     } else {
  195.         memset(ctx->qmat_luma, 4, 64);
  196.         ctx->qmat_changed = 1;
  197.     }
  198.  
  199.     if (flags & 1) {
  200.         if (ptr - buf > hdr_size - 64) {
  201.             av_log(avctx, AV_LOG_ERROR, "header data too small\n");
  202.             return -1;
  203.         }
  204.         if (memcmp(ctx->qmat_chroma, ptr, 64)) {
  205.             memcpy(ctx->qmat_chroma, ptr, 64);
  206.             ctx->qmat_changed = 1;
  207.         }
  208.     } else {
  209.         memset(ctx->qmat_chroma, 4, 64);
  210.         ctx->qmat_changed = 1;
  211.     }
  212.  
  213.     return hdr_size;
  214. }
  215.  
  216.  
  217. static int decode_picture_header(ProresContext *ctx, const uint8_t *buf,
  218.                                  const int data_size, AVCodecContext *avctx)
  219. {
  220.     int   i, hdr_size, pic_data_size, num_slices;
  221.     int   slice_width_factor, slice_height_factor;
  222.     int   remainder, num_x_slices;
  223.     const uint8_t *data_ptr, *index_ptr;
  224.  
  225.     hdr_size = data_size > 0 ? buf[0] >> 3 : 0;
  226.     if (hdr_size < 8 || hdr_size > data_size) {
  227.         av_log(avctx, AV_LOG_ERROR, "picture header too small\n");
  228.         return AVERROR_INVALIDDATA;
  229.     }
  230.  
  231.     pic_data_size = AV_RB32(buf + 1);
  232.     if (pic_data_size > data_size) {
  233.         av_log(avctx, AV_LOG_ERROR, "picture data too small\n");
  234.         return AVERROR_INVALIDDATA;
  235.     }
  236.  
  237.     slice_width_factor  = buf[7] >> 4;
  238.     slice_height_factor = buf[7] & 0xF;
  239.     if (slice_width_factor > 3 || slice_height_factor) {
  240.         av_log(avctx, AV_LOG_ERROR,
  241.                "unsupported slice dimension: %d x %d\n",
  242.                1 << slice_width_factor, 1 << slice_height_factor);
  243.         return AVERROR_INVALIDDATA;
  244.     }
  245.  
  246.     ctx->slice_width_factor  = slice_width_factor;
  247.     ctx->slice_height_factor = slice_height_factor;
  248.  
  249.     ctx->num_x_mbs = (avctx->width + 15) >> 4;
  250.     ctx->num_y_mbs = (avctx->height +
  251.                       (1 << (4 + ctx->frame->interlaced_frame)) - 1) >>
  252.                      (4 + ctx->frame->interlaced_frame);
  253.  
  254.     remainder    = ctx->num_x_mbs & ((1 << slice_width_factor) - 1);
  255.     num_x_slices = (ctx->num_x_mbs >> slice_width_factor) + (remainder & 1) +
  256.                    ((remainder >> 1) & 1) + ((remainder >> 2) & 1);
  257.  
  258.     num_slices = num_x_slices * ctx->num_y_mbs;
  259.     if (num_slices != AV_RB16(buf + 5)) {
  260.         av_log(avctx, AV_LOG_ERROR, "invalid number of slices\n");
  261.         return AVERROR_INVALIDDATA;
  262.     }
  263.  
  264.     if (ctx->total_slices != num_slices) {
  265.         av_freep(&ctx->slice_data);
  266.         ctx->slice_data = av_malloc((num_slices + 1) * sizeof(ctx->slice_data[0]));
  267.         if (!ctx->slice_data)
  268.             return AVERROR(ENOMEM);
  269.         ctx->total_slices = num_slices;
  270.     }
  271.  
  272.     if (hdr_size + num_slices * 2 > data_size) {
  273.         av_log(avctx, AV_LOG_ERROR, "slice table too small\n");
  274.         return AVERROR_INVALIDDATA;
  275.     }
  276.  
  277.     /* parse slice table allowing quick access to the slice data */
  278.     index_ptr = buf + hdr_size;
  279.     data_ptr = index_ptr + num_slices * 2;
  280.  
  281.     for (i = 0; i < num_slices; i++) {
  282.         ctx->slice_data[i].index = data_ptr;
  283.         ctx->slice_data[i].prev_slice_sf = 0;
  284.         data_ptr += AV_RB16(index_ptr + i * 2);
  285.     }
  286.     ctx->slice_data[i].index = data_ptr;
  287.     ctx->slice_data[i].prev_slice_sf = 0;
  288.  
  289.     if (data_ptr > buf + data_size) {
  290.         av_log(avctx, AV_LOG_ERROR, "out of slice data\n");
  291.         return -1;
  292.     }
  293.  
  294.     return pic_data_size;
  295. }
  296.  
  297.  
  298. /**
  299.  * Read an unsigned rice/exp golomb codeword.
  300.  */
  301. static inline int decode_vlc_codeword(GetBitContext *gb, unsigned codebook)
  302. {
  303.     unsigned int rice_order, exp_order, switch_bits;
  304.     unsigned int buf, code;
  305.     int log, prefix_len, len;
  306.  
  307.     OPEN_READER(re, gb);
  308.     UPDATE_CACHE(re, gb);
  309.     buf = GET_CACHE(re, gb);
  310.  
  311.     /* number of prefix bits to switch between Rice and expGolomb */
  312.     switch_bits = (codebook & 3) + 1;
  313.     rice_order  = codebook >> 5;        /* rice code order */
  314.     exp_order   = (codebook >> 2) & 7;  /* exp golomb code order */
  315.  
  316.     log = 31 - av_log2(buf); /* count prefix bits (zeroes) */
  317.  
  318.     if (log < switch_bits) { /* ok, we got a rice code */
  319.         if (!rice_order) {
  320.             /* shortcut for faster decoding of rice codes without remainder */
  321.             code = log;
  322.             LAST_SKIP_BITS(re, gb, log + 1);
  323.         } else {
  324.             prefix_len = log + 1;
  325.             code = (log << rice_order) + NEG_USR32(buf << prefix_len, rice_order);
  326.             LAST_SKIP_BITS(re, gb, prefix_len + rice_order);
  327.         }
  328.     } else { /* otherwise we got a exp golomb code */
  329.         len  = (log << 1) - switch_bits + exp_order + 1;
  330.         code = NEG_USR32(buf, len) - (1 << exp_order) + (switch_bits << rice_order);
  331.         LAST_SKIP_BITS(re, gb, len);
  332.     }
  333.  
  334.     CLOSE_READER(re, gb);
  335.  
  336.     return code;
  337. }
  338.  
  339. #define LSB2SIGN(x) (-((x) & 1))
  340. #define TOSIGNED(x) (((x) >> 1) ^ LSB2SIGN(x))
  341.  
  342. /**
  343.  * Decode DC coefficients for all blocks in a slice.
  344.  */
  345. static inline void decode_dc_coeffs(GetBitContext *gb, int16_t *out,
  346.                                     int nblocks)
  347. {
  348.     int16_t prev_dc;
  349.     int     i, sign;
  350.     int16_t delta;
  351.     unsigned int code;
  352.  
  353.     code   = decode_vlc_codeword(gb, FIRST_DC_CB);
  354.     out[0] = prev_dc = TOSIGNED(code);
  355.  
  356.     out   += 64; /* move to the DC coeff of the next block */
  357.     delta  = 3;
  358.  
  359.     for (i = 1; i < nblocks; i++, out += 64) {
  360.         code = decode_vlc_codeword(gb, ff_prores_dc_codebook[FFMIN(FFABS(delta), 3)]);
  361.  
  362.         sign     = -(((delta >> 15) & 1) ^ (code & 1));
  363.         delta    = (((code + 1) >> 1) ^ sign) - sign;
  364.         prev_dc += delta;
  365.         out[0]   = prev_dc;
  366.     }
  367. }
  368.  
  369.  
  370. /**
  371.  * Decode AC coefficients for all blocks in a slice.
  372.  */
  373. static inline int decode_ac_coeffs(GetBitContext *gb, int16_t *out,
  374.                                    int blocks_per_slice,
  375.                                    int plane_size_factor,
  376.                                    const uint8_t *scan)
  377. {
  378.     int pos, block_mask, run, level, sign, run_cb_index, lev_cb_index;
  379.     int max_coeffs, bits_left;
  380.  
  381.     /* set initial prediction values */
  382.     run   = 4;
  383.     level = 2;
  384.  
  385.     max_coeffs = blocks_per_slice << 6;
  386.     block_mask = blocks_per_slice - 1;
  387.  
  388.     for (pos = blocks_per_slice - 1; pos < max_coeffs;) {
  389.         run_cb_index = ff_prores_run_to_cb_index[FFMIN(run, 15)];
  390.         lev_cb_index = ff_prores_lev_to_cb_index[FFMIN(level, 9)];
  391.  
  392.         bits_left = get_bits_left(gb);
  393.         if (bits_left <= 0 || (bits_left <= 8 && !show_bits(gb, bits_left)))
  394.             return 0;
  395.  
  396.         run = decode_vlc_codeword(gb, ff_prores_ac_codebook[run_cb_index]);
  397.         if (run < 0)
  398.             return AVERROR_INVALIDDATA;
  399.  
  400.         bits_left = get_bits_left(gb);
  401.         if (bits_left <= 0 || (bits_left <= 8 && !show_bits(gb, bits_left)))
  402.             return AVERROR_INVALIDDATA;
  403.  
  404.         level = decode_vlc_codeword(gb, ff_prores_ac_codebook[lev_cb_index]) + 1;
  405.         if (level < 0)
  406.             return AVERROR_INVALIDDATA;
  407.  
  408.         pos += run + 1;
  409.         if (pos >= max_coeffs)
  410.             break;
  411.  
  412.         sign = get_sbits(gb, 1);
  413.         out[((pos & block_mask) << 6) + scan[pos >> plane_size_factor]] =
  414.             (level ^ sign) - sign;
  415.     }
  416.  
  417.     return 0;
  418. }
  419.  
  420.  
  421. /**
  422.  * Decode a slice plane (luma or chroma).
  423.  */
  424. static int decode_slice_plane(ProresContext *ctx, ProresThreadData *td,
  425.                               const uint8_t *buf,
  426.                               int data_size, uint16_t *out_ptr,
  427.                               int linesize, int mbs_per_slice,
  428.                               int blocks_per_mb, int plane_size_factor,
  429.                               const int16_t *qmat, int is_chroma)
  430. {
  431.     GetBitContext gb;
  432.     int16_t *block_ptr;
  433.     int mb_num, blocks_per_slice, ret;
  434.  
  435.     blocks_per_slice = mbs_per_slice * blocks_per_mb;
  436.  
  437.     memset(td->blocks, 0, 8 * 4 * 64 * sizeof(*td->blocks));
  438.  
  439.     init_get_bits(&gb, buf, data_size << 3);
  440.  
  441.     decode_dc_coeffs(&gb, td->blocks, blocks_per_slice);
  442.  
  443.     ret = decode_ac_coeffs(&gb, td->blocks, blocks_per_slice,
  444.                            plane_size_factor, ctx->scantable.permutated);
  445.     if (ret < 0)
  446.         return ret;
  447.  
  448.     /* inverse quantization, inverse transform and output */
  449.     block_ptr = td->blocks;
  450.  
  451.     if (!is_chroma) {
  452.         for (mb_num = 0; mb_num < mbs_per_slice; mb_num++, out_ptr += blocks_per_mb * 4) {
  453.             ctx->dsp.idct_put(out_ptr,                    linesize, block_ptr, qmat);
  454.             block_ptr += 64;
  455.             if (blocks_per_mb > 2) {
  456.                 ctx->dsp.idct_put(out_ptr + 8,            linesize, block_ptr, qmat);
  457.                 block_ptr += 64;
  458.             }
  459.             ctx->dsp.idct_put(out_ptr + linesize * 4,     linesize, block_ptr, qmat);
  460.             block_ptr += 64;
  461.             if (blocks_per_mb > 2) {
  462.                 ctx->dsp.idct_put(out_ptr + linesize * 4 + 8, linesize, block_ptr, qmat);
  463.                 block_ptr += 64;
  464.             }
  465.         }
  466.     } else {
  467.         for (mb_num = 0; mb_num < mbs_per_slice; mb_num++, out_ptr += blocks_per_mb * 4) {
  468.             ctx->dsp.idct_put(out_ptr,                    linesize, block_ptr, qmat);
  469.             block_ptr += 64;
  470.             ctx->dsp.idct_put(out_ptr + linesize * 4,     linesize, block_ptr, qmat);
  471.             block_ptr += 64;
  472.             if (blocks_per_mb > 2) {
  473.                 ctx->dsp.idct_put(out_ptr + 8,            linesize, block_ptr, qmat);
  474.                 block_ptr += 64;
  475.                 ctx->dsp.idct_put(out_ptr + linesize * 4 + 8, linesize, block_ptr, qmat);
  476.                 block_ptr += 64;
  477.             }
  478.         }
  479.     }
  480.     return 0;
  481. }
  482.  
  483.  
  484. static void unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs,
  485.                          const int num_bits)
  486. {
  487.     const int mask = (1 << num_bits) - 1;
  488.     int i, idx, val, alpha_val;
  489.  
  490.     idx       = 0;
  491.     alpha_val = mask;
  492.     do {
  493.         do {
  494.             if (get_bits1(gb))
  495.                 val = get_bits(gb, num_bits);
  496.             else {
  497.                 int sign;
  498.                 val  = get_bits(gb, num_bits == 16 ? 7 : 4);
  499.                 sign = val & 1;
  500.                 val  = (val + 2) >> 1;
  501.                 if (sign)
  502.                     val = -val;
  503.             }
  504.             alpha_val = (alpha_val + val) & mask;
  505.             if (num_bits == 16)
  506.                 dst[idx++] = alpha_val >> 6;
  507.             else
  508.                 dst[idx++] = (alpha_val << 2) | (alpha_val >> 6);
  509.             if (idx >= num_coeffs) {
  510.                 break;
  511.             }
  512.         } while (get_bits1(gb));
  513.         val = get_bits(gb, 4);
  514.         if (!val)
  515.             val = get_bits(gb, 11);
  516.         if (idx + val > num_coeffs)
  517.             val = num_coeffs - idx;
  518.         if (num_bits == 16)
  519.             for (i = 0; i < val; i++)
  520.                 dst[idx++] = alpha_val >> 6;
  521.         else
  522.             for (i = 0; i < val; i++)
  523.                 dst[idx++] = (alpha_val << 2) | (alpha_val >> 6);
  524.     } while (idx < num_coeffs);
  525. }
  526.  
  527. /**
  528.  * Decode alpha slice plane.
  529.  */
  530. static void decode_alpha_plane(ProresContext *ctx, ProresThreadData *td,
  531.                                const uint8_t *buf, int data_size,
  532.                                uint16_t *out_ptr, int linesize,
  533.                                int mbs_per_slice)
  534. {
  535.     GetBitContext gb;
  536.     int i;
  537.     uint16_t *block_ptr;
  538.  
  539.     memset(td->blocks, 0, 8 * 4 * 64 * sizeof(*td->blocks));
  540.  
  541.     init_get_bits(&gb, buf, data_size << 3);
  542.  
  543.     if (ctx->alpha_info == 2)
  544.         unpack_alpha(&gb, td->blocks, mbs_per_slice * 4 * 64, 16);
  545.     else
  546.         unpack_alpha(&gb, td->blocks, mbs_per_slice * 4 * 64, 8);
  547.  
  548.     block_ptr = td->blocks;
  549.  
  550.     for (i = 0; i < 16; i++) {
  551.         memcpy(out_ptr, block_ptr, 16 * mbs_per_slice * sizeof(*out_ptr));
  552.         out_ptr   += linesize >> 1;
  553.         block_ptr += 16 * mbs_per_slice;
  554.     }
  555. }
  556.  
  557. static int decode_slice(AVCodecContext *avctx, void *tdata)
  558. {
  559.     ProresThreadData *td = tdata;
  560.     ProresContext *ctx = avctx->priv_data;
  561.     int mb_x_pos  = td->x_pos;
  562.     int mb_y_pos  = td->y_pos;
  563.     int pic_num   = ctx->pic_num;
  564.     int slice_num = td->slice_num;
  565.     int mbs_per_slice = td->slice_width;
  566.     const uint8_t *buf;
  567.     uint8_t *y_data, *u_data, *v_data, *a_data;
  568.     AVFrame *pic = ctx->frame;
  569.     int i, sf, slice_width_factor;
  570.     int slice_data_size, hdr_size;
  571.     int y_data_size, u_data_size, v_data_size, a_data_size;
  572.     int y_linesize, u_linesize, v_linesize, a_linesize;
  573.     int coff[4];
  574.     int ret;
  575.  
  576.     buf             = ctx->slice_data[slice_num].index;
  577.     slice_data_size = ctx->slice_data[slice_num + 1].index - buf;
  578.  
  579.     slice_width_factor = av_log2(mbs_per_slice);
  580.  
  581.     y_data     = pic->data[0];
  582.     u_data     = pic->data[1];
  583.     v_data     = pic->data[2];
  584.     a_data     = pic->data[3];
  585.     y_linesize = pic->linesize[0];
  586.     u_linesize = pic->linesize[1];
  587.     v_linesize = pic->linesize[2];
  588.     a_linesize = pic->linesize[3];
  589.  
  590.     if (pic->interlaced_frame) {
  591.         if (!(pic_num ^ pic->top_field_first)) {
  592.             y_data += y_linesize;
  593.             u_data += u_linesize;
  594.             v_data += v_linesize;
  595.             if (a_data)
  596.                 a_data += a_linesize;
  597.         }
  598.         y_linesize <<= 1;
  599.         u_linesize <<= 1;
  600.         v_linesize <<= 1;
  601.         a_linesize <<= 1;
  602.     }
  603.     y_data += (mb_y_pos << 4) * y_linesize + (mb_x_pos << 5);
  604.     u_data += (mb_y_pos << 4) * u_linesize + (mb_x_pos << ctx->mb_chroma_factor);
  605.     v_data += (mb_y_pos << 4) * v_linesize + (mb_x_pos << ctx->mb_chroma_factor);
  606.     if (a_data)
  607.         a_data += (mb_y_pos << 4) * a_linesize + (mb_x_pos << 5);
  608.  
  609.     if (slice_data_size < 6) {
  610.         av_log(avctx, AV_LOG_ERROR, "slice data too small\n");
  611.         return AVERROR_INVALIDDATA;
  612.     }
  613.  
  614.     /* parse slice header */
  615.     hdr_size    = buf[0] >> 3;
  616.     coff[0]     = hdr_size;
  617.     y_data_size = AV_RB16(buf + 2);
  618.     coff[1]     = coff[0] + y_data_size;
  619.     u_data_size = AV_RB16(buf + 4);
  620.     coff[2]     = coff[1] + u_data_size;
  621.     v_data_size = hdr_size > 7 ? AV_RB16(buf + 6) : slice_data_size - coff[2];
  622.     coff[3]     = coff[2] + v_data_size;
  623.     a_data_size = ctx->alpha_info ? slice_data_size - coff[3] : 0;
  624.  
  625.     /* if V or alpha component size is negative that means that previous
  626.        component sizes are too large */
  627.     if (v_data_size < 0 || a_data_size < 0 || hdr_size < 6) {
  628.         av_log(avctx, AV_LOG_ERROR, "invalid data size\n");
  629.         return AVERROR_INVALIDDATA;
  630.     }
  631.  
  632.     sf = av_clip(buf[1], 1, 224);
  633.     sf = sf > 128 ? (sf - 96) << 2 : sf;
  634.  
  635.     /* scale quantization matrixes according with slice's scale factor */
  636.     /* TODO: this can be SIMD-optimized a lot */
  637.     if (ctx->qmat_changed || sf != td->prev_slice_sf) {
  638.         td->prev_slice_sf = sf;
  639.         for (i = 0; i < 64; i++) {
  640.             td->qmat_luma_scaled[ctx->dsp.idct_permutation[i]]   = ctx->qmat_luma[i]   * sf;
  641.             td->qmat_chroma_scaled[ctx->dsp.idct_permutation[i]] = ctx->qmat_chroma[i] * sf;
  642.         }
  643.     }
  644.  
  645.     /* decode luma plane */
  646.     ret = decode_slice_plane(ctx, td, buf + coff[0], y_data_size,
  647.                              (uint16_t*) y_data, y_linesize,
  648.                              mbs_per_slice, 4, slice_width_factor + 2,
  649.                              td->qmat_luma_scaled, 0);
  650.  
  651.     if (ret < 0)
  652.         return ret;
  653.  
  654.     /* decode U chroma plane */
  655.     ret = decode_slice_plane(ctx, td, buf + coff[1], u_data_size,
  656.                              (uint16_t*) u_data, u_linesize,
  657.                              mbs_per_slice, ctx->num_chroma_blocks,
  658.                              slice_width_factor + ctx->chroma_factor - 1,
  659.                              td->qmat_chroma_scaled, 1);
  660.     if (ret < 0)
  661.         return ret;
  662.  
  663.     /* decode V chroma plane */
  664.     ret = decode_slice_plane(ctx, td, buf + coff[2], v_data_size,
  665.                              (uint16_t*) v_data, v_linesize,
  666.                              mbs_per_slice, ctx->num_chroma_blocks,
  667.                              slice_width_factor + ctx->chroma_factor - 1,
  668.                              td->qmat_chroma_scaled, 1);
  669.     if (ret < 0)
  670.         return ret;
  671.  
  672.     /* decode alpha plane if available */
  673.     if (a_data && a_data_size)
  674.         decode_alpha_plane(ctx, td, buf + coff[3], a_data_size,
  675.                            (uint16_t*) a_data, a_linesize,
  676.                            mbs_per_slice);
  677.  
  678.     return 0;
  679. }
  680.  
  681.  
  682. static int decode_picture(ProresContext *ctx, int pic_num,
  683.                           AVCodecContext *avctx)
  684. {
  685.     int slice_num, slice_width, x_pos, y_pos;
  686.  
  687.     slice_num = 0;
  688.  
  689.     ctx->pic_num = pic_num;
  690.     for (y_pos = 0; y_pos < ctx->num_y_mbs; y_pos++) {
  691.         slice_width = 1 << ctx->slice_width_factor;
  692.  
  693.         for (x_pos = 0; x_pos < ctx->num_x_mbs && slice_width;
  694.              x_pos += slice_width) {
  695.             while (ctx->num_x_mbs - x_pos < slice_width)
  696.                 slice_width >>= 1;
  697.  
  698.             ctx->slice_data[slice_num].slice_num   = slice_num;
  699.             ctx->slice_data[slice_num].x_pos       = x_pos;
  700.             ctx->slice_data[slice_num].y_pos       = y_pos;
  701.             ctx->slice_data[slice_num].slice_width = slice_width;
  702.  
  703.             slice_num++;
  704.         }
  705.     }
  706.  
  707.     return avctx->execute(avctx, decode_slice,
  708.                           ctx->slice_data, NULL, slice_num,
  709.                           sizeof(ctx->slice_data[0]));
  710. }
  711.  
  712.  
  713. #define MOVE_DATA_PTR(nbytes) buf += (nbytes); buf_size -= (nbytes)
  714.  
  715. static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
  716.                         AVPacket *avpkt)
  717. {
  718.     ProresContext *ctx = avctx->priv_data;
  719.     const uint8_t *buf = avpkt->data;
  720.     int buf_size       = avpkt->size;
  721.     int frame_hdr_size, pic_num, pic_data_size;
  722.  
  723.     ctx->frame            = data;
  724.     ctx->frame->pict_type = AV_PICTURE_TYPE_I;
  725.     ctx->frame->key_frame = 1;
  726.  
  727.     /* check frame atom container */
  728.     if (buf_size < 28 || buf_size < AV_RB32(buf) ||
  729.         AV_RB32(buf + 4) != FRAME_ID) {
  730.         av_log(avctx, AV_LOG_ERROR, "invalid frame\n");
  731.         return AVERROR_INVALIDDATA;
  732.     }
  733.  
  734.     MOVE_DATA_PTR(8);
  735.  
  736.     frame_hdr_size = decode_frame_header(ctx, buf, buf_size, avctx);
  737.     if (frame_hdr_size < 0)
  738.         return AVERROR_INVALIDDATA;
  739.  
  740.     MOVE_DATA_PTR(frame_hdr_size);
  741.  
  742.     if (ff_get_buffer(avctx, ctx->frame, 0) < 0)
  743.         return -1;
  744.  
  745.     for (pic_num = 0; ctx->frame->interlaced_frame - pic_num + 1; pic_num++) {
  746.         pic_data_size = decode_picture_header(ctx, buf, buf_size, avctx);
  747.         if (pic_data_size < 0)
  748.             return AVERROR_INVALIDDATA;
  749.  
  750.         if (decode_picture(ctx, pic_num, avctx))
  751.             return -1;
  752.  
  753.         MOVE_DATA_PTR(pic_data_size);
  754.     }
  755.  
  756.     ctx->frame = NULL;
  757.     *got_frame = 1;
  758.  
  759.     return avpkt->size;
  760. }
  761.  
  762.  
  763. static av_cold int decode_close(AVCodecContext *avctx)
  764. {
  765.     ProresContext *ctx = avctx->priv_data;
  766.  
  767.     av_freep(&ctx->slice_data);
  768.  
  769.     return 0;
  770. }
  771.  
  772.  
  773. AVCodec ff_prores_lgpl_decoder = {
  774.     .name           = "prores_lgpl",
  775.     .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"),
  776.     .type           = AVMEDIA_TYPE_VIDEO,
  777.     .id             = AV_CODEC_ID_PRORES,
  778.     .priv_data_size = sizeof(ProresContext),
  779.     .init           = decode_init,
  780.     .close          = decode_close,
  781.     .decode         = decode_frame,
  782.     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
  783. };
  784.