| /* ------------------------------------------------------------------ |
| * Copyright (C) 1998-2009 PacketVideo |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either |
| * express or implied. |
| * See the License for the specific language governing permissions |
| * and limitations under the License. |
| * ------------------------------------------------------------------- |
| */ |
| |
| #ifndef _MP4LIB_INT_H_ |
| #define _MP4LIB_INT_H_ |
| |
| #include "mp4def.h" |
| #include "mp4enc_api.h" |
| #include "rate_control.h" |
| |
| /* BitstreamEncVideo will be modified */ |
| typedef struct tagBitstream |
| { |
| Int(*writeVideoPacket)(UChar *buf, Int nbytes_required); /*write video packet out */ |
| UChar *bitstreamBuffer; /*buffer to hold one video packet*/ |
| Int bufferSize; /*total bitstream buffer size in bytes */ |
| Int byteCount; /*how many bytes already encoded*/ |
| UInt word; /*hold one word temporarily */ |
| Int bitLeft; /*number of bits left in "word" */ |
| UChar* overrunBuffer; /* pointer to overrun buffer */ |
| Int oBSize; /* length of overrun buffer */ |
| struct tagVideoEncData *video; |
| } BitstreamEncVideo; |
| |
| typedef struct tagVOP |
| { |
| PIXEL *allChan; /* [yuv]Chan point into this buffer */ |
| PIXEL *yChan; /* The Y component */ |
| PIXEL *uChan; /* The U component */ |
| PIXEL *vChan; /* The V component */ |
| Int frame; /* frame number */ |
| Int volID; /* Layer number */ |
| //Int timeStamp; /* Vop TimeStamp in msec */ |
| |
| /* Syntax elements copied from VOL (standard) */ |
| Int width; /* Width (multiple of 16) */ |
| Int height; /* Height (multiple of 16) */ |
| Int pitch; /* Pitch (differs from width for UMV case) */ |
| Int padded; /* flag whether this frame has been padded */ |
| |
| /* Actual syntax elements for VOP (standard) */ |
| Int predictionType; /* VOP prediction type */ |
| Int timeInc; /* VOP time increment (relative to last mtb) */ |
| Int vopCoded; |
| Int roundingType; |
| Int intraDCVlcThr; |
| Int quantizer; /* VOP quantizer */ |
| Int fcodeForward; /* VOP dynamic range of motion vectors */ |
| Int fcodeBackward; /* VOP dynamic range of motion vectors */ |
| Int refSelectCode; /* enhancement layer reference select code */ |
| |
| /* H.263 parameters */ |
| Int gobNumber; |
| Int gobFrameID; |
| Int temporalRef; /* temporal reference, roll over at 256 */ |
| Int temporalInterval; /* increase every 256 temporalRef */ |
| |
| } Vop; |
| |
| typedef struct tagVol |
| { |
| Int volID; /* VOL identifier (for tracking) */ |
| Int shortVideoHeader; /* shortVideoHeader mode */ |
| Int GOVStart; /* Insert GOV Header */ |
| Int timeIncrementResolution; /* VOL time increment */ |
| Int nbitsTimeIncRes; /* number of bits for time increment */ |
| Int timeIncrement; /* time increment */ |
| Int moduloTimeBase; /* internal decoder clock */ |
| Int prevModuloTimeBase; /* in case of pre-frameskip */ |
| |
| Int fixedVopRate; |
| BitstreamEncVideo *stream; /* library bitstream buffer (input buffer) */ |
| |
| /* VOL Dimensions */ |
| Int width; /* Width */ |
| Int height; /* Height */ |
| |
| /* Error Resilience Flags */ |
| Int ResyncMarkerDisable; /* VOL Disable Resynch Markers */ |
| Int useReverseVLC; /* VOL reversible VLCs */ |
| Int dataPartitioning; /* VOL data partitioning */ |
| |
| /* Quantization related parameters */ |
| Int quantPrecision; /* Quantizer precision */ |
| Int quantType; /* MPEG-4 or H.263 Quantization Type */ |
| |
| /* Added loaded quant mat, 05/22/2000 */ |
| Int loadIntraQuantMat; /* Load intra quantization matrix */ |
| Int loadNonIntraQuantMat; /* Load nonintra quantization matrix */ |
| Int iqmat[64]; /* Intra quant.matrix */ |
| Int niqmat[64]; /* Non-intra quant.matrix */ |
| |
| |
| /* Parameters used for scalability */ |
| Int scalability; /* VOL scalability (flag) */ |
| Int scalType; /* temporal = 0, spatial = 1, both = 2 */ |
| |
| Int refVolID; /* VOL id of reference VOL */ |
| Int refSampDir; /* VOL resol. of ref. VOL */ |
| Int horSamp_n; /* VOL hor. resampling of ref. VOL given by */ |
| Int horSamp_m; /* sampfac = hor_samp_n/hor_samp_m */ |
| Int verSamp_n; /* VOL ver. resampling of ref. VOL given by */ |
| Int verSamp_m; /* sampfac = ver_samp_n/ver_samp_m */ |
| Int enhancementType; /* VOL type of enhancement layer */ |
| |
| /* These variables were added since they are used a lot. */ |
| Int nMBPerRow, nMBPerCol; /* number of MBs in each row & column */ |
| Int nTotalMB; |
| Int nBitsForMBID; /* how many bits required for MB number? */ |
| |
| /* for short video header */ |
| Int nMBinGOB; /* number of MBs in GOB, 05/22/00 */ |
| Int nGOBinVop; /* number of GOB in Vop 05/22/00 */ |
| } Vol; |
| |
| typedef struct tagMacroBlock |
| { |
| Int mb_x; /* X coordinate */ |
| Int mb_y; /* Y coordinate */ |
| Short block[9][64]; /* 4-Y, U and V blocks , and AAN Scale*/ |
| } MacroBlock; |
| |
| typedef struct tagRunLevelBlock |
| { |
| Int run[64]; /* Runlength */ |
| Int level[64]; /* Abs(level) */ |
| Int s[64]; /* sign level */ |
| } RunLevelBlock; |
| |
| typedef struct tagHeaderInfoDecVideo |
| { |
| UChar *Mode; /* Modes INTRA/INTER/etc. */ |
| UChar *CBP; /* MCBPC/CBPY stuff */ |
| } HeaderInfoEncVideo; |
| |
| typedef Short typeDCStore[6]; /* ACDC */ |
| typedef Short typeDCACStore[4][8]; |
| |
| typedef struct tagMOT |
| { |
| Int x; /* half-pel resolution x component */ |
| Int y; /* half-pel resolution y component */ |
| Int sad; /* SAD */ |
| } MOT; |
| |
| typedef struct tagHintTrackInfo |
| { |
| UChar MTB; |
| UChar LayerID; |
| UChar CodeType; |
| UChar RefSelCode; |
| |
| } HintTrackInfo; |
| |
| |
| typedef struct tagVideoEncParams |
| { |
| //Int Width; /* Input Width */ |
| //Int Height; /* Input Height */ |
| //float FrameRate; /* Input Frame Rate */ |
| UInt TimeIncrementRes; /* timeIncrementRes */ |
| |
| /*VOL Parameters */ |
| Int nLayers; |
| Int LayerWidth[4]; /* Encoded Width */ |
| Int LayerHeight[4]; /* Encoded Height */ |
| float LayerFrameRate[4]; /* Encoded Frame Rate */ |
| Int LayerBitRate[4]; /* Encoded BitRate */ |
| Int LayerMaxBitRate[4]; /* Maximum Encoded BitRate */ |
| float LayerMaxFrameRate[4]; /* Maximum Encoded Frame Rate */ |
| Int LayerMaxMbsPerSec[4]; /* Maximum mbs per second, according to the specified profile and level */ |
| Int LayerMaxBufferSize[4]; /* Maximum buffer size, according to the specified profile and level */ |
| |
| Bool ResyncMarkerDisable; /* Disable Resync Marker */ |
| Bool DataPartitioning; /* Base Layer Data Partitioning */ |
| Bool ReversibleVLC; /* RVLC when Data Partitioning */ |
| Bool ACDCPrediction; /* AC/DC Prediction */ |
| Int QuantType[4]; /* H263, MPEG2 */ |
| Int InitQuantBvop[4]; |
| Int InitQuantPvop[4]; |
| Int InitQuantIvop[4]; |
| Int ResyncPacketsize; |
| |
| Int RoundingType; |
| Int IntraDCVlcThr; |
| |
| /* Rate Control Parameters */ |
| MP4RateControlType RC_Type; /*Constant Q, M4 constantRate, VM5+, M4RC,MPEG2TM5 */ |
| |
| /* Intra Refresh Parameters */ |
| Int IntraPeriod; /* Intra update period */ |
| Int Refresh; /* Number of MBs refresh in each frame */ |
| /* Other Parameters */ |
| Bool SceneChange_Det; /* scene change detection */ |
| Bool FineFrameSkip_Enabled; /* src rate resolution frame skipping */ |
| Bool VBR_Enabled; /* VBR rate control */ |
| Bool NoFrameSkip_Enabled; /* do not allow frame skip */ |
| Bool NoPreSkip_Enabled; /* do not allow pre-skip */ |
| |
| Bool H263_Enabled; /* H263 Short Header */ |
| Bool GOV_Enabled; /* GOV Header Enabled */ |
| Bool SequenceStartCode; /* This probably should be removed */ |
| Bool FullSearch_Enabled; /* full-pel exhaustive search motion estimation */ |
| Bool HalfPel_Enabled; /* Turn Halfpel ME on or off */ |
| Bool MV8x8_Enabled; /* Enable 8x8 motion vectors */ |
| Bool RD_opt_Enabled; /* Enable operational R-D optimization */ |
| Int GOB_Header_Interval; /* Enable encoding GOB header in H263_WITH_ERR_RES and SHORT_HERDER_WITH_ERR_RES */ |
| Int SearchRange; /* Search range for 16x16 motion vector */ |
| Int MemoryUsage; /* Amount of memory allocated */ |
| Int GetVolHeader[2]; /* Flag to check if Vol Header has been retrieved */ |
| Int BufferSize[2]; /* Buffer Size for Base and Enhance Layers */ |
| Int ProfileLevel[2]; /* Profile and Level for encoding purposes */ |
| float VBV_delay; /* VBV buffer size in the form of delay */ |
| Int maxFrameSize; /* maximum frame size(bits) for H263/Short header mode, k*16384 */ |
| Int profile_table_index; /* index for profile and level tables given the specified profile and level */ |
| |
| } VideoEncParams; |
| |
| /* platform dependent functions */ |
| typedef struct tagFuncPtr |
| { |
| // Int (*SAD_MB_HalfPel)(UChar *ref,UChar *blk,Int dmin_lx,Int xh,Int yh,void *extra_info); |
| Int(*SAD_MB_HalfPel[4])(UChar*, UChar*, Int, void *); |
| Int(*SAD_Blk_HalfPel)(UChar *ref, UChar *blk, Int dmin, Int lx, Int rx, Int xh, Int yh, void *extra_info); |
| Int(*SAD_Macroblock)(UChar *ref, UChar *blk, Int dmin_lx, void *extra_info); |
| Int(*SAD_Block)(UChar *ref, UChar *blk, Int dmin, Int lx, void *extra_info); |
| Int(*SAD_MB_PADDING)(UChar *ref, UChar *blk, Int dmin, Int lx, void *extra_info); /*, 4/21/01 */ |
| void (*ComputeMBSum)(UChar *cur, Int lx, MOT *mot_mb); |
| void (*ChooseMode)(UChar *Mode, UChar *cur, Int lx, Int min_SAD); |
| void (*GetHalfPelMBRegion)(UChar *cand, UChar *hmem, Int lx); |
| void (*blockIdct)(Int *block); |
| |
| |
| } FuncPtr; |
| |
| /* 04/09/01, for multipass rate control */ |
| |
| typedef struct tagRDInfo |
| { |
| Int QP; |
| Int actual_bits; |
| float mad; |
| float R_D; |
| } RDInfo; |
| |
| typedef struct tagMultiPass |
| { |
| /* multipass rate control data */ |
| Int target_bits; /* target bits for current frame, = rc->T */ |
| Int actual_bits; /* actual bits for current frame obtained after encoding, = rc->Rc*/ |
| Int QP; /* quantization level for current frame, = rc->Qc*/ |
| Int prev_QP; /* quantization level for previous frame */ |
| Int prev_prev_QP; /* quantization level for previous frame before last*/ |
| float mad; /* mad for current frame, = video->avgMAD*/ |
| Int bitrate; /* bitrate for current frame */ |
| float framerate; /* framerate for current frame*/ |
| |
| Int nRe_Quantized; /* control variable for multipass encoding, */ |
| /* 0 : first pass */ |
| /* 1 : intermediate pass(quantization and VLC loop only) */ |
| /* 2 : final pass(de-quantization, idct, etc) */ |
| /* 3 : macroblock level rate control */ |
| |
| Int encoded_frames; /* counter for all encoded frames */ |
| Int re_encoded_frames; /* counter for all multipass encoded frames*/ |
| Int re_encoded_times; /* counter for all times of multipass frame encoding */ |
| |
| /* Multiple frame prediction*/ |
| RDInfo **pRDSamples; /* pRDSamples[30][32], 30->30fps, 32 -> 5 bit quantizer, 32 candidates*/ |
| Int framePos; /* specific position in previous multiple frames*/ |
| Int frameRange; /* number of overall previous multiple frames */ |
| Int samplesPerFrame[30]; /* number of samples per frame, 30->30fps */ |
| |
| /* Bit allocation for scene change frames and high motion frames */ |
| float sum_mad; |
| Int counter_BTsrc; /* BT = Bit Transfer, bit transfer from low motion frames or less complicatedly compressed frames */ |
| Int counter_BTdst; /* BT = Bit Transfer, bit transfer to scene change frames or high motion frames or more complicatedly compressed frames */ |
| float sum_QP; |
| Int diff_counter; /* diff_counter = -diff_counter_BTdst, or diff_counter_BTsrc */ |
| |
| /* For target bitrate or framerate update */ |
| float target_bits_per_frame; /* = C = bitrate/framerate */ |
| float target_bits_per_frame_prev; /* previous C */ |
| float aver_mad; /* so-far average mad could replace sum_mad */ |
| float aver_mad_prev; /* previous average mad */ |
| Int overlapped_win_size; /* transition period of time */ |
| Int encoded_frames_prev; /* previous encoded_frames */ |
| } MultiPass; |
| |
| /* End */ |
| |
| #ifdef HTFM |
| typedef struct tagHTFM_Stat |
| { |
| Int abs_dif_mad_avg; |
| UInt countbreak; |
| Int offsetArray[16]; |
| Int offsetRef[16]; |
| } HTFM_Stat; |
| #endif |
| |
| /* Global structure that can be passed around */ |
| typedef struct tagVideoEncData |
| { |
| /* VOL Header Initialization */ |
| UChar volInitialize[4]; /* Used to Write VOL Headers */ |
| /* Data For Layers (Scalability) */ |
| Int numberOfLayers; /* Number of Layers */ |
| Vol **vol; /* Data stored for each VOL */ |
| |
| /* Data used for encoding frames */ |
| VideoEncFrameIO *input; /* original input frame */ |
| Vop *currVop; /* Current reconstructed VOP */ |
| Vop *prevBaseVop; /* Previous reference Base Vop */ |
| Vop *nextBaseVop; /* Next reference Base Vop */ |
| Vop *prevEnhanceVop;/* Previous Enhancement Layer Vop */ |
| Vop *forwardRefVop; /* Forward Reference VOP */ |
| Vop *backwardRefVop; /* Backward Reference VOP */ |
| |
| /* scratch memory */ |
| BitstreamEncVideo *bitstream1; /* Used for data partitioning */ |
| BitstreamEncVideo *bitstream2; /* and combined modes as */ |
| BitstreamEncVideo *bitstream3; /* intermediate storages */ |
| |
| UChar *overrunBuffer; /* extra output buffer to prevent current skip due to output buffer overrun*/ |
| Int oBSize; /* size of allocated overrun buffer */ |
| |
| Int dc_scalar_1; /*dc scalar for Y block */ |
| Int dc_scalar_2; /*dc scalar for U, V block*/ |
| |
| /* Annex L Rate Control */ |
| rateControl *rc[4]; /* Pointer to Rate Control structure*/ |
| /* 12/25/00, each R.C. for each layer */ |
| |
| /********* motion compensation related variables ****************/ |
| MOT **mot; /* Motion vectors */ |
| /* where [mbnum][0] = 1MV. |
| [mbnum][1...4] = 4MVs |
| [mbnum][5] = backward MV. |
| [mbnum][6] = delta MV for direct mode. |
| [mbnum][7] = nothing yet. */ |
| UChar *intraArray; /* Intra Update Arrary */ |
| float sumMAD; /* SAD/MAD for frame */ |
| |
| /* to speedup the SAD calculation */ |
| void *sad_extra_info; |
| #ifdef HTFM |
| Int nrmlz_th[48]; /* Threshold for fast SAD calculation using HTFM */ |
| HTFM_Stat htfm_stat; /* For statistics collection */ |
| #endif |
| |
| /*Tao 04/09/00 For DCT routine */ |
| UChar currYMB[256]; /* interleaved current macroblock in HTFM order */ |
| MacroBlock *outputMB; /* Output MB to VLC encode */ |
| UChar predictedMB[384]; /* scrath memory for predicted value */ |
| RunLevelBlock RLB[6]; /* Run and Level of coefficients! */ |
| Short dataBlock[128]; /* DCT block data before and after quant/dequant*/ |
| |
| UChar bitmaprow[8]; /* Need to keep it for ACDCPrediction, 8 bytes for alignment, need only 6 */ |
| UChar bitmapcol[6][8]; |
| UInt bitmapzz[6][2]; /* for zigzag bitmap */ |
| Int zeroMV; /* flag for zero MV */ |
| |
| Int usePrevQP; /* flag for intraDCVlcThreshold switch decision */ |
| Int QP_prev; /* use for DQUANT calculation */ |
| Int *acPredFlag; /* */ |
| typeDCStore *predDC; /* The DC coeffs for each MB */ |
| typeDCACStore *predDCAC_row; |
| typeDCACStore *predDCAC_col; |
| |
| |
| UChar *sliceNo; /* Slice Number for each MB */ |
| |
| Int header_bits; /* header bits in frmae */ |
| HeaderInfoEncVideo headerInfo; /* MB Header information */ |
| UChar zz_direction; /* direction of zigzag scan */ |
| UChar *QPMB; /* Quantizer value for each MB */ |
| |
| /* Miscellaneous data points to be passed */ |
| float FrameRate; /* Src frame Rate */ |
| |
| ULong nextModTime; /* expected next frame time */ |
| UInt prevFrameNum[4]; /* previous frame number starting from modTimeRef */ |
| UInt modTimeRef; /* Reference modTime update every I-Vop*/ |
| UInt refTick[4]; /* second aligned referenc tick */ |
| Int relLayerCodeTime[4];/* Next coding time for each Layer relative to highest layer */ |
| |
| ULong modTime; /* Input frame modTime */ |
| Int currLayer; /* Current frame layer */ |
| Int mbnum; /* Macroblock number */ |
| |
| /* slice coding, state variables */ |
| Vop *tempForwRefVop; |
| Int tempRefSelCode; |
| Int end_of_buf; /* end of bitstream buffer flag */ |
| Int slice_coding; /* flag for slice based coding */ |
| Int totalSAD; /* So far total SAD for a frame */ |
| Int numIntra; /* So far number of Intra MB */ |
| Int offset; /* So far MB offset */ |
| Int ind_x, ind_y; /* So far MB coordinate */ |
| Int collect; |
| Int hp_guess; |
| /*********************************/ |
| |
| HintTrackInfo hintTrackInfo; /* hintTrackInfo */ |
| /* IntraPeriod, Timestamp, etc. */ |
| float nextEncIVop; /* counter til the next I-Vop */ |
| float numVopsInGOP; /* value at the beginning of nextEncIVop */ |
| |
| /* platform dependent functions */ |
| FuncPtr *functionPointer; /* structure containing platform dependent functions */ |
| |
| /* Application controls */ |
| VideoEncControls *videoEncControls; |
| VideoEncParams *encParams; |
| |
| MultiPass *pMP[4]; /* for multipass encoding, 4 represents 4 layer encoding */ |
| |
| } VideoEncData; |
| |
| /*************************************************************/ |
| /* VLC structures */ |
| /*************************************************************/ |
| |
| typedef struct tagVLCtable |
| { |
| unsigned int code; /* right justified */ |
| int len; |
| } VLCtable, *LPVLCtable; |
| |
| |
| /*************************************************************/ |
| /* Approx DCT */ |
| /*************************************************************/ |
| typedef struct struct_approxDCT approxDCT; |
| struct struct_approxDCT |
| { |
| Void(*BlockDCT8x8)(Int *, Int *, UChar *, UChar *, Int, Int); |
| Void(*BlockDCT8x8Intra)(Int *, Int *, UChar *, UChar *, Int, Int); |
| Void(*BlockDCT8x8wSub)(Int *, Int *, UChar *, UChar *, Int, Int); |
| }; |
| |
| /*************************************************************/ |
| /* QP structure */ |
| /*************************************************************/ |
| |
| struct QPstruct |
| { |
| Int QPx2 ; |
| Int QP; |
| Int QPdiv2; |
| Int QPx2plus; |
| Int Addition; |
| }; |
| |
| |
| #endif /* _MP4LIB_INT_H_ */ |
| |
