diff options
Diffstat (limited to 'Src/mpeg4dec/mp4def.h')
| -rw-r--r-- | Src/mpeg4dec/mp4def.h | 975 |
1 files changed, 975 insertions, 0 deletions
diff --git a/Src/mpeg4dec/mp4def.h b/Src/mpeg4dec/mp4def.h new file mode 100644 index 00000000..603ebf2d --- /dev/null +++ b/Src/mpeg4dec/mp4def.h @@ -0,0 +1,975 @@ +/* /////////////////////////////////////////////////////////////////////// +// +// 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 + |