eatgq.c

Go to the documentation of this file.

/*
 * Electronic Arts TGQ Video Decoder
 * Copyright (c) 2007-2008 Peter Ross <pross@xvid.org>
 *
 * 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 St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
/**
 * @file
 * Electronic Arts TGQ Video Decoder
 * @author Peter Ross <pross@xvid.org>
 *
 * Technical details here:
 * http://wiki.multimedia.cx/index.php?title=Electronic_Arts_TGQ
 */
 
#include "libavutil/attributes.h"
#define BITSTREAM_READER_LE
 
#include "libavutil/mem_internal.h"
 
#include "aandcttab.h"
#include "avcodec.h"
#include "bytestream.h"
#include "codec_internal.h"
#include "copy_block.h"
#include "decode.h"
#include "eaidct.h"
#include "get_bits.h"
 
typedef struct TgqContext {
    AVCodecContext *avctx;
    AVFrame *last_frame;
    int width, height;
    int qtable[64];
    DECLARE_ALIGNED(16, int16_t, block)[6][64];
} TgqContext;
 
static av_cold int tgq_decode_init(AVCodecContext *avctx)
{
    TgqContext *s = avctx->priv_data;
    s->avctx = avctx;
    avctx->framerate = (AVRational){ 15, 1 };
    avctx->pix_fmt   = AV_PIX_FMT_YUV420P;
    s->last_frame = av_frame_alloc();
    if (!s->last_frame)
        return AVERROR(ENOMEM);
    return 0;
}
 
static int tgq_decode_block(TgqContext *s, int16_t block[64], GetBitContext *gb)
{
    const uint8_t *scantable = ff_zigzag_direct;
    int i, j, value;
    block[0] = get_sbits(gb, 8) * s->qtable[0];
    for (i = 1; i < 64;) {
        switch (show_bits(gb, 3)) {
        case 4:
            if (i >= 63)
                return AVERROR_INVALIDDATA;
            block[scantable[i++]] = 0;
            av_fallthrough;
        case 0:
            block[scantable[i++]] = 0;
            skip_bits(gb, 3);
            break;
        case 5:
        case 1:
            skip_bits(gb, 2);
            value = get_bits(gb, 6);
            if (value > 64 - i)
                return AVERROR_INVALIDDATA;
            for (j = 0; j < value; j++)
                block[scantable[i++]] = 0;
            break;
        case 6:
            skip_bits(gb, 3);
            block[scantable[i]] = -s->qtable[scantable[i]];
            i++;
            break;
        case 2:
            skip_bits(gb, 3);
            block[scantable[i]] = s->qtable[scantable[i]];
            i++;
            break;
        case 7: // 111b
        case 3: // 011b
            skip_bits(gb, 2);
            if (show_bits(gb, 6) == 0x3F) {
                skip_bits(gb, 6);
                block[scantable[i]] = get_sbits(gb, 8) * s->qtable[scantable[i]];
            } else {
                block[scantable[i]] = get_sbits(gb, 6) * s->qtable[scantable[i]];
            }
            i++;
            break;
        }
    }
    block[0] += 128 << 4;
    return 0;
}
 
static void tgq_idct_put_mb(TgqContext *s, int16_t (*block)[64], AVFrame *frame,
                            int mb_x, int mb_y)
{
    ptrdiff_t linesize = frame->linesize[0];
    uint8_t *dest_y  = frame->data[0] + (mb_y * 16 * linesize)           + mb_x * 16;
    uint8_t *dest_cb = frame->data[1] + (mb_y * 8  * frame->linesize[1]) + mb_x * 8;
    uint8_t *dest_cr = frame->data[2] + (mb_y * 8  * frame->linesize[2]) + mb_x * 8;
 
    ff_ea_idct_put_c(dest_y                   , linesize, block[0]);
    ff_ea_idct_put_c(dest_y                + 8, linesize, block[1]);
    ff_ea_idct_put_c(dest_y + 8 * linesize    , linesize, block[2]);
    ff_ea_idct_put_c(dest_y + 8 * linesize + 8, linesize, block[3]);
    if (!(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
         ff_ea_idct_put_c(dest_cb, frame->linesize[1], block[4]);
         ff_ea_idct_put_c(dest_cr, frame->linesize[2], block[5]);
    }
}
 
static inline void tgq_dconly(TgqContext *s, unsigned char *dst,
                              ptrdiff_t dst_stride, int dc)
{
    int level = av_clip_uint8((dc*s->qtable[0] + 2056) >> 4);
    int j;
    for (j = 0; j < 8; j++)
        memset(dst + j * dst_stride, level, 8);
}
 
static void tgq_idct_put_mb_dconly(TgqContext *s, AVFrame *frame,
                                   int mb_x, int mb_y, const int8_t *dc)
{
    ptrdiff_t linesize = frame->linesize[0];
    uint8_t *dest_y  = frame->data[0] + (mb_y * 16 * linesize)             + mb_x * 16;
    uint8_t *dest_cb = frame->data[1] + (mb_y * 8  * frame->linesize[1]) + mb_x * 8;
    uint8_t *dest_cr = frame->data[2] + (mb_y * 8  * frame->linesize[2]) + mb_x * 8;
    tgq_dconly(s, dest_y,                    linesize, dc[0]);
    tgq_dconly(s, dest_y                + 8, linesize, dc[1]);
    tgq_dconly(s, dest_y + 8 * linesize,     linesize, dc[2]);
    tgq_dconly(s, dest_y + 8 * linesize + 8, linesize, dc[3]);
    if (!(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
        tgq_dconly(s, dest_cb, frame->linesize[1], dc[4]);
        tgq_dconly(s, dest_cr, frame->linesize[2], dc[5]);
    }
}
 
static int tgq_decode_mb(TgqContext *s, GetByteContext *gbyte,
                         AVFrame *frame, int mb_y, int mb_x)
{
    int mode;
    int i;
 
    mode = bytestream2_get_byte(gbyte);
    if (mode > 12) {
        GetBitContext gb;
        int ret = init_get_bits8(&gb, gbyte->buffer, FFMIN(bytestream2_get_bytes_left(gbyte), mode));
        if (ret < 0)
            return ret;
 
        for (i = 0; i < 6; i++) {
            ret = tgq_decode_block(s, s->block[i], &gb);
            if (ret < 0)
                return ret;
        }
        tgq_idct_put_mb(s, s->block, frame, mb_x, mb_y);
        bytestream2_skip(gbyte, mode);
    } else {
        int8_t dc[6];
        if (mode == 1) {
            int x, y;
            int mv = bytestream2_get_byte(gbyte);
            int mv_x = mv >> 4;
            int mv_y = mv & 0x0F;
            if (!s->last_frame->data[0]) {
                av_log(s->avctx, AV_LOG_ERROR, "missing reference frame\n");
                return -1;
            }
            if (mv_x >= 8) mv_x -= 16;
            if (mv_y >= 8) mv_y -= 16;
            x = mb_x * 16 - mv_x;
            y = mb_y * 16 - mv_y;
            if (x < 0 || x + 16 > s->width || y < 0 || y + 16 > s->height) {
                av_log(s->avctx, AV_LOG_ERROR, "invalid motion vector\n");
                return -1;
            }
            copy_block16(frame->data[0] + (mb_y * 16 * frame->linesize[0]) + mb_x * 16,
                         s->last_frame->data[0] + y * s->last_frame->linesize[0] + x,
                         frame->linesize[0], s->last_frame->linesize[0], 16);
            for (int p = 1; p < 3; p++)
                copy_block8(frame->data[p] + (mb_y * 8 * frame->linesize[p]) + mb_x * 8,
                            s->last_frame->data[p] + (y >> 1) * s->last_frame->linesize[p] + (x >> 1),
                            frame->linesize[p], s->last_frame->linesize[p], 8);
            frame->flags &= ~AV_FRAME_FLAG_KEY;
            return 0;
        } else if (mode == 3) {
            memset(dc, bytestream2_get_byte(gbyte), 4);
            dc[4] = bytestream2_get_byte(gbyte);
            dc[5] = bytestream2_get_byte(gbyte);
        } else if (mode == 6) {
            if (bytestream2_get_buffer(gbyte, dc, 6) != 6)
                return AVERROR_INVALIDDATA;
        } else if (mode == 12) {
            for (i = 0; i < 6; i++) {
                dc[i] = bytestream2_get_byte(gbyte);
                bytestream2_skip(gbyte, 1);
            }
        } else {
            av_log(s->avctx, AV_LOG_ERROR, "unsupported mb mode %i\n", mode);
            return -1;
        }
        tgq_idct_put_mb_dconly(s, frame, mb_x, mb_y, dc);
    }
    return 0;
}
 
static void tgq_calculate_qtable(TgqContext *s, int quant)
{
    int i, j;
    const int a = (14 * (100 - quant)) / 100 + 1;
    const int b = (11 * (100 - quant)) / 100 + 4;
    for (j = 0; j < 8; j++)
        for (i = 0; i < 8; i++)
            s->qtable[j * 8 + i] = ((a * (j + i) / (7 + 7) + b) *
                                    ff_inv_aanscales[j * 8 + i]) >> (14 - 4);
}
 
static int tgq_decode_frame(AVCodecContext *avctx, AVFrame *frame,
                            int *got_frame, AVPacket *avpkt)
{
    const uint8_t *buf = avpkt->data;
    int buf_size       = avpkt->size;
    TgqContext *s      = avctx->priv_data;
    GetByteContext gbyte;
    int x, y, ret;
    int big_endian;
 
    if (buf_size < 16) {
        av_log(avctx, AV_LOG_WARNING, "truncated header\n");
        return AVERROR_INVALIDDATA;
    }
    big_endian = AV_RL32(&buf[4]) > 0x000FFFFF;
    bytestream2_init(&gbyte, buf + 8, buf_size - 8);
    if (big_endian) {
        s->width  = bytestream2_get_be16u(&gbyte);
        s->height = bytestream2_get_be16u(&gbyte);
    } else {
        s->width  = bytestream2_get_le16u(&gbyte);
        s->height = bytestream2_get_le16u(&gbyte);
    }
 
    if (s->avctx->width != s->width || s->avctx->height != s->height) {
        av_frame_unref(s->last_frame);
        ret = ff_set_dimensions(s->avctx, s->width, s->height);
        if (ret < 0)
            return ret;
    }
 
    tgq_calculate_qtable(s, bytestream2_get_byteu(&gbyte));
    bytestream2_skipu(&gbyte, 3);
 
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
        return ret;
 
    frame->flags |= AV_FRAME_FLAG_KEY;
    for (y = 0; y < FFALIGN(avctx->height, 16) >> 4; y++)
        for (x = 0; x < FFALIGN(avctx->width, 16) >> 4; x++)
            if (tgq_decode_mb(s, &gbyte, frame, y, x) < 0)
                return AVERROR_INVALIDDATA;
 
    if ((ret = av_frame_replace(s->last_frame, frame)) < 0)
        return ret;
 
    *got_frame = 1;
 
    return avpkt->size;
}
 
static av_cold int tgq_decode_close(AVCodecContext *avctx)
{
    TgqContext *s = avctx->priv_data;
    av_frame_free(&s->last_frame);
    return 0;
}
 
const FFCodec ff_eatgq_decoder = {
    .p.name         = "eatgq",
    CODEC_LONG_NAME("Electronic Arts TGQ video"),
    .p.type         = AVMEDIA_TYPE_VIDEO,
    .p.id           = AV_CODEC_ID_TGQ,
    .priv_data_size = sizeof(TgqContext),
    .init           = tgq_decode_init,
    .close          = tgq_decode_close,
    FF_CODEC_DECODE_CB(tgq_decode_frame),
    .p.capabilities = AV_CODEC_CAP_DR1,
};