mirror/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-09-24 15:54:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
winamp/Src/mpeg4dec/mp4def.h
Jef 0954e03b3a Initial community commit
2024-09-24 14:54:57 +02:00

975 lines
34 KiB
C
Raw Permalink Blame History

/* ///////////////////////////////////////////////////////////////////////
//
// 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
Reference in a new issue View git blame Copy permalink