/*

 * Indeo Video v3 compatible decoder

 * Copyright (c) 2009 - 2011 Maxim Poliakovski

 *

 * 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

 */

/**

 * @file

 * This is a decoder for Intel Indeo Video v3.

 * It is based on vector quantization, run-length coding and motion compensation.

 * Known container formats: .avi and .mov

 * Known FOURCCs: 'IV31', 'IV32'

 *

 * @see http://wiki.multimedia.cx/index.php?title=Indeo_3

 */

#include "libavutil/imgutils.h"

#include "libavutil/intreadwrite.h"

#include "avcodec.h"

#include "copy_block.h"

#include "bytestream.h"

#include "get_bits.h"

#include "hpeldsp.h"

#include "internal.h"

#include "indeo3data.h"

/* RLE opcodes. */

enum {

    RLE_ESC_F9    = 249, ///< same as RLE_ESC_FA + do the same with next block

    RLE_ESC_FA    = 250, ///< INTRA: skip block, INTER: copy data from reference

    RLE_ESC_FB    = 251, ///< apply null delta to N blocks / skip N blocks

    RLE_ESC_FC    = 252, ///< same as RLE_ESC_FD + do the same with next block

    RLE_ESC_FD    = 253, ///< apply null delta to all remaining lines of this block

    RLE_ESC_FE    = 254, ///< apply null delta to all lines up to the 3rd line

    RLE_ESC_FF    = 255  ///< apply null delta to all lines up to the 2nd line

};

/* Some constants for parsing frame bitstream flags. */

#define BS_8BIT_PEL     (1 << 1) ///< 8-bit pixel bitdepth indicator

#define BS_KEYFRAME     (1 << 2) ///< intra frame indicator

#define BS_MV_Y_HALF    (1 << 4) ///< vertical mv halfpel resolution indicator

#define BS_MV_X_HALF    (1 << 5) ///< horizontal mv halfpel resolution indicator

#define BS_NONREF       (1 << 8) ///< nonref (discardable) frame indicator

#define BS_BUFFER        9       ///< indicates which of two frame buffers should be used

typedef struct Plane {

    uint8_t         *buffers[2];

    uint8_t         *pixels[2]; ///< pointer to the actual pixel data of the buffers above

    uint32_t        width;

    uint32_t        height;

    ptrdiff_t       pitch;

} Plane;

#define CELL_STACK_MAX  20

typedef struct Cell {

    int16_t         xpos;       ///< cell coordinates in 4x4 blocks

    int16_t         ypos;

    int16_t         width;      ///< cell width  in 4x4 blocks

    int16_t         height;     ///< cell height in 4x4 blocks

    uint8_t         tree;       ///< tree id: 0- MC tree, 1 - VQ tree

    const int8_t    *mv_ptr;    ///< ptr to the motion vector if any

} Cell;

typedef struct Indeo3DecodeContext {

    AVCodecContext *avctx;

    HpelDSPContext  hdsp;

    GetBitContext   gb;

    int             need_resync;

    int             skip_bits;

    const uint8_t   *next_cell_data;

    const uint8_t   *last_byte;

    const int8_t    *mc_vectors;

    unsigned        num_vectors;    ///< number of motion vectors in mc_vectors

    int16_t         width, height;

    uint32_t        frame_num;      ///< current frame number (zero-based)

    int             data_size;      ///< size of the frame data in bytes

    uint16_t        frame_flags;    ///< frame properties

    uint8_t         cb_offset;      ///< needed for selecting VQ tables

    uint8_t         buf_sel;        ///< active frame buffer: 0 - primary, 1 -secondary

    const uint8_t   *y_data_ptr;

    const uint8_t   *v_data_ptr;

    const uint8_t   *u_data_ptr;

    int32_t         y_data_size;

    int32_t         v_data_size;

    int32_t         u_data_size;

    const uint8_t   *alt_quant;     ///< secondary VQ table set for the modes 1 and 4

    Plane           planes[3];

} Indeo3DecodeContext;

static uint8_t requant_tab[8][128];

/*

 *  Build the static requantization table.

 *  This table is used to remap pixel values according to a specific

 *  quant index and thus avoid overflows while adding deltas.

 */

{

    static const int8_t offsets[8] = { 1, 1, 2, -3, -3, 3, 4, 4 };

    static const int8_t deltas [8] = { 0, 1, 0,  4,  4, 1, 0, 1 };

    int i, j, step;

    }

    /* some last elements calculated above will have values >= 128 */

    /* pixel values shall never exceed 127 so set them to non-overflowing values */

    /* according with the quantization step of the respective section */

    /* Patch for compatibility with the Intel's binary decoders */

{

    int p;

    }

                                          AVCodecContext *avctx, int luma_width, int luma_height)

{

    int p, chroma_width, chroma_height;

    int luma_size, chroma_size;

    ptrdiff_t luma_pitch, chroma_pitch;

               luma_width, luma_height);

    }

    /* Calculate size of the luminance plane.  */

    /* Add one line more for INTRA prediction. */

    /* Calculate size of a chrominance planes. */

    /* Add one line more for INTRA prediction. */

    /* allocate frame buffers */

        }

        /* fill the INTRA prediction lines with the middle pixel value = 64 */

        /* set buffer pointers = buf_ptr + pitch and thus skip the INTRA prediction line */

    }

}

/**

 *  Copy pixels of the cell(x + mv_x, y + mv_y) from the previous frame into

 *  the cell(x, y) in the current frame.

 *

 *  @param ctx      pointer to the decoder context

 *  @param plane    pointer to the plane descriptor

 *  @param cell     pointer to the cell  descriptor

 */

{

    int     h, w, mv_x, mv_y, offset, offset_dst;

    uint8_t *src, *dst;

    /* setup output and reference pointers */

    }else

    /* -1 because there is an extra line on top for prediction */

               "Motion vectors point out of the frame.\n");

    }

        /* copy using 16xH blocks */

        }

        /* copy using 8xH blocks */

        }

    }

}

/* Average 4/8 pixels at once without rounding using SWAR */

#define AVG_32(dst, src, ref) \

    AV_WN32A(dst, ((AV_RN32(src) + AV_RN32(ref)) >> 1) & 0x7F7F7F7FUL)

#define AVG_64(dst, src, ref) \

    AV_WN64A(dst, ((AV_RN64(src) + AV_RN64(ref)) >> 1) & 0x7F7F7F7F7F7F7F7FULL)

/*

 *  Replicate each even pixel as follows:

 *  ABCDEFGH -> AACCEEGG

 */

#if HAVE_BIGENDIAN

    a &= 0xFF00FF00FF00FF00ULL;

    a |= a >> 8;

#else

#endif

}

#if HAVE_BIGENDIAN

    a &= 0xFF00FF00UL;

    a |= a >> 8;

#else

#endif

}

/* Fill n lines with 64-bit pixel value pix */

                           int32_t row_offset)

{

/* Error codes for cell decoding. */

enum {

    IV3_NOERR       = 0,

    IV3_BAD_RLE     = 1,

    IV3_BAD_DATA    = 2,

    IV3_BAD_COUNTER = 3,

    IV3_UNSUPPORTED = 4,

    IV3_OUT_OF_DATA = 5

};

#define BUFFER_PRECHECK \

if (*data_ptr >= last_ptr) \

    return IV3_OUT_OF_DATA; \

#define RLE_BLOCK_COPY \

    if (cell->mv_ptr || !skip_flag) \

        copy_block4(dst, ref, row_offset, row_offset, 4 << v_zoom)

#define RLE_BLOCK_COPY_8 \

    pix64 = AV_RN64(ref);\

    if (is_first_row) {/* special prediction case: top line of a cell */\

        pix64 = replicate64(pix64);\

        fill_64(dst + row_offset, pix64, 7, row_offset);\

        AVG_64(dst, ref, dst + row_offset);\

    } else \

        fill_64(dst, pix64, 8, row_offset)

#define RLE_LINES_COPY \

    copy_block4(dst, ref, row_offset, row_offset, num_lines << v_zoom)

#define RLE_LINES_COPY_M10 \

    pix64 = AV_RN64(ref);\

    if (is_top_of_cell) {\

        pix64 = replicate64(pix64);\

        fill_64(dst + row_offset, pix64, (num_lines << 1) - 1, row_offset);\

        AVG_64(dst, ref, dst + row_offset);\

    } else \

        fill_64(dst, pix64, num_lines << 1, row_offset)

#define APPLY_DELTA_4 \

    AV_WN16A(dst + line_offset    ,\

             (AV_RN16(ref    ) + delta_tab->deltas[dyad1]) & 0x7F7F);\

    AV_WN16A(dst + line_offset + 2,\

             (AV_RN16(ref + 2) + delta_tab->deltas[dyad2]) & 0x7F7F);\

    if (mode >= 3) {\

        if (is_top_of_cell && !cell->ypos) {\

            AV_COPY32U(dst, dst + row_offset);\

        } else {\

            AVG_32(dst, ref, dst + row_offset);\

        }\

    }

#define APPLY_DELTA_8 \

    /* apply two 32-bit VQ deltas to next even line */\

    if (is_top_of_cell) { \

        AV_WN32A(dst + row_offset    , \

                 (replicate32(AV_RN32(ref    )) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\

        AV_WN32A(dst + row_offset + 4, \

                 (replicate32(AV_RN32(ref + 4)) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\

    } else { \

        AV_WN32A(dst + row_offset    , \

                 (AV_RN32(ref    ) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\

        AV_WN32A(dst + row_offset + 4, \

                 (AV_RN32(ref + 4) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\

    } \

    /* odd lines are not coded but rather interpolated/replicated */\

    /* first line of the cell on the top of image? - replicate */\

    /* otherwise - interpolate */\

    if (is_top_of_cell && !cell->ypos) {\

        AV_COPY64U(dst, dst + row_offset);\

    } else \

        AVG_64(dst, ref, dst + row_offset);

#define APPLY_DELTA_1011_INTER \

    if (mode == 10) { \

        AV_WN32A(dst                 , \

                 (AV_RN32(dst                 ) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\

        AV_WN32A(dst + 4             , \

                 (AV_RN32(dst + 4             ) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\

        AV_WN32A(dst + row_offset    , \

                 (AV_RN32(dst + row_offset    ) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\

        AV_WN32A(dst + row_offset + 4, \

                 (AV_RN32(dst + row_offset + 4) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\

    } else { \

        AV_WN16A(dst                 , \

                 (AV_RN16(dst                 ) + delta_tab->deltas[dyad1]) & 0x7F7F);\

        AV_WN16A(dst + 2             , \

                 (AV_RN16(dst + 2             ) + delta_tab->deltas[dyad2]) & 0x7F7F);\

        AV_WN16A(dst + row_offset    , \

                 (AV_RN16(dst + row_offset    ) + delta_tab->deltas[dyad1]) & 0x7F7F);\

        AV_WN16A(dst + row_offset + 2, \

                 (AV_RN16(dst + row_offset + 2) + delta_tab->deltas[dyad2]) & 0x7F7F);\

    }

                            uint8_t *block, uint8_t *ref_block,

                            ptrdiff_t row_offset, int h_zoom, int v_zoom, int mode,

                            const vqEntry *delta[2], int swap_quads[2],

                            const uint8_t **data_ptr, const uint8_t *last_ptr)

{

    int           x, y, line, num_lines;

    uint8_t       code, *dst, *ref;

    const vqEntry *delta_tab;

    unsigned int  dyad1, dyad2;

    uint64_t      pix64;

    int           blk_row_offset, line_offset;

                }

            } else {

                    /* select primary VQ table for odd, secondary for even lines */

                    else

                        } else {

                            /* process QUADS */

                        }

                        } else {

                        }

                    } else {

                        /* process RLE codes */

                            /* FALLTHROUGH */

                        case RLE_ESC_FE:

                        case RLE_ESC_FD:

                            }

                                }

                            }

                            /* FALLTHROUGH */

                                }

                            }

                        }

                    }

                }

            }

            /* move to next horizontal block */

        }

        /* move to next line of blocks */

    }

}

/**

 *  Decode a vector-quantized cell.

 *  It consists of several routines, each of which handles one or more "modes"

 *  with which a cell can be encoded.

 *

 *  @param ctx      pointer to the decoder context

 *  @param avctx    ptr to the AVCodecContext

 *  @param plane    pointer to the plane descriptor

 *  @param cell     pointer to the cell  descriptor

 *  @param data_ptr pointer to the compressed data

 *  @param last_ptr pointer to the last byte to catch reads past end of buffer

 *  @return         number of consumed bytes or negative number in case of error

 */

                       Plane *plane, Cell *cell, const uint8_t *data_ptr,

                       const uint8_t *last_ptr)

{

    int           x, mv_x, mv_y, mode, vq_index, prim_indx, second_indx;

    int           zoom_fac;

    const vqEntry *delta[2];

    /* get coding mode and VQ table index from the VQ descriptor byte */

    /* setup output and reference pointers */

        /* use previous line as reference for INTRA cells */

        /* for mode 10 and 11 INTER first copy the predicted cell into the current one */

        /* so we don't need to do data copying for each RLE code later */

    } else {

        /* set the pointer to the reference pixels for modes 0-4 INTER */

        /* -1 because there is an extra line on top for prediction */

                   "Motion vectors point out of the frame.\n");

        }

    }

    /* select VQ tables as follows: */

    /* modes 0 and 3 use only the primary table for all lines in a block */

    /* while modes 1 and 4 switch between primary and secondary tables on alternate lines */

    } else {

    }

               prim_indx, second_indx);

    }

    /* requantize the prediction if VQ index of this cell differs from VQ index */

    /* of the predicted cell in order to avoid overflows. */

    }

    case 1:

    case 3: /*------------------ MODES 3 & 4 (4x8 block processing) --------------------*/

    case 4:

        }

                                 0, zoom_fac, mode, delta, swap_quads,

                                 &data_ptr, last_ptr);

    case 11: /*----------------- MODE 11 (4x8 INTER block processing) ------------------*/

                                     1, 1, mode, delta, swap_quads,

                                     &data_ptr, last_ptr);

        } else { /* mode 10 and 11 INTER processing */

            }

                                     zoom_fac, 1, mode, delta, swap_quads,

                                     &data_ptr, last_ptr);

        }

    }//switch mode

    }

}

/* Binary tree codes. */

enum {

    H_SPLIT    = 0,

    V_SPLIT    = 1,

    INTRA_NULL = 2,

    INTER_DATA = 3

};

#define SPLIT_CELL(size, new_size) (new_size) = ((size) > 2) ? ((((size) + 2) >> 2) << 1) : 1

#define UPDATE_BITPOS(n) \

    ctx->skip_bits  += (n); \

    ctx->need_resync = 1

#define RESYNC_BITSTREAM \

    if (ctx->need_resync && !(get_bits_count(&ctx->gb) & 7)) { \

        skip_bits_long(&ctx->gb, ctx->skip_bits);              \

        ctx->skip_bits   = 0;                                  \

        ctx->need_resync = 0;                                  \

    }

#define CHECK_CELL \

    if (curr_cell.xpos + curr_cell.width > (plane->width >> 2) ||               \

        curr_cell.ypos + curr_cell.height > (plane->height >> 2)) {             \

        av_log(avctx, AV_LOG_ERROR, "Invalid cell: x=%d, y=%d, w=%d, h=%d\n",   \

               curr_cell.xpos, curr_cell.ypos, curr_cell.width, curr_cell.height); \

        return AVERROR_INVALIDDATA;                                                              \

    }

                         Plane *plane, int code, Cell *ref_cell,

                         const int depth, const int strip_width)

{

    Cell    curr_cell;

    int     bytes_used, ret;

    }

            /* split strip */

        } else

    }

        case V_SPLIT:

            } else { /* VQ tree NULL code */

                }

            }

                unsigned mv_idx;

                /* get motion vector index and setup the pointer to the mv set */

                }

                }

            } else { /* VQ tree DATA code */

                                         ctx->next_cell_data, ctx->last_byte);

            }

        }

}

                        Plane *plane, const uint8_t *data, int32_t data_size,

                        int32_t strip_width)

{

    Cell            curr_cell;

    unsigned        num_vectors;

    /* each plane data starts with mc_vector_count field, */

    /* an optional array of motion vectors followed by the vq data */

               "Read invalid number of motion vectors %d\n", num_vectors);

    }

    /* init the bitreader */

    /* initialize the 1st cell and set its dimensions to whole plane */

}

#define OS_HDR_ID   MKBETAG('F', 'R', 'M', 'H')

                                const uint8_t *buf, int buf_size)

{

    GetByteContext gb;

    const uint8_t   *bs_hdr;

    uint32_t        frame_num, word2, check_sum, data_size;

    int             y_offset, u_offset, v_offset;

    uint32_t        starts[3], ends[3];

    uint16_t        height, width;

    int             i, j;

    /* parse and check the OS header */

    }

    /* parse the bitstream header */

    }

    /* check frame dimensions */

        int res;

        ff_dlog(avctx, "Frame dimensions changed!\n");