Head

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/aic.c	Lines:	171	196	87.2 %
Date:	2020-01-27 20:17:04	Branches:	95	116	81.9 %


/*
 * Apple Intermediate Codec decoder
 *
 * Copyright (c) 2013 Konstantin Shishkov
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <inttypes.h>

#include "avcodec.h"
#include "bytestream.h"
#include "internal.h"
#include "get_bits.h"
#include "golomb.h"
#include "idctdsp.h"
#include "thread.h"
#include "unary.h"

#define AIC_HDR_SIZE    24
#define AIC_BAND_COEFFS (64 + 32 + 192 + 96)

enum AICBands {
    COEFF_LUMA = 0,
    COEFF_CHROMA,
    COEFF_LUMA_EXT,
    COEFF_CHROMA_EXT,
    NUM_BANDS
};

static const uint8_t aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };

static const uint16_t aic_band_off[NUM_BANDS] = { 0, 64, 96, 288 };

static const uint8_t aic_quant_matrix[64] = {
     8, 16, 19, 22, 22, 26, 26, 27,
    16, 16, 22, 22, 26, 27, 27, 29,
    19, 22, 26, 26, 27, 29, 29, 35,
    22, 24, 27, 27, 29, 32, 34, 38,
    26, 27, 29, 29, 32, 35, 38, 46,
    27, 29, 34, 34, 35, 40, 46, 56,
    29, 34, 34, 37, 40, 48, 56, 69,
    34, 37, 38, 40, 48, 58, 69, 83,
};

static const uint8_t aic_y_scan[64] = {
     0,  4,  1,  2,  5,  8, 12,  9,
     6,  3,  7, 10, 13, 14, 11, 15,
    47, 43, 46, 45, 42, 39, 35, 38,
    41, 44, 40, 37, 34, 33, 36, 32,
    16, 20, 17, 18, 21, 24, 28, 25,
    22, 19, 23, 26, 29, 30, 27, 31,
    63, 59, 62, 61, 58, 55, 51, 54,
    57, 60, 56, 53, 50, 49, 52, 48,
};

static const uint8_t aic_y_ext_scan[192] = {
     64,  72,  65,  66,  73,  80,  88,  81,
     74,  67,  75,  82,  89,  90,  83,  91,
      0,   4,   1,   2,   5,   8,  12,   9,
      6,   3,   7,  10,  13,  14,  11,  15,
     16,  20,  17,  18,  21,  24,  28,  25,
     22,  19,  23,  26,  29,  30,  27,  31,
    155, 147, 154, 153, 146, 139, 131, 138,
    145, 152, 144, 137, 130, 129, 136, 128,
     47,  43,  46,  45,  42,  39,  35,  38,
     41,  44,  40,  37,  34,  33,  36,  32,
     63,  59,  62,  61,  58,  55,  51,  54,
     57,  60,  56,  53,  50,  49,  52,  48,
     96, 104,  97,  98, 105, 112, 120, 113,
    106,  99, 107, 114, 121, 122, 115, 123,
     68,  76,  69,  70,  77,  84,  92,  85,
     78,  71,  79,  86,  93,  94,  87,  95,
    100, 108, 101, 102, 109, 116, 124, 117,
    110, 103, 111, 118, 125, 126, 119, 127,
    187, 179, 186, 185, 178, 171, 163, 170,
    177, 184, 176, 169, 162, 161, 168, 160,
    159, 151, 158, 157, 150, 143, 135, 142,
    149, 156, 148, 141, 134, 133, 140, 132,
    191, 183, 190, 189, 182, 175, 167, 174,
    181, 188, 180, 173, 166, 165, 172, 164,
};

static const uint8_t aic_c_scan[64] = {
     0,  4,  1,  2,  5,  8, 12,  9,
     6,  3,  7, 10, 13, 14, 11, 15,
    31, 27, 30, 29, 26, 23, 19, 22,
    25, 28, 24, 21, 18, 17, 20, 16,
    32, 36, 33, 34, 37, 40, 44, 41,
    38, 35, 39, 42, 45, 46, 43, 47,
    63, 59, 62, 61, 58, 55, 51, 54,
    57, 60, 56, 53, 50, 49, 52, 48,
};

static const uint8_t aic_c_ext_scan[192] = {
     16,  24,  17,  18,  25,  32,  40,  33,
     26,  19,  27,  34,  41,  42,  35,  43,
      0,   4,   1,   2,   5,   8,  12,   9,
      6,   3,   7,  10,  13,  14,  11,  15,
     20,  28,  21,  22,  29,  36,  44,  37,
     30,  23,  31,  38,  45,  46,  39,  47,
     95,  87,  94,  93,  86,  79,  71,  78,
     85,  92,  84,  77,  70,  69,  76,  68,
     63,  59,  62,  61,  58,  55,  51,  54,
     57,  60,  56,  53,  50,  49,  52,  48,
     91,  83,  90,  89,  82,  75,  67,  74,
     81,  88,  80,  73,  66,  65,  72,  64,
    112, 120, 113, 114, 121, 128, 136, 129,
    122, 115, 123, 130, 137, 138, 131, 139,
     96, 100,  97,  98, 101, 104, 108, 105,
    102,  99, 103, 106, 109, 110, 107, 111,
    116, 124, 117, 118, 125, 132, 140, 133,
    126, 119, 127, 134, 141, 142, 135, 143,
    191, 183, 190, 189, 182, 175, 167, 174,
    181, 188, 180, 173, 166, 165, 172, 164,
    159, 155, 158, 157, 154, 151, 147, 150,
    153, 156, 152, 149, 146, 145, 148, 144,
    187, 179, 186, 185, 178, 171, 163, 170,
    177, 184, 176, 169, 162, 161, 168, 160,
};

static const uint8_t * const aic_scan[NUM_BANDS] = {
    aic_y_scan, aic_c_scan, aic_y_ext_scan, aic_c_ext_scan
};

typedef struct AICContext {
    AVCodecContext *avctx;
    AVFrame        *frame;
    IDCTDSPContext idsp;
    ScanTable      scantable;

    int            num_x_slices;
    int            slice_width;
    int            mb_width, mb_height;
    int            quant;
    int            interlaced;

    int16_t        *slice_data;
    int16_t        *data_ptr[NUM_BANDS];

    DECLARE_ALIGNED(16, int16_t, block)[64];
    DECLARE_ALIGNED(16, uint8_t, quant_matrix)[64];
} AICContext;

static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
{
    uint32_t frame_size;
    int width, height;

    if (src[0] != 1) {
        av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
        return AVERROR_INVALIDDATA;
    }
    if (src[1] != AIC_HDR_SIZE - 2) {
        av_log(ctx->avctx, AV_LOG_ERROR, "Invalid header size %d\n", src[1]);
        return AVERROR_INVALIDDATA;
    }
    frame_size = AV_RB32(src + 2);
    width      = AV_RB16(src + 6);
    height     = AV_RB16(src + 8);
    if (frame_size > size) {
        av_log(ctx->avctx, AV_LOG_ERROR, "Frame size should be %"PRIu32" got %d\n",
               frame_size, size);
        return AVERROR_INVALIDDATA;
    }
    if (width != ctx->avctx->width || height != ctx->avctx->height) {
        av_log(ctx->avctx, AV_LOG_ERROR,
               "Picture dimension changed: old: %d x %d, new: %d x %d\n",
               ctx->avctx->width, ctx->avctx->height, width, height);
        return AVERROR_INVALIDDATA;
    }
    ctx->quant      = src[15];
    ctx->interlaced = ((src[16] >> 4) == 3);

    return 0;
}

#define GET_CODE(val, type, add_bits)                         \
    do {                                                      \
        if (type)                                             \
            val = get_ue_golomb(gb);                          \
        else                                                  \
            val = get_unary(gb, 1, 31);                       \
        if (add_bits)                                         \
            val = (val << add_bits) + get_bits(gb, add_bits); \
    } while (0)

static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,
                             int band, int slice_width, int force_chroma)
{
    int has_skips, coeff_type, coeff_bits, skip_type, skip_bits;
    const int num_coeffs = aic_num_band_coeffs[band];
    const uint8_t *scan = aic_scan[band | force_chroma];
    int mb, idx;
    unsigned val;

    if (get_bits_left(gb) < 5)
        return AVERROR_INVALIDDATA;

    has_skips  = get_bits1(gb);
    coeff_type = get_bits1(gb);
    coeff_bits = get_bits(gb, 3);

    if (has_skips) {
        skip_type = get_bits1(gb);
        skip_bits = get_bits(gb, 3);

        for (mb = 0; mb < slice_width; mb++) {
            idx = -1;
            do {
                GET_CODE(val, skip_type, skip_bits);
                if (val >= 0x10000)
                    return AVERROR_INVALIDDATA;
                idx += val + 1;
                if (idx >= num_coeffs)
                    break;
                GET_CODE(val, coeff_type, coeff_bits);
                val++;
                if (val >= 0x10000)
                    return AVERROR_INVALIDDATA;
                dst[scan[idx]] = val;
            } while (idx < num_coeffs - 1);
            dst += num_coeffs;
        }
    } else {
        for (mb = 0; mb < slice_width; mb++) {
            for (idx = 0; idx < num_coeffs; idx++) {
                GET_CODE(val, coeff_type, coeff_bits);
                if (val >= 0x10000)
                    return AVERROR_INVALIDDATA;
                dst[scan[idx]] = val;
            }
            dst += num_coeffs;
        }
    }
    return 0;
}

static void recombine_block(int16_t *dst, const uint8_t *scan,
                            int16_t **base, int16_t **ext)
{
    int i, j;

    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++)
            dst[scan[i * 8 + j]]     = (*base)[j];
        for (j = 0; j < 4; j++)
            dst[scan[i * 8 + j + 4]] = (*ext)[j];
        *base += 4;
        *ext  += 4;
    }
    for (; i < 8; i++) {
        for (j = 0; j < 8; j++)
            dst[scan[i * 8 + j]] = (*ext)[j];
        *ext  += 8;
    }
}

static void recombine_block_il(int16_t *dst, const uint8_t *scan,
                               int16_t **base, int16_t **ext,
                               int block_no)
{
    int i, j;

    if (block_no < 2) {
        for (i = 0; i < 8; i++) {
            for (j = 0; j < 4; j++)
                dst[scan[i * 8 + j]]     = (*base)[j];
            for (j = 0; j < 4; j++)
                dst[scan[i * 8 + j + 4]] = (*ext)[j];
            *base += 4;
            *ext  += 4;
        }
    } else {
        for (i = 0; i < 64; i++)
            dst[scan[i]] = (*ext)[i];
        *ext += 64;
    }
}

static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
{
    int i;

    for (i = 0; i < 64; i++) {
        int val  = (uint16_t)block[i];
        int sign = val & 1;

        block[i] = (((val >> 1) ^ -sign) * q * quant_matrix[i] >> 4)
                   + sign;
    }
}

static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
                            const uint8_t *src, int src_size)
{
    GetBitContext gb;
    int ret, i, mb, blk;
    int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
    int last_row = mb_y && mb_y == ctx->mb_height - 1;
    int y_pos, c_pos;
    uint8_t *Y, *C[2];
    uint8_t *dst;
    int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
    int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
    int16_t *ext_y  = ctx->data_ptr[COEFF_LUMA_EXT];
    int16_t *ext_c  = ctx->data_ptr[COEFF_CHROMA_EXT];
    const int ystride = ctx->frame->linesize[0];

    if (last_row) {
        y_pos = (ctx->avctx->height - 16);
        c_pos = ((ctx->avctx->height+1)/2 - 8);
    } else {
        y_pos = mb_y * 16;
        c_pos = mb_y * 8;
    }

    Y = ctx->frame->data[0] + mb_x * 16 + y_pos * ystride;
    for (i = 0; i < 2; i++)
        C[i] = ctx->frame->data[i + 1] + mb_x * 8
               + c_pos * ctx->frame->linesize[i + 1];
    init_get_bits(&gb, src, src_size * 8);

    memset(ctx->slice_data, 0,
           sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
    for (i = 0; i < NUM_BANDS; i++)
        if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
                                     i, slice_width,
                                     !ctx->interlaced)) < 0)
            return ret;

    for (mb = 0; mb < slice_width; mb++) {
        for (blk = 0; blk < 4; blk++) {
            if (!ctx->interlaced)
                recombine_block(ctx->block, ctx->scantable.permutated,
                                &base_y, &ext_y);
            else
                recombine_block_il(ctx->block, ctx->scantable.permutated,
                                   &base_y, &ext_y, blk);
            unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
            ctx->idsp.idct(ctx->block);

            if (!ctx->interlaced) {
                dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
                ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
            } else {
                dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
                ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
                                                    ystride * 2);
            }
        }
        Y += 16;

        for (blk = 0; blk < 2; blk++) {
            recombine_block(ctx->block, ctx->scantable.permutated,
                            &base_c, &ext_c);
            unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
            ctx->idsp.idct(ctx->block);
            ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],
                                                ctx->frame->linesize[blk + 1]);
            C[blk] += 8;
        }
    }

    return 0;
}

static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
                            AVPacket *avpkt)
{
    AICContext *ctx    = avctx->priv_data;
    const uint8_t *buf = avpkt->data;
    int buf_size       = avpkt->size;
    GetByteContext gb;
    uint32_t off;
    int x, y, ret;
    int slice_size;
    ThreadFrame frame = { .f = data };

    ctx->frame            = data;
    ctx->frame->pict_type = AV_PICTURE_TYPE_I;
    ctx->frame->key_frame = 1;

    off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);

    if (buf_size < off) {
        av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
        return AVERROR_INVALIDDATA;
    }

    ret = aic_decode_header(ctx, buf, buf_size);
    if (ret < 0) {
        av_log(avctx, AV_LOG_ERROR, "Invalid header\n");
        return ret;
    }

    if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
        return ret;

    bytestream2_init(&gb, buf + AIC_HDR_SIZE,
                     ctx->num_x_slices * ctx->mb_height * 2);

    for (y = 0; y < ctx->mb_height; y++) {
        for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
            slice_size = bytestream2_get_le16(&gb) * 4;
            if (slice_size + off > buf_size || !slice_size) {
                av_log(avctx, AV_LOG_ERROR,
                       "Incorrect slice size %d at %d.%d\n", slice_size, x, y);
                return AVERROR_INVALIDDATA;
            }

            ret = aic_decode_slice(ctx, x, y, buf + off, slice_size);
            if (ret < 0) {
                av_log(avctx, AV_LOG_ERROR,
                       "Error decoding slice at %d.%d\n", x, y);
                return ret;
            }

            off += slice_size;
        }
    }

    *got_frame = 1;

    return avpkt->size;
}

static av_cold int aic_decode_init(AVCodecContext *avctx)
{
    AICContext *ctx = avctx->priv_data;
    int i;
    uint8_t scan[64];

    ctx->avctx = avctx;

    avctx->pix_fmt = AV_PIX_FMT_YUV420P;

    ff_idctdsp_init(&ctx->idsp, avctx);

    for (i = 0; i < 64; i++)
        scan[i] = i;
    ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, scan);
    for (i = 0; i < 64; i++)
        ctx->quant_matrix[ctx->idsp.idct_permutation[i]] = aic_quant_matrix[i];

    ctx->mb_width  = FFALIGN(avctx->width,  16) >> 4;
    ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;

    ctx->num_x_slices = (ctx->mb_width + 15) >> 4;
    ctx->slice_width  = 16;
    for (i = 1; i < ctx->mb_width; i++) {
        if (!(ctx->mb_width % i) && (ctx->mb_width / i <= 32)) {
            ctx->slice_width  = ctx->mb_width / i;
            ctx->num_x_slices = i;
            break;
        }
    }

    ctx->slice_data = av_malloc_array(ctx->slice_width, AIC_BAND_COEFFS
                                * sizeof(*ctx->slice_data));
    if (!ctx->slice_data) {
        av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");

        return AVERROR(ENOMEM);
    }

    for (i = 0; i < NUM_BANDS; i++)
        ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
                                             * aic_band_off[i];

    return 0;
}

static av_cold int aic_decode_close(AVCodecContext *avctx)
{
    AICContext *ctx = avctx->priv_data;

    av_freep(&ctx->slice_data);

    return 0;
}

AVCodec ff_aic_decoder = {
    .name           = "aic",
    .long_name      = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_AIC,
    .priv_data_size = sizeof(AICContext),
    .init           = aic_decode_init,
    .close          = aic_decode_close,
    .decode         = aic_decode_frame,
    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
    .init_thread_copy = ONLY_IF_THREADS_ENABLED(aic_decode_init),
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
};


Generated by: GCOVR (Version 4.1)

Line	Branch	Exec	Source
1			/*
2			* Apple Intermediate Codec decoder
3			*
4			* Copyright (c) 2013 Konstantin Shishkov
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			#include <inttypes.h>
24
25			#include "avcodec.h"
26			#include "bytestream.h"
27			#include "internal.h"
28			#include "get_bits.h"
29			#include "golomb.h"
30			#include "idctdsp.h"
31			#include "thread.h"
32			#include "unary.h"
33
34			#define AIC_HDR_SIZE 24
35			#define AIC_BAND_COEFFS (64 + 32 + 192 + 96)
36
37			enum AICBands {
38			COEFF_LUMA = 0,
39			COEFF_CHROMA,
40			COEFF_LUMA_EXT,
41			COEFF_CHROMA_EXT,
42			NUM_BANDS
43			};
44
45			static const uint8_t aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };
46
47			static const uint16_t aic_band_off[NUM_BANDS] = { 0, 64, 96, 288 };
48
49			static const uint8_t aic_quant_matrix[64] = {
50			8, 16, 19, 22, 22, 26, 26, 27,
51			16, 16, 22, 22, 26, 27, 27, 29,
52			19, 22, 26, 26, 27, 29, 29, 35,
53			22, 24, 27, 27, 29, 32, 34, 38,
54			26, 27, 29, 29, 32, 35, 38, 46,
55			27, 29, 34, 34, 35, 40, 46, 56,
56			29, 34, 34, 37, 40, 48, 56, 69,
57			34, 37, 38, 40, 48, 58, 69, 83,
58			};
59
60			static const uint8_t aic_y_scan[64] = {
61			0, 4, 1, 2, 5, 8, 12, 9,
62			6, 3, 7, 10, 13, 14, 11, 15,
63			47, 43, 46, 45, 42, 39, 35, 38,
64			41, 44, 40, 37, 34, 33, 36, 32,
65			16, 20, 17, 18, 21, 24, 28, 25,
66			22, 19, 23, 26, 29, 30, 27, 31,
67			63, 59, 62, 61, 58, 55, 51, 54,
68			57, 60, 56, 53, 50, 49, 52, 48,
69			};
70
71			static const uint8_t aic_y_ext_scan[192] = {
72			64, 72, 65, 66, 73, 80, 88, 81,
73			74, 67, 75, 82, 89, 90, 83, 91,
74			0, 4, 1, 2, 5, 8, 12, 9,
75			6, 3, 7, 10, 13, 14, 11, 15,
76			16, 20, 17, 18, 21, 24, 28, 25,
77			22, 19, 23, 26, 29, 30, 27, 31,
78			155, 147, 154, 153, 146, 139, 131, 138,
79			145, 152, 144, 137, 130, 129, 136, 128,
80			47, 43, 46, 45, 42, 39, 35, 38,
81			41, 44, 40, 37, 34, 33, 36, 32,
82			63, 59, 62, 61, 58, 55, 51, 54,
83			57, 60, 56, 53, 50, 49, 52, 48,
84			96, 104, 97, 98, 105, 112, 120, 113,
85			106, 99, 107, 114, 121, 122, 115, 123,
86			68, 76, 69, 70, 77, 84, 92, 85,
87			78, 71, 79, 86, 93, 94, 87, 95,
88			100, 108, 101, 102, 109, 116, 124, 117,
89			110, 103, 111, 118, 125, 126, 119, 127,
90			187, 179, 186, 185, 178, 171, 163, 170,
91			177, 184, 176, 169, 162, 161, 168, 160,
92			159, 151, 158, 157, 150, 143, 135, 142,
93			149, 156, 148, 141, 134, 133, 140, 132,
94			191, 183, 190, 189, 182, 175, 167, 174,
95			181, 188, 180, 173, 166, 165, 172, 164,
96			};
97
98			static const uint8_t aic_c_scan[64] = {
99			0, 4, 1, 2, 5, 8, 12, 9,
100			6, 3, 7, 10, 13, 14, 11, 15,
101			31, 27, 30, 29, 26, 23, 19, 22,
102			25, 28, 24, 21, 18, 17, 20, 16,
103			32, 36, 33, 34, 37, 40, 44, 41,
104			38, 35, 39, 42, 45, 46, 43, 47,
105			63, 59, 62, 61, 58, 55, 51, 54,
106			57, 60, 56, 53, 50, 49, 52, 48,
107			};
108
109			static const uint8_t aic_c_ext_scan[192] = {
110			16, 24, 17, 18, 25, 32, 40, 33,
111			26, 19, 27, 34, 41, 42, 35, 43,
112			0, 4, 1, 2, 5, 8, 12, 9,
113			6, 3, 7, 10, 13, 14, 11, 15,
114			20, 28, 21, 22, 29, 36, 44, 37,
115			30, 23, 31, 38, 45, 46, 39, 47,
116			95, 87, 94, 93, 86, 79, 71, 78,
117			85, 92, 84, 77, 70, 69, 76, 68,
118			63, 59, 62, 61, 58, 55, 51, 54,
119			57, 60, 56, 53, 50, 49, 52, 48,
120			91, 83, 90, 89, 82, 75, 67, 74,
121			81, 88, 80, 73, 66, 65, 72, 64,
122			112, 120, 113, 114, 121, 128, 136, 129,
123			122, 115, 123, 130, 137, 138, 131, 139,
124			96, 100, 97, 98, 101, 104, 108, 105,
125			102, 99, 103, 106, 109, 110, 107, 111,
126			116, 124, 117, 118, 125, 132, 140, 133,
127			126, 119, 127, 134, 141, 142, 135, 143,
128			191, 183, 190, 189, 182, 175, 167, 174,
129			181, 188, 180, 173, 166, 165, 172, 164,
130			159, 155, 158, 157, 154, 151, 147, 150,
131			153, 156, 152, 149, 146, 145, 148, 144,
132			187, 179, 186, 185, 178, 171, 163, 170,
133			177, 184, 176, 169, 162, 161, 168, 160,
134			};
135
136			static const uint8_t * const aic_scan[NUM_BANDS] = {
137			aic_y_scan, aic_c_scan, aic_y_ext_scan, aic_c_ext_scan
138			};
139
140			typedef struct AICContext {
141			AVCodecContext *avctx;
142			AVFrame *frame;
143			IDCTDSPContext idsp;
144			ScanTable scantable;
145
146			int num_x_slices;
147			int slice_width;
148			int mb_width, mb_height;
149			int quant;
150			int interlaced;
151
152			int16_t *slice_data;
153			int16_t *data_ptr[NUM_BANDS];
154
155			DECLARE_ALIGNED(16, int16_t, block)[64];
156			DECLARE_ALIGNED(16, uint8_t, quant_matrix)[64];
157			} AICContext;
158
159		72	static int aic_decode_header(AICContext ctx, const uint8_t src, int size)
160			{
161			uint32_t frame_size;
162			int width, height;
163
164	✗✓	72	if (src[0] != 1) {
165			av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
166			return AVERROR_INVALIDDATA;
167			}
168	✗✓	72	if (src[1] != AIC_HDR_SIZE - 2) {
169			av_log(ctx->avctx, AV_LOG_ERROR, "Invalid header size %d\n", src[1]);
170			return AVERROR_INVALIDDATA;
171			}
172		72	frame_size = AV_RB32(src + 2);
173		72	width = AV_RB16(src + 6);
174		72	height = AV_RB16(src + 8);
175	✗✓	72	if (frame_size > size) {
176			av_log(ctx->avctx, AV_LOG_ERROR, "Frame size should be %"PRIu32" got %d\n",
177			frame_size, size);
178			return AVERROR_INVALIDDATA;
179			}
180	✓✗✗✓	72	if (width != ctx->avctx->width \|\| height != ctx->avctx->height) {
181			av_log(ctx->avctx, AV_LOG_ERROR,
182			"Picture dimension changed: old: %d x %d, new: %d x %d\n",
183			ctx->avctx->width, ctx->avctx->height, width, height);
184			return AVERROR_INVALIDDATA;
185			}
186		72	ctx->quant = src[15];
187		72	ctx->interlaced = ((src[16] >> 4) == 3);
188
189		72	return 0;
190			}
191
192			#define GET_CODE(val, type, add_bits) \
193			do { \
194			if (type) \
195			val = get_ue_golomb(gb); \
196			else \
197			val = get_unary(gb, 1, 31); \
198			if (add_bits) \
199			val = (val << add_bits) + get_bits(gb, add_bits); \
200			} while (0)
201
202		15888	static int aic_decode_coeffs(GetBitContext gb, int16_t dst,
203			int band, int slice_width, int force_chroma)
204			{
205			int has_skips, coeff_type, coeff_bits, skip_type, skip_bits;
206		15888	const int num_coeffs = aic_num_band_coeffs[band];
207		15888	const uint8_t *scan = aic_scan[band \| force_chroma];
208			int mb, idx;
209			unsigned val;
210
211	✗✓	15888	if (get_bits_left(gb) < 5)
212			return AVERROR_INVALIDDATA;
213
214		15888	has_skips = get_bits1(gb);
215		15888	coeff_type = get_bits1(gb);
216		15888	coeff_bits = get_bits(gb, 3);
217
218	✓✓	15888	if (has_skips) {
219		13996	skip_type = get_bits1(gb);
220		13996	skip_bits = get_bits(gb, 3);
221
222	✓✓	437433	for (mb = 0; mb < slice_width; mb++) {
223		423437	idx = -1;
224			do {
225	✓✗✓✓	5032630	GET_CODE(val, skip_type, skip_bits);
226	✗✓	5032630	if (val >= 0x10000)
227			return AVERROR_INVALIDDATA;
228		5032630	idx += val + 1;
229	✓✓	5032630	if (idx >= num_coeffs)
230		252068	break;
231	✓✓✓✓	4780562	GET_CODE(val, coeff_type, coeff_bits);
232		4780562	val++;
233	✗✓	4780562	if (val >= 0x10000)
234			return AVERROR_INVALIDDATA;
235		4780562	dst[scan[idx]] = val;
236	✓✓	4780562	} while (idx < num_coeffs - 1);
237		423437	dst += num_coeffs;
238			}
239			} else {
240	✓✓	58743	for (mb = 0; mb < slice_width; mb++) {
241	✓✓	10576595	for (idx = 0; idx < num_coeffs; idx++) {
242	✓✗✓✓	10519744	GET_CODE(val, coeff_type, coeff_bits);
243	✗✓	10519744	if (val >= 0x10000)
244			return AVERROR_INVALIDDATA;
245		10519744	dst[scan[idx]] = val;
246			}
247		56851	dst += num_coeffs;
248			}
249			}
250		15888	return 0;
251			}
252
253		353232	static void recombine_block(int16_t dst, const uint8_t scan,
254			int16_t base, int16_t ext)
255			{
256			int i, j;
257
258	✓✓	1766160	for (i = 0; i < 4; i++) {
259	✓✓	7064640	for (j = 0; j < 4; j++)
260		5651712	dst[scan[i * 8 + j]] = (*base)[j];
261	✓✓	7064640	for (j = 0; j < 4; j++)
262		5651712	dst[scan[i * 8 + j + 4]] = (*ext)[j];
263		1412928	*base += 4;
264		1412928	*ext += 4;
265			}
266	✓✓	1766160	for (; i < 8; i++) {
267	✓✓	12716352	for (j = 0; j < 8; j++)
268		11303424	dst[scan[i * 8 + j]] = (*ext)[j];
269		1412928	*ext += 8;
270			}
271		353232	}
272
273		367200	static void recombine_block_il(int16_t dst, const uint8_t scan,
274			int16_t base, int16_t ext,
275			int block_no)
276			{
277			int i, j;
278
279	✓✓	367200	if (block_no < 2) {
280	✓✓	1652400	for (i = 0; i < 8; i++) {
281	✓✓	7344000	for (j = 0; j < 4; j++)
282		5875200	dst[scan[i * 8 + j]] = (*base)[j];
283	✓✓	7344000	for (j = 0; j < 4; j++)
284		5875200	dst[scan[i * 8 + j + 4]] = (*ext)[j];
285		1468800	*base += 4;
286		1468800	*ext += 4;
287			}
288			} else {
289	✓✓	11934000	for (i = 0; i < 64; i++)
290		11750400	dst[scan[i]] = (*ext)[i];
291		183600	*ext += 64;
292			}
293		367200	}
294
295		720432	static void unquant_block(int16_t block, int q, uint8_t quant_matrix)
296			{
297			int i;
298
299	✓✓	46828080	for (i = 0; i < 64; i++) {
300		46107648	int val = (uint16_t)block[i];
301		46107648	int sign = val & 1;
302
303		46107648	block[i] = (((val >> 1) ^ -sign) * q * quant_matrix[i] >> 4)
304		46107648	+ sign;
305			}
306		720432	}
307
308		3972	static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
309			const uint8_t *src, int src_size)
310			{
311			GetBitContext gb;
312			int ret, i, mb, blk;
313		3972	int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
314	✓✓✓✓	3972	int last_row = mb_y && mb_y == ctx->mb_height - 1;
315			int y_pos, c_pos;
316			uint8_t Y, C[2];
317			uint8_t *dst;
318		3972	int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
319		3972	int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
320		3972	int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];
321		3972	int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];
322		3972	const int ystride = ctx->frame->linesize[0];
323
324	✓✓	3972	if (last_row) {
325		102	y_pos = (ctx->avctx->height - 16);
326		102	c_pos = ((ctx->avctx->height+1)/2 - 8);
327			} else {
328		3870	y_pos = mb_y * 16;
329		3870	c_pos = mb_y * 8;
330			}
331
332		3972	Y = ctx->frame->data[0] + mb_x * 16 + y_pos * ystride;
333	✓✓	11916	for (i = 0; i < 2; i++)
334		7944	C[i] = ctx->frame->data[i + 1] + mb_x * 8
335		7944	+ c_pos * ctx->frame->linesize[i + 1];
336		3972	init_get_bits(&gb, src, src_size * 8);
337
338		3972	memset(ctx->slice_data, 0,
339			sizeof(ctx->slice_data) slice_width * AIC_BAND_COEFFS);
340	✓✓	19860	for (i = 0; i < NUM_BANDS; i++)
341	✗✓	15888	if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
342			i, slice_width,
343		15888	!ctx->interlaced)) < 0)
344			return ret;
345
346	✓✓	124044	for (mb = 0; mb < slice_width; mb++) {
347	✓✓	600360	for (blk = 0; blk < 4; blk++) {
348	✓✓	480288	if (!ctx->interlaced)
349		113088	recombine_block(ctx->block, ctx->scantable.permutated,
350			&base_y, &ext_y);
351			else
352		367200	recombine_block_il(ctx->block, ctx->scantable.permutated,
353			&base_y, &ext_y, blk);
354		480288	unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
355		480288	ctx->idsp.idct(ctx->block);
356
357	✓✓	480288	if (!ctx->interlaced) {
358		113088	dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
359		113088	ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
360			} else {
361		367200	dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
362		367200	ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
363		367200	ystride * 2);
364			}
365			}
366		120072	Y += 16;
367
368	✓✓	360216	for (blk = 0; blk < 2; blk++) {
369		240144	recombine_block(ctx->block, ctx->scantable.permutated,
370			&base_c, &ext_c);
371		240144	unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
372		240144	ctx->idsp.idct(ctx->block);
373		240144	ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],
374		240144	ctx->frame->linesize[blk + 1]);
375		240144	C[blk] += 8;
376			}
377			}
378
379		3972	return 0;
380			}
381
382		72	static int aic_decode_frame(AVCodecContext avctx, void data, int *got_frame,
383			AVPacket *avpkt)
384			{
385		72	AICContext *ctx = avctx->priv_data;
386		72	const uint8_t *buf = avpkt->data;
387		72	int buf_size = avpkt->size;
388			GetByteContext gb;
389			uint32_t off;
390			int x, y, ret;
391			int slice_size;
392		72	ThreadFrame frame = { .f = data };
393
394		72	ctx->frame = data;
395		72	ctx->frame->pict_type = AV_PICTURE_TYPE_I;
396		72	ctx->frame->key_frame = 1;
397
398		72	off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
399
400	✗✓	72	if (buf_size < off) {
401			av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
402			return AVERROR_INVALIDDATA;
403			}
404
405		72	ret = aic_decode_header(ctx, buf, buf_size);
406	✗✓	72	if (ret < 0) {
407			av_log(avctx, AV_LOG_ERROR, "Invalid header\n");
408			return ret;
409			}
410
411	✗✓	72	if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
412			return ret;
413
414		72	bytestream2_init(&gb, buf + AIC_HDR_SIZE,
415		72	ctx->num_x_slices * ctx->mb_height * 2);
416
417	✓✓	2004	for (y = 0; y < ctx->mb_height; y++) {
418	✓✓	5904	for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
419		3972	slice_size = bytestream2_get_le16(&gb) * 4;
420	✓✗✗✓	3972	if (slice_size + off > buf_size \|\| !slice_size) {
421			av_log(avctx, AV_LOG_ERROR,
422			"Incorrect slice size %d at %d.%d\n", slice_size, x, y);
423			return AVERROR_INVALIDDATA;
424			}
425
426		3972	ret = aic_decode_slice(ctx, x, y, buf + off, slice_size);
427	✗✓	3972	if (ret < 0) {
428			av_log(avctx, AV_LOG_ERROR,
429			"Error decoding slice at %d.%d\n", x, y);
430			return ret;
431			}
432
433		3972	off += slice_size;
434			}
435			}
436
437		72	*got_frame = 1;
438
439		72	return avpkt->size;
440			}
441
442		4	static av_cold int aic_decode_init(AVCodecContext *avctx)
443			{
444		4	AICContext *ctx = avctx->priv_data;
445			int i;
446			uint8_t scan[64];
447
448		4	ctx->avctx = avctx;
449
450		4	avctx->pix_fmt = AV_PIX_FMT_YUV420P;
451
452		4	ff_idctdsp_init(&ctx->idsp, avctx);
453
454	✓✓	260	for (i = 0; i < 64; i++)
455		256	scan[i] = i;
456		4	ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, scan);
457	✓✓	260	for (i = 0; i < 64; i++)
458		256	ctx->quant_matrix[ctx->idsp.idct_permutation[i]] = aic_quant_matrix[i];
459
460		4	ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
461		4	ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
462
463		4	ctx->num_x_slices = (ctx->mb_width + 15) >> 4;
464		4	ctx->slice_width = 16;
465	✓✗	8	for (i = 1; i < ctx->mb_width; i++) {
466	✓✗✓✓	8	if (!(ctx->mb_width % i) && (ctx->mb_width / i <= 32)) {
467		4	ctx->slice_width = ctx->mb_width / i;
468		4	ctx->num_x_slices = i;
469		4	break;
470			}
471			}
472
473		4	ctx->slice_data = av_malloc_array(ctx->slice_width, AIC_BAND_COEFFS
474			* sizeof(*ctx->slice_data));
475	✗✓	4	if (!ctx->slice_data) {
476			av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
477
478			return AVERROR(ENOMEM);
479			}
480
481	✓✓	20	for (i = 0; i < NUM_BANDS; i++)
482		16	ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
483		16	* aic_band_off[i];
484
485		4	return 0;
486			}
487
488		4	static av_cold int aic_decode_close(AVCodecContext *avctx)
489			{
490		4	AICContext *ctx = avctx->priv_data;
491
492		4	av_freep(&ctx->slice_data);
493
494		4	return 0;
495			}
496
497			AVCodec ff_aic_decoder = {
498			.name = "aic",
499			.long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
500			.type = AVMEDIA_TYPE_VIDEO,
501			.id = AV_CODEC_ID_AIC,
502			.priv_data_size = sizeof(AICContext),
503			.init = aic_decode_init,
504			.close = aic_decode_close,
505			.decode = aic_decode_frame,
506			.capabilities = AV_CODEC_CAP_DR1 \| AV_CODEC_CAP_FRAME_THREADS,
507			.init_thread_copy = ONLY_IF_THREADS_ENABLED(aic_decode_init),
508			.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
509			};