LCOV - code coverage report
Current view: top level - libavcodec - proresdec2.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 310 366 84.7 %
Date: 2018-05-20 11:54:08 Functions: 14 14 100.0 %

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

Generated by: LCOV version 1.13