mvha.c

Go to the documentation of this file.

/*
 * MidiVid Archive codec
 *
 * Copyright (c) 2019 Paul B Mahol
 *
 * 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
 */
 
#define CACHED_BITSTREAM_READER !ARCH_X86_32
#include "libavutil/intreadwrite.h"
 
#include "avcodec.h"
#include "codec_internal.h"
#include "decode.h"
#include "get_bits.h"
#include "lossless_videodsp.h"
#include "zlib_wrapper.h"
 
#include <zlib.h>
 
typedef struct MVHAContext {
    GetBitContext     gb;
    int nb_symbols;
 
    uint8_t           symb[256];
    uint32_t          prob[256];
    VLC               vlc;
 
    FFZStream         zstream;
    LLVidDSPContext   llviddsp;
} MVHAContext;
 
typedef struct Node {
    int16_t  sym;
    int16_t  n0;
    int16_t  l, r;
    uint32_t count;
} Node;
 
static void get_tree_codes(uint32_t *bits, int16_t *lens, uint8_t *xlat,
                           Node *nodes, int node,
                           uint32_t pfx, int pl, int *pos)
{
    int s;
 
    s = nodes[node].sym;
    if (s != -1) {
        bits[*pos] = (~pfx) & ((1ULL << FFMAX(pl, 1)) - 1);
        lens[*pos] = FFMAX(pl, 1);
        xlat[*pos] = s + (pl == 0);
        (*pos)++;
    } else {
        pfx <<= 1;
        pl++;
        get_tree_codes(bits, lens, xlat, nodes, nodes[node].l, pfx, pl,
                       pos);
        pfx |= 1;
        get_tree_codes(bits, lens, xlat, nodes, nodes[node].r, pfx, pl,
                       pos);
    }
}
 
static int build_vlc(AVCodecContext *avctx, VLC *vlc)
{
    MVHAContext *s = avctx->priv_data;
    Node nodes[512];
    uint32_t bits[256];
    int16_t lens[256];
    uint8_t xlat[256];
    int cur_node, i, j, pos = 0;
 
    ff_vlc_free(vlc);
 
    for (i = 0; i < s->nb_symbols; i++) {
        nodes[i].count = s->prob[i];
        nodes[i].sym   = s->symb[i];
        nodes[i].n0    = -2;
        nodes[i].l     = i;
        nodes[i].r     = i;
    }
 
    cur_node = s->nb_symbols;
    j = 0;
    do {
        for (i = 0; ; i++) {
            int new_node = j;
            int first_node = cur_node;
            int second_node = cur_node;
            unsigned nd, st;
 
            nodes[cur_node].count = -1;
 
            do {
                int val = nodes[new_node].count;
                if (val && (val < nodes[first_node].count)) {
                    if (val >= nodes[second_node].count) {
                        first_node = new_node;
                    } else {
                        first_node = second_node;
                        second_node = new_node;
                    }
                }
                new_node += 1;
            } while (new_node != cur_node);
 
            if (first_node == cur_node)
                break;
 
            nd = nodes[second_node].count;
            st = nodes[first_node].count;
            nodes[second_node].count = 0;
            nodes[first_node].count  = 0;
            if (nd >= UINT32_MAX - st) {
                av_log(avctx, AV_LOG_ERROR, "count overflow\n");
                return AVERROR_INVALIDDATA;
            }
            nodes[cur_node].count = nd + st;
            nodes[cur_node].sym = -1;
            nodes[cur_node].n0 = cur_node;
            nodes[cur_node].l = first_node;
            nodes[cur_node].r = second_node;
            cur_node++;
        }
        j++;
    } while (cur_node - s->nb_symbols == j);
 
    get_tree_codes(bits, lens, xlat, nodes, cur_node - 1, 0, 0, &pos);
 
    return ff_vlc_init_sparse(vlc, 12, pos, lens, 2, 2, bits, 4, 4, xlat, 1, 1, 0);
}
 
static int decode_frame(AVCodecContext *avctx, AVFrame *frame,
                        int *got_frame, AVPacket *avpkt)
{
    MVHAContext *s = avctx->priv_data;
    uint32_t type, size;
    int ret;
 
    if (avpkt->size <= 8)
        return AVERROR_INVALIDDATA;
 
    type = AV_RB32(avpkt->data);
    size = AV_RL32(avpkt->data + 4);
 
    if (size < 1 || size >= avpkt->size)
        return AVERROR_INVALIDDATA;
 
    if (type == MKTAG('L','Z','Y','V')) {
        z_stream *const zstream = &s->zstream.zstream;
        ret = inflateReset(zstream);
        if (ret != Z_OK) {
            av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);
            return AVERROR_EXTERNAL;
        }
 
        if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
            return ret;
 
        zstream->next_in  = avpkt->data + 8;
        zstream->avail_in = avpkt->size - 8;
 
        for (int p = 0; p < 3; p++) {
            for (int y = 0; y < avctx->height; y++) {
                zstream->next_out  = frame->data[p] + (avctx->height - y - 1) * frame->linesize[p];
                zstream->avail_out = avctx->width >> (p > 0);
 
                ret = inflate(zstream, Z_SYNC_FLUSH);
                if (ret != Z_OK && ret != Z_STREAM_END) {
                    av_log(avctx, AV_LOG_ERROR, "Inflate error: %d\n", ret);
                    return AVERROR_EXTERNAL;
                }
                if (zstream->avail_out > 0)
                    memset(zstream->next_out, 0, zstream->avail_out);
            }
        }
    } else if (type == MKTAG('H','U','F','Y')) {
        GetBitContext *gb = &s->gb;
        int first_symbol, symbol;
 
        ret = init_get_bits8(gb, avpkt->data + 8, avpkt->size - 8);
        if (ret < 0)
            return ret;
 
        skip_bits(gb, 24);
 
        first_symbol = get_bits(gb, 8);
        s->nb_symbols = get_bits(gb, 8) + 1;
 
        symbol = first_symbol;
        for (int i = 0; i < s->nb_symbols; symbol++) {
            int prob;
 
            if (get_bits_left(gb) < 4)
                return AVERROR_INVALIDDATA;
 
            if (get_bits1(gb)) {
                prob = get_bits(gb, 12);
            } else {
                prob = get_bits(gb, 3);
            }
 
            if (prob) {
                s->symb[i] = symbol;
                s->prob[i] = prob;
                i++;
            }
        }
 
        if (get_bits_left(gb) < avctx->height * avctx->width)
            return AVERROR_INVALIDDATA;
 
        ret = build_vlc(avctx, &s->vlc);
        if (ret < 0)
            return ret;
 
        if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
            return ret;
 
        for (int p = 0; p < 3; p++) {
            int width = avctx->width >> (p > 0);
            ptrdiff_t stride = frame->linesize[p];
            uint8_t *dst;
 
            dst = frame->data[p] + (avctx->height - 1) * frame->linesize[p];
            for (int y = 0; y < avctx->height; y++) {
                if (get_bits_left(gb) < width)
                    return AVERROR_INVALIDDATA;
                for (int x = 0; x < width; x++) {
                    int v = get_vlc2(gb, s->vlc.table, s->vlc.bits, 3);
 
                    if (v < 0)
                        return AVERROR_INVALIDDATA;
 
                    dst[x] = v;
                }
                dst -= stride;
            }
        }
    } else {
        return AVERROR_INVALIDDATA;
    }
 
    for (int p = 0; p < 3; p++) {
        int left, lefttop;
        int width = avctx->width >> (p > 0);
        ptrdiff_t stride = frame->linesize[p];
        uint8_t *dst;
 
        dst = frame->data[p] + (avctx->height - 1) * frame->linesize[p];
        s->llviddsp.add_left_pred(dst, dst, width, 0);
        if (avctx->height > 1) {
            dst -= stride;
            lefttop = left = dst[0];
            for (int y = 1; y < avctx->height; y++) {
                s->llviddsp.add_median_pred(dst, dst + stride, dst, width, &left, &lefttop);
                lefttop = left = dst[0];
                dst -= stride;
            }
        }
    }
 
    *got_frame = 1;
 
    return avpkt->size;
}
 
static av_cold int decode_init(AVCodecContext *avctx)
{
    MVHAContext *s = avctx->priv_data;
 
    avctx->pix_fmt = AV_PIX_FMT_YUV422P;
 
    ff_llviddsp_init(&s->llviddsp);
 
    return ff_inflate_init(&s->zstream, avctx);
}
 
static av_cold int decode_close(AVCodecContext *avctx)
{
    MVHAContext *s = avctx->priv_data;
 
    ff_inflate_end(&s->zstream);
    ff_vlc_free(&s->vlc);
 
    return 0;
}
 
const FFCodec ff_mvha_decoder = {
    .p.name           = "mvha",
    CODEC_LONG_NAME("MidiVid Archive Codec"),
    .p.type           = AVMEDIA_TYPE_VIDEO,
    .p.id             = AV_CODEC_ID_MVHA,
    .priv_data_size   = sizeof(MVHAContext),
    .init             = decode_init,
    .close            = decode_close,
    FF_CODEC_DECODE_CB(decode_frame),
    .p.capabilities   = AV_CODEC_CAP_DR1,
    .caps_internal    = FF_CODEC_CAP_INIT_CLEANUP,
};