FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/aic.c	Lines:	171	196	87.2 %
Date:	2021-01-26 11:44:58	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 "libavutil/mem_internal.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,
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
};


Generated by: GCOVR (Version 4.2)

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