/*
 * 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 "libavutil/crc.h"
#include "libavutil/mem.h"
#include "libavutil/pixdesc.h"
#include "rangecoder.h"
#include "ffv1.h"

static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale)
{
    int v;
    int i = 0;
    uint8_t state[CONTEXT_SIZE];

    memset(state, 128, sizeof(state));

    for (v = 0; i < 128; v++) {
        unsigned len = ff_ffv1_get_symbol(c, state, 0) + 1U;

        if (len > 128 - i || !len)
            return AVERROR_INVALIDDATA;

        while (len--) {
            quant_table[i] = scale * v;
            i++;
        }
    }

    for (i = 1; i < 128; i++)
        quant_table[256 - i] = -quant_table[i];
    quant_table[128] = -quant_table[127];

    return 2 * v - 1;
}

int ff_ffv1_read_quant_tables(RangeCoder *c,
                              int16_t quant_table[MAX_CONTEXT_INPUTS][256])
{
    int i;
    int context_count = 1;

    for (i = 0; i < 5; i++) {
        int ret = read_quant_table(c, quant_table[i], context_count);
        if (ret < 0)
            return ret;
        context_count *= ret;
        if (context_count > 32768U) {
            return AVERROR_INVALIDDATA;
        }
    }
    return (context_count + 1) / 2;
}

int ff_ffv1_read_extra_header(FFV1Context *f)
{
    RangeCoder c;
    uint8_t state[CONTEXT_SIZE];
    int ret;
    uint8_t state2[32][CONTEXT_SIZE];
    unsigned crc = 0;

    memset(state2, 128, sizeof(state2));
    memset(state, 128, sizeof(state));

    ff_init_range_decoder(&c, f->avctx->extradata, f->avctx->extradata_size);
    ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);

    f->version = ff_ffv1_get_symbol(&c, state, 0);
    if (f->version < 2) {
        av_log(f->avctx, AV_LOG_ERROR, "Invalid version in global header\n");
        return AVERROR_INVALIDDATA;
    }
    if (f->version > 4) {
        av_log(f->avctx, AV_LOG_ERROR, "unsupported version %d\n",
            f->version);
        return AVERROR_PATCHWELCOME;
    }
    f->combined_version = f->version << 16;
    if (f->version > 2) {
        c.bytestream_end -= 4;
        f->micro_version = ff_ffv1_get_symbol(&c, state, 0);
        if (f->micro_version < 0 || f->micro_version > 65535)
            return AVERROR_INVALIDDATA;
        f->combined_version += f->micro_version;
    }
    f->ac = ff_ffv1_get_symbol(&c, state, 0);

    if (f->ac == AC_RANGE_CUSTOM_TAB) {
        for (int i = 1; i < 256; i++)
            f->state_transition[i] = ff_ffv1_get_symbol(&c, state, 1) + c.one_state[i];
    } else {
        RangeCoder rc;
        ff_build_rac_states(&rc, 0.05 * (1LL << 32), 256 - 8);
        for (int i = 1; i < 256; i++)
            f->state_transition[i] = rc.one_state[i];
    }

    f->colorspace                 = ff_ffv1_get_symbol(&c, state, 0); //YUV cs type
    f->avctx->bits_per_raw_sample = ff_ffv1_get_symbol(&c, state, 0);
    f->chroma_planes              = get_rac(&c, state);
    f->chroma_h_shift             = ff_ffv1_get_symbol(&c, state, 0);
    f->chroma_v_shift             = ff_ffv1_get_symbol(&c, state, 0);
    f->transparency               = get_rac(&c, state);
    f->plane_count                = 1 + (f->chroma_planes || f->version<4) + f->transparency;
    f->num_h_slices               = 1 + ff_ffv1_get_symbol(&c, state, 0);
    f->num_v_slices               = 1 + ff_ffv1_get_symbol(&c, state, 0);

    if (f->chroma_h_shift > 4U || f->chroma_v_shift > 4U) {
        av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n",
               f->chroma_h_shift, f->chroma_v_shift);
        return AVERROR_INVALIDDATA;
    }

    if (f->num_h_slices > (unsigned)f->width  || !f->num_h_slices ||
        f->num_v_slices > (unsigned)f->height || !f->num_v_slices
       ) {
        av_log(f->avctx, AV_LOG_ERROR, "slice count invalid\n");
        return AVERROR_INVALIDDATA;
    }

    if (f->num_h_slices > MAX_SLICES / f->num_v_slices) {
        av_log(f->avctx, AV_LOG_ERROR, "slice count unsupported\n");
        return AVERROR_PATCHWELCOME;
    }

    f->quant_table_count = ff_ffv1_get_symbol(&c, state, 0);
    if (f->quant_table_count > (unsigned)MAX_QUANT_TABLES || !f->quant_table_count) {
        av_log(f->avctx, AV_LOG_ERROR, "quant table count %d is invalid\n", f->quant_table_count);
        f->quant_table_count = 0;
        return AVERROR_INVALIDDATA;
    }

    for (int i = 0; i < f->quant_table_count; i++) {
        f->context_count[i] = ff_ffv1_read_quant_tables(&c, f->quant_tables[i]);
        if (f->context_count[i] < 0) {
            av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
            return AVERROR_INVALIDDATA;
        }
    }
    if ((ret = ff_ffv1_allocate_initial_states(f)) < 0)
        return ret;

    for (int i = 0; i < f->quant_table_count; i++)
        if (get_rac(&c, state)) {
            for (int j = 0; j < f->context_count[i]; j++)
                for (int k = 0; k < CONTEXT_SIZE; k++) {
                    int pred = j ? f->initial_states[i][j - 1][k] : 128;
                    f->initial_states[i][j][k] =
                        (pred + ff_ffv1_get_symbol(&c, state2[k], 1)) & 0xFF;
                }
        }

    if (f->version > 2) {
        f->ec = ff_ffv1_get_symbol(&c, state, 0);
        if (f->ec >= 2)
            f->crcref = 0x7a8c4079;
        if (f->combined_version >= 0x30003)
            f->intra = ff_ffv1_get_symbol(&c, state, 0);
        if (f->combined_version >= 0x40004)
            f->flt = ff_ffv1_get_symbol(&c, state, 0);
    }

    if (f->version > 2) {
        unsigned v;
        v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), f->crcref,
                   f->avctx->extradata, f->avctx->extradata_size);
        if (v != f->crcref || f->avctx->extradata_size < 4) {
            av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", v);
            return AVERROR_INVALIDDATA;
        }
        crc = AV_RB32(f->avctx->extradata + f->avctx->extradata_size - 4);
    }

    if (f->avctx->debug & FF_DEBUG_PICT_INFO)
        av_log(f->avctx, AV_LOG_DEBUG,
               "global: ver:%d.%d, coder:%d, colorspace: %d bpr:%d chroma:%d(%d:%d), alpha:%d slices:%dx%d qtabs:%d ec:%d intra:%d CRC:0x%08X\n",
               f->version, f->micro_version,
               f->ac,
               f->colorspace,
               f->avctx->bits_per_raw_sample,
               f->chroma_planes, f->chroma_h_shift, f->chroma_v_shift,
               f->transparency,
               f->num_h_slices, f->num_v_slices,
               f->quant_table_count,
               f->ec,
               f->intra,
               crc
              );
    return 0;
}

int ff_ffv1_parse_header(FFV1Context *f, RangeCoder *c, uint8_t *state)
{
    if (f->version < 2) {
        int chroma_planes, chroma_h_shift, chroma_v_shift, transparency, colorspace, bits_per_raw_sample;
        unsigned v= ff_ffv1_get_symbol(c, state, 0);
        if (v >= 2) {
            av_log(f->avctx, AV_LOG_ERROR, "invalid version %d in ver01 header\n", v);
            return AVERROR_INVALIDDATA;
        }
        f->version = v;
        f->ac = ff_ffv1_get_symbol(c, state, 0);

        if (f->ac == AC_RANGE_CUSTOM_TAB) {
            for (int i = 1; i < 256; i++) {
                int st = ff_ffv1_get_symbol(c, state, 1) + c->one_state[i];
                if (st < 1 || st > 255) {
                    av_log(f->avctx, AV_LOG_ERROR, "invalid state transition %d\n", st);
                    return AVERROR_INVALIDDATA;
                }
                f->state_transition[i] = st;
            }
        } else {
            RangeCoder rc;
            ff_build_rac_states(&rc, 0.05 * (1LL << 32), 256 - 8);
            for (int i = 1; i < 256; i++)
                f->state_transition[i] = rc.one_state[i];
        }

        colorspace          = ff_ffv1_get_symbol(c, state, 0); //YUV cs type
        bits_per_raw_sample = f->version > 0 ? ff_ffv1_get_symbol(c, state, 0) : f->avctx->bits_per_raw_sample;
        chroma_planes       = get_rac(c, state);
        chroma_h_shift      = ff_ffv1_get_symbol(c, state, 0);
        chroma_v_shift      = ff_ffv1_get_symbol(c, state, 0);
        transparency        = get_rac(c, state);
        if (colorspace == 0 && f->avctx->skip_alpha)
            transparency = 0;

        if (f->plane_count) {
            if (colorspace          != f->colorspace                 ||
                bits_per_raw_sample != f->avctx->bits_per_raw_sample ||
                chroma_planes       != f->chroma_planes              ||
                chroma_h_shift      != f->chroma_h_shift             ||
                chroma_v_shift      != f->chroma_v_shift             ||
                transparency        != f->transparency) {
                av_log(f->avctx, AV_LOG_ERROR, "Invalid change of global parameters\n");
                return AVERROR_INVALIDDATA;
            }
        }

        if (chroma_h_shift > 4U || chroma_v_shift > 4U) {
            av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n",
                   chroma_h_shift, chroma_v_shift);
            return AVERROR_INVALIDDATA;
        }

        f->colorspace                 = colorspace;
        f->avctx->bits_per_raw_sample = bits_per_raw_sample;
        f->chroma_planes              = chroma_planes;
        f->chroma_h_shift             = chroma_h_shift;
        f->chroma_v_shift             = chroma_v_shift;
        f->transparency               = transparency;

        f->plane_count    = 2 + f->transparency;
    }

    if (f->colorspace == 0) {
        if (!f->transparency && !f->chroma_planes) {
            if (f->avctx->bits_per_raw_sample <= 8)
                f->pix_fmt = AV_PIX_FMT_GRAY8;
            else if (f->avctx->bits_per_raw_sample == 9) {
                f->packed_at_lsb = 1;
                f->pix_fmt = AV_PIX_FMT_GRAY9;
            } else if (f->avctx->bits_per_raw_sample == 10) {
                f->packed_at_lsb = 1;
                f->pix_fmt = AV_PIX_FMT_GRAY10;
            } else if (f->avctx->bits_per_raw_sample == 12) {
                f->packed_at_lsb = 1;
                f->pix_fmt = AV_PIX_FMT_GRAY12;
            } else if (f->avctx->bits_per_raw_sample == 14) {
                f->packed_at_lsb = 1;
                f->pix_fmt = AV_PIX_FMT_GRAY14;
            } else if (f->avctx->bits_per_raw_sample == 16) {
                f->packed_at_lsb = 1;
                f->pix_fmt = AV_PIX_FMT_GRAY16;
            } else if (f->avctx->bits_per_raw_sample < 16) {
                f->pix_fmt = AV_PIX_FMT_GRAY16;
            } else
                return AVERROR(ENOSYS);
        } else if (f->transparency && !f->chroma_planes) {
            if (f->avctx->bits_per_raw_sample <= 8)
                f->pix_fmt = AV_PIX_FMT_YA8;
            else
                return AVERROR(ENOSYS);
        } else if (f->avctx->bits_per_raw_sample<=8 && !f->transparency) {
            switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P; break;
            case 0x01: f->pix_fmt = AV_PIX_FMT_YUV440P; break;
            case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P; break;
            case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P; break;
            case 0x20: f->pix_fmt = AV_PIX_FMT_YUV411P; break;
            case 0x22: f->pix_fmt = AV_PIX_FMT_YUV410P; break;
            }
        } else if (f->avctx->bits_per_raw_sample <= 8 && f->transparency) {
            switch(16*f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P; break;
            case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P; break;
            case 0x11: f->pix_fmt = AV_PIX_FMT_YUVA420P; break;
            }
        } else if (f->avctx->bits_per_raw_sample == 9 && !f->transparency) {
            f->packed_at_lsb = 1;
            switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P9; break;
            case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P9; break;
            case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P9; break;
            }
        } else if (f->avctx->bits_per_raw_sample == 9 && f->transparency) {
            f->packed_at_lsb = 1;
            switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P9; break;
            case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P9; break;
            case 0x11: f->pix_fmt = AV_PIX_FMT_YUVA420P9; break;
            }
        } else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency) {
            f->packed_at_lsb = 1;
            switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P10; break;
            case 0x01: f->pix_fmt = AV_PIX_FMT_YUV440P10; break;
            case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P10; break;
            case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P10; break;
            }
        } else if (f->avctx->bits_per_raw_sample == 10 && f->transparency) {
            f->packed_at_lsb = 1;
            switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P10; break;
            case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P10; break;
            case 0x11: f->pix_fmt = AV_PIX_FMT_YUVA420P10; break;
            }
        } else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency) {
            f->packed_at_lsb = 1;
            switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P12; break;
            case 0x01: f->pix_fmt = AV_PIX_FMT_YUV440P12; break;
            case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P12; break;
            case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P12; break;
            }
        } else if (f->avctx->bits_per_raw_sample == 12 && f->transparency) {
            f->packed_at_lsb = 1;
            switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P12; break;
            case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P12; break;
            }
        } else if (f->avctx->bits_per_raw_sample == 14 && !f->transparency) {
            f->packed_at_lsb = 1;
            switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P14; break;
            case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P14; break;
            case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P14; break;
            }
        } else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency){
            f->packed_at_lsb = 1;
            switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00: f->pix_fmt = AV_PIX_FMT_YUV444P16; break;
            case 0x10: f->pix_fmt = AV_PIX_FMT_YUV422P16; break;
            case 0x11: f->pix_fmt = AV_PIX_FMT_YUV420P16; break;
            }
        } else if (f->avctx->bits_per_raw_sample == 16 && f->transparency){
            f->packed_at_lsb = 1;
            switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00: f->pix_fmt = AV_PIX_FMT_YUVA444P16; break;
            case 0x10: f->pix_fmt = AV_PIX_FMT_YUVA422P16; break;
            case 0x11: f->pix_fmt = AV_PIX_FMT_YUVA420P16; break;
            }
        }
    } else if (f->colorspace == 1) {
        if (f->chroma_h_shift || f->chroma_v_shift) {
            av_log(f->avctx, AV_LOG_ERROR,
                   "chroma subsampling not supported in this colorspace\n");
            return AVERROR(ENOSYS);
        }
        if (     f->avctx->bits_per_raw_sample <=  8 && !f->transparency)
            f->pix_fmt = AV_PIX_FMT_0RGB32;
        else if (f->avctx->bits_per_raw_sample <=  8 && f->transparency)
            f->pix_fmt = AV_PIX_FMT_RGB32;
        else if (f->avctx->bits_per_raw_sample ==  9 && !f->transparency)
            f->pix_fmt = AV_PIX_FMT_GBRP9;
        else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency)
            f->pix_fmt = AV_PIX_FMT_GBRP10;
        else if (f->avctx->bits_per_raw_sample == 10 && f->transparency)
            f->pix_fmt = AV_PIX_FMT_GBRAP10;
        else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency)
            f->pix_fmt = AV_PIX_FMT_GBRP12;
        else if (f->avctx->bits_per_raw_sample == 12 && f->transparency)
            f->pix_fmt = AV_PIX_FMT_GBRAP12;
        else if (f->avctx->bits_per_raw_sample == 14 && !f->transparency)
            f->pix_fmt = AV_PIX_FMT_GBRP14;
        else if (f->avctx->bits_per_raw_sample == 14 && f->transparency)
            f->pix_fmt = AV_PIX_FMT_GBRAP14;
        else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency) {
            if (f->flt) {
                f->pix_fmt = AV_PIX_FMT_GBRPF16;
            } else
                f->pix_fmt = AV_PIX_FMT_GBRP16;
            f->use32bit = 1;
        } else if (f->avctx->bits_per_raw_sample == 16 && f->transparency) {
            if (f->flt) {
                f->pix_fmt = AV_PIX_FMT_GBRAPF16;
            } else
                f->pix_fmt = AV_PIX_FMT_GBRAP16;
            f->use32bit = 1;
        }
    } else {
        av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
        return AVERROR(ENOSYS);
    }
    if (f->pix_fmt == AV_PIX_FMT_NONE) {
        av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
        return AVERROR(ENOSYS);
    }

    return 0;
}