/*

 * MPEG-4 decoder

 * Copyright (c) 2000,2001 Fabrice Bellard

 * Copyright (c) 2002-2010 Michael Niedermayer <michaelni@gmx.at>

 *

 * 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 UNCHECKED_BITSTREAM_READER 1

#include "config_components.h"

#include "libavutil/avassert.h"

#include "libavutil/internal.h"

#include "libavutil/opt.h"

#include "libavutil/thread.h"

#include "codec_internal.h"

#include "error_resilience.h"

#include "hwconfig.h"

#include "idctdsp.h"

#include "mpegutils.h"

#include "mpegvideo.h"

#include "mpegvideodata.h"

#include "mpegvideodec.h"

#include "mpegvideo_unquantize.h"

#include "mpeg4video.h"

#include "mpeg4videodata.h"

#include "mpeg4videodec.h"

#include "mpeg4videodefs.h"

#include "h263.h"

#include "h263data.h"

#include "h263dec.h"

#include "internal.h"

#include "profiles.h"

#include "qpeldsp.h"

#include "threadprogress.h"

#include "unary.h"

#if 0 //3IV1 is quite rare and it slows things down a tiny bit

#define IS_3IV1 (s->codec_tag == AV_RL32("3IV1"))

#else

#define IS_3IV1 0

#endif

/* The defines below define the number of bits that are read at once for

 * reading vlc values. Changing these may improve speed and data cache needs

 * be aware though that decreasing them may need the number of stages that is

 * passed to get_vlc* to be increased. */

#define SPRITE_TRAJ_VLC_BITS 6

#define DC_VLC_BITS 9

#define MB_TYPE_B_VLC_BITS 4

#define STUDIO_INTRA_BITS 9

static VLCElem dc_lum[512], dc_chrom[512];

static VLCElem sprite_trajectory[128];

static VLCElem mb_type_b_vlc[16];

static const VLCElem *studio_intra_tab[12];

static VLCElem studio_luma_dc[528];

static VLCElem studio_chroma_dc[528];

static const uint8_t mpeg4_block_count[4] = { 0, 6, 8, 12 };

static const int16_t mb_type_b_map[4] = {

    MB_TYPE_DIRECT2     | MB_TYPE_BIDIR_MV,

    MB_TYPE_BIDIR_MV    | MB_TYPE_16x16,

    MB_TYPE_BACKWARD_MV | MB_TYPE_16x16,

    MB_TYPE_FORWARD_MV  | MB_TYPE_16x16,

};

static inline Mpeg4DecContext *h263_to_mpeg4(H263DecContext *h)

{

    av_assert2(h->c.codec_id == AV_CODEC_ID_MPEG4 && h->c.avctx->priv_data == h);

    return (Mpeg4DecContext*)h;

}

static void gmc1_motion(MpegEncContext *s, const Mpeg4DecContext *ctx,

                        uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

                        uint8_t *const *ref_picture)

{

    const uint8_t *ptr;

    int src_x, src_y, motion_x, motion_y;

    ptrdiff_t offset, linesize, uvlinesize;

    int emu = 0;

    motion_x   = ctx->sprite_offset[0][0];

    motion_y   = ctx->sprite_offset[0][1];

    src_x      = s->mb_x * 16 + (motion_x >> (ctx->sprite_warping_accuracy + 1));

    src_y      = s->mb_y * 16 + (motion_y >> (ctx->sprite_warping_accuracy + 1));

    motion_x *= 1 << (3 - ctx->sprite_warping_accuracy);

    motion_y *= 1 << (3 - ctx->sprite_warping_accuracy);

    src_x      = av_clip(src_x, -16, s->width);

    if (src_x == s->width)

        motion_x = 0;

    src_y = av_clip(src_y, -16, s->height);

    if (src_y == s->height)

        motion_y = 0;

    linesize   = s->linesize;

    uvlinesize = s->uvlinesize;

    ptr = ref_picture[0] + src_y * linesize + src_x;

    if ((unsigned)src_x >= FFMAX(s->h_edge_pos - 17, 0) ||

        (unsigned)src_y >= FFMAX(s->v_edge_pos - 17, 0)) {

        s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,

                                 linesize, linesize,

                                 17, 17,

                                 src_x, src_y,

                                 s->h_edge_pos, s->v_edge_pos);

        ptr = s->sc.edge_emu_buffer;

    }

    if ((motion_x | motion_y) & 7) {

        ctx->mdsp.gmc1(dest_y, ptr, linesize, 16,

                       motion_x & 15, motion_y & 15, 128 - s->no_rounding);

        ctx->mdsp.gmc1(dest_y + 8, ptr + 8, linesize, 16,

                       motion_x & 15, motion_y & 15, 128 - s->no_rounding);

    } else {

        int dxy;

        dxy = ((motion_x >> 3) & 1) | ((motion_y >> 2) & 2);

        if (s->no_rounding) {

            s->hdsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);

        } else {

            s->hdsp.put_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);

        }

    }

    if (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY)

        return;

    motion_x   = ctx->sprite_offset[1][0];

    motion_y   = ctx->sprite_offset[1][1];

    src_x      = s->mb_x * 8 + (motion_x >> (ctx->sprite_warping_accuracy + 1));

    src_y      = s->mb_y * 8 + (motion_y >> (ctx->sprite_warping_accuracy + 1));

    motion_x  *= 1 << (3 - ctx->sprite_warping_accuracy);

    motion_y  *= 1 << (3 - ctx->sprite_warping_accuracy);

    src_x      = av_clip(src_x, -8, s->width >> 1);

    if (src_x == s->width >> 1)

        motion_x = 0;

    src_y = av_clip(src_y, -8, s->height >> 1);

    if (src_y == s->height >> 1)

        motion_y = 0;

    offset = (src_y * uvlinesize) + src_x;

    ptr    = ref_picture[1] + offset;

    if ((unsigned)src_x >= FFMAX((s->h_edge_pos >> 1) - 9, 0) ||

        (unsigned)src_y >= FFMAX((s->v_edge_pos >> 1) - 9, 0)) {

        s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,

                                 uvlinesize, uvlinesize,

                                 9, 9,

                                 src_x, src_y,

                                 s->h_edge_pos >> 1, s->v_edge_pos >> 1);

        ptr = s->sc.edge_emu_buffer;

        emu = 1;

    }

    ctx->mdsp.gmc1(dest_cb, ptr, uvlinesize, 8,

                   motion_x & 15, motion_y & 15, 128 - s->no_rounding);

    ptr = ref_picture[2] + offset;

    if (emu) {

        s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,

                                 uvlinesize, uvlinesize,

                                 9, 9,

                                 src_x, src_y,

                                 s->h_edge_pos >> 1, s->v_edge_pos >> 1);

        ptr = s->sc.edge_emu_buffer;

    }

    ctx->mdsp.gmc1(dest_cr, ptr, uvlinesize, 8,

                   motion_x & 15, motion_y & 15, 128 - s->no_rounding);

}

static void gmc_motion(MpegEncContext *s, const Mpeg4DecContext *ctx,

                       uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

                       uint8_t *const *ref_picture)

{

    const uint8_t *ptr;

    int linesize, uvlinesize;

    const int a = ctx->sprite_warping_accuracy;

    int ox, oy;

    linesize   = s->linesize;

    uvlinesize = s->uvlinesize;

    ptr = ref_picture[0];

    ox = ctx->sprite_offset[0][0] + ctx->sprite_delta[0][0] * s->mb_x * 16 +

         ctx->sprite_delta[0][1] * s->mb_y * 16;

    oy = ctx->sprite_offset[0][1] + ctx->sprite_delta[1][0] * s->mb_x * 16 +

         ctx->sprite_delta[1][1] * s->mb_y * 16;

    ctx->mdsp.gmc(dest_y, ptr, linesize, 16,

                  ox, oy,

                  ctx->sprite_delta[0][0], ctx->sprite_delta[0][1],

                  ctx->sprite_delta[1][0], ctx->sprite_delta[1][1],

                  a + 1, (1 << (2 * a + 1)) - s->no_rounding,

                  s->h_edge_pos, s->v_edge_pos);

    ctx->mdsp.gmc(dest_y + 8, ptr, linesize, 16,

                  ox + ctx->sprite_delta[0][0] * 8,

                  oy + ctx->sprite_delta[1][0] * 8,

                  ctx->sprite_delta[0][0], ctx->sprite_delta[0][1],

                  ctx->sprite_delta[1][0], ctx->sprite_delta[1][1],

                  a + 1, (1 << (2 * a + 1)) - s->no_rounding,

                  s->h_edge_pos, s->v_edge_pos);

    if (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY)

        return;

    ox = ctx->sprite_offset[1][0] + ctx->sprite_delta[0][0] * s->mb_x * 8 +

         ctx->sprite_delta[0][1] * s->mb_y * 8;

    oy = ctx->sprite_offset[1][1] + ctx->sprite_delta[1][0] * s->mb_x * 8 +

         ctx->sprite_delta[1][1] * s->mb_y * 8;

    ptr = ref_picture[1];

    ctx->mdsp.gmc(dest_cb, ptr, uvlinesize, 8,

                  ox, oy,

                  ctx->sprite_delta[0][0], ctx->sprite_delta[0][1],

                  ctx->sprite_delta[1][0], ctx->sprite_delta[1][1],

                  a + 1, (1 << (2 * a + 1)) - s->no_rounding,

                  (s->h_edge_pos + 1) >> 1, (s->v_edge_pos + 1) >> 1);

    ptr = ref_picture[2];

    ctx->mdsp.gmc(dest_cr, ptr, uvlinesize, 8,

                  ox, oy,

                  ctx->sprite_delta[0][0], ctx->sprite_delta[0][1],

                  ctx->sprite_delta[1][0], ctx->sprite_delta[1][1],

                  a + 1, (1 << (2 * a + 1)) - s->no_rounding,

                  (s->h_edge_pos + 1) >> 1, (s->v_edge_pos + 1) >> 1);

}

void ff_mpeg4_mcsel_motion(MpegEncContext *s,

                           uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

                           uint8_t *const *ref_picture)

{

    const Mpeg4DecContext *const ctx = (Mpeg4DecContext*)s;

    if (ctx->real_sprite_warping_points == 1) {

        gmc1_motion(s, ctx, dest_y, dest_cb, dest_cr,

                    ref_picture);

    } else {

        gmc_motion(s, ctx, dest_y, dest_cb, dest_cr,

                    ref_picture);

    }

}

void ff_mpeg4_decode_studio(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb,

                            uint8_t *dest_cr, int block_size, int uvlinesize,

                            int dct_linesize, int dct_offset)

{

    Mpeg4DecContext *const ctx = (Mpeg4DecContext*)s;

    const int act_block_size = block_size * 2;

    if (ctx->dpcm_direction == 0) {

        s->idsp.idct_put(dest_y,                               dct_linesize, (int16_t*)ctx->block32[0]);

        s->idsp.idct_put(dest_y              + act_block_size, dct_linesize, (int16_t*)ctx->block32[1]);

        s->idsp.idct_put(dest_y + dct_offset,                  dct_linesize, (int16_t*)ctx->block32[2]);

        s->idsp.idct_put(dest_y + dct_offset + act_block_size, dct_linesize, (int16_t*)ctx->block32[3]);

        dct_linesize = uvlinesize << s->interlaced_dct;

        dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;

        s->idsp.idct_put(dest_cb,              dct_linesize, (int16_t*)ctx->block32[4]);

        s->idsp.idct_put(dest_cr,              dct_linesize, (int16_t*)ctx->block32[5]);

        s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, (int16_t*)ctx->block32[6]);

        s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, (int16_t*)ctx->block32[7]);

        if (!s->chroma_x_shift){ //Chroma444

            s->idsp.idct_put(dest_cb + act_block_size,              dct_linesize, (int16_t*)ctx->block32[8]);

            s->idsp.idct_put(dest_cr + act_block_size,              dct_linesize, (int16_t*)ctx->block32[9]);

            s->idsp.idct_put(dest_cb + act_block_size + dct_offset, dct_linesize, (int16_t*)ctx->block32[10]);

            s->idsp.idct_put(dest_cr + act_block_size + dct_offset, dct_linesize, (int16_t*)ctx->block32[11]);

        }

    } else if (ctx->dpcm_direction == 1) {

        uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};

        int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};

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

            const uint16_t *src = ctx->dpcm_macroblock[i];

            int vsub = i ? s->chroma_y_shift : 0;

            int hsub = i ? s->chroma_x_shift : 0;

            int lowres = s->avctx->lowres;

            int step = 1 << lowres;

            for (int h = 0; h < (16 >> (vsub + lowres)); h++){

                for (int w = 0, idx = 0; w < (16 >> (hsub + lowres)); w++, idx += step)

                    dest_pcm[i][w] = src[idx];

                dest_pcm[i] += linesize[i] / 2;

                src         += (16 >> hsub) * step;

            }

        }

    } else {

        uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};

        int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};

        av_assert2(ctx->dpcm_direction == -1);

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

            const uint16_t *src = ctx->dpcm_macroblock[i];

            int vsub = i ? s->chroma_y_shift : 0;

            int hsub = i ? s->chroma_x_shift : 0;

            int lowres = s->avctx->lowres;

            int step = 1 << lowres;

            dest_pcm[i] += (linesize[i] / 2) * ((16 >> vsub + lowres) - 1);

            for (int h = (16 >> (vsub + lowres)) - 1; h >= 0; h--){

                for (int w = (16 >> (hsub + lowres)) - 1, idx = 0; w >= 0; w--, idx += step)

                    dest_pcm[i][w] = src[idx];

                src += step * (16 >> hsub);

                dest_pcm[i] -= linesize[i] / 2;

            }

        }

    }

}

/**

 * Predict the ac.

 * @param n block index (0-3 are luma, 4-5 are chroma)

 * @param dir the ac prediction direction

 */

void ff_mpeg4_pred_ac(H263DecContext *const h, int16_t *block, int n, int dir)

{

    int i;

    int16_t *ac_val, *ac_val1;

    int8_t *const qscale_table = h->c.cur_pic.qscale_table;

    /* find prediction */

    ac_val  = &h->c.ac_val[0][0] + h->c.block_index[n] * 16;

    ac_val1 = ac_val;

    if (h->c.ac_pred) {

        if (dir == 0) {

            const int xy = h->c.mb_x - 1 + h->c.mb_y * h->c.mb_stride;

            /* left prediction */

            ac_val -= 16;

            if (h->c.mb_x == 0 || h->c.qscale == qscale_table[xy] ||

                n == 1 || n == 3) {

                /* same qscale */

                for (i = 1; i < 8; i++)

                    block[h->c.idsp.idct_permutation[i << 3]] += ac_val[i];

            } else {

                /* different qscale, we must rescale */

                for (i = 1; i < 8; i++)

                    block[h->c.idsp.idct_permutation[i << 3]] += ROUNDED_DIV(ac_val[i] * qscale_table[xy], h->c.qscale);

            }

        } else {

            const int xy = h->c.mb_x + h->c.mb_y * h->c.mb_stride - h->c.mb_stride;

            /* top prediction */

            ac_val -= 16 * h->c.block_wrap[n];

            if (h->c.mb_y == 0 || h->c.qscale == qscale_table[xy] ||

                n == 2 || n == 3) {

                /* same qscale */

                for (i = 1; i < 8; i++)

                    block[h->c.idsp.idct_permutation[i]] += ac_val[i + 8];

            } else {

                /* different qscale, we must rescale */

                for (i = 1; i < 8; i++)

                    block[h->c.idsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8] * qscale_table[xy], h->c.qscale);

            }

        }

    }

    /* left copy */

    for (i = 1; i < 8; i++)

        ac_val1[i] = block[h->c.idsp.idct_permutation[i << 3]];

    /* top copy */

    for (i = 1; i < 8; i++)

        ac_val1[8 + i] = block[h->c.idsp.idct_permutation[i]];

}

/**

 * check if the next stuff is a resync marker or the end.

 * @return 0 if not

 */

static inline int mpeg4_is_resync(Mpeg4DecContext *ctx)

{

    H263DecContext *const h = &ctx->h;

    int bits_count = get_bits_count(&h->gb);

    int v          = show_bits(&h->gb, 16);

    if (h->c.workaround_bugs & FF_BUG_NO_PADDING && !ctx->resync_marker)

        return 0;

    while (v <= 0xFF) {

        if (h->c.pict_type == AV_PICTURE_TYPE_B ||

            (v >> (8 - h->c.pict_type) != 1) || h->partitioned_frame)

            break;

        skip_bits(&h->gb, 8 + h->c.pict_type);

        bits_count += 8 + h->c.pict_type;

        v = show_bits(&h->gb, 16);

    }

    if (bits_count + 8 >= h->gb.size_in_bits) {

        v >>= 8;

        v  |= 0x7F >> (7 - (bits_count & 7));

        if (v == 0x7F)

            return h->c.mb_num;

    } else {

        static const uint16_t mpeg4_resync_prefix[8] = {

            0x7F00, 0x7E00, 0x7C00, 0x7800, 0x7000, 0x6000, 0x4000, 0x0000

        };

        if (v == mpeg4_resync_prefix[bits_count & 7]) {

            int len, mb_num;

            int mb_num_bits = av_log2(h->c.mb_num - 1) + 1;

            GetBitContext gb = h->gb;

            skip_bits(&h->gb, 1);

            align_get_bits(&h->gb);

            for (len = 0; len < 32; len++)

                if (get_bits1(&h->gb))

                    break;

            mb_num = get_bits(&h->gb, mb_num_bits);

            if (!mb_num || mb_num > h->c.mb_num || get_bits_count(&h->gb) + 6 > h->gb.size_in_bits)

                mb_num= -1;

            h->gb = gb;

            if (len >= ff_mpeg4_get_video_packet_prefix_length(h->c.pict_type, ctx->f_code, ctx->b_code))

                return mb_num;

        }

    }

    return 0;

}

static int mpeg4_decode_sprite_trajectory(Mpeg4DecContext *ctx, GetBitContext *gb)

{

    MpegEncContext *s = &ctx->h.c;

    int a     = 2 << ctx->sprite_warping_accuracy;

    int rho   = 3  - ctx->sprite_warping_accuracy;

    int r     = 16 / a;

    int alpha = 1;

    int beta  = 0;

    int w     = s->width;

    int h     = s->height;

    int min_ab, i, w2, h2, w3, h3;

    int sprite_ref[4][2];

    int virtual_ref[2][2];

    int64_t sprite_offset[2][2];

    int64_t sprite_delta[2][2];

    // only true for rectangle shapes

    const int vop_ref[4][2] = { { 0, 0 },         { s->width, 0 },

                                { 0, s->height }, { s->width, s->height } };

    int d[4][2]             = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } };

    if (w <= 0 || h <= 0)

        return AVERROR_INVALIDDATA;

    for (i = 0; i < ctx->num_sprite_warping_points; i++) {

        int length;

        int x = 0, y = 0;

        length = get_vlc2(gb, sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 2);

        if (length > 0)

            x = get_xbits(gb, length);

        if (!(ctx->divx_version == 500 && ctx->divx_build == 413))

            check_marker(s->avctx, gb, "before sprite_trajectory");

        length = get_vlc2(gb, sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 2);

        if (length > 0)

            y = get_xbits(gb, length);

        check_marker(s->avctx, gb, "after sprite_trajectory");

        ctx->sprite_traj[i][0] = d[i][0] = x;

        ctx->sprite_traj[i][1] = d[i][1] = y;

    }

    for (; i < 4; i++)

        ctx->sprite_traj[i][0] = ctx->sprite_traj[i][1] = 0;

    while ((1 << alpha) < w)

        alpha++;

    while ((1 << beta) < h)

        beta++;  /* typo in the MPEG-4 std for the definition of w' and h' */

    w2 = 1 << alpha;

    h2 = 1 << beta;

    // Note, the 4th point isn't used for GMC

    if (ctx->divx_version == 500 && ctx->divx_build == 413) {

        sprite_ref[0][0] = a * vop_ref[0][0] + d[0][0];

        sprite_ref[0][1] = a * vop_ref[0][1] + d[0][1];

        sprite_ref[1][0] = a * vop_ref[1][0] + d[0][0] + d[1][0];

        sprite_ref[1][1] = a * vop_ref[1][1] + d[0][1] + d[1][1];

        sprite_ref[2][0] = a * vop_ref[2][0] + d[0][0] + d[2][0];

        sprite_ref[2][1] = a * vop_ref[2][1] + d[0][1] + d[2][1];

    } else {

        sprite_ref[0][0] = (a >> 1) * (2 * vop_ref[0][0] + d[0][0]);

        sprite_ref[0][1] = (a >> 1) * (2 * vop_ref[0][1] + d[0][1]);

        sprite_ref[1][0] = (a >> 1) * (2 * vop_ref[1][0] + d[0][0] + d[1][0]);

        sprite_ref[1][1] = (a >> 1) * (2 * vop_ref[1][1] + d[0][1] + d[1][1]);

        sprite_ref[2][0] = (a >> 1) * (2 * vop_ref[2][0] + d[0][0] + d[2][0]);

        sprite_ref[2][1] = (a >> 1) * (2 * vop_ref[2][1] + d[0][1] + d[2][1]);

    }

    /* sprite_ref[3][0] = (a >> 1) * (2 * vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);

     * sprite_ref[3][1] = (a >> 1) * (2 * vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */

    /* This is mostly identical to the MPEG-4 std (and is totally unreadable

     * because of that...). Perhaps it should be reordered to be more readable.

     * The idea behind this virtual_ref mess is to be able to use shifts later

     * per pixel instead of divides so the distance between points is converted

     * from w&h based to w2&h2 based which are of the 2^x form. */

    virtual_ref[0][0] = 16 * (vop_ref[0][0] + w2) +

                         ROUNDED_DIV(((w - w2) *

                                           (r * sprite_ref[0][0] - 16LL * vop_ref[0][0]) +

                                      w2 * (r * sprite_ref[1][0] - 16LL * vop_ref[1][0])), w);

    virtual_ref[0][1] = 16 * vop_ref[0][1] +

                        ROUNDED_DIV(((w - w2) *

                                          (r * sprite_ref[0][1] - 16LL * vop_ref[0][1]) +

                                     w2 * (r * sprite_ref[1][1] - 16LL * vop_ref[1][1])), w);

    virtual_ref[1][0] = 16 * vop_ref[0][0] +

                        ROUNDED_DIV(((h - h2) * (r * sprite_ref[0][0] - 16LL * vop_ref[0][0]) +

                                           h2 * (r * sprite_ref[2][0] - 16LL * vop_ref[2][0])), h);

    virtual_ref[1][1] = 16 * (vop_ref[0][1] + h2) +

                        ROUNDED_DIV(((h - h2) * (r * sprite_ref[0][1] - 16LL * vop_ref[0][1]) +

                                           h2 * (r * sprite_ref[2][1] - 16LL * vop_ref[2][1])), h);

    switch (ctx->num_sprite_warping_points) {

    case 0:

        sprite_offset[0][0]    =

        sprite_offset[0][1]    =

        sprite_offset[1][0]    =

        sprite_offset[1][1]    = 0;

        sprite_delta[0][0]     = a;

        sprite_delta[0][1]     =

        sprite_delta[1][0]     = 0;

        sprite_delta[1][1]     = a;

        ctx->sprite_shift[0]   =

        ctx->sprite_shift[1]   = 0;

        break;

    case 1:     // GMC only

        sprite_offset[0][0]    = sprite_ref[0][0] - a * vop_ref[0][0];

        sprite_offset[0][1]    = sprite_ref[0][1] - a * vop_ref[0][1];

        sprite_offset[1][0]    = ((sprite_ref[0][0] >> 1) | (sprite_ref[0][0] & 1)) -

                                 a * (vop_ref[0][0] / 2);

        sprite_offset[1][1]    = ((sprite_ref[0][1] >> 1) | (sprite_ref[0][1] & 1)) -

                                 a * (vop_ref[0][1] / 2);

        sprite_delta[0][0]     = a;

        sprite_delta[0][1]     =

        sprite_delta[1][0]     = 0;

        sprite_delta[1][1]     = a;

        ctx->sprite_shift[0]   =

        ctx->sprite_shift[1]   = 0;

        break;

    case 2:

        sprite_offset[0][0]    = ((int64_t)      sprite_ref[0][0] * (1 << alpha + rho)) +

                                 ((int64_t) -r * sprite_ref[0][0] + virtual_ref[0][0]) *

                                 ((int64_t)        -vop_ref[0][0]) +

                                 ((int64_t)  r * sprite_ref[0][1] - virtual_ref[0][1]) *

                                 ((int64_t)        -vop_ref[0][1]) + (1 << (alpha + rho - 1));

        sprite_offset[0][1]    = ((int64_t)      sprite_ref[0][1] * (1 << alpha + rho)) +

                                 ((int64_t) -r * sprite_ref[0][1] + virtual_ref[0][1]) *

                                 ((int64_t)        -vop_ref[0][0]) +

                                 ((int64_t) -r * sprite_ref[0][0] + virtual_ref[0][0]) *

                                 ((int64_t)        -vop_ref[0][1]) + (1 << (alpha + rho - 1));

        sprite_offset[1][0]    = (((int64_t)-r * sprite_ref[0][0] + virtual_ref[0][0]) *

                                  ((int64_t)-2 *    vop_ref[0][0] + 1) +

                                  ((int64_t) r * sprite_ref[0][1] - virtual_ref[0][1]) *

                                  ((int64_t)-2 *    vop_ref[0][1] + 1) + 2 * w2 * r *

                                   (int64_t)     sprite_ref[0][0] - 16 * w2 + (1 << (alpha + rho + 1)));

        sprite_offset[1][1]    = (((int64_t)-r * sprite_ref[0][1] + virtual_ref[0][1]) *

                                  ((int64_t)-2 *    vop_ref[0][0] + 1) +

                                  ((int64_t)-r * sprite_ref[0][0] + virtual_ref[0][0]) *

                                  ((int64_t)-2 *    vop_ref[0][1] + 1) + 2 * w2 * r *

                                  (int64_t)      sprite_ref[0][1] - 16 * w2 + (1 << (alpha + rho + 1)));

        sprite_delta[0][0] = (-r * sprite_ref[0][0] + virtual_ref[0][0]);

        sprite_delta[0][1] = (+r * sprite_ref[0][1] - virtual_ref[0][1]);

        sprite_delta[1][0] = (-r * sprite_ref[0][1] + virtual_ref[0][1]);

        sprite_delta[1][1] = (-r * sprite_ref[0][0] + virtual_ref[0][0]);

        ctx->sprite_shift[0]  = alpha + rho;

        ctx->sprite_shift[1]  = alpha + rho + 2;

        break;

    case 3:

        min_ab = FFMIN(alpha, beta);

        w3     = w2 >> min_ab;

        h3     = h2 >> min_ab;

        sprite_offset[0][0]    = ((int64_t)sprite_ref[0][0] * (1 << (alpha + beta + rho - min_ab))) +

                                 ((int64_t)-r * sprite_ref[0][0] + virtual_ref[0][0]) * h3 * (-vop_ref[0][0]) +

                                 ((int64_t)-r * sprite_ref[0][0] + virtual_ref[1][0]) * w3 * (-vop_ref[0][1]) +

                                 ((int64_t)1 << (alpha + beta + rho - min_ab - 1));

        sprite_offset[0][1]    = ((int64_t)sprite_ref[0][1] * (1 << (alpha + beta + rho - min_ab))) +

                                 ((int64_t)-r * sprite_ref[0][1] + virtual_ref[0][1]) * h3 * (-vop_ref[0][0]) +

                                 ((int64_t)-r * sprite_ref[0][1] + virtual_ref[1][1]) * w3 * (-vop_ref[0][1]) +

                                 ((int64_t)1 << (alpha + beta + rho - min_ab - 1));

        sprite_offset[1][0]    = ((int64_t)-r * sprite_ref[0][0] + virtual_ref[0][0]) * h3 * (-2 * vop_ref[0][0] + 1) +

                                 ((int64_t)-r * sprite_ref[0][0] + virtual_ref[1][0]) * w3 * (-2 * vop_ref[0][1] + 1) +

                                  (int64_t)2 * w2 * h3 * r * sprite_ref[0][0] - 16 * w2 * h3 +

                                 ((int64_t)1 << (alpha + beta + rho - min_ab + 1));

        sprite_offset[1][1]    = ((int64_t)-r * sprite_ref[0][1] + virtual_ref[0][1]) * h3 * (-2 * vop_ref[0][0] + 1) +

                                 ((int64_t)-r * sprite_ref[0][1] + virtual_ref[1][1]) * w3 * (-2 * vop_ref[0][1] + 1) +

                                  (int64_t)2 * w2 * h3 * r * sprite_ref[0][1] - 16 * w2 * h3 +

                                 ((int64_t)1 << (alpha + beta + rho - min_ab + 1));

        sprite_delta[0][0] = (-r * (int64_t)sprite_ref[0][0] + virtual_ref[0][0]) * h3;

        sprite_delta[0][1] = (-r * (int64_t)sprite_ref[0][0] + virtual_ref[1][0]) * w3;

        sprite_delta[1][0] = (-r * (int64_t)sprite_ref[0][1] + virtual_ref[0][1]) * h3;

        sprite_delta[1][1] = (-r * (int64_t)sprite_ref[0][1] + virtual_ref[1][1]) * w3;

        ctx->sprite_shift[0]  = alpha + beta + rho - min_ab;

        ctx->sprite_shift[1]  = alpha + beta + rho - min_ab + 2;

        break;

    default:

        av_unreachable("num_sprite_warping_points outside of 0..3 results in an error"

                       "in which num_sprite_warping_points is reset to zero");

    }

    /* try to simplify the situation */

    if (sprite_delta[0][0] == a << ctx->sprite_shift[0] &&

        sprite_delta[0][1] == 0 &&

        sprite_delta[1][0] == 0 &&

        sprite_delta[1][1] == a << ctx->sprite_shift[0]) {

        sprite_offset[0][0] >>= ctx->sprite_shift[0];

        sprite_offset[0][1] >>= ctx->sprite_shift[0];

        sprite_offset[1][0] >>= ctx->sprite_shift[1];

        sprite_offset[1][1] >>= ctx->sprite_shift[1];

        sprite_delta[0][0] = a;

        sprite_delta[0][1] = 0;

        sprite_delta[1][0] = 0;

        sprite_delta[1][1] = a;

        ctx->sprite_shift[0] = 0;

        ctx->sprite_shift[1] = 0;

        ctx->real_sprite_warping_points = 1;

    } else {

        int shift_y = 16 - ctx->sprite_shift[0];

        int shift_c = 16 - ctx->sprite_shift[1];

        for (i = 0; i < 2; i++) {

            if (shift_c < 0 || shift_y < 0 ||

                FFABS(  sprite_offset[0][i]) >= INT_MAX >> shift_y  ||

                FFABS(  sprite_offset[1][i]) >= INT_MAX >> shift_c  ||

                FFABS(   sprite_delta[0][i]) >= INT_MAX >> shift_y  ||

                FFABS(   sprite_delta[1][i]) >= INT_MAX >> shift_y

            ) {

                avpriv_request_sample(s->avctx, "Too large sprite shift, delta or offset");

                goto overflow;

            }

        }

        for (i = 0; i < 2; i++) {

            sprite_offset[0][i]    *= 1 << shift_y;

            sprite_offset[1][i]    *= 1 << shift_c;

            sprite_delta[0][i]     *= 1 << shift_y;

            sprite_delta[1][i]     *= 1 << shift_y;

            ctx->sprite_shift[i]     = 16;

        }

        for (i = 0; i < 2; i++) {

            int64_t sd[2] = {

                sprite_delta[i][0] - a * (1LL<<16),

                sprite_delta[i][1] - a * (1LL<<16)

            };

            if (llabs(sprite_offset[0][i] + sprite_delta[i][0] * (w+16LL)) >= INT_MAX ||

                llabs(sprite_offset[0][i] + sprite_delta[i][1] * (h+16LL)) >= INT_MAX ||

                llabs(sprite_offset[0][i] + sprite_delta[i][0] * (w+16LL) + sprite_delta[i][1] * (h+16LL)) >= INT_MAX ||

                llabs(sprite_delta[i][0] * (w+16LL)) >= INT_MAX ||

                llabs(sprite_delta[i][1] * (h+16LL)) >= INT_MAX ||

                llabs(sd[0]) >= INT_MAX ||

                llabs(sd[1]) >= INT_MAX ||

                llabs(sprite_offset[0][i] + sd[0] * (w+16LL)) >= INT_MAX ||

                llabs(sprite_offset[0][i] + sd[1] * (h+16LL)) >= INT_MAX ||

                llabs(sprite_offset[0][i] + sd[0] * (w+16LL) + sd[1] * (h+16LL)) >= INT_MAX

            ) {

                avpriv_request_sample(s->avctx, "Overflow on sprite points");

                goto overflow;

            }

        }

        ctx->real_sprite_warping_points = ctx->num_sprite_warping_points;

    }

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

        ctx->sprite_offset[i&1][i>>1] = sprite_offset[i&1][i>>1];

        ctx->sprite_delta [i&1][i>>1] = sprite_delta [i&1][i>>1];

    }

    return 0;

overflow:

    memset(ctx->sprite_offset, 0, sizeof(ctx->sprite_offset));

    memset(ctx->sprite_delta,  0, sizeof(ctx->sprite_delta));

    return AVERROR_PATCHWELCOME;

}

static int decode_new_pred(Mpeg4DecContext *ctx, GetBitContext *gb) {

    int len = FFMIN(ctx->time_increment_bits + 3, 15);

    get_bits(gb, len);

    if (get_bits1(gb))

        get_bits(gb, len);

    check_marker(ctx->h.c.avctx, gb, "after new_pred");

    return 0;

}

/**

 * Decode the next video packet.

 * @return <0 if something went wrong

 */

int ff_mpeg4_decode_video_packet_header(H263DecContext *const h)

{

    Mpeg4DecContext *const ctx = h263_to_mpeg4(h);

    int mb_num_bits      = av_log2(h->c.mb_num - 1) + 1;

    int header_extension = 0, mb_num, len;

    /* is there enough space left for a video packet + header */

    if (get_bits_count(&h->gb) > h->gb.size_in_bits - 20)

        return AVERROR_INVALIDDATA;

    for (len = 0; len < 32; len++)

        if (get_bits1(&h->gb))

            break;

    if (len != ff_mpeg4_get_video_packet_prefix_length(h->c.pict_type, ctx->f_code, ctx->b_code)) {

        av_log(h->c.avctx, AV_LOG_ERROR, "marker does not match f_code\n");

        return AVERROR_INVALIDDATA;

    }

    if (ctx->shape != RECT_SHAPE) {

        header_extension = get_bits1(&h->gb);

        // FIXME more stuff here

    }

    mb_num = get_bits(&h->gb, mb_num_bits);

    if (mb_num >= h->c.mb_num || !mb_num) {

        av_log(h->c.avctx, AV_LOG_ERROR,

               "illegal mb_num in video packet (%d %d) \n", mb_num, h->c.mb_num);

        return AVERROR_INVALIDDATA;

    }

    h->c.mb_x = mb_num % h->c.mb_width;

    h->c.mb_y = mb_num / h->c.mb_width;

    if (ctx->shape != BIN_ONLY_SHAPE) {

        int qscale = get_bits(&h->gb, ctx->quant_precision);

        if (qscale)

            h->c.chroma_qscale = h->c.qscale = qscale;

    }

    if (ctx->shape == RECT_SHAPE)

        header_extension = get_bits1(&h->gb);

    if (header_extension) {

        while (get_bits1(&h->gb) != 0)

            ;

        check_marker(h->c.avctx, &h->gb, "before time_increment in video packed header");

        skip_bits(&h->gb, ctx->time_increment_bits);      /* time_increment */

        check_marker(h->c.avctx, &h->gb, "before vop_coding_type in video packed header");

        skip_bits(&h->gb, 2); /* vop coding type */

        // FIXME not rect stuff here

        if (ctx->shape != BIN_ONLY_SHAPE) {

            skip_bits(&h->gb, 3); /* intra dc vlc threshold */

            // FIXME don't just ignore everything

            if (h->c.pict_type == AV_PICTURE_TYPE_S &&

                ctx->vol_sprite_usage == GMC_SPRITE) {

                if (mpeg4_decode_sprite_trajectory(ctx, &h->gb) < 0)

                    return AVERROR_INVALIDDATA;

                av_log(h->c.avctx, AV_LOG_ERROR, "untested\n");

            }

            // FIXME reduced res stuff here

            if (h->c.pict_type != AV_PICTURE_TYPE_I) {

                int f_code = get_bits(&h->gb, 3);       /* fcode_for */

                if (f_code == 0)

                    av_log(h->c.avctx, AV_LOG_ERROR,

                           "Error, video packet header damaged (f_code=0)\n");

            }

            if (h->c.pict_type == AV_PICTURE_TYPE_B) {

                int b_code = get_bits(&h->gb, 3);

                if (b_code == 0)

                    av_log(h->c.avctx, AV_LOG_ERROR,

                           "Error, video packet header damaged (b_code=0)\n");

            }

        }

    }

    if (ctx->new_pred)

        decode_new_pred(ctx, &h->gb);

    return 0;

}

static void reset_studio_dc_predictors(Mpeg4DecContext *const ctx)

{

    H263DecContext *const h = &ctx->h;

    /* Reset DC Predictors */

    h->last_dc[0] =

    h->last_dc[1] =

    h->last_dc[2] = 1 << (h->c.avctx->bits_per_raw_sample + ctx->dct_precision + h->c.intra_dc_precision - 1);

}

/**

 * Decode the next video packet.

 * @return <0 if something went wrong

 */

int ff_mpeg4_decode_studio_slice_header(H263DecContext *const h)

{

    Mpeg4DecContext *const ctx = h263_to_mpeg4(h);

    GetBitContext *gb = &h->gb;

    unsigned vlc_len;

    uint16_t mb_num;

    if (get_bits_left(gb) >= 32 && get_bits_long(gb, 32) == SLICE_STARTCODE) {

        vlc_len = av_log2(h->c.mb_width * h->c.mb_height) + 1;

        mb_num = get_bits(gb, vlc_len);

        if (mb_num >= h->c.mb_num)

            return AVERROR_INVALIDDATA;

        h->c.mb_x = mb_num % h->c.mb_width;

        h->c.mb_y = mb_num / h->c.mb_width;

        if (ctx->shape != BIN_ONLY_SHAPE)

            h->c.qscale = mpeg_get_qscale(&h->gb, h->c.q_scale_type);

        if (get_bits1(gb)) {  /* slice_extension_flag */

            skip_bits1(gb);   /* intra_slice */

            skip_bits1(gb);   /* slice_VOP_id_enable */

            skip_bits(gb, 6); /* slice_VOP_id */

            while (get_bits1(gb)) /* extra_bit_slice */

                skip_bits(gb, 8); /* extra_information_slice */

        }

        reset_studio_dc_predictors(ctx);

    }

    else {

        return AVERROR_INVALIDDATA;

    }

    return 0;

}

/**

 * Get the average motion vector for a GMC MB.

 * @param n either 0 for the x component or 1 for y

 * @return the average MV for a GMC MB

 */

static inline int get_amv(Mpeg4DecContext *ctx, int n)

{

    MPVContext *const s = &ctx->h.c;

    int x, y, mb_v, sum, dx, dy, shift;

    int len     = 1 << (ctx->f_code + 4);

    const int a = ctx->sprite_warping_accuracy;

    if (s->workaround_bugs & FF_BUG_AMV)

        len >>= s->quarter_sample;

    if (ctx->real_sprite_warping_points == 1) {

        if (ctx->divx_version == 500 && ctx->divx_build == 413 && a >= s->quarter_sample)

            sum = ctx->sprite_offset[0][n] / (1 << (a - s->quarter_sample));

        else

            sum = RSHIFT(ctx->sprite_offset[0][n] * (1 << s->quarter_sample), a);

    } else {

        dx    = ctx->sprite_delta[n][0];

        dy    = ctx->sprite_delta[n][1];

        shift = ctx->sprite_shift[0];

        if (n)

            dy -= 1 << (shift + a + 1);

        else

            dx -= 1 << (shift + a + 1);

        mb_v = ctx->sprite_offset[0][n] + dx * s->mb_x * 16U + dy * s->mb_y * 16U;

        sum = 0;

        for (y = 0; y < 16; y++) {

            int v;

            v = mb_v + (unsigned)dy * y;

            // FIXME optimize

            for (x = 0; x < 16; x++) {

                sum += v >> shift;

                v   += dx;

            }

        }

        sum = RSHIFT(sum, a + 8 - s->quarter_sample);

    }

    if (sum < -len)

        sum = -len;

    else if (sum >= len)

        sum = len - 1;

    return sum;

}

/**

 * Predict the dc.

 * @param n block index (0-3 are luma, 4-5 are chroma)

 * @param dir_ptr pointer to an integer where the prediction direction will be stored

 */

static inline int mpeg4_pred_dc(MpegEncContext *s, int n, int *dir_ptr)

{

    const int16_t *const dc_val = s->dc_val + s->block_index[n];

    const int wrap = s->block_wrap[n];

    int pred;

    /* find prediction */

    /* B C

     * A X

     */

    int a = dc_val[-1];

    int b = dc_val[-1 - wrap];

    int c = dc_val[-wrap];

    /* outside slice handling (we can't do that by memset as we need the

     * dc for error resilience) */

    if (s->first_slice_line && n != 3) {

        if (n != 2)

            b = c = 1024;

        if (n != 1 && s->mb_x == s->resync_mb_x)

            b = a = 1024;

    }

    if (s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y + 1) {

        if (n == 0 || n == 4 || n == 5)

            b = 1024;

    }

    if (abs(a - b) < abs(b - c)) {

        pred     = c;

        *dir_ptr = 1; /* top */

    } else {

        pred     = a;

        *dir_ptr = 0; /* left */

    }

    return pred;

}

static inline int mpeg4_get_level_dc(MpegEncContext *s, int n, int pred, int level)

{

    int scale = n < 4 ? s->y_dc_scale : s->c_dc_scale;

    int ret;

    if (IS_3IV1)

        scale = 8;

    /* we assume pred is positive */

    pred = FASTDIV((pred + (scale >> 1)), scale);

    level += pred;

    ret    = level;

    level *= scale;

    if (level & (~2047)) {

        if (s->avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) {

            if (level < 0) {

                av_log(s->avctx, AV_LOG_ERROR,

                       "dc<0 at %dx%d\n", s->mb_x, s->mb_y);

                return AVERROR_INVALIDDATA;

            }

            if (level > 2048 + scale) {

                av_log(s->avctx, AV_LOG_ERROR,

                       "dc overflow at %dx%d\n", s->mb_x, s->mb_y);

                return AVERROR_INVALIDDATA;

            }

        }

        if (level < 0)

            level = 0;

        else if (!(s->workaround_bugs & FF_BUG_DC_CLIP))

            level = 2047;

    }

    s->dc_val[s->block_index[n]] = level;

    return ret;

}

/**

 * Decode the dc value.

 * @param n block index (0-3 are luma, 4-5 are chroma)

 * @param dir_ptr the prediction direction will be stored here

 * @return the quantized dc

 */

static inline int mpeg4_decode_dc(H263DecContext *const h, int n, int *dir_ptr)

{

    int level, code, pred;

    if (n < 4)

        code = get_vlc2(&h->gb, dc_lum, DC_VLC_BITS, 1);

    else

        code = get_vlc2(&h->gb, dc_chrom, DC_VLC_BITS, 1);

    if (code < 0) {

        av_log(h->c.avctx, AV_LOG_ERROR, "illegal dc vlc\n");

        return AVERROR_INVALIDDATA;

    }

    if (code == 0) {

        level = 0;

    } else {

        if (IS_3IV1) {

            if (code == 1)

                level = 2 * get_bits1(&h->gb) - 1;

            else {

                if (get_bits1(&h->gb))

                    level = get_bits(&h->gb, code - 1) + (1 << (code - 1));

                else

                    level = -get_bits(&h->gb, code - 1) - (1 << (code - 1));

            }

        } else {

            level = get_xbits(&h->gb, code);

        }

        if (code > 8) {

            if (get_bits1(&h->gb) == 0) { /* marker */

                if (h->c.avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)) {

                    av_log(h->c.avctx, AV_LOG_ERROR, "dc marker bit missing\n");

                    return AVERROR_INVALIDDATA;

                }

            }

        }

    }

    pred = mpeg4_pred_dc(&h->c, n, dir_ptr);

    return mpeg4_get_level_dc(&h->c, n, pred, level);

}

/**