/*

 * Argonaut Games Video decoder

 * Copyright (c) 2020 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

 */

#include <string.h>

#include "libavutil/attributes.h"

#include "libavutil/internal.h"

#include "libavutil/intreadwrite.h"

#include "avcodec.h"

#include "bytestream.h"

#include "codec_internal.h"

#include "decode.h"

typedef struct ArgoContext {

    GetByteContext gb;

    int bpp;

    int key;

    int mv0[128][2];

    int mv1[16][2];

    uint32_t pal[256];

    AVFrame *frame;

} ArgoContext;

static int decode_pal8(AVCodecContext *avctx, uint32_t *pal)

{

    ArgoContext *s = avctx->priv_data;

    GetByteContext *gb = &s->gb;

    int start, count;

    start = bytestream2_get_le16(gb);

    count = bytestream2_get_le16(gb);

    if (start + count > 256)

        return AVERROR_INVALIDDATA;

    if (bytestream2_get_bytes_left(gb) < 3 * count)

        return AVERROR_INVALIDDATA;

    for (int i = 0; i < count; i++)

        pal[start + i] = (0xFFU << 24) | bytestream2_get_be24u(gb);

    return 0;

}

static int decode_avcf(AVCodecContext *avctx, AVFrame *frame)

{

    ArgoContext *s = avctx->priv_data;

    GetByteContext *gb = &s->gb;

    const int l = frame->linesize[0];

    const uint8_t *map = gb->buffer;

    uint8_t *dst = frame->data[0];

    if (bytestream2_get_bytes_left(gb) < 1024 + (frame->width / 2) * (frame->height / 2))

        return AVERROR_INVALIDDATA;

    bytestream2_skipu(gb, 1024);

    for (int y = 0; y < frame->height; y += 2) {

        for (int x = 0; x < frame->width; x += 2) {

            int index = bytestream2_get_byteu(gb);

            const uint8_t *block = map + index * 4;

            dst[x+0]   = block[0];

            dst[x+1]   = block[1];

            dst[x+l]   = block[2];

            dst[x+l+1] = block[3];

        }

        dst += frame->linesize[0] * 2;

    }

    return 0;

}

static int decode_alcd(AVCodecContext *avctx, AVFrame *frame)

{

    ArgoContext *s = avctx->priv_data;

    GetByteContext *gb = &s->gb;

    GetByteContext sb;

    const int l = frame->linesize[0];

    const uint8_t *map = gb->buffer;

    uint8_t *dst = frame->data[0];

    uint8_t codes = 0;

    int count = 0;

    if (bytestream2_get_bytes_left(gb) < 1024 + (((frame->width / 2) * (frame->height / 2) + 7) >> 3))

        return AVERROR_INVALIDDATA;

    bytestream2_skipu(gb, 1024);

    sb = *gb;

    bytestream2_skipu(gb, ((frame->width / 2) * (frame->height / 2) + 7) >> 3);

    for (int y = 0; y < frame->height; y += 2) {

        for (int x = 0; x < frame->width; x += 2) {

            const uint8_t *block;

            int index;

            if (count == 0) {

                codes = bytestream2_get_byteu(&sb);

                count = 8;

            }

            if (codes & 0x80) {

                index = bytestream2_get_byte(gb);

                block = map + index * 4;

                dst[x+0]   = block[0];

                dst[x+1]   = block[1];

                dst[x+l]   = block[2];

                dst[x+l+1] = block[3];

            }

            codes <<= 1;

            count--;

        }

        dst += frame->linesize[0] * 2;

    }

    return 0;

}

static int decode_mad1(AVCodecContext *avctx, AVFrame *frame)

{

    ArgoContext *s = avctx->priv_data;

    GetByteContext *gb = &s->gb;

    const int w = frame->width;

    const int h = frame->height;

    const int l = frame->linesize[0];

    while (bytestream2_get_bytes_left(gb) > 0) {

        int size, type, pos, dy;

        uint8_t *dst;

        type = bytestream2_get_byte(gb);

        if (type == 0xFF)

            break;

        switch (type) {

        case 8:

            dst = frame->data[0];

            for (int y = 0; y < h; y += 8) {

                for (int x = 0; x < w; x += 8) {

                    int fill = bytestream2_get_byte(gb);

                    uint8_t *ddst = dst + x;

                    for (int by = 0; by < 8; by++) {

                        memset(ddst, fill, 8);

                        ddst += l;

                    }

                }

                dst += 8 * l;

            }

            break;

        case 7:

            while (bytestream2_get_bytes_left(gb) > 0) {

                int bsize = bytestream2_get_byte(gb);

                uint8_t *src;

                int count;

                if (!bsize)

                    break;

                count = bytestream2_get_be16(gb);

                while (count > 0) {

                    int mvx, mvy, a, b, c, mx, my;

                    int bsize_w, bsize_h;

                    bsize_w = bsize_h = bsize;

                    if (bytestream2_get_bytes_left(gb) < 4)

                        return AVERROR_INVALIDDATA;

                    mvx = bytestream2_get_byte(gb) * bsize;

                    mvy = bytestream2_get_byte(gb) * bsize;

                    a = bytestream2_get_byte(gb);

                    b = bytestream2_get_byte(gb);

                    c = ((a & 0x3F) << 8) + b;

                    mx = mvx + (c  & 0x7F) - 64;

                    my = mvy + (c >>    7) - 64;

                    if (mvy < 0 || mvy >= h)

                        return AVERROR_INVALIDDATA;

                    if (mvx < 0 || mvx >= w)

                        return AVERROR_INVALIDDATA;

                    if (my < 0 || my >= h)

                        return AVERROR_INVALIDDATA;

                    if (mx < 0 || mx >= w)

                        return AVERROR_INVALIDDATA;

                    dst = frame->data[0] + mvx + l * mvy;

                    src = frame->data[0] + mx  + l * my;

                    bsize_w = FFMIN3(bsize_w, w - mvx, w - mx);

                    bsize_h = FFMIN3(bsize_h, h - mvy, h - my);

                    if (mvy >= my && (mvy != my || mvx >= mx)) {

                        src += (bsize_h - 1) * l;

                        dst += (bsize_h - 1) * l;

                        for (int by = 0; by < bsize_h; by++) {

                            memmove(dst, src, bsize_w);

                            src -= l;

                            dst -= l;

                        }

                    } else {

                        for (int by = 0; by < bsize_h; by++) {

                            memmove(dst, src, bsize_w);

                            src += l;

                            dst += l;

                        }

                    }

                    count--;

                }

            }

            break;

        case 6:

            dst = frame->data[0];

            if (bytestream2_get_bytes_left(gb) < w * h)

                return AVERROR_INVALIDDATA;

            for (int y = 0; y < h; y++) {

                bytestream2_get_bufferu(gb, dst, w);

                dst += l;

            }

            break;

        case 5:

            dst = frame->data[0];

            for (int y = 0; y < h; y += 2) {

                for (int x = 0; x < w; x += 2) {

                    int fill = bytestream2_get_byte(gb);

                    uint8_t *ddst = dst + x;

                    fill = (fill << 8) | fill;

                    for (int by = 0; by < 2; by++) {

                            AV_WN16(ddst, fill);

                        ddst += l;

                    }

                }

                dst += 2 * l;

            }

            break;

        case 3:

            size = bytestream2_get_le16(gb);

            if (size > 0) {

                int x = bytestream2_get_byte(gb) * 4;

                int y = bytestream2_get_byte(gb) * 4;

                int count = bytestream2_get_byte(gb);

                int fill = bytestream2_get_byte(gb);

                av_log(avctx, AV_LOG_DEBUG, "%d %d %d %d\n", x, y, count, fill);

                for (int i = 0; i < count; i++)

                    ;

                return AVERROR_PATCHWELCOME;

            }

            break;

        case 2:

            dst = frame->data[0];

            pos = 0;

            dy  = 0;

            while (bytestream2_get_bytes_left(gb) > 0) {

                int count = bytestream2_get_byteu(gb);

                int skip = count & 0x3F;

                count = count >> 6;

                if (skip == 0x3F) {

                    pos += 0x3E;

                    while (pos >= w) {

                        pos -= w;

                        dst += l;

                        dy++;

                        if (dy >= h)

                            return 0;

                    }

                } else {

                    pos += skip;

                    while (pos >= w) {

                        pos -= w;

                        dst += l;

                        dy++;

                        if (dy >= h)

                            return 0;

                    }

                    while (count >= 0) {

                        int bits = bytestream2_get_byte(gb);

                        for (int i = 0; i < 4; i++) {

                            switch (bits & 3) {

                            case 0:

                                break;

                            case 1:

                                if (dy < 1 && !pos)

                                    return AVERROR_INVALIDDATA;

                                else

                                    dst[pos] = pos ? dst[pos - 1] : dst[-l + w - 1];

                                break;

                            case 2:

                                if (dy < 1)

                                    return AVERROR_INVALIDDATA;

                                dst[pos] = dst[pos - l];

                                break;

                            case 3:

                                dst[pos] = bytestream2_get_byte(gb);

                                break;

                            }

                            pos++;

                            if (pos >= w) {

                                pos -= w;

                                dst += l;

                                dy++;

                                if (dy >= h)

                                    return 0;

                            }

                            bits >>= 2;

                        }

                        count--;

                    }

                }

            }

            break;

        default:

            return AVERROR_INVALIDDATA;

        }

    }

    return 0;

}

static int decode_mad1_24(AVCodecContext *avctx, AVFrame *frame)

{

    ArgoContext *s = avctx->priv_data;

    GetByteContext *gb = &s->gb;

    const int w = frame->width;

    const int h = frame->height;

    const int l = frame->linesize[0] / 4;

    while (bytestream2_get_bytes_left(gb) > 0) {

        int osize, type, pos, dy, di, bcode, value, v14;

        const uint8_t *bits;

        uint32_t *dst;

        type = bytestream2_get_byte(gb);

        if (type == 0xFF)

            return 0;

        switch (type) {

        case 8:

            dst = (uint32_t *)frame->data[0];

            for (int y = 0; y + 12 <= h; y += 12) {

                for (int x = 0; x + 12 <= w; x += 12) {

                    int fill = bytestream2_get_be24(gb);

                    uint32_t *dstp = dst + x;

                    for (int by = 0; by < 12; by++) {

                        for (int bx = 0; bx < 12; bx++)

                            dstp[bx] = fill;

                        dstp += l;

                    }

                }

                dst += 12 * l;

            }

            break;

        case 7:

            while (bytestream2_get_bytes_left(gb) > 0) {

                int bsize = bytestream2_get_byte(gb);

                uint32_t *src;

                int count;

                if (!bsize)

                    break;

                count = bytestream2_get_be16(gb);

                while (count > 0) {

                    int mvx, mvy, a, b, c, mx, my;

                    int bsize_w, bsize_h;

                    bsize_w = bsize_h = bsize;

                    if (bytestream2_get_bytes_left(gb) < 4)

                        return AVERROR_INVALIDDATA;

                    mvx = bytestream2_get_byte(gb) * bsize;

                    mvy = bytestream2_get_byte(gb) * bsize;

                    a = bytestream2_get_byte(gb);

                    b = bytestream2_get_byte(gb);

                    c = ((a & 0x3F) << 8) + b;

                    mx = mvx + (c  & 0x7F) - 64;

                    my = mvy + (c >>    7) - 64;

                    if (mvy < 0 || mvy >= h)

                        return AVERROR_INVALIDDATA;

                    if (mvx < 0 || mvx >= w)

                        return AVERROR_INVALIDDATA;

                    if (my < 0 || my >= h)

                        return AVERROR_INVALIDDATA;

                    if (mx < 0 || mx >= w)

                        return AVERROR_INVALIDDATA;

                    dst = (uint32_t *)frame->data[0] + mvx + l * mvy;

                    src = (uint32_t *)frame->data[0] + mx  + l * my;

                    bsize_w = FFMIN3(bsize_w, w - mvx, w - mx);

                    bsize_h = FFMIN3(bsize_h, h - mvy, h - my);

                    if (mvy >= my && (mvy != my || mvx >= mx)) {

                        src += (bsize_h - 1) * l;

                        dst += (bsize_h - 1) * l;

                        for (int by = 0; by < bsize_h; by++) {

                            memmove(dst, src, bsize_w * 4);

                            src -= l;

                            dst -= l;

                        }

                    } else {

                        for (int by = 0; by < bsize_h; by++) {

                            memmove(dst, src, bsize_w * 4);

                            src += l;

                            dst += l;

                        }

                    }

                    count--;

                }

            }

            break;

        case 12:

            osize = ((h + 3) / 4) * ((w + 3) / 4) + 7;

            bits = gb->buffer;

            di   = 0;

            bcode = v14 = 0;

            if (bytestream2_get_bytes_left(gb) < osize >> 3)

                return AVERROR_INVALIDDATA;

            bytestream2_skip(gb, osize >> 3);

            for (int x = 0; x < w; x += 4) {

                for (int y = 0; y < h; y += 4) {

                    int astate = 0;

                    if (bits[di >> 3] & (1 << (di & 7))) {

                        int codes = bytestream2_get_byte(gb);

                        for (int count = 0; count < 4; count++) {

                            uint32_t *src = (uint32_t *)frame->data[0];

                            size_t src_size = l * (h - 1) + (w - 1);

                            int nv, v, code = codes & 3;

                            pos = x;

                            dy  = y + count;

                            dst = (uint32_t *)frame->data[0] + pos + dy * l;

                            if (code & 1)

                                bcode = bytestream2_get_byte(gb);

                            if (code == 3) {

                                for (int j = 0; j < 4; j++) {

                                    switch (bcode & 3) {

                                    case 0:

                                        break;

                                    case 1:

                                        if (dy < 1 && !pos)

                                            return AVERROR_INVALIDDATA;

                                        dst[0] = dst[-1];

                                        break;

                                    case 2:

                                        if (dy < 1)

                                            return AVERROR_INVALIDDATA;

                                        dst[0] = dst[-l];

                                        break;

                                    case 3:

                                        if (astate) {

                                            nv = value >> 4;

                                        } else {

                                            value = bytestream2_get_byte(gb);

                                            nv = value & 0xF;

                                        }

                                        astate ^= 1;

                                        dst[0] = src[av_clip(l * (dy + s->mv1[nv][1]) + pos +

                                                             s->mv1[nv][0], 0, src_size)];

                                        break;

                                    }

                                    bcode >>= 2;

                                    dst++;

                                    pos++;

                                }

                            } else if (code) {

                                if (code == 1)

                                    v14 = bcode;

                                else

                                    bcode = v14;

                                for (int j = 0; j < 4; j++) {

                                    switch (bcode & 3) {

                                    case 0:

                                        break;

                                    case 1:

                                        if (dy < 1 && !pos)

                                            return AVERROR_INVALIDDATA;

                                        dst[0] = dst[-1];

                                        break;

                                    case 2:

                                        if (dy < 1)

                                            return AVERROR_INVALIDDATA;

                                        dst[0] = dst[-l];

                                        break;

                                    case 3:

                                        v = bytestream2_get_byte(gb);

                                        if (v < 128) {

                                            dst[0] = src[av_clip(l * (dy + s->mv0[v][1]) + pos +

                                                                 s->mv0[v][0], 0, src_size)];

                                        } else {

                                            dst[0] = ((v & 0x7F) << 17) | bytestream2_get_be16(gb);

                                        }

                                        break;

                                    }

                                    bcode >>= 2;

                                    dst++;

                                    pos++;

                                }

                            }

                            codes >>= 2;

                        }

                    }

                    di++;

                }

            }

            break;

        default:

            return AVERROR_INVALIDDATA;

        }

    }

    return AVERROR_INVALIDDATA;

}

static int decode_rle(AVCodecContext *avctx, AVFrame *frame)

{

    ArgoContext *s = avctx->priv_data;

    GetByteContext *gb = &s->gb;

    const int w = frame->width;

    const int h = frame->height;

    const int l = frame->linesize[0];

    uint8_t *dst = frame->data[0];

    int pos = 0, y = 0;

    while (bytestream2_get_bytes_left(gb) > 0) {

        int count = bytestream2_get_byte(gb);

        int pixel = bytestream2_get_byte(gb);

        if (!count) {

            pos += pixel;

            while (pos >= w) {

                pos -= w;

                y++;

                if (y >= h)

                    return 0;

            }

        } else {

            while (count > 0) {

                dst[pos + y * l] = pixel;

                count--;

                pos++;

                if (pos >= w) {

                    pos = 0;

                    y++;

                    if (y >= h)

                        return 0;

                }

            }

        }

    }

    return 0;

}

static int decode_frame(AVCodecContext *avctx, AVFrame *rframe,

                        int *got_frame, AVPacket *avpkt)

{

    ArgoContext *s = avctx->priv_data;

    GetByteContext *gb = &s->gb;

    AVFrame *frame = s->frame;

    uint32_t chunk;

    int ret;

    if (avpkt->size < 4)

        return AVERROR_INVALIDDATA;

    bytestream2_init(gb, avpkt->data, avpkt->size);

    if ((ret = ff_reget_buffer(avctx, frame, 0)) < 0)

        return ret;

    chunk = bytestream2_get_be32(gb);

    switch (chunk) {

    case MKBETAG('P', 'A', 'L', '8'):

        for (int y = 0; y < frame->height; y++)

            memset(frame->data[0] + y * frame->linesize[0], 0, frame->width * s->bpp);

        if (avctx->pix_fmt == AV_PIX_FMT_PAL8)

            memset(frame->data[1], 0, AVPALETTE_SIZE);

        return decode_pal8(avctx, s->pal);

    case MKBETAG('M', 'A', 'D', '1'):

        if (avctx->pix_fmt == AV_PIX_FMT_PAL8)

            ret = decode_mad1(avctx, frame);

        else

            ret = decode_mad1_24(avctx, frame);

        break;

    case MKBETAG('A', 'V', 'C', 'F'):

        if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {

            s->key = 1;

            ret = decode_avcf(avctx, frame);

            break;

        }

    case MKBETAG('A', 'L', 'C', 'D'):

        if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {

            s->key = 0;

            ret = decode_alcd(avctx, frame);

            break;

        }

    case MKBETAG('R', 'L', 'E', 'F'):

        if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {

            s->key = 1;

            ret = decode_rle(avctx, frame);

            break;

        }

    case MKBETAG('R', 'L', 'E', 'D'):

        if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {

            s->key = 0;

            ret = decode_rle(avctx, frame);

            break;

        }

    default:

        av_log(avctx, AV_LOG_DEBUG, "unknown chunk 0x%X\n", chunk);

        break;

    }

    if (ret < 0)

        return ret;

    if (avctx->pix_fmt == AV_PIX_FMT_PAL8)

        memcpy(frame->data[1], s->pal, AVPALETTE_SIZE);

    if ((ret = av_frame_ref(rframe, s->frame)) < 0)

        return ret;

    frame->pict_type = s->key ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;

    if (s->key)

        frame->flags |= AV_FRAME_FLAG_KEY;

    else

        frame->flags &= ~AV_FRAME_FLAG_KEY;

    *got_frame = 1;

    return avpkt->size;

}

static av_cold int decode_init(AVCodecContext *avctx)

{

    ArgoContext *s = avctx->priv_data;

    switch (avctx->bits_per_coded_sample) {

    case  8: s->bpp = 1;

             avctx->pix_fmt = AV_PIX_FMT_PAL8; break;

    case 24: s->bpp = 4;

             avctx->pix_fmt = AV_PIX_FMT_BGR0; break;

    default: avpriv_request_sample(s, "depth == %u", avctx->bits_per_coded_sample);

             return AVERROR_PATCHWELCOME;

    }

    if (avctx->width % 2 || avctx->height % 2) {

        avpriv_request_sample(s, "Odd dimensions\n");

        return AVERROR_PATCHWELCOME;

    }

    s->frame = av_frame_alloc();

    if (!s->frame)

        return AVERROR(ENOMEM);

    for (int n = 0, i = -4; i < 4; i++) {

        for (int j = -14; j < 2; j++) {

            s->mv0[n][0] = j;

            s->mv0[n++][1] = i;

        }

    }

    for (int n = 0, i = -5; i <= 1; i += 2) {

        int j = -5;

        while (j <= 1) {

            s->mv1[n][0] = j;

            s->mv1[n++][1] = i;

            j += 2;

        }

    }

    return 0;

}

static av_cold void decode_flush(AVCodecContext *avctx)

{

    ArgoContext *s = avctx->priv_data;

    av_frame_unref(s->frame);

}

static av_cold int decode_close(AVCodecContext *avctx)

{

    ArgoContext *s = avctx->priv_data;

    av_frame_free(&s->frame);

    return 0;

}

const FFCodec ff_argo_decoder = {

    .p.name         = "argo",

    CODEC_LONG_NAME("Argonaut Games Video"),

    .p.type         = AVMEDIA_TYPE_VIDEO,

    .p.id           = AV_CODEC_ID_ARGO,

    .priv_data_size = sizeof(ArgoContext),

    .init           = decode_init,

    FF_CODEC_DECODE_CB(decode_frame),

    .flush          = decode_flush,

    .close          = decode_close,

    .p.capabilities = AV_CODEC_CAP_DR1,

    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,

};