[deb_ffmpeg.git] / ffmpeg / libavcodec / aic.c

/*
 * 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 "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 int aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };

static const int 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;

    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);
    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];

    Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;
    for (i = 0; i < 2; i++)
        C[i] = ctx->frame->data[i + 1] + mb_x * 8
               + mb_y * 8 * 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;

    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;
    }

    if ((ret = aic_decode_header(ctx, buf, buf_size)) < 0)
        return ret;

    if ((ret = ff_get_buffer(avctx, ctx->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\n");
                return AVERROR_INVALIDDATA;
            }

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