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 "idctdsp.h"
  38. #include "internal.h"
  39. #include "proresdata.h"
  40. #include "proresdsp.h"
  41. #include "get_bits.h"
  42.  
  43. typedef struct ProresThreadData {
  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 ProresContext {
  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_array(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. #define MAX_PADDING 16
  370.  
  371. /**
  372.  * Decode AC coefficients for all blocks in a slice.
  373.  */
  374. static inline int decode_ac_coeffs(GetBitContext *gb, int16_t *out,
  375.                                    int blocks_per_slice,
  376.                                    int plane_size_factor,
  377.                                    const uint8_t *scan)
  378. {
  379.     int pos, block_mask, run, level, sign, run_cb_index, lev_cb_index;
  380.     int max_coeffs, bits_left;
  381.  
  382.     /* set initial prediction values */
  383.     run   = 4;
  384.     level = 2;
  385.  
  386.     max_coeffs = blocks_per_slice << 6;
  387.     block_mask = blocks_per_slice - 1;
  388.  
  389.     for (pos = blocks_per_slice - 1; pos < max_coeffs;) {
  390.         run_cb_index = ff_prores_run_to_cb_index[FFMIN(run, 15)];
  391.         lev_cb_index = ff_prores_lev_to_cb_index[FFMIN(level, 9)];
  392.  
  393.         bits_left = get_bits_left(gb);
  394.         if (bits_left <= 0 || (bits_left <= MAX_PADDING && !show_bits(gb, bits_left)))
  395.             return 0;
  396.  
  397.         run = decode_vlc_codeword(gb, ff_prores_ac_codebook[run_cb_index]);
  398.         if (run < 0)
  399.             return AVERROR_INVALIDDATA;
  400.  
  401.         bits_left = get_bits_left(gb);
  402.         if (bits_left <= 0 || (bits_left <= MAX_PADDING && !show_bits(gb, bits_left)))
  403.             return AVERROR_INVALIDDATA;
  404.  
  405.         level = decode_vlc_codeword(gb, ff_prores_ac_codebook[lev_cb_index]) + 1;
  406.         if (level < 0)
  407.             return AVERROR_INVALIDDATA;
  408.  
  409.         pos += run + 1;
  410.         if (pos >= max_coeffs)
  411.             break;
  412.  
  413.         sign = get_sbits(gb, 1);
  414.         out[((pos & block_mask) << 6) + scan[pos >> plane_size_factor]] =
  415.             (level ^ sign) - sign;
  416.     }
  417.  
  418.     return 0;
  419. }
  420.  
  421.  
  422. /**
  423.  * Decode a slice plane (luma or chroma).
  424.  */
  425. static int decode_slice_plane(ProresContext *ctx, ProresThreadData *td,
  426.                               const uint8_t *buf,
  427.                               int data_size, uint16_t *out_ptr,
  428.                               int linesize, int mbs_per_slice,
  429.                               int blocks_per_mb, int plane_size_factor,
  430.                               const int16_t *qmat, int is_chroma)
  431. {
  432.     GetBitContext gb;
  433.     int16_t *block_ptr;
  434.     int mb_num, blocks_per_slice, ret;
  435.  
  436.     blocks_per_slice = mbs_per_slice * blocks_per_mb;
  437.  
  438.     memset(td->blocks, 0, 8 * 4 * 64 * sizeof(*td->blocks));
  439.  
  440.     init_get_bits(&gb, buf, data_size << 3);
  441.  
  442.     decode_dc_coeffs(&gb, td->blocks, blocks_per_slice);
  443.  
  444.     ret = decode_ac_coeffs(&gb, td->blocks, blocks_per_slice,
  445.                            plane_size_factor, ctx->scantable.permutated);
  446.     if (ret < 0)
  447.         return ret;
  448.  
  449.     /* inverse quantization, inverse transform and output */
  450.     block_ptr = td->blocks;
  451.  
  452.     if (!is_chroma) {
  453.         for (mb_num = 0; mb_num < mbs_per_slice; mb_num++, out_ptr += blocks_per_mb * 4) {
  454.             ctx->dsp.idct_put(out_ptr,                    linesize, block_ptr, qmat);
  455.             block_ptr += 64;
  456.             if (blocks_per_mb > 2) {
  457.                 ctx->dsp.idct_put(out_ptr + 8,            linesize, block_ptr, qmat);
  458.                 block_ptr += 64;
  459.             }
  460.             ctx->dsp.idct_put(out_ptr + linesize * 4,     linesize, block_ptr, qmat);
  461.             block_ptr += 64;
  462.             if (blocks_per_mb > 2) {
  463.                 ctx->dsp.idct_put(out_ptr + linesize * 4 + 8, linesize, block_ptr, qmat);
  464.                 block_ptr += 64;
  465.             }
  466.         }
  467.     } else {
  468.         for (mb_num = 0; mb_num < mbs_per_slice; mb_num++, out_ptr += blocks_per_mb * 4) {
  469.             ctx->dsp.idct_put(out_ptr,                    linesize, block_ptr, qmat);
  470.             block_ptr += 64;
  471.             ctx->dsp.idct_put(out_ptr + linesize * 4,     linesize, block_ptr, qmat);
  472.             block_ptr += 64;
  473.             if (blocks_per_mb > 2) {
  474.                 ctx->dsp.idct_put(out_ptr + 8,            linesize, block_ptr, qmat);
  475.                 block_ptr += 64;
  476.                 ctx->dsp.idct_put(out_ptr + linesize * 4 + 8, linesize, block_ptr, qmat);
  477.                 block_ptr += 64;
  478.             }
  479.         }
  480.     }
  481.     return 0;
  482. }
  483.  
  484.  
  485. static void unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs,
  486.                          const int num_bits)
  487. {
  488.     const int mask = (1 << num_bits) - 1;
  489.     int i, idx, val, alpha_val;
  490.  
  491.     idx       = 0;
  492.     alpha_val = mask;
  493.     do {
  494.         do {
  495.             if (get_bits1(gb))
  496.                 val = get_bits(gb, num_bits);
  497.             else {
  498.                 int sign;
  499.                 val  = get_bits(gb, num_bits == 16 ? 7 : 4);
  500.                 sign = val & 1;
  501.                 val  = (val + 2) >> 1;
  502.                 if (sign)
  503.                     val = -val;
  504.             }
  505.             alpha_val = (alpha_val + val) & mask;
  506.             if (num_bits == 16)
  507.                 dst[idx++] = alpha_val >> 6;
  508.             else
  509.                 dst[idx++] = (alpha_val << 2) | (alpha_val >> 6);
  510.             if (idx >= num_coeffs) {
  511.                 break;
  512.             }
  513.         } while (get_bits1(gb));
  514.         val = get_bits(gb, 4);
  515.         if (!val)
  516.             val = get_bits(gb, 11);
  517.         if (idx + val > num_coeffs)
  518.             val = num_coeffs - idx;
  519.         if (num_bits == 16)
  520.             for (i = 0; i < val; i++)
  521.                 dst[idx++] = alpha_val >> 6;
  522.         else
  523.             for (i = 0; i < val; i++)
  524.                 dst[idx++] = (alpha_val << 2) | (alpha_val >> 6);
  525.     } while (idx < num_coeffs);
  526. }
  527.  
  528. /**
  529.  * Decode alpha slice plane.
  530.  */
  531. static void decode_alpha_plane(ProresContext *ctx, ProresThreadData *td,
  532.                                const uint8_t *buf, int data_size,
  533.                                uint16_t *out_ptr, int linesize,
  534.                                int mbs_per_slice)
  535. {
  536.     GetBitContext gb;
  537.     int i;
  538.     uint16_t *block_ptr;
  539.  
  540.     memset(td->blocks, 0, 8 * 4 * 64 * sizeof(*td->blocks));
  541.  
  542.     init_get_bits(&gb, buf, data_size << 3);
  543.  
  544.     if (ctx->alpha_info == 2)
  545.         unpack_alpha(&gb, td->blocks, mbs_per_slice * 4 * 64, 16);
  546.     else
  547.         unpack_alpha(&gb, td->blocks, mbs_per_slice * 4 * 64, 8);
  548.  
  549.     block_ptr = td->blocks;
  550.  
  551.     for (i = 0; i < 16; i++) {
  552.         memcpy(out_ptr, block_ptr, 16 * mbs_per_slice * sizeof(*out_ptr));
  553.         out_ptr   += linesize >> 1;
  554.         block_ptr += 16 * mbs_per_slice;
  555.     }
  556. }
  557.  
  558. static int decode_slice(AVCodecContext *avctx, void *tdata)
  559. {
  560.     ProresThreadData *td = tdata;
  561.     ProresContext *ctx = avctx->priv_data;
  562.     int mb_x_pos  = td->x_pos;
  563.     int mb_y_pos  = td->y_pos;
  564.     int pic_num   = ctx->pic_num;
  565.     int slice_num = td->slice_num;
  566.     int mbs_per_slice = td->slice_width;
  567.     const uint8_t *buf;
  568.     uint8_t *y_data, *u_data, *v_data, *a_data;
  569.     AVFrame *pic = ctx->frame;
  570.     int i, sf, slice_width_factor;
  571.     int slice_data_size, hdr_size;
  572.     int y_data_size, u_data_size, v_data_size, a_data_size;
  573.     int y_linesize, u_linesize, v_linesize, a_linesize;
  574.     int coff[4];
  575.     int ret;
  576.  
  577.     buf             = ctx->slice_data[slice_num].index;
  578.     slice_data_size = ctx->slice_data[slice_num + 1].index - buf;
  579.  
  580.     slice_width_factor = av_log2(mbs_per_slice);
  581.  
  582.     y_data     = pic->data[0];
  583.     u_data     = pic->data[1];
  584.     v_data     = pic->data[2];
  585.     a_data     = pic->data[3];
  586.     y_linesize = pic->linesize[0];
  587.     u_linesize = pic->linesize[1];
  588.     v_linesize = pic->linesize[2];
  589.     a_linesize = pic->linesize[3];
  590.  
  591.     if (pic->interlaced_frame) {
  592.         if (!(pic_num ^ pic->top_field_first)) {
  593.             y_data += y_linesize;
  594.             u_data += u_linesize;
  595.             v_data += v_linesize;
  596.             if (a_data)
  597.                 a_data += a_linesize;
  598.         }
  599.         y_linesize <<= 1;
  600.         u_linesize <<= 1;
  601.         v_linesize <<= 1;
  602.         a_linesize <<= 1;
  603.     }
  604.     y_data += (mb_y_pos << 4) * y_linesize + (mb_x_pos << 5);
  605.     u_data += (mb_y_pos << 4) * u_linesize + (mb_x_pos << ctx->mb_chroma_factor);
  606.     v_data += (mb_y_pos << 4) * v_linesize + (mb_x_pos << ctx->mb_chroma_factor);
  607.     if (a_data)
  608.         a_data += (mb_y_pos << 4) * a_linesize + (mb_x_pos << 5);
  609.  
  610.     if (slice_data_size < 6) {
  611.         av_log(avctx, AV_LOG_ERROR, "slice data too small\n");
  612.         return AVERROR_INVALIDDATA;
  613.     }
  614.  
  615.     /* parse slice header */
  616.     hdr_size    = buf[0] >> 3;
  617.     coff[0]     = hdr_size;
  618.     y_data_size = AV_RB16(buf + 2);
  619.     coff[1]     = coff[0] + y_data_size;
  620.     u_data_size = AV_RB16(buf + 4);
  621.     coff[2]     = coff[1] + u_data_size;
  622.     v_data_size = hdr_size > 7 ? AV_RB16(buf + 6) : slice_data_size - coff[2];
  623.     coff[3]     = coff[2] + v_data_size;
  624.     a_data_size = ctx->alpha_info ? slice_data_size - coff[3] : 0;
  625.  
  626.     /* if V or alpha component size is negative that means that previous
  627.        component sizes are too large */
  628.     if (v_data_size < 0 || a_data_size < 0 || hdr_size < 6) {
  629.         av_log(avctx, AV_LOG_ERROR, "invalid data size\n");
  630.         return AVERROR_INVALIDDATA;
  631.     }
  632.  
  633.     sf = av_clip(buf[1], 1, 224);
  634.     sf = sf > 128 ? (sf - 96) << 2 : sf;
  635.  
  636.     /* scale quantization matrixes according with slice's scale factor */
  637.     /* TODO: this can be SIMD-optimized a lot */
  638.     if (ctx->qmat_changed || sf != td->prev_slice_sf) {
  639.         td->prev_slice_sf = sf;
  640.         for (i = 0; i < 64; i++) {
  641.             td->qmat_luma_scaled[ctx->dsp.idct_permutation[i]]   = ctx->qmat_luma[i]   * sf;
  642.             td->qmat_chroma_scaled[ctx->dsp.idct_permutation[i]] = ctx->qmat_chroma[i] * sf;
  643.         }
  644.     }
  645.  
  646.     /* decode luma plane */
  647.     ret = decode_slice_plane(ctx, td, buf + coff[0], y_data_size,
  648.                              (uint16_t*) y_data, y_linesize,
  649.                              mbs_per_slice, 4, slice_width_factor + 2,
  650.                              td->qmat_luma_scaled, 0);
  651.  
  652.     if (ret < 0)
  653.         return ret;
  654.  
  655.     /* decode U chroma plane */
  656.     ret = decode_slice_plane(ctx, td, buf + coff[1], u_data_size,
  657.                              (uint16_t*) u_data, u_linesize,
  658.                              mbs_per_slice, ctx->num_chroma_blocks,
  659.                              slice_width_factor + ctx->chroma_factor - 1,
  660.                              td->qmat_chroma_scaled, 1);
  661.     if (ret < 0)
  662.         return ret;
  663.  
  664.     /* decode V chroma plane */
  665.     ret = decode_slice_plane(ctx, td, buf + coff[2], v_data_size,
  666.                              (uint16_t*) v_data, v_linesize,
  667.                              mbs_per_slice, ctx->num_chroma_blocks,
  668.                              slice_width_factor + ctx->chroma_factor - 1,
  669.                              td->qmat_chroma_scaled, 1);
  670.     if (ret < 0)
  671.         return ret;
  672.  
  673.     /* decode alpha plane if available */
  674.     if (a_data && a_data_size)
  675.         decode_alpha_plane(ctx, td, buf + coff[3], a_data_size,
  676.                            (uint16_t*) a_data, a_linesize,
  677.                            mbs_per_slice);
  678.  
  679.     return 0;
  680. }
  681.  
  682.  
  683. static int decode_picture(ProresContext *ctx, int pic_num,
  684.                           AVCodecContext *avctx)
  685. {
  686.     int slice_num, slice_width, x_pos, y_pos;
  687.  
  688.     slice_num = 0;
  689.  
  690.     ctx->pic_num = pic_num;
  691.     for (y_pos = 0; y_pos < ctx->num_y_mbs; y_pos++) {
  692.         slice_width = 1 << ctx->slice_width_factor;
  693.  
  694.         for (x_pos = 0; x_pos < ctx->num_x_mbs && slice_width;
  695.              x_pos += slice_width) {
  696.             while (ctx->num_x_mbs - x_pos < slice_width)
  697.                 slice_width >>= 1;
  698.  
  699.             ctx->slice_data[slice_num].slice_num   = slice_num;
  700.             ctx->slice_data[slice_num].x_pos       = x_pos;
  701.             ctx->slice_data[slice_num].y_pos       = y_pos;
  702.             ctx->slice_data[slice_num].slice_width = slice_width;
  703.  
  704.             slice_num++;
  705.         }
  706.     }
  707.  
  708.     return avctx->execute(avctx, decode_slice,
  709.                           ctx->slice_data, NULL, slice_num,
  710.                           sizeof(ctx->slice_data[0]));
  711. }
  712.  
  713.  
  714. #define MOVE_DATA_PTR(nbytes) buf += (nbytes); buf_size -= (nbytes)
  715.  
  716. static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
  717.                         AVPacket *avpkt)
  718. {
  719.     ProresContext *ctx = avctx->priv_data;
  720.     const uint8_t *buf = avpkt->data;
  721.     int buf_size       = avpkt->size;
  722.     int frame_hdr_size, pic_num, pic_data_size;
  723.  
  724.     ctx->frame            = data;
  725.     ctx->frame->pict_type = AV_PICTURE_TYPE_I;
  726.     ctx->frame->key_frame = 1;
  727.  
  728.     /* check frame atom container */
  729.     if (buf_size < 28 || buf_size < AV_RB32(buf) ||
  730.         AV_RB32(buf + 4) != FRAME_ID) {
  731.         av_log(avctx, AV_LOG_ERROR, "invalid frame\n");
  732.         return AVERROR_INVALIDDATA;
  733.     }
  734.  
  735.     MOVE_DATA_PTR(8);
  736.  
  737.     frame_hdr_size = decode_frame_header(ctx, buf, buf_size, avctx);
  738.     if (frame_hdr_size < 0)
  739.         return AVERROR_INVALIDDATA;
  740.  
  741.     MOVE_DATA_PTR(frame_hdr_size);
  742.  
  743.     if (ff_get_buffer(avctx, ctx->frame, 0) < 0)
  744.         return -1;
  745.  
  746.     for (pic_num = 0; ctx->frame->interlaced_frame - pic_num + 1; pic_num++) {
  747.         pic_data_size = decode_picture_header(ctx, buf, buf_size, avctx);
  748.         if (pic_data_size < 0)
  749.             return AVERROR_INVALIDDATA;
  750.  
  751.         if (decode_picture(ctx, pic_num, avctx))
  752.             return -1;
  753.  
  754.         MOVE_DATA_PTR(pic_data_size);
  755.     }
  756.  
  757.     ctx->frame = NULL;
  758.     *got_frame = 1;
  759.  
  760.     return avpkt->size;
  761. }
  762.  
  763.  
  764. static av_cold int decode_close(AVCodecContext *avctx)
  765. {
  766.     ProresContext *ctx = avctx->priv_data;
  767.  
  768.     av_freep(&ctx->slice_data);
  769.  
  770.     return 0;
  771. }
  772.  
  773.  
  774. AVCodec ff_prores_lgpl_decoder = {
  775.     .name           = "prores_lgpl",
  776.     .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"),
  777.     .type           = AVMEDIA_TYPE_VIDEO,
  778.     .id             = AV_CODEC_ID_PRORES,
  779.     .priv_data_size = sizeof(ProresContext),
  780.     .init           = decode_init,
  781.     .close          = decode_close,
  782.     .decode         = decode_frame,
  783.     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS,
  784. };
  785.