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

/*
 * Copyright (C) 2005  Ole André Vadla Ravnås <oleavr@gmail.com>
 * Copyright (C) 2008  Ramiro Polla
 *
 * 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 <stdlib.h>
#include <string.h>
#include <stdint.h>

#include "avcodec.h"
#include "blockdsp.h"
#include "internal.h"
#include "get_bits.h"
#include "bytestream.h"
#include "bswapdsp.h"
#include "hpeldsp.h"
#include "idctdsp.h"
#include "thread.h"

#define MIMIC_HEADER_SIZE   20

typedef struct {
    AVCodecContext *avctx;

    int             num_vblocks[3];
    int             num_hblocks[3];

    void           *swap_buf;
    int             swap_buf_size;

    int             cur_index;
    int             prev_index;

    ThreadFrame     frames     [16];
    AVPicture       flipped_ptrs[16];

    DECLARE_ALIGNED(16, int16_t, dct_block)[64];

    GetBitContext   gb;
    ScanTable       scantable;
    BlockDSPContext bdsp;
    BswapDSPContext bbdsp;
    HpelDSPContext  hdsp;
    IDCTDSPContext  idsp;
    VLC             vlc;

    /* Kept in the context so multithreading can have a constant to read from */
    int             next_cur_index;
    int             next_prev_index;
} MimicContext;

static const uint32_t huffcodes[] = {
    0x0000000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000000b,
    0x0000001b, 0x00000038, 0x00000078, 0x00000079, 0x0000007a, 0x000000f9,
    0x000000fa, 0x000003fb, 0x000007f8, 0x000007f9, 0x000007fa, 0x000007fb,
    0x00000ff8, 0x00000ff9, 0x00000001, 0x00000039, 0x0000007b, 0x000000fb,
    0x000001f8, 0x000001f9, 0x00000ffa, 0x00000ffb, 0x00001ff8, 0x00001ff9,
    0x00001ffa, 0x00001ffb, 0x00003ff8, 0x00003ff9, 0x00003ffa, 0x00000000,
    0x00000004, 0x0000003a, 0x000001fa, 0x00003ffb, 0x00007ff8, 0x00007ff9,
    0x00007ffa, 0x00007ffb, 0x0000fff8, 0x0000fff9, 0x0000fffa, 0x0000fffb,
    0x0001fff8, 0x0001fff9, 0x0001fffa, 0x00000000, 0x0000000c, 0x000000f8,
    0x000001fb, 0x0001fffb, 0x0003fff8, 0x0003fff9, 0x0003fffa, 0x0003fffb,
    0x0007fff8, 0x0007fff9, 0x0007fffa, 0x0007fffb, 0x000ffff8, 0x000ffff9,
    0x000ffffa, 0x00000000, 0x0000001a, 0x000003f8, 0x000ffffb, 0x001ffff8,
    0x001ffff9, 0x001ffffa, 0x001ffffb, 0x003ffff8, 0x003ffff9, 0x003ffffa,
    0x003ffffb, 0x007ffff8, 0x007ffff9, 0x007ffffa, 0x007ffffb, 0x00000000,
    0x0000003b, 0x000003f9, 0x00fffff8, 0x00fffff9, 0x00fffffa, 0x00fffffb,
    0x01fffff8, 0x01fffff9, 0x01fffffa, 0x01fffffb, 0x03fffff8, 0x03fffff9,
    0x03fffffa, 0x03fffffb, 0x07fffff8, 0x00000000, 0x000003fa, 0x07fffff9,
    0x07fffffa, 0x07fffffb, 0x0ffffff8, 0x0ffffff9, 0x0ffffffa, 0x0ffffffb,
    0x1ffffff8, 0x1ffffff9, 0x1ffffffa, 0x1ffffffb, 0x3ffffff8, 0x3ffffff9,
    0x3ffffffa,
};

static const uint8_t huffbits[] = {
     4,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
     0,  0,  0,  0,  2,  4,  5,  6,  7,  7,  7,  8,
     8, 10, 11, 11, 11, 11, 12, 12,  2,  6,  7,  8,
     9,  9, 12, 12, 13, 13, 13, 13, 14, 14, 14,  0,
     3,  6,  9, 14, 15, 15, 15, 15, 16, 16, 16, 16,
    17, 17, 17,  0,  4,  8,  9, 17, 18, 18, 18, 18,
    19, 19, 19, 19, 20, 20, 20,  0,  5, 10, 20, 21,
    21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23,  0,
     6, 10, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26,
    26, 26, 27,  0, 10, 27, 27, 27, 28, 28, 28, 28,
    29, 29, 29, 29, 30, 30, 30,
};

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

static av_cold int mimic_decode_end(AVCodecContext *avctx)
{
    MimicContext *ctx = avctx->priv_data;
    int i;

    av_freep(&ctx->swap_buf);
    ctx->swap_buf_size = 0;

    for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
        if (ctx->frames[i].f)
            ff_thread_release_buffer(avctx, &ctx->frames[i]);
        av_frame_free(&ctx->frames[i].f);
    }

    if (!avctx->internal->is_copy)
        ff_free_vlc(&ctx->vlc);

    return 0;
}

static av_cold int mimic_decode_init(AVCodecContext *avctx)
{
    MimicContext *ctx = avctx->priv_data;
    int ret, i;

    avctx->internal->allocate_progress = 1;

    ctx->prev_index = 0;
    ctx->cur_index  = 15;

    if ((ret = init_vlc(&ctx->vlc, 11, FF_ARRAY_ELEMS(huffbits),
                        huffbits, 1, 1, huffcodes, 4, 4, 0)) < 0) {
        av_log(avctx, AV_LOG_ERROR, "error initializing vlc table\n");
        return ret;
    }
    ff_blockdsp_init(&ctx->bdsp, avctx);
    ff_bswapdsp_init(&ctx->bbdsp);
    ff_hpeldsp_init(&ctx->hdsp, avctx->flags);
    ff_idctdsp_init(&ctx->idsp, avctx);
    ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, col_zag);

    for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
        ctx->frames[i].f = av_frame_alloc();
        if (!ctx->frames[i].f) {
            mimic_decode_end(avctx);
            return AVERROR(ENOMEM);
        }
    }

    return 0;
}

static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
{
    MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data;
    int i, ret;

    if (avctx == avctx_from)
        return 0;

    dst->cur_index  = src->next_cur_index;
    dst->prev_index = src->next_prev_index;

    memcpy(dst->flipped_ptrs, src->flipped_ptrs, sizeof(src->flipped_ptrs));

    for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) {
        ff_thread_release_buffer(avctx, &dst->frames[i]);
        if (i != src->next_cur_index && src->frames[i].f->data[0]) {
            ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]);
            if (ret < 0)
                return ret;
        }
    }

    return 0;
}

static const int8_t vlcdec_lookup[9][64] = {
    {    0, },
    {   -1,   1, },
    {   -3,   3,   -2,   2, },
    {   -7,   7,   -6,   6,   -5,   5,   -4,   4, },
    {  -15,  15,  -14,  14,  -13,  13,  -12,  12,
       -11,  11,  -10,  10,   -9,   9,   -8,   8, },
    {  -31,  31,  -30,  30,  -29,  29,  -28,  28,
       -27,  27,  -26,  26,  -25,  25,  -24,  24,
       -23,  23,  -22,  22,  -21,  21,  -20,  20,
       -19,  19,  -18,  18,  -17,  17,  -16,  16, },
    {  -63,  63,  -62,  62,  -61,  61,  -60,  60,
       -59,  59,  -58,  58,  -57,  57,  -56,  56,
       -55,  55,  -54,  54,  -53,  53,  -52,  52,
       -51,  51,  -50,  50,  -49,  49,  -48,  48,
       -47,  47,  -46,  46,  -45,  45,  -44,  44,
       -43,  43,  -42,  42,  -41,  41,  -40,  40,
       -39,  39,  -38,  38,  -37,  37,  -36,  36,
       -35,  35,  -34,  34,  -33,  33,  -32,  32, },
    { -127, 127, -126, 126, -125, 125, -124, 124,
      -123, 123, -122, 122, -121, 121, -120, 120,
      -119, 119, -118, 118, -117, 117, -116, 116,
      -115, 115, -114, 114, -113, 113, -112, 112,
      -111, 111, -110, 110, -109, 109, -108, 108,
      -107, 107, -106, 106, -105, 105, -104, 104,
      -103, 103, -102, 102, -101, 101, -100, 100,
       -99,  99,  -98,  98,  -97,  97,  -96,  96, },
    {  -95,  95,  -94,  94,  -93,  93,  -92,  92,
       -91,  91,  -90,  90,  -89,  89,  -88,  88,
       -87,  87,  -86,  86,  -85,  85,  -84,  84,
       -83,  83,  -82,  82,  -81,  81,  -80,  80,
       -79,  79,  -78,  78,  -77,  77,  -76,  76,
       -75,  75,  -74,  74,  -73,  73,  -72,  72,
       -71,  71,  -70,  70,  -69,  69,  -68,  68,
       -67,  67,  -66,  66,  -65,  65,  -64,  64, },
};

static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
{
    int16_t *block = ctx->dct_block;
    unsigned int pos;

    ctx->bdsp.clear_block(block);

    block[0] = get_bits(&ctx->gb, 8) << 3;

    for (pos = 1; pos < num_coeffs; pos++) {
        uint32_t vlc, num_bits;
        int value;
        int coeff;

        vlc = get_vlc2(&ctx->gb, ctx->vlc.table, ctx->vlc.bits, 3);
        if (!vlc) /* end-of-block code */
            return 0;
        if (vlc == -1)
            return AVERROR_INVALIDDATA;

        /* pos_add and num_bits are coded in the vlc code */
        pos     += vlc & 15; // pos_add
        num_bits = vlc >> 4; // num_bits

        if (pos >= 64)
            return AVERROR_INVALIDDATA;

        value = get_bits(&ctx->gb, num_bits);

        /* FFmpeg's IDCT behaves somewhat different from the original code, so
         * a factor of 4 was added to the input */

        coeff = vlcdec_lookup[num_bits][value];
        if (pos < 3)
            coeff <<= 4;
        else /* TODO Use >> 10 instead of / 1001 */
            coeff = (coeff * qscale) / 1001;

        block[ctx->scantable.permutated[pos]] = coeff;
    }

    return 0;
}

static int decode(MimicContext *ctx, int quality, int num_coeffs,
                  int is_iframe)
{
    int ret, y, x, plane, cur_row = 0;

    for (plane = 0; plane < 3; plane++) {
        const int is_chroma = !!plane;
        const int qscale    = av_clip(10000 - quality, is_chroma ? 1000 : 2000,
                                      10000) << 2;
        const int stride    = ctx->flipped_ptrs[ctx->cur_index ].linesize[plane];
        const uint8_t *src  = ctx->flipped_ptrs[ctx->prev_index].data[plane];
        uint8_t       *dst  = ctx->flipped_ptrs[ctx->cur_index ].data[plane];

        for (y = 0; y < ctx->num_vblocks[plane]; y++) {
            for (x = 0; x < ctx->num_hblocks[plane]; x++) {
                /* Check for a change condition in the current block.
                 * - iframes always change.
                 * - Luma plane changes on get_bits1 == 0
                 * - Chroma planes change on get_bits1 == 1 */
                if (is_iframe || get_bits1(&ctx->gb) == is_chroma) {
                    /* Luma planes may use a backreference from the 15 last
                     * frames preceding the previous. (get_bits1 == 1)
                     * Chroma planes don't use backreferences. */
                    if (is_chroma || is_iframe || !get_bits1(&ctx->gb)) {
                        if ((ret = vlc_decode_block(ctx, num_coeffs,
                                                    qscale)) < 0) {
                            av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding "
                                   "block.\n");
                            return ret;
                        }
                        ctx->idsp.idct_put(dst, stride, ctx->dct_block);
                    } else {
                        unsigned int backref = get_bits(&ctx->gb, 4);
                        int index            = (ctx->cur_index + backref) & 15;
                        uint8_t *p           = ctx->flipped_ptrs[index].data[0];

                        if (index != ctx->cur_index && p) {
                            ff_thread_await_progress(&ctx->frames[index],
                                                     cur_row, 0);
                            p += src -
                                 ctx->flipped_ptrs[ctx->prev_index].data[plane];
                            ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8);
                        } else {
                            av_log(ctx->avctx, AV_LOG_ERROR,
                                     "No such backreference! Buggy sample.\n");
                        }
                    }
                } else {
                    ff_thread_await_progress(&ctx->frames[ctx->prev_index],
                                             cur_row, 0);
                    ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8);
                }
                src += 8;
                dst += 8;
            }
            src += (stride - ctx->num_hblocks[plane]) << 3;
            dst += (stride - ctx->num_hblocks[plane]) << 3;

            ff_thread_report_progress(&ctx->frames[ctx->cur_index],
                                      cur_row++, 0);
        }
    }

    return 0;
}

/**
 * Flip the buffer upside-down and put it in the YVU order to match the
 * way Mimic encodes frames.
 */
static void prepare_avpic(MimicContext *ctx, AVPicture *dst, AVFrame *src)
{
    int i;
    dst->data[0] = src->data[0] + ( ctx->avctx->height       - 1) * src->linesize[0];
    dst->data[1] = src->data[2] + ((ctx->avctx->height >> 1) - 1) * src->linesize[2];
    dst->data[2] = src->data[1] + ((ctx->avctx->height >> 1) - 1) * src->linesize[1];
    for (i = 0; i < 3; i++)
        dst->linesize[i] = -src->linesize[i];
}

static int mimic_decode_frame(AVCodecContext *avctx, void *data,
                              int *got_frame, AVPacket *avpkt)
{
    const uint8_t *buf = avpkt->data;
    int buf_size       = avpkt->size;
    int swap_buf_size  = buf_size - MIMIC_HEADER_SIZE;
    MimicContext *ctx  = avctx->priv_data;
    GetByteContext gb;
    int is_pframe;
    int width, height;
    int quality, num_coeffs;
    int res;

    if (buf_size <= MIMIC_HEADER_SIZE) {
        av_log(avctx, AV_LOG_ERROR, "insufficient data\n");
        return AVERROR_INVALIDDATA;
    }

    bytestream2_init(&gb, buf, MIMIC_HEADER_SIZE);
    bytestream2_skip(&gb, 2); /* some constant (always 256) */
    quality    = bytestream2_get_le16u(&gb);
    width      = bytestream2_get_le16u(&gb);
    height     = bytestream2_get_le16u(&gb);
    bytestream2_skip(&gb, 4); /* some constant */
    is_pframe  = bytestream2_get_le32u(&gb);
    num_coeffs = bytestream2_get_byteu(&gb);
    bytestream2_skip(&gb, 3); /* some constant */

    if (!ctx->avctx) {
        int i;

        if (!(width == 160 && height == 120) &&
            !(width == 320 && height == 240)) {
            av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n");
            return AVERROR_INVALIDDATA;
        }

        ctx->avctx     = avctx;
        avctx->width   = width;
        avctx->height  = height;
        avctx->pix_fmt = AV_PIX_FMT_YUV420P;
        for (i = 0; i < 3; i++) {
            ctx->num_vblocks[i] = FF_CEIL_RSHIFT(height,   3 + !!i);
            ctx->num_hblocks[i] =                width >> (3 + !!i);
        }
    } else if (width != ctx->avctx->width || height != ctx->avctx->height) {
        avpriv_request_sample(avctx, "Resolution changing");
        return AVERROR_PATCHWELCOME;
    }

    if (is_pframe && !ctx->frames[ctx->prev_index].f->data[0]) {
        av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");
        return AVERROR_INVALIDDATA;
    }

    ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
    ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P :
                                                           AV_PICTURE_TYPE_I;
    if ((res = ff_thread_get_buffer(avctx, &ctx->frames[ctx->cur_index],
                                    AV_GET_BUFFER_FLAG_REF)) < 0)
        return res;

    ctx->next_prev_index = ctx->cur_index;
    ctx->next_cur_index  = (ctx->cur_index - 1) & 15;

    prepare_avpic(ctx, &ctx->flipped_ptrs[ctx->cur_index],
                  ctx->frames[ctx->cur_index].f);

    ff_thread_finish_setup(avctx);

    av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size);
    if (!ctx->swap_buf)
        return AVERROR(ENOMEM);

    ctx->bbdsp.bswap_buf(ctx->swap_buf,
                         (const uint32_t *) (buf + MIMIC_HEADER_SIZE),
                         swap_buf_size >> 2);
    init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3);

    res = decode(ctx, quality, num_coeffs, !is_pframe);
    ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0);
    if (res < 0) {
        if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
            ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
            return res;
        }
    }

    if ((res = av_frame_ref(data, ctx->frames[ctx->cur_index].f)) < 0)
        return res;
    *got_frame      = 1;

    ctx->prev_index = ctx->next_prev_index;
    ctx->cur_index  = ctx->next_cur_index;

    /* Only release frames that aren't used for backreferences anymore */
    ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);

    return buf_size;
}

static av_cold int mimic_init_thread_copy(AVCodecContext *avctx)
{
    MimicContext *ctx = avctx->priv_data;
    int i;

    for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
        ctx->frames[i].f = av_frame_alloc();
        if (!ctx->frames[i].f) {
            mimic_decode_end(avctx);
            return AVERROR(ENOMEM);
        }
    }

    return 0;
}

AVCodec ff_mimic_decoder = {
    .name                  = "mimic",
    .long_name             = NULL_IF_CONFIG_SMALL("Mimic"),
    .type                  = AVMEDIA_TYPE_VIDEO,
    .id                    = AV_CODEC_ID_MIMIC,
    .priv_data_size        = sizeof(MimicContext),
    .init                  = mimic_decode_init,
    .close                 = mimic_decode_end,
    .decode                = mimic_decode_frame,
    .capabilities          = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
    .update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context),
    .init_thread_copy      = ONLY_IF_THREADS_ENABLED(mimic_init_thread_copy),
};
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* Copyright (C) 2005 Ole André Vadla Ravnås <oleavr@gmail.com>
	3	* Copyright (C) 2008 Ramiro Polla
	4	*
	5	* This file is part of FFmpeg.
	6	*
	7	* FFmpeg is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2.1 of the License, or (at your option) any later version.
	11	*
	12	* FFmpeg is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with FFmpeg; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	#include <stdlib.h>
	23	#include <string.h>
	24	#include <stdint.h>
	25
	26	#include "avcodec.h"
	27	#include "blockdsp.h"
	28	#include "internal.h"
	29	#include "get_bits.h"
	30	#include "bytestream.h"
	31	#include "bswapdsp.h"
	32	#include "hpeldsp.h"
	33	#include "idctdsp.h"
	34	#include "thread.h"
	35
	36	#define MIMIC_HEADER_SIZE 20
	37
	38	typedef struct {
	39	AVCodecContext *avctx;
	40
	41	int num_vblocks[3];
	42	int num_hblocks[3];
	43
	44	void *swap_buf;
	45	int swap_buf_size;
	46
	47	int cur_index;
	48	int prev_index;
	49
	50	ThreadFrame frames [16];
	51	AVPicture flipped_ptrs[16];
	52
	53	DECLARE_ALIGNED(16, int16_t, dct_block)[64];
	54
	55	GetBitContext gb;
	56	ScanTable scantable;
	57	BlockDSPContext bdsp;
	58	BswapDSPContext bbdsp;
	59	HpelDSPContext hdsp;
	60	IDCTDSPContext idsp;
	61	VLC vlc;
	62
	63	/* Kept in the context so multithreading can have a constant to read from */
	64	int next_cur_index;
65	int next_prev_index;
66	} MimicContext;
67
68	static const uint32_t huffcodes[] = {
69	0x0000000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
70	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
71	0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000000b,
72	0x0000001b, 0x00000038, 0x00000078, 0x00000079, 0x0000007a, 0x000000f9,
73	0x000000fa, 0x000003fb, 0x000007f8, 0x000007f9, 0x000007fa, 0x000007fb,
74	0x00000ff8, 0x00000ff9, 0x00000001, 0x00000039, 0x0000007b, 0x000000fb,
75	0x000001f8, 0x000001f9, 0x00000ffa, 0x00000ffb, 0x00001ff8, 0x00001ff9,
76	0x00001ffa, 0x00001ffb, 0x00003ff8, 0x00003ff9, 0x00003ffa, 0x00000000,
77	0x00000004, 0x0000003a, 0x000001fa, 0x00003ffb, 0x00007ff8, 0x00007ff9,
78	0x00007ffa, 0x00007ffb, 0x0000fff8, 0x0000fff9, 0x0000fffa, 0x0000fffb,
79	0x0001fff8, 0x0001fff9, 0x0001fffa, 0x00000000, 0x0000000c, 0x000000f8,
80	0x000001fb, 0x0001fffb, 0x0003fff8, 0x0003fff9, 0x0003fffa, 0x0003fffb,
81	0x0007fff8, 0x0007fff9, 0x0007fffa, 0x0007fffb, 0x000ffff8, 0x000ffff9,
82	0x000ffffa, 0x00000000, 0x0000001a, 0x000003f8, 0x000ffffb, 0x001ffff8,
83	0x001ffff9, 0x001ffffa, 0x001ffffb, 0x003ffff8, 0x003ffff9, 0x003ffffa,
84	0x003ffffb, 0x007ffff8, 0x007ffff9, 0x007ffffa, 0x007ffffb, 0x00000000,
85	0x0000003b, 0x000003f9, 0x00fffff8, 0x00fffff9, 0x00fffffa, 0x00fffffb,
86	0x01fffff8, 0x01fffff9, 0x01fffffa, 0x01fffffb, 0x03fffff8, 0x03fffff9,
87	0x03fffffa, 0x03fffffb, 0x07fffff8, 0x00000000, 0x000003fa, 0x07fffff9,
88	0x07fffffa, 0x07fffffb, 0x0ffffff8, 0x0ffffff9, 0x0ffffffa, 0x0ffffffb,
89	0x1ffffff8, 0x1ffffff9, 0x1ffffffa, 0x1ffffffb, 0x3ffffff8, 0x3ffffff9,
90	0x3ffffffa,
91	};
92
93	static const uint8_t huffbits[] = {
94	4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
95	0, 0, 0, 0, 2, 4, 5, 6, 7, 7, 7, 8,
96	8, 10, 11, 11, 11, 11, 12, 12, 2, 6, 7, 8,
97	9, 9, 12, 12, 13, 13, 13, 13, 14, 14, 14, 0,
98	3, 6, 9, 14, 15, 15, 15, 15, 16, 16, 16, 16,
99	17, 17, 17, 0, 4, 8, 9, 17, 18, 18, 18, 18,
100	19, 19, 19, 19, 20, 20, 20, 0, 5, 10, 20, 21,
101	21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 0,
102	6, 10, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26,
103	26, 26, 27, 0, 10, 27, 27, 27, 28, 28, 28, 28,
104	29, 29, 29, 29, 30, 30, 30,
105	};
106
107	static const uint8_t col_zag[64] = {
108	0, 8, 1, 2, 9, 16, 24, 17,
109	10, 3, 4, 11, 18, 25, 32, 40,
110	33, 26, 19, 12, 5, 6, 13, 20,
111	27, 34, 41, 48, 56, 49, 42, 35,
112	28, 21, 14, 7, 15, 22, 29, 36,
113	43, 50, 57, 58, 51, 44, 37, 30,
114	23, 31, 38, 45, 52, 59, 39, 46,
115	53, 60, 61, 54, 47, 55, 62, 63,
116	};
117
118	static av_cold int mimic_decode_end(AVCodecContext *avctx)
119	{
120	MimicContext *ctx = avctx->priv_data;
121	int i;
122
123	av_freep(&ctx->swap_buf);
124	ctx->swap_buf_size = 0;
125
126	for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
127	if (ctx->frames[i].f)
128	ff_thread_release_buffer(avctx, &ctx->frames[i]);
129	av_frame_free(&ctx->frames[i].f);
130	}
131
132	if (!avctx->internal->is_copy)
133	ff_free_vlc(&ctx->vlc);
134
135	return 0;
136	}
137
138	static av_cold int mimic_decode_init(AVCodecContext *avctx)
139	{
140	MimicContext *ctx = avctx->priv_data;
141	int ret, i;
142
143	avctx->internal->allocate_progress = 1;
144
145	ctx->prev_index = 0;
146	ctx->cur_index = 15;
147
148	if ((ret = init_vlc(&ctx->vlc, 11, FF_ARRAY_ELEMS(huffbits),
149	huffbits, 1, 1, huffcodes, 4, 4, 0)) < 0) {
150	av_log(avctx, AV_LOG_ERROR, "error initializing vlc table\n");
151	return ret;
152	}
153	ff_blockdsp_init(&ctx->bdsp, avctx);
154	ff_bswapdsp_init(&ctx->bbdsp);
155	ff_hpeldsp_init(&ctx->hdsp, avctx->flags);
156	ff_idctdsp_init(&ctx->idsp, avctx);
157	ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, col_zag);
158
159	for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
160	ctx->frames[i].f = av_frame_alloc();
161	if (!ctx->frames[i].f) {
162	mimic_decode_end(avctx);
163	return AVERROR(ENOMEM);
164	}
165	}
166
167	return 0;
168	}
169
170	static int mimic_decode_update_thread_context(AVCodecContext avctx, const AVCodecContext avctx_from)
171	{
172	MimicContext dst = avctx->priv_data, src = avctx_from->priv_data;
173	int i, ret;
174
175	if (avctx == avctx_from)
176	return 0;
177
178	dst->cur_index = src->next_cur_index;
179	dst->prev_index = src->next_prev_index;
180
181	memcpy(dst->flipped_ptrs, src->flipped_ptrs, sizeof(src->flipped_ptrs));
182
183	for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) {
184	ff_thread_release_buffer(avctx, &dst->frames[i]);
185	if (i != src->next_cur_index && src->frames[i].f->data[0]) {
186	ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]);
187	if (ret < 0)
188	return ret;
189	}
190	}
191
192	return 0;
193	}
194
195	static const int8_t vlcdec_lookup[9][64] = {
196	{ 0, },
197	{ -1, 1, },
198	{ -3, 3, -2, 2, },
199	{ -7, 7, -6, 6, -5, 5, -4, 4, },
200	{ -15, 15, -14, 14, -13, 13, -12, 12,
201	-11, 11, -10, 10, -9, 9, -8, 8, },
202	{ -31, 31, -30, 30, -29, 29, -28, 28,
203	-27, 27, -26, 26, -25, 25, -24, 24,
204	-23, 23, -22, 22, -21, 21, -20, 20,
205	-19, 19, -18, 18, -17, 17, -16, 16, },
206	{ -63, 63, -62, 62, -61, 61, -60, 60,
207	-59, 59, -58, 58, -57, 57, -56, 56,
208	-55, 55, -54, 54, -53, 53, -52, 52,
209	-51, 51, -50, 50, -49, 49, -48, 48,
210	-47, 47, -46, 46, -45, 45, -44, 44,
211	-43, 43, -42, 42, -41, 41, -40, 40,
212	-39, 39, -38, 38, -37, 37, -36, 36,
213	-35, 35, -34, 34, -33, 33, -32, 32, },
214	{ -127, 127, -126, 126, -125, 125, -124, 124,
215	-123, 123, -122, 122, -121, 121, -120, 120,
216	-119, 119, -118, 118, -117, 117, -116, 116,
217	-115, 115, -114, 114, -113, 113, -112, 112,
218	-111, 111, -110, 110, -109, 109, -108, 108,
219	-107, 107, -106, 106, -105, 105, -104, 104,
220	-103, 103, -102, 102, -101, 101, -100, 100,
221	-99, 99, -98, 98, -97, 97, -96, 96, },
222	{ -95, 95, -94, 94, -93, 93, -92, 92,
223	-91, 91, -90, 90, -89, 89, -88, 88,
224	-87, 87, -86, 86, -85, 85, -84, 84,
225	-83, 83, -82, 82, -81, 81, -80, 80,
226	-79, 79, -78, 78, -77, 77, -76, 76,
227	-75, 75, -74, 74, -73, 73, -72, 72,
228	-71, 71, -70, 70, -69, 69, -68, 68,
229	-67, 67, -66, 66, -65, 65, -64, 64, },
230	};
231
232	static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
233	{
234	int16_t *block = ctx->dct_block;
235	unsigned int pos;
236
237	ctx->bdsp.clear_block(block);
238
239	block[0] = get_bits(&ctx->gb, 8) << 3;
240
241	for (pos = 1; pos < num_coeffs; pos++) {
242	uint32_t vlc, num_bits;
243	int value;
244	int coeff;
245
246	vlc = get_vlc2(&ctx->gb, ctx->vlc.table, ctx->vlc.bits, 3);
247	if (!vlc) /* end-of-block code */
248	return 0;
249	if (vlc == -1)
250	return AVERROR_INVALIDDATA;
251
252	/* pos_add and num_bits are coded in the vlc code */
253	pos += vlc & 15; // pos_add
254	num_bits = vlc >> 4; // num_bits
255
256	if (pos >= 64)
257	return AVERROR_INVALIDDATA;
258
259	value = get_bits(&ctx->gb, num_bits);
260
261	/* FFmpeg's IDCT behaves somewhat different from the original code, so
262	* a factor of 4 was added to the input */
263
264	coeff = vlcdec_lookup[num_bits][value];
265	if (pos < 3)
266	coeff <<= 4;
267	else /* TODO Use >> 10 instead of / 1001 */
268	coeff = (coeff * qscale) / 1001;
269
270	block[ctx->scantable.permutated[pos]] = coeff;
271	}
272
273	return 0;
274	}
275
276	static int decode(MimicContext *ctx, int quality, int num_coeffs,
277	int is_iframe)
278	{
279	int ret, y, x, plane, cur_row = 0;
280
281	for (plane = 0; plane < 3; plane++) {
282	const int is_chroma = !!plane;
283	const int qscale = av_clip(10000 - quality, is_chroma ? 1000 : 2000,
284	10000) << 2;
285	const int stride = ctx->flipped_ptrs[ctx->cur_index ].linesize[plane];
286	const uint8_t *src = ctx->flipped_ptrs[ctx->prev_index].data[plane];
287	uint8_t *dst = ctx->flipped_ptrs[ctx->cur_index ].data[plane];
288
289	for (y = 0; y < ctx->num_vblocks[plane]; y++) {
290	for (x = 0; x < ctx->num_hblocks[plane]; x++) {
291	/* Check for a change condition in the current block.
292	* - iframes always change.
293	* - Luma plane changes on get_bits1 == 0
294	* - Chroma planes change on get_bits1 == 1 */
295	if (is_iframe \|\| get_bits1(&ctx->gb) == is_chroma) {
296	/* Luma planes may use a backreference from the 15 last
297	* frames preceding the previous. (get_bits1 == 1)
298	* Chroma planes don't use backreferences. */
299	if (is_chroma \|\| is_iframe \|\| !get_bits1(&ctx->gb)) {
300	if ((ret = vlc_decode_block(ctx, num_coeffs,
301	qscale)) < 0) {
302	av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding "
303	"block.\n");
304	return ret;
305	}
306	ctx->idsp.idct_put(dst, stride, ctx->dct_block);
307	} else {
308	unsigned int backref = get_bits(&ctx->gb, 4);
309	int index = (ctx->cur_index + backref) & 15;
310	uint8_t *p = ctx->flipped_ptrs[index].data[0];
311
312	if (index != ctx->cur_index && p) {
313	ff_thread_await_progress(&ctx->frames[index],
314	cur_row, 0);
315	p += src -
316	ctx->flipped_ptrs[ctx->prev_index].data[plane];
317	ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8);
318	} else {
319	av_log(ctx->avctx, AV_LOG_ERROR,
320	"No such backreference! Buggy sample.\n");
321	}
322	}
323	} else {
324	ff_thread_await_progress(&ctx->frames[ctx->prev_index],
325	cur_row, 0);
326	ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8);
327	}
328	src += 8;
329	dst += 8;
330	}
331	src += (stride - ctx->num_hblocks[plane]) << 3;
332	dst += (stride - ctx->num_hblocks[plane]) << 3;
333
334	ff_thread_report_progress(&ctx->frames[ctx->cur_index],
335	cur_row++, 0);
336	}
337	}
338
339	return 0;
340	}
341
342	/**
343	* Flip the buffer upside-down and put it in the YVU order to match the
344	* way Mimic encodes frames.
345	*/
346	static void prepare_avpic(MimicContext ctx, AVPicture dst, AVFrame *src)
347	{
348	int i;
349	dst->data[0] = src->data[0] + ( ctx->avctx->height - 1) * src->linesize[0];
350	dst->data[1] = src->data[2] + ((ctx->avctx->height >> 1) - 1) * src->linesize[2];
351	dst->data[2] = src->data[1] + ((ctx->avctx->height >> 1) - 1) * src->linesize[1];
352	for (i = 0; i < 3; i++)
353	dst->linesize[i] = -src->linesize[i];
354	}
355
356	static int mimic_decode_frame(AVCodecContext avctx, void data,
357	int got_frame, AVPacket avpkt)
358	{
359	const uint8_t *buf = avpkt->data;
360	int buf_size = avpkt->size;
361	int swap_buf_size = buf_size - MIMIC_HEADER_SIZE;
362	MimicContext *ctx = avctx->priv_data;
363	GetByteContext gb;
364	int is_pframe;
365	int width, height;
366	int quality, num_coeffs;
367	int res;
368
369	if (buf_size <= MIMIC_HEADER_SIZE) {
370	av_log(avctx, AV_LOG_ERROR, "insufficient data\n");
371	return AVERROR_INVALIDDATA;
372	}
373
374	bytestream2_init(&gb, buf, MIMIC_HEADER_SIZE);
375	bytestream2_skip(&gb, 2); /* some constant (always 256) */
376	quality = bytestream2_get_le16u(&gb);
377	width = bytestream2_get_le16u(&gb);
378	height = bytestream2_get_le16u(&gb);
379	bytestream2_skip(&gb, 4); /* some constant */
380	is_pframe = bytestream2_get_le32u(&gb);
381	num_coeffs = bytestream2_get_byteu(&gb);
382	bytestream2_skip(&gb, 3); /* some constant */
383
384	if (!ctx->avctx) {
385	int i;
386
387	if (!(width == 160 && height == 120) &&
388	!(width == 320 && height == 240)) {
389	av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n");
390	return AVERROR_INVALIDDATA;
391	}
392
393	ctx->avctx = avctx;
394	avctx->width = width;
395	avctx->height = height;
396	avctx->pix_fmt = AV_PIX_FMT_YUV420P;
397	for (i = 0; i < 3; i++) {
398	ctx->num_vblocks[i] = FF_CEIL_RSHIFT(height, 3 + !!i);
399	ctx->num_hblocks[i] = width >> (3 + !!i);
400	}
401	} else if (width != ctx->avctx->width \|\| height != ctx->avctx->height) {
402	avpriv_request_sample(avctx, "Resolution changing");
403	return AVERROR_PATCHWELCOME;
404	}
405
406	if (is_pframe && !ctx->frames[ctx->prev_index].f->data[0]) {
407	av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");
408	return AVERROR_INVALIDDATA;
409	}
410
411	ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
412	ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P :
413	AV_PICTURE_TYPE_I;
414	if ((res = ff_thread_get_buffer(avctx, &ctx->frames[ctx->cur_index],
415	AV_GET_BUFFER_FLAG_REF)) < 0)
416	return res;
417
418	ctx->next_prev_index = ctx->cur_index;
419	ctx->next_cur_index = (ctx->cur_index - 1) & 15;
420
421	prepare_avpic(ctx, &ctx->flipped_ptrs[ctx->cur_index],
422	ctx->frames[ctx->cur_index].f);
423
424	ff_thread_finish_setup(avctx);
425
426	av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size);
427	if (!ctx->swap_buf)
428	return AVERROR(ENOMEM);
429
430	ctx->bbdsp.bswap_buf(ctx->swap_buf,
431	(const uint32_t *) (buf + MIMIC_HEADER_SIZE),
432	swap_buf_size >> 2);
433	init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3);
434
435	res = decode(ctx, quality, num_coeffs, !is_pframe);
436	ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0);
437	if (res < 0) {
438	if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
439	ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
440	return res;
441	}
442	}
443
444	if ((res = av_frame_ref(data, ctx->frames[ctx->cur_index].f)) < 0)
445	return res;
446	*got_frame = 1;
447
448	ctx->prev_index = ctx->next_prev_index;
449	ctx->cur_index = ctx->next_cur_index;
450
451	/* Only release frames that aren't used for backreferences anymore */
452	ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
453
454	return buf_size;
455	}
456
457	static av_cold int mimic_init_thread_copy(AVCodecContext *avctx)
458	{
459	MimicContext *ctx = avctx->priv_data;
460	int i;
461
462	for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
463	ctx->frames[i].f = av_frame_alloc();
464	if (!ctx->frames[i].f) {
465	mimic_decode_end(avctx);
466	return AVERROR(ENOMEM);
467	}
468	}
469
470	return 0;
471	}
472
473	AVCodec ff_mimic_decoder = {
474	.name = "mimic",
475	.long_name = NULL_IF_CONFIG_SMALL("Mimic"),
476	.type = AVMEDIA_TYPE_VIDEO,
477	.id = AV_CODEC_ID_MIMIC,
478	.priv_data_size = sizeof(MimicContext),
479	.init = mimic_decode_init,
480	.close = mimic_decode_end,
481	.decode = mimic_decode_frame,
482	.capabilities = CODEC_CAP_DR1 \| CODEC_CAP_FRAME_THREADS,
483	.update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context),
484	.init_thread_copy = ONLY_IF_THREADS_ENABLED(mimic_init_thread_copy),
485	};