winamp/Src/mpeg4dec/mp4def.h

/* ///////////////////////////////////////////////////////////////////////
//
//               INTEL CORPORATION PROPRIETARY INFORMATION
//  This software is supplied under the terms of a license agreement or
//  nondisclosure agreement with Intel Corporation and may not be copied
//  or disclosed except in accordance with the terms of that agreement.
//        Copyright (c) 2001-2008 Intel Corporation. All Rights Reserved.
//
//  Description:    MPEG-4 header.
//
*/

#pragma once

#include <bfc/platform/types.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "../tools/staticlib/ipp_px.h"
#include "ippdefs.h"
#include "ippcore.h"
#include "ipps.h"
#include "ippi.h"
#include "ippvc.h"
//#include "vm_debug.h"
//#include "vm_thread.h"

#pragma warning(disable : 4710) // function not inlined
#pragma warning(disable : 4514) // unreferenced inline function has been removed CL
#pragma warning(disable : 4100) // unreferenced formal parameter CL

#ifdef __cplusplus
extern "C" {
#endif

//#define USE_INLINE_BITS_FUNC
#define USE_NOTCODED_STATE

#if defined(__INTEL_COMPILER) || defined(_MSC_VER)
    #define __INLINE static __inline
#elif defined( __GNUC__ )
    #define __INLINE static __inline__
#else
    #define __INLINE static
#endif

#if defined(__INTEL_COMPILER) && !defined(_WIN32_WCE)
    #define __ALIGN16(type, name, size) \
        __declspec (align(16)) type name[size]
#else
    #if defined(_WIN64) || defined(WIN64) || defined(LINUX64)
        #define __ALIGN16(type, name, size) \
            uint8_t _a16_##name[(size)*sizeof(type)+15]; type *name = (type*)(((int64_t)(_a16_##name) + 15) & ~15)
    #else
        #define __ALIGN16(type, name, size) \
            uint8_t _a16_##name[(size)*sizeof(type)+15]; type *name = (type*)(((int32_t)(_a16_##name) + 15) & ~15)
    #endif
#endif

#define mp4_CLIP(x, min, max) if ((x) < (min)) (x) = (min); else if ((x) > (max)) (x) = (max)
#define mp4_CLIPR(x, max) if ((x) > (max)) (x) = (max)
#define mp4_SWAP(type, x, y) {mp4_Frame *t = (x); (x) = (y); (y) = t;}
#define mp4_ABS(a) ((a) >= 0 ? (a) : -(a))

/* Timer Info */
#if defined(_WIN32) || defined(_WIN64) || defined(WIN32) || defined(WIN64)

#include <windows.h>

    typedef struct _mp4_Timer {
        LARGE_INTEGER  count;
        LARGE_INTEGER  start;
        LARGE_INTEGER  stop;
        int32_t         calls;
    } mp4_Timer;

    __INLINE void mp4_TimerStart(mp4_Timer *t)
    {
        QueryPerformanceCounter(&t->start);
    }

    __INLINE void mp4_TimerStop(mp4_Timer *t)
    {
        QueryPerformanceCounter(&t->stop);
        t->count.QuadPart += t->stop.QuadPart - t->start.QuadPart;
        t->calls ++;
    }

#define TIMER_FREQ_TYPE LARGE_INTEGER

    __INLINE void mp4_GetTimerFreq(TIMER_FREQ_TYPE *f)
    {
        QueryPerformanceFrequency(f);
    }

    __INLINE double mp4_GetTimerSec(mp4_Timer *t, TIMER_FREQ_TYPE f)
    {
        return (double)t->count.QuadPart / (double)f.QuadPart;
    }

#else  // LINUX

#include <time.h>

    typedef struct _mp4_Timer {
        clock_t  count;
        clock_t  start;
        clock_t  stop;
        int32_t   calls;
    } mp4_Timer;

    __INLINE void mp4_TimerStart(mp4_Timer *t)
    {
        t->start = clock();
    }

    __INLINE void mp4_TimerStop(mp4_Timer *t)
    {
        t->stop = clock();
        t->count += t->stop - t->start;
        t->calls ++;
    }

#define TIMER_FREQ_TYPE int32_t

    __INLINE void mp4_GetTimerFreq(TIMER_FREQ_TYPE *f)
    {
        *f = CLOCKS_PER_SEC;
    }

    __INLINE double mp4_GetTimerSec(mp4_Timer *t, TIMER_FREQ_TYPE f)
    {
        return (double)t->count / (double)f;
    }

#endif

/* number of exterior MB */
#define MP4_NUM_EXT_MB 1

/* Statistic Info */
typedef struct _mp4_Statistic {
    // VideoObjectLayer Info
    int32_t      nVOP;
    int32_t      nVOP_I;
    int32_t      nVOP_P;
    int32_t      nVOP_B;
    int32_t      nVOP_S;
    int32_t      nMB;
    int32_t      nMB_INTER;
    int32_t      nMB_INTER_Q;
    int32_t      nMB_INTRA;
    int32_t      nMB_INTRA_Q;
    int32_t      nMB_INTER4V;
    int32_t      nMB_DIRECT;
    int32_t      nMB_INTERPOLATE;
    int32_t      nMB_BACKWARD;
    int32_t      nMB_FORWARD;
    int32_t      nMB_NOTCODED;
    int32_t      nB_INTRA_DC;
    int32_t      nB_INTRA_AC;
    int32_t      nB_INTER_C;
    int32_t      nB_INTER_NC;
    // app Timing Info
    mp4_Timer   time_DecodeShow;    // decode + draw + file reading
    mp4_Timer   time_Decode;        // decode + file reading
    mp4_Timer   time_DecodeOnly;    // decode only
} mp4_Statistic;

__INLINE void mp4_StatisticInc(int32_t *s)
{
    *s = (*s) + 1;
}

// when using Full Statistic, FPS is less
#ifdef MP4_FULL_STAT
#define mp4_StatisticInc_(s) mp4_StatisticInc(s)
#define mp4_TimerStart_(t) mp4_TimerStart(t)
#define mp4_TimerStop_(t) mp4_TimerStop(t)
#else
#define mp4_StatisticInc_(s)
#define mp4_TimerStart_(t)
#define mp4_TimerStop_(t)
#endif

/* status codes */
typedef enum {
    MP4_STATUS_OK           =  0,   // no error
    MP4_STATUS_NO_MEM       = -1,   // out of memory
    MP4_STATUS_FILE_ERROR   = -2,   // file error
    MP4_STATUS_NOTSUPPORT   = -3,   // not supported mode
    MP4_STATUS_PARSE_ERROR  = -4,   // fail in parse MPEG-4 stream
    MP4_STATUS_ERROR        = -5    // unknown/unspecified error
} mp4_Status;

/* MPEG-4 start code values */
// ISO/IEC 14496-2: table 6-3
enum {
    MP4_VIDEO_OBJECT_MIN_SC       = 0x00,
    MP4_VIDEO_OBJECT_MAX_SC       = 0x1F,
    MP4_VIDEO_OBJECT_LAYER_MIN_SC = 0x20,
    MP4_VIDEO_OBJECT_LAYER_MAX_SC = 0x2F,
    MP4_FGS_BP_MIN_SC             = 0x40,
    MP4_FGS_BP_MAX_SC             = 0x5F,
    MP4_VISUAL_OBJECT_SEQUENCE_SC = 0xB0,
    MP4_VISUAL_OBJECT_SEQUENCE_EC = 0xB1,
    MP4_USER_DATA_SC              = 0xB2,
    MP4_GROUP_OF_VOP_SC           = 0xB3,
    MP4_VIDEO_SESSION_ERROR_SC    = 0xB4,
    MP4_VISUAL_OBJECT_SC          = 0xB5,
    MP4_VIDEO_OBJECT_PLANE_SC     = 0xB6,
    MP4_SLICE_SC                  = 0xB7,
    MP4_EXTENSION_SC              = 0xB8,
    MP4_FGS_VOP_SC                = 0xB9,
    MP4_FBA_OBJECT_SC             = 0xBA,
    MP4_FBA_OBJECT_PLANE_SC       = 0xBB,
    MP4_MESH_OBJECT_SC            = 0xBC,
    MP4_MESH_OBJECT_PLANE_SC      = 0xBD,
    MP4_STILL_TEXTURE_OBJECT_SC   = 0xBE,
    MP4_TEXTURE_SPATIAL_LAYER_SC  = 0xBF,
    MP4_TEXTURE_SNR_LAYER_SC      = 0xC0,
    MP4_TEXTURE_TILE_SC           = 0xC1,
    MP4_TEXTURE_SHAPE_LAYER_SC    = 0xC2,
    MP4_STUFFING_SC               = 0xC3
};

/* MPEG-4 code values */
// ISO/IEC 14496-2:2004 table 6-6
enum {
    MP4_VISUAL_OBJECT_TYPE_VIDEO     = 1,
    MP4_VISUAL_OBJECT_TYPE_TEXTURE   = 2,
    MP4_VISUAL_OBJECT_TYPE_MESH      = 3,
    MP4_VISUAL_OBJECT_TYPE_FBA       = 4,
    MP4_VISUAL_OBJECT_TYPE_3DMESH    = 5
};

// ISO/IEC 14496-2:2004 table 6-7
enum {
    MP4_VIDEO_FORMAT_COMPONENT      = 0,
    MP4_VIDEO_FORMAT_PAL            = 1,
    MP4_VIDEO_FORMAT_NTSC           = 2,
    MP4_VIDEO_FORMAT_SECAM          = 3,
    MP4_VIDEO_FORMAT_MAC            = 4,
    MP4_VIDEO_FORMAT_UNSPECIFIED    = 5
};

// ISO/IEC 14496-2:2004 table 6-8..10
enum {
    MP4_VIDEO_COLORS_FORBIDDEN         = 0,
    MP4_VIDEO_COLORS_ITU_R_BT_709      = 1,
    MP4_VIDEO_COLORS_UNSPECIFIED       = 2,
    MP4_VIDEO_COLORS_RESERVED          = 3,
    MP4_VIDEO_COLORS_ITU_R_BT_470_2_M  = 4,
    MP4_VIDEO_COLORS_ITU_R_BT_470_2_BG = 5,
    MP4_VIDEO_COLORS_SMPTE_170M        = 6,
    MP4_VIDEO_COLORS_SMPTE_240M        = 7,
    MP4_VIDEO_COLORS_GENERIC_FILM      = 8
};

// ISO/IEC 14496-2:2004 table 6-11
enum {
    MP4_VIDEO_OBJECT_TYPE_SIMPLE                     = 1,
    MP4_VIDEO_OBJECT_TYPE_SIMPLE_SCALABLE            = 2,
    MP4_VIDEO_OBJECT_TYPE_CORE                       = 3,
    MP4_VIDEO_OBJECT_TYPE_MAIN                       = 4,
    MP4_VIDEO_OBJECT_TYPE_NBIT                       = 5,
    MP4_VIDEO_OBJECT_TYPE_2DTEXTURE                  = 6,
    MP4_VIDEO_OBJECT_TYPE_2DMESH                     = 7,
    MP4_VIDEO_OBJECT_TYPE_SIMPLE_FACE                = 8,
    MP4_VIDEO_OBJECT_TYPE_STILL_SCALABLE_TEXTURE     = 9,
    MP4_VIDEO_OBJECT_TYPE_ADVANCED_REAL_TIME_SIMPLE  = 10,
    MP4_VIDEO_OBJECT_TYPE_CORE_SCALABLE              = 11,
    MP4_VIDEO_OBJECT_TYPE_ADVANCED_CODING_EFFICIENCY = 12,
    MP4_VIDEO_OBJECT_TYPE_ADVANCED_SCALABLE_TEXTURE  = 13,
    MP4_VIDEO_OBJECT_TYPE_SIMPLE_FBA                 = 14,
    MP4_VIDEO_OBJECT_TYPE_SIMPLE_STUDIO              = 15,
    MP4_VIDEO_OBJECT_TYPE_CORE_STUDIO                = 16,
    MP4_VIDEO_OBJECT_TYPE_ADVANCED_SIMPLE            = 17,
    MP4_VIDEO_OBJECT_TYPE_FINE_GRANULARITY_SCALABLE  = 18
};

// ISO/IEC 14496-2:2004 table 6.17 (maximum defined video_object_layer_shape_extension)
#define MP4_SHAPE_EXT_NUM 13
// ISO/IEC 14496-2:2004 table 6-14
enum {
    MP4_ASPECT_RATIO_FORBIDDEN  = 0,
    MP4_ASPECT_RATIO_1_1        = 1,
    MP4_ASPECT_RATIO_12_11      = 2,
    MP4_ASPECT_RATIO_10_11      = 3,
    MP4_ASPECT_RATIO_16_11      = 4,
    MP4_ASPECT_RATIO_40_33      = 5,
    MP4_ASPECT_RATIO_EXTPAR     = 15
};

// ISO/IEC 14496-2:2004 table 6-15
#define MP4_CHROMA_FORMAT_420    1
// ISO/IEC 14496-2:2004 table 6-16
enum {
    MP4_SHAPE_TYPE_RECTANGULAR  = 0,
    MP4_SHAPE_TYPE_BINARY       = 1,
    MP4_SHAPE_TYPE_BINARYONLY   = 2,
    MP4_SHAPE_TYPE_GRAYSCALE    = 3
};

// ISO/IEC 14496-2:2004 table 6-19
#define MP4_SPRITE_STATIC   1
#define MP4_SPRITE_GMC      2
// ISO/IEC 14496-2:2004 table 6-24
enum {
    MP4_VOP_TYPE_I  = 0,
    MP4_VOP_TYPE_P  = 1,
    MP4_VOP_TYPE_B  = 2,
    MP4_VOP_TYPE_S  = 3
};

// ISO/IEC 14496-2:2004 table 6-26
enum {
    MP4_SPRITE_TRANSMIT_MODE_STOP   = 0,
    MP4_SPRITE_TRANSMIT_MODE_PIECE  = 1,
    MP4_SPRITE_TRANSMIT_MODE_UPDATE = 2,
    MP4_SPRITE_TRANSMIT_MODE_PAUSE  = 3
};

// ISO/IEC 14496-2:2004 table 7-3
enum {
    MP4_BAB_TYPE_MVDSZ_NOUPDATE  = 0,
    MP4_BAB_TYPE_MVDSNZ_NOUPDATE = 1,
    MP4_BAB_TYPE_TRANSPARENT     = 2,
    MP4_BAB_TYPE_OPAQUE          = 3,
    MP4_BAB_TYPE_INTRACAE        = 4,
    MP4_BAB_TYPE_MVDSZ_INTERCAE  = 5,
    MP4_BAB_TYPE_MVDSNZ_INTERCAE = 6
};

#define MP4_DC_MARKER  0x6B001 // 110 1011 0000 0000 0001
#define MP4_MV_MARKER  0x1F001 //   1 1111 0000 0000 0001

// ISO/IEC 14496-2:2004 table G.1
enum {
    MP4_SIMPLE_PROFILE_LEVEL_1                     = 0x01,
    MP4_SIMPLE_PROFILE_LEVEL_2                     = 0x02,
    MP4_SIMPLE_PROFILE_LEVEL_3                     = 0x03,
    MP4_SIMPLE_PROFILE_LEVEL_0                     = 0x08,
    MP4_SIMPLE_SCALABLE_PROFILE_LEVEL_0            = 0x10,
    MP4_SIMPLE_SCALABLE_PROFILE_LEVEL_1            = 0x11,
    MP4_SIMPLE_SCALABLE_PROFILE_LEVEL_2            = 0x12,
    MP4_CORE_PROFILE_LEVEL_1                       = 0x21,
    MP4_CORE_PROFILE_LEVEL_2                       = 0x22,
    MP4_MAIN_PROFILE_LEVEL_2                       = 0x32,
    MP4_MAIN_PROFILE_LEVEL_3                       = 0x33,
    MP4_MAIN_PROFILE_LEVEL_4                       = 0x34,
    MP4_NBIT_PROFILE_LEVEL_2                       = 0x42,
    MP4_SCALABLE_TEXTURE_PROFILE_LEVEL_1           = 0x51,
    MP4_SIMPLE_FACE_ANIMATION_PROFILE_LEVEL_1      = 0x61,
    MP4_SIMPLE_FACE_ANIMATION_PROFILE_LEVEL_2      = 0x62,
    MP4_SIMPLE_FBA_PROFILE_LEVEL_1                 = 0x63,
    MP4_SIMPLE_FBA_PROFILE_LEVEL_2                 = 0x64,
    MP4_BASIC_ANIMATED_TEXTURE_PROFILE_LEVEL_1     = 0x71,
    MP4_BASIC_ANIMATED_TEXTURE_PROFILE_LEVEL_2     = 0x72,
    MP4_HYBRID_PROFILE_LEVEL_1                     = 0x81,
    MP4_HYBRID_PROFILE_LEVEL_2                     = 0x82,
    MP4_ADVANCED_REAL_TIME_SIMPLE_PROFILE_LEVEL_1  = 0x91,
    MP4_ADVANCED_REAL_TIME_SIMPLE_PROFILE_LEVEL_2  = 0x92,
    MP4_ADVANCED_REAL_TIME_SIMPLE_PROFILE_LEVEL_3  = 0x93,
    MP4_ADVANCED_REAL_TIME_SIMPLE_PROFILE_LEVEL_4  = 0x94,
    MP4_CORE_SCALABLE_PROFILE_LEVEL_1              = 0xA1,
    MP4_CORE_SCALABLE_PROFILE_LEVEL_2              = 0xA2,
    MP4_CORE_SCALABLE_PROFILE_LEVEL_3              = 0xA3,
    MP4_ADVANCED_CODING_EFFICIENCY_PROFILE_LEVEL_1 = 0xB1,
    MP4_ADVANCED_CODING_EFFICIENCY_PROFILE_LEVEL_2 = 0xB2,
    MP4_ADVANCED_CODING_EFFICIENCY_PROFILE_LEVEL_3 = 0xB3,
    MP4_ADVANCED_CODING_EFFICIENCY_PROFILE_LEVEL_4 = 0xB4,
    MP4_ADVANCED_CORE_PROFILE_LEVEL_1              = 0xC1,
    MP4_ADVANCED_CORE_PROFILE_LEVEL_2              = 0xC2,
    MP4_ADVANCED_SCALABLE_TEXTURE_PROFILE_LEVEL_1  = 0xD1,
    MP4_ADVANCED_SCALABLE_TEXTURE_PROFILE_LEVEL_2  = 0xD2,
    MP4_ADVANCED_SCALABLE_TEXTURE_PROFILE_LEVEL_3  = 0xD3,
    MP4_SIMPLE_STUDIO_PROFILE_LEVEL_1              = 0xE1,
    MP4_SIMPLE_STUDIO_PROFILE_LEVEL_2              = 0xE2,
    MP4_SIMPLE_STUDIO_PROFILE_LEVEL_3              = 0xE3,
    MP4_SIMPLE_STUDIO_PROFILE_LEVEL_4              = 0xE4,
    MP4_CORE_STUDIO_PROFILE_LEVEL_1                = 0xE5,
    MP4_CORE_STUDIO_PROFILE_LEVEL_2                = 0xE6,
    MP4_CORE_STUDIO_PROFILE_LEVEL_3                = 0xE7,
    MP4_CORE_STUDIO_PROFILE_LEVEL_4                = 0xE8,
    MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_0            = 0xF0,
    MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_1            = 0xF1,
    MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_2            = 0xF2,
    MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_3            = 0xF3,
    MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_4            = 0xF4,
    MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_5            = 0xF5,
    MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_3B           = 0xF7,
    MP4_FGS_PROFILE_LEVEL_0                        = 0xF8,
    MP4_FGS_PROFILE_LEVEL_1                        = 0xF9,
    MP4_FGS_PROFILE_LEVEL_2                        = 0xFA,
    MP4_FGS_PROFILE_LEVEL_3                        = 0xFB,
    MP4_FGS_PROFILE_LEVEL_4                        = 0xFC,
    MP4_FGS_PROFILE_LEVEL_5                        = 0xFD
};

/* Frame Info */
typedef struct _mp4_Frame {
    uint8_t*      apY;        // allocated with border
    uint8_t*      apCb;       // allocated with border
    uint8_t*      apCr;       // allocated with border
    int32_t      stepY;
    int32_t      stepCr;
    int32_t      stepCb;
    uint8_t*      pY;         // real pointer
    uint8_t*      pCb;        // real pointer
    uint8_t*      pCr;        // real pointer
    int32_t      type;
    int64_t      time;
    int32_t      mbPerRow;   // info for realloc VOP with Shape
    int32_t      mbPerCol;
    uint8_t*      apB;        // for binary mask
    uint8_t*      pB;
    uint8_t*      apA[3];     // for aux components
    uint8_t*      pA[3];
    uint8_t*      mid;
		uint64_t	timestamp; // user-provided timestamp
		int QP;
		unsigned int reference_count;
		int outputted; // for debugging purposes
		int sprite; // 0 - frame, 1 - sprite
		struct _mp4_Frame *next; // benski> for linked list of display & free frames
} mp4_Frame;

/* Block Info for Intra Prediction */
typedef struct _mp4_IntraPredBlock {
    struct _mp4_IntraPredBlock  *predA;
    struct _mp4_IntraPredBlock  *predB;
    struct _mp4_IntraPredBlock  *predC;
    int16_t      dct_acA[8];
    int16_t      dct_acC[8];
    int16_t      dct_dc;
} mp4_IntraPredBlock;

/* Buffer for Intra Prediction */
typedef struct _mp4_IntraPredBuff {
    uint8_t               *quant;     // quant buffer;
    mp4_IntraPredBlock  dcB[6];     // blocks for Left-Top DC only
    mp4_IntraPredBlock  *block;
} mp4_IntraPredBuff;

/* MacroBlock Info Data Partitioned mode */
typedef struct _mp4_DataPartMacroBlock {
    int16_t          dct_dc[6];
    uint8_t           type;
    uint8_t           not_coded;
    uint8_t           mcsel;
    uint8_t           ac_pred_flag;
    uint8_t           pat;
    uint8_t           quant;
} mp4_DataPartMacroBlock;

/* MacroBlock Info for Motion */
typedef struct _mp4_MacroBlock {
    IppMotionVector mv[4];
    uint8_t        validPred;     // for MV pred, OBMC
    uint8_t        type;          // for OBMC, BVOP
    uint8_t        not_coded;     // for OBMC, BVOP
    uint8_t        field_info;    // for Interlaced BVOP Direct mode
} mp4_MacroBlock;

/* Group Of Video Object Plane Info */
typedef struct _mp4_GroupOfVideoObjectPlane {
    int64_t      time_code;
    int32_t      closed_gov;
    int32_t      broken_link;
} mp4_GroupOfVideoObjectPlane;

/* Video Object Plane Info */
typedef struct _mp4_VideoObjectPlane {
    int32_t      coding_type;
    int32_t      modulo_time_base;
    int32_t      time_increment;
    int32_t      coded;
    int32_t      id;                             // verid != 1 (newpred)
    int32_t      id_for_prediction_indication;   // verid != 1 (newpred)
    int32_t      id_for_prediction;              // verid != 1 (newpred)
    int32_t      rounding_type;
    int32_t      reduced_resolution;             // verid != 1
    int32_t      vop_width;
    int32_t      vop_height;
    int32_t      vop_horizontal_mc_spatial_ref;
    int32_t      vop_vertical_mc_spatial_ref;
    int32_t      background_composition;
    int32_t      change_conv_ratio_disable;
    int32_t      vop_constant_alpha;
    int32_t      vop_constant_alpha_value;
    int32_t      intra_dc_vlc_thr;
    int32_t      top_field_first;
    int32_t      alternate_vertical_scan_flag;
    int32_t      sprite_transmit_mode;
    int32_t      warping_mv_code_du[4];
    int32_t      warping_mv_code_dv[4];
    int32_t      brightness_change_factor;
    int32_t      quant;
    int32_t      alpha_quant[3];
    int32_t      fcode_forward;
    int32_t      fcode_backward;
    int32_t      shape_coding_type;
    int32_t      load_backward_shape;
    int32_t      ref_select_code;
    int32_t      dx;
    int32_t      dy;
    int32_t      quant_scale;
    int32_t      macroblock_num;
    int32_t      vop_id;
    int32_t      vop_id_for_prediction_indication;
    int32_t      vop_id_for_prediction;
} mp4_VideoObjectPlane;

/* mp4_ComplexityEstimation Info */
typedef struct _mp4_ComplexityEstimation {
    int32_t      estimation_method;
    int32_t      shape_complexity_estimation_disable;
    int32_t      opaque;
    int32_t      transparent;
    int32_t      intra_cae;
    int32_t      inter_cae;
    int32_t      no_update;
    int32_t      upsampling;
    int32_t      texture_complexity_estimation_set_1_disable;
    int32_t      intra_blocks;
    int32_t      inter_blocks;
    int32_t      inter4v_blocks;
    int32_t      not_coded_blocks;
    int32_t      texture_complexity_estimation_set_2_disable;
    int32_t      dct_coefs;
    int32_t      dct_lines;
    int32_t      vlc_symbols;
    int32_t      vlc_bits;
    int32_t      motion_compensation_complexity_disable;
    int32_t      apm;
    int32_t      npm;
    int32_t      interpolate_mc_q;
    int32_t      forw_back_mc_q;
    int32_t      halfpel2;
    int32_t      halfpel4;
    int32_t      version2_complexity_estimation_disable;     // verid != 1
    int32_t      sadct;                                      // verid != 1
    int32_t      quarterpel;                                 // verid != 1
    int32_t      dcecs_opaque;
    int32_t      dcecs_transparent;
    int32_t      dcecs_intra_cae;
    int32_t      dcecs_inter_cae;
    int32_t      dcecs_no_update;
    int32_t      dcecs_upsampling;
    int32_t      dcecs_intra_blocks;
    int32_t      dcecs_inter_blocks;
    int32_t      dcecs_inter4v_blocks;
    int32_t      dcecs_not_coded_blocks;
    int32_t      dcecs_dct_coefs;
    int32_t      dcecs_dct_lines;
    int32_t      dcecs_vlc_symbols;
    int32_t      dcecs_vlc_bits;
    int32_t      dcecs_apm;
    int32_t      dcecs_npm;
    int32_t      dcecs_interpolate_mc_q;
    int32_t      dcecs_forw_back_mc_q;
    int32_t      dcecs_halfpel2;
    int32_t      dcecs_halfpel4;
    int32_t      dcecs_sadct;                                // verid != 1
    int32_t      dcecs_quarterpel;                           // verid != 1
} mp4_ComplexityEstimation;

/* mp4_Scalability Info */
typedef struct _mp4_ScalabilityParameters {
    int32_t      dummy;
} mp4_ScalabilityParameters;

/* VOLControlParameters Info */
typedef struct _mp4_VOLControlParameters {
    int32_t      chroma_format;
    int32_t      low_delay;
    int32_t      vbv_parameters;
    int32_t      bit_rate;
    int32_t      vbv_buffer_size;
    int32_t      vbv_occupancy;
} mp4_VOLControlParameters;

/* Video Object Plane with int16_t header Info */
typedef struct _mp4_VideoObjectPlaneH263 {
    int32_t      temporal_reference;
    int32_t      split_screen_indicator;
    int32_t      document_camera_indicator;
    int32_t      full_picture_freeze_release;
    int32_t      source_format;
    int32_t      picture_coding_type;
    int32_t      vop_quant;
    int32_t      gob_number;
    int32_t      num_gobs_in_vop;
    int32_t      num_macroblocks_in_gob;
    int32_t      gob_header_empty;
    int32_t      gob_frame_id;
    int32_t      quant_scale;
    int32_t      num_rows_in_gob;
} mp4_VideoObjectPlaneH263;

/* Video Object Info */
typedef struct _mp4_VideoObject {
// iso part
    int32_t                      id;
    int32_t                      short_video_header;
    int32_t                      random_accessible_vol;
    int32_t                      type_indication;
    int32_t                      is_identifier;
    int32_t                      verid;
    int32_t                      priority;
    int32_t                      aspect_ratio_info;
    int32_t                      aspect_ratio_info_par_width;
    int32_t                      aspect_ratio_info_par_height;
    int32_t                      is_vol_control_parameters;
    mp4_VOLControlParameters    VOLControlParameters;
    int32_t                      shape;
    int32_t                      shape_extension;                // verid != 1
    int32_t                      vop_time_increment_resolution;
    int32_t                      vop_time_increment_resolution_bits;
    int32_t                      fixed_vop_rate;
    int32_t                      fixed_vop_time_increment;
    int32_t                      width;
    int32_t                      height;
    int32_t                      interlaced;
    int32_t                      obmc_disable;
    int32_t                      sprite_enable;                  // if verid != 1 (2 bit GMC is added)
    int32_t                      sprite_width;
    int32_t                      sprite_height;
    int32_t                      sprite_left_coordinate;
    int32_t                      sprite_top_coordinate;
    int32_t                      sprite_warping_points;
    int32_t                      sprite_warping_accuracy;
    int32_t                      sprite_brightness_change;
    int32_t                      low_latency_sprite_enable;
    int32_t                      sadct_disable;                  // verid != 1
    int32_t                      not_8_bit;
    int32_t                      quant_precision;
    int32_t                      bits_per_pixel;
    int32_t                      no_gray_quant_update;
    int32_t                      composition_method;
    int32_t                      linear_composition;
    int32_t                      quant_type;
    int32_t                      load_intra_quant_mat;
    uint8_t                       intra_quant_mat[64];
    int32_t                      load_nonintra_quant_mat;
    uint8_t                       nonintra_quant_mat[64];
    int32_t                      load_intra_quant_mat_grayscale[3];
    uint8_t                       intra_quant_mat_grayscale[3][64];
    int32_t                      load_nonintra_quant_mat_grayscale[3];
    uint8_t                       nonintra_quant_mat_grayscale[3][64];
    int32_t                      quarter_sample;                 // verid != 1
    int32_t                      complexity_estimation_disable;
    mp4_ComplexityEstimation    ComplexityEstimation;
    int32_t                      resync_marker_disable;
    int32_t                      data_partitioned;
    int32_t                      reversible_vlc;
    int32_t                      newpred_enable;                 // verid != 1
    int32_t                      requested_upstream_message_type;// verid != 1
    int32_t                      newpred_segment_type;           // verid != 1
    int32_t                      reduced_resolution_vop_enable;  // verid != 1
    int32_t                      scalability;
    mp4_ScalabilityParameters   ScalabilityParameters;
    mp4_GroupOfVideoObjectPlane GroupOfVideoObjectPlane;
    mp4_VideoObjectPlane        VideoObjectPlane;
    mp4_VideoObjectPlaneH263    VideoObjectPlaneH263;
// app part
    int32_t                      VOPindex;
    int32_t                      MacroBlockPerRow;
    int32_t                      MacroBlockPerCol;
    int32_t                      MacroBlockPerVOP;
    int32_t                      mbns; // num bits for MacroBlockPerVOP
    mp4_MacroBlock*             MBinfo;
    mp4_IntraPredBuff           IntraPredBuff;
    mp4_DataPartMacroBlock*     DataPartBuff;
    IppiQuantInvIntraSpec_MPEG4*  QuantInvIntraSpec;
    IppiQuantInvInterSpec_MPEG4*  QuantInvInterSpec;
    IppiWarpSpec_MPEG4*         WarpSpec;
    // for B-VOP
    int32_t                      prevPlaneIsB;
    // for interlaced B-VOP direct mode
    int32_t                      Tframe;
    IppMotionVector*            FieldMV;
    // for B-VOP direct mode
    int32_t                      TRB, TRD;
    // time increment of past and future VOP for B-VOP
    int64_t                      rTime, nTime;
    // VOP global time
    int64_t                      vop_sync_time, vop_sync_time_b;
#ifdef USE_NOTCODED_STATE
    // not_coded MB state
    uint8_t*                      ncState;
    int32_t                      ncStateCleared;
#endif
} mp4_VideoObject;

/* StillTexture Object Info */
typedef struct _mp4_StillTextureObject {
    int32_t  dummy;
} mp4_StillTextureObject;

/* Mesh Object Info */
typedef struct _mp4_MeshObject {
    int32_t  dummy;
} mp4_MeshObject;

/* Face Object Info */
typedef struct _mp4_FaceObject {
    int32_t  dummy;
} mp4_FaceObject;

/* video_signal_type Info */
typedef struct _mp4_VideoSignalType {
    int32_t  is_video_signal_type;
    int32_t  video_format;
    int32_t  video_range;
    int32_t  is_colour_description;
    int32_t  colour_primaries;
    int32_t  transfer_characteristics;
    int32_t  matrix_coefficients;
} mp4_VideoSignalType;

/* Visual Object Info */
typedef struct _mp4_VisualObject {
    int32_t                  is_identifier;
    int32_t                  verid;
    int32_t                  priority;
    int32_t                  type;
    mp4_VideoSignalType     VideoSignalType;
    mp4_VideoObject         VideoObject;
    mp4_StillTextureObject  StillTextureObject;
    mp4_MeshObject          MeshObject;
    mp4_FaceObject          FaceObject;
    mp4_Frame              *sFrame;  // static sprite
    mp4_Frame              *cFrame;  // current TODO make pointer
    mp4_Frame              *rFrame;  // reference in past TODO make pointer
    mp4_Frame              *nFrame;  // reference in future TODO make pointer
    int32_t                  frameCount;
    int32_t                  frameInterval;
    int32_t                  frameScale;
    mp4_Statistic           Statistic;
		mp4_Frame *frame_cache; // linked list of available frames (malloc cache)
		mp4_Frame *sprite_cache; // linked list of available sprite (malloc cache)
		mp4_Frame *display_frames; // linked list of display frames
} mp4_VisualObject;

/* Full Info */
typedef struct _mp4_Info {
    int32_t      ftype;          // 0 - raw, 1 - mp4, 2 - avi
    int32_t      ftype_f;        // ftype == 1 (0 - QuickTime(tm)), ftype == 2 (0 - DivX(tm) v. < 5, XVID, 1 - DivX(tm) v. >= 5)
    uint8_t*      buffer;         /* buffer header for saving MPEG-4 stream */
    size_t    buflen;         /* total buffer length */
    size_t    len;            /* valid data in buffer */
    uint8_t*      bufptr;         /* current frame, point to header or data */
    int32_t      bitoff;         /* mostly point to next frame header or PSC */
    int32_t      profile_and_level_indication;
    mp4_VisualObject    VisualObject;
    int32_t      stopOnErr;
    int         strictSyntaxCheck;
    int         noPVOPs;
    int         noBVOPs;
} mp4_Info;

/* bitstream functions */
extern uint8_t*     mp4_FindStartCodePtr(mp4_Info* pInfo);
extern uint8_t*     mp4_FindStartCodeOrShortPtr(mp4_Info* pInfo);
extern int32_t     mp4_SeekStartCodePtr(mp4_Info* pInfo);
extern int32_t     mp4_SeekStartCodeOrShortPtr(mp4_Info* pInfo);
extern int32_t     mp4_SeekStartCodeValue(mp4_Info* pInfo, uint8_t code);
extern uint8_t*     mp4_FindShortVideoStartMarkerPtr(mp4_Info* pInfo);
extern int32_t     mp4_SeekShortVideoStartMarker(mp4_Info* pInfo);
extern int32_t     mp4_SeekGOBMarker(mp4_Info* pInfo);
extern int32_t     mp4_SeekResyncMarker(mp4_Info* pInfo);
extern int32_t     mp4_FindResyncMarker(mp4_Info* pInfo);
extern int        mp4_IsStartCodeOrShort(mp4_Info* pInfo);
extern int        mp4_IsStartCodeValue(mp4_Info* pInfo, int min, int max);
extern int        mp4_IsShortCode(mp4_Info* pInfo);

/* tables */
typedef struct _mp4_VLC1 {
    uint8_t  code;
    uint8_t  len;
} mp4_VLC1;

extern const uint8_t mp4_DefaultIntraQuantMatrix[];
extern const uint8_t mp4_DefaultNonIntraQuantMatrix[];
extern const uint8_t mp4_ClassicalZigzag[];
extern const uint8_t mp4_DCScalerLuma[];
extern const uint8_t mp4_DCScalerChroma[];
extern const uint8_t mp4_cCbCrMvRound16[];
extern const uint8_t mp4_cCbCrMvRound12[];
extern const uint8_t mp4_cCbCrMvRound8[];
extern const uint8_t mp4_cCbCrMvRound4[];
extern const Ipp8s mp4_dquant[];
extern const mp4_VLC1 mp4_cbpy1[];
extern const mp4_VLC1 mp4_cbpy2[];
extern const mp4_VLC1 mp4_cbpy3[];
extern const mp4_VLC1 mp4_cbpy4[];
extern const mp4_VLC1* mp4_cbpy_t[];
extern const uint8_t mp4_cbpy_b[];
extern const int32_t mp4_DC_vlc_Threshold[];
extern const uint8_t mp4_PVOPmb_type[];
extern const uint8_t mp4_PVOPmb_cbpc[];
extern const uint8_t mp4_PVOPmb_bits[];
extern const mp4_VLC1 mp4_BVOPmb_type[];
extern const mp4_VLC1 mp4_MVD_B12_1[];
extern const mp4_VLC1 mp4_MVD_B12_2[];
extern const int32_t mp4_H263_width[];
extern const int32_t mp4_H263_height[];
extern const int32_t mp4_H263_mbgob[];
extern const int32_t mp4_H263_gobvop[];
extern const int32_t mp4_H263_rowgob[];
extern const uint8_t mp4_aux_comp_count[];
extern const uint8_t mp4_aux_comp_is_alpha[];
extern const uint8_t mp4_BABtypeIntra[][3];
extern const int32_t mp4_DivIntraDivisor[];

// project functions
extern void       mp4_Error(const char *str);
//#define mp4_Error(str) puts(str)
extern mp4_Status mp4_InitVOL(mp4_Info *pInfo);
extern mp4_Status mp4_FreeVOL(mp4_Info *pInfo);
extern void       mp4_ResetVOL(mp4_Info *pInfo);
//extern void       mp4_ShowFrame(mp4_Frame *frame);
#define mp4_ShowFrame(frame)
extern mp4_Status mp4_Parse_VisualObjectSequence(mp4_Info* pInfo);
extern mp4_Status mp4_Parse_VisualObject(mp4_Info* pInfo);
extern mp4_Status mp4_Parse_VideoObject(mp4_Info* pInfo);
extern mp4_Status mp4_Parse_GroupOfVideoObjectPlane(mp4_Info* pInfo);
extern mp4_Status mp4_Parse_VideoObjectPlane(mp4_Info* pInfo);
extern mp4_Status mp4_DecodeVideoObjectPlane(mp4_Info* pInfo);

#ifndef USE_INLINE_BITS_FUNC
extern uint32_t mp4_ShowBits(mp4_Info* pInfo, int32_t n);
extern uint32_t mp4_ShowBit(mp4_Info* pInfo);
extern uint32_t mp4_ShowBits9(mp4_Info* pInfo, int32_t n);
extern void   mp4_FlushBits(mp4_Info* pInfo, int32_t n);
extern uint32_t mp4_GetBits(mp4_Info* pInfo, int32_t n);
//extern uint32_t mp4_GetBit(mp4_Info* pInfo);
extern uint32_t mp4_GetBits9(mp4_Info* pInfo, int32_t n);
extern void   mp4_AlignBits(mp4_Info* pInfo);
extern void   mp4_AlignBits7F(mp4_Info* pInfo);
extern uint32_t mp4_ShowBitsAlign(mp4_Info* pInfo, int32_t n);
extern uint32_t mp4_ShowBitsAlign7F(mp4_Info* pInfo, int32_t n);
#else
__INLINE uint32_t mp4_ShowBits(mp4_Info* pInfo, int32_t n)
{
    uint8_t* ptr = pInfo->bufptr;
    uint32_t tmp = (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] <<  8) | (ptr[3]);
    tmp <<= pInfo->bitoff;
    tmp >>= 32 - n;
    return tmp;
}

__INLINE uint32_t mp4_ShowBit(mp4_Info* pInfo)
{
    uint32_t tmp = pInfo->bufptr[0];
    tmp >>= 7 - pInfo->bitoff;
    return (tmp & 1);
}

__INLINE uint32_t mp4_ShowBits9(mp4_Info* pInfo, int32_t n)
{
    uint8_t* ptr = pInfo->bufptr;
    uint32_t tmp = (ptr[0] <<  8) | ptr[1];
    tmp <<= (pInfo->bitoff + 16);
    tmp >>= 32 - n;
    return tmp;
}

__INLINE void mp4_FlushBits(mp4_Info* pInfo, int32_t n)
{
    n = n + pInfo->bitoff;
    pInfo->bufptr += n >> 3;
    pInfo->bitoff = n & 7;
}

__INLINE uint32_t mp4_GetBits(mp4_Info* pInfo, int32_t n)
{
    uint8_t* ptr = pInfo->bufptr;
    uint32_t tmp = (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] <<  8) | (ptr[3]);
    tmp <<= pInfo->bitoff;
    tmp >>= 32 - n;
    n = n + pInfo->bitoff;
    pInfo->bufptr += n >> 3;
    pInfo->bitoff = n & 7;
    return tmp;
}

__INLINE uint32_t mp4_GetBits9(mp4_Info* pInfo, int32_t n)
{
    uint8_t* ptr = pInfo->bufptr;
    uint32_t tmp = (ptr[0] <<  8) | ptr[1];
    tmp <<= (pInfo->bitoff + 16);
    tmp >>= 32 - n;
    n = n + pInfo->bitoff;
    pInfo->bufptr += n >> 3;
    pInfo->bitoff = n & 7;
    return tmp;
}

__INLINE void mp4_AlignBits(mp4_Info* pInfo)
{
    if (pInfo->bitoff > 0) {
        pInfo->bitoff = 0;
        (pInfo->bufptr)++;
    }
}

__INLINE void mp4_AlignBits7F(mp4_Info* pInfo)
{
    if (pInfo->bitoff > 0) {
        pInfo->bitoff = 0;
        (pInfo->bufptr)++;
    } else {
        if (*pInfo->bufptr == 0x7F)
            (pInfo->bufptr)++;
    }
}

__INLINE uint32_t mp4_ShowBitsAlign(mp4_Info* pInfo, int32_t n)
{
    uint8_t* ptr = pInfo->bitoff ? (pInfo->bufptr + 1) : pInfo->bufptr;
    uint32_t tmp = (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] <<  8) | (ptr[3]);
    tmp >>= 32 - n;
    return tmp;
}

__INLINE uint32_t mp4_ShowBitsAlign7F(mp4_Info* pInfo, int32_t n)
{
    uint8_t* ptr = pInfo->bitoff ? (pInfo->bufptr + 1) : pInfo->bufptr;
    uint32_t tmp;
    if (!pInfo->bitoff) {
        if (*ptr == 0x7F)
            ptr ++;
    }
    tmp = (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] <<  8) | (ptr[3]);
    tmp >>= 32 - n;
    return tmp;
}

#endif // USE_INLINE_BITS_FUNC

__INLINE uint32_t mp4_GetBit(mp4_Info* pInfo)
{
    uint32_t tmp = pInfo->bufptr[0];
    if (pInfo->bitoff != 7) {
        tmp >>= 7 - pInfo->bitoff;
        pInfo->bitoff ++;
    } else {
        pInfo->bitoff = 0;
        pInfo->bufptr ++;
    }
    return (tmp & 1);
}

__INLINE int32_t mp4_GetMarkerBit(mp4_Info* pInfo) {
    if (!mp4_GetBit(pInfo)) {
        mp4_Error("Error: wrong marker bit");
        return 0;
    }
    return 1;
}

// added by benski
extern mp4_Frame *CreateFrame(mp4_VisualObject *object);
extern void ReleaseFrame(mp4_VisualObject *object, mp4_Frame *frame);
extern mp4_Frame *GetDisplayFrame(mp4_VisualObject *object);
extern void DisplayFrame(mp4_VisualObject *object, mp4_Frame *frame);
extern void FreeCache(mp4_VisualObject *object);

#ifdef __cplusplus
}
#endif