| /* ------------------------------------------------------------------ |
| * 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. |
| * ------------------------------------------------------------------- |
| */ |
| /** |
| This file contains application function interfaces to the AVC encoder library |
| and necessary type defitionitions and enumerations. |
| @publishedAll |
| */ |
| |
| #ifndef AVCENC_INT_H_INCLUDED |
| #define AVCENC_INT_H_INCLUDED |
| |
| #ifndef AVCINT_COMMON_H_INCLUDED |
| #include "avcint_common.h" |
| #endif |
| #ifndef AVCENC_API_H_INCLUDED |
| #include "avcenc_api.h" |
| #endif |
| |
| typedef float OsclFloat; |
| |
| /* Definition for the structures below */ |
| #define DEFAULT_ATTR 0 /* default memory attribute */ |
| #define MAX_INPUT_FRAME 30 /* some arbitrary number, it can be much higher than this. */ |
| #define MAX_REF_FRAME 16 /* max size of the RefPicList0 and RefPicList1 */ |
| #define MAX_REF_PIC_LIST 33 |
| |
| #define MIN_QP 0 |
| #define MAX_QP 51 |
| #define SHIFT_QP 12 |
| #define LAMBDA_ACCURACY_BITS 16 |
| #define LAMBDA_FACTOR(lambda) ((int)((double)(1<<LAMBDA_ACCURACY_BITS)*(lambda)+0.5)) |
| |
| |
| #define DISABLE_THRESHOLDING 0 |
| // for better R-D performance |
| #define _LUMA_COEFF_COST_ 4 //!< threshold for luma coeffs |
| #define _CHROMA_COEFF_COST_ 4 //!< threshold for chroma coeffs, used to be 7 |
| #define _LUMA_MB_COEFF_COST_ 5 //!< threshold for luma coeffs of inter Macroblocks |
| #define _LUMA_8x8_COEFF_COST_ 5 //!< threshold for luma coeffs of 8x8 Inter Partition |
| #define MAX_VALUE 999999 //!< used for start value for some variables |
| |
| #define WEIGHTED_COST(factor,bits) (((factor)*(bits))>>LAMBDA_ACCURACY_BITS) |
| #define MV_COST(f,s,cx,cy,px,py) (WEIGHTED_COST(f,mvbits[((cx)<<(s))-(px)]+mvbits[((cy)<<((s)))-(py)])) |
| #define MV_COST_S(f,cx,cy,px,py) (WEIGHTED_COST(f,mvbits[(cx)-(px)]+mvbits[(cy)-(py)])) |
| |
| /* for sub-pel search and interpolation */ |
| #define SUBPEL_PRED_BLK_SIZE 576 // 24x24 |
| #define REF_CENTER 75 |
| #define V2Q_H0Q 1 |
| #define V0Q_H2Q 2 |
| #define V2Q_H2Q 3 |
| |
| /* |
| #define V3Q_H0Q 1 |
| #define V3Q_H1Q 2 |
| #define V0Q_H1Q 3 |
| #define V1Q_H1Q 4 |
| #define V1Q_H0Q 5 |
| #define V1Q_H3Q 6 |
| #define V0Q_H3Q 7 |
| #define V3Q_H3Q 8 |
| #define V2Q_H3Q 9 |
| #define V2Q_H0Q 10 |
| #define V2Q_H1Q 11 |
| #define V2Q_H2Q 12 |
| #define V3Q_H2Q 13 |
| #define V0Q_H2Q 14 |
| #define V1Q_H2Q 15 |
| */ |
| |
| |
| #define DEFAULT_OVERRUN_BUFFER_SIZE 1000 |
| |
| // associated with the above cost model |
| const uint8 COEFF_COST[2][16] = |
| { |
| {3, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, |
| {9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9} |
| }; |
| |
| |
| |
| //! convert from H.263 QP to H.264 quant given by: quant=pow(2,QP/6) |
| const int QP2QUANT[40] = |
| { |
| 1, 1, 1, 1, 2, 2, 2, 2, |
| 3, 3, 3, 4, 4, 4, 5, 6, |
| 6, 7, 8, 9, 10, 11, 13, 14, |
| 16, 18, 20, 23, 25, 29, 32, 36, |
| 40, 45, 51, 57, 64, 72, 81, 91 |
| }; |
| |
| |
| /** |
| This enumeration keeps track of the internal status of the encoder whether it is doing |
| something. The encoding flow follows the order in which these states are. |
| @publishedAll |
| */ |
| typedef enum |
| { |
| AVCEnc_Initializing = 0, |
| AVCEnc_Encoding_SPS, |
| AVCEnc_Encoding_PPS, |
| AVCEnc_Analyzing_Frame, |
| AVCEnc_WaitingForBuffer, // pending state |
| AVCEnc_Encoding_Frame, |
| } AVCEnc_State ; |
| |
| /** |
| Bitstream structure contains bitstream related parameters such as the pointer |
| to the buffer, the current byte position and bit position. The content of the |
| bitstreamBuffer will be in EBSP format as the emulation prevention codes are |
| automatically inserted as the RBSP is recorded. |
| @publishedAll |
| */ |
| typedef struct tagEncBitstream |
| { |
| uint8 *bitstreamBuffer; /* pointer to buffer memory */ |
| int buf_size; /* size of the buffer memory */ |
| int write_pos; /* next position to write to bitstreamBuffer */ |
| int count_zeros; /* count number of consecutive zero */ |
| uint current_word; /* byte-swapped (MSB left) current word to write to buffer */ |
| int bit_left; /* number of bit left in current_word */ |
| uint8 *overrunBuffer; /* extra output buffer to prevent current skip due to output buffer overrun*/ |
| int oBSize; /* size of allocated overrun buffer */ |
| void *encvid; /* pointer to the main object */ |
| |
| } AVCEncBitstream; |
| |
| /** |
| This structure is used for rate control purpose and other performance related control |
| variables such as, RD cost, statistics, motion search stuffs, etc. |
| should be in this structure. |
| @publishedAll |
| */ |
| |
| |
| typedef struct tagRDInfo |
| { |
| int QP; |
| int actual_bits; |
| OsclFloat mad; |
| OsclFloat 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*/ |
| OsclFloat mad; /* mad for current frame, = video->avgMAD*/ |
| int bitrate; /* bitrate for current frame */ |
| OsclFloat 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 */ |
| OsclFloat 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 */ |
| OsclFloat sum_QP; |
| int diff_counter; /* diff_counter = -diff_counter_BTdst, or diff_counter_BTsrc */ |
| |
| /* For target bitrate or framerate update */ |
| OsclFloat target_bits_per_frame; /* = C = bitrate/framerate */ |
| OsclFloat target_bits_per_frame_prev; /* previous C */ |
| OsclFloat aver_mad; /* so-far average mad could replace sum_mad */ |
| OsclFloat aver_mad_prev; /* previous average mad */ |
| int overlapped_win_size; /* transition period of time */ |
| int encoded_frames_prev; /* previous encoded_frames */ |
| } MultiPass; |
| |
| |
| typedef struct tagdataPointArray |
| { |
| int Qp; |
| int Rp; |
| OsclFloat Mp; /* for MB-based RC */ |
| struct tagdataPointArray *next; |
| struct tagdataPointArray *prev; |
| } dataPointArray; |
| |
| typedef struct tagAVCRateControl |
| { |
| |
| /* these parameters are initialized by the users AVCEncParams */ |
| /* bitrate-robustness tradeoff */ |
| uint scdEnable; /* enable scene change detection */ |
| int idrPeriod; /* IDR period in number of frames */ |
| int intraMBRate; /* intra MB refresh rate per frame */ |
| uint dpEnable; /* enable data partitioning */ |
| |
| /* quality-complexity tradeoff */ |
| uint subPelEnable; /* enable quarter pel search */ |
| int mvRange; /* motion vector search range in +/- pixel */ |
| uint subMBEnable; /* enable sub MB prediction mode (4x4, 4x8, 8x4) */ |
| uint rdOptEnable; /* enable RD-opt mode selection */ |
| uint twoPass; /* flag for 2 pass encoding ( for future )*/ |
| uint bidirPred; /* bi-directional prediction for B-frame. */ |
| |
| uint rcEnable; /* enable rate control, '1' on, '0' const QP */ |
| int initQP; /* initial QP */ |
| |
| /* note the following 3 params are for HRD, these triplets can be a series |
| of triplets as the generalized HRD allows. SEI message must be generated in this case. */ |
| /* We no longer have to differentiate between CBR and VBR. The users to the |
| AVC encoder lib will do the mapping from CBR/VBR to these parameters. */ |
| int32 bitRate; /* target bit rate for the overall clip in bits/second*/ |
| int32 cpbSize; /* coded picture buffer size in bytes */ |
| int32 initDelayOffset; /* initial CBP removal delay in bits */ |
| |
| OsclFloat frame_rate; /* frame rate */ |
| int srcInterval; /* source frame rate in msec */ |
| int basicUnit; /* number of macroblocks per BU */ |
| |
| /* Then internal parameters for the operation */ |
| uint first_frame; /* a flag for the first frame */ |
| int lambda_mf; /* for example */ |
| int totalSAD; /* SAD of current frame */ |
| |
| /*******************************************/ |
| /* this part comes from MPEG4 rate control */ |
| int alpha; /* weight for I frame */ |
| int Rs; /*bit rate for the sequence (or segment) e.g., 24000 bits/sec */ |
| int Rc; /*bits used for the current frame. It is the bit count obtained after encoding. */ |
| int Rp; /*bits to be removed from the buffer per picture. */ |
| /*? is this the average one, or just the bits coded for the previous frame */ |
| int Rps; /*bit to be removed from buffer per src frame */ |
| OsclFloat Ts; /*number of seconds for the sequence (or segment). e.g., 10 sec */ |
| OsclFloat Ep; |
| OsclFloat Ec; /*mean absolute difference for the current frame after motion compensation.*/ |
| /*If the macroblock is intra coded, the original spatial pixel values are summed.*/ |
| int Qc; /*quantization level used for the current frame. */ |
| int Nr; /*number of P frames remaining for encoding.*/ |
| int Rr; /*number of bits remaining for encoding this sequence (or segment).*/ |
| int Rr_Old; |
| int T; /*target bit to be used for the current frame.*/ |
| int S; /*number of bits used for encoding the previous frame.*/ |
| int Hc; /*header and motion vector bits used in the current frame. It includes all the information except to the residual information.*/ |
| int Hp; /*header and motion vector bits used in the previous frame. It includes all the information except to the residual information.*/ |
| int Ql; /*quantization level used in the previous frame */ |
| int Bs; /*buffer size e.g., R/2 */ |
| int B; /*current buffer level e.g., R/4 - start from the middle of the buffer */ |
| OsclFloat X1; |
| OsclFloat X2; |
| OsclFloat X11; |
| OsclFloat M; /*safe margin for the buffer */ |
| OsclFloat smTick; /*ratio of src versus enc frame rate */ |
| double remnant; /*remainder frame of src/enc frame for fine frame skipping */ |
| int timeIncRes; /* vol->timeIncrementResolution */ |
| |
| dataPointArray *end; /*quantization levels for the past (20) frames */ |
| |
| int frameNumber; /* ranging from 0 to 20 nodes*/ |
| int w; |
| int Nr_Original; |
| int Nr_Old, Nr_Old2; |
| int skip_next_frame; |
| int Qdep; /* smooth Q adjustment */ |
| int VBR_Enabled; |
| |
| int totalFrameNumber; /* total coded frames, for debugging!!*/ |
| |
| char oFirstTime; |
| |
| int numFrameBits; /* keep track of number of bits of the current frame */ |
| int NumberofHeaderBits; |
| int NumberofTextureBits; |
| int numMBHeaderBits; |
| int numMBTextureBits; |
| double *MADofMB; |
| int32 bitsPerFrame; |
| |
| /* BX rate control, something like TMN8 rate control*/ |
| |
| MultiPass *pMP; |
| |
| int TMN_W; |
| int TMN_TH; |
| int VBV_fullness; |
| int max_BitVariance_num; /* the number of the maximum bit variance within the given buffer with the unit of 10% of bitrate/framerate*/ |
| int encoded_frames; /* counter for all encoded frames */ |
| int low_bound; /* bound for underflow detection, usually low_bound=-Bs/2, but could be changed in H.263 mode */ |
| int VBV_fullness_offset; /* offset of VBV_fullness, usually is zero, but can be changed in H.263 mode*/ |
| /* End BX */ |
| |
| } AVCRateControl; |
| |
| |
| /** |
| This structure is for the motion vector information. */ |
| typedef struct tagMV |
| { |
| int x; |
| int y; |
| uint sad; |
| } AVCMV; |
| |
| /** |
| This structure contains function pointers for different platform dependent implementation of |
| functions. */ |
| typedef struct tagAVCEncFuncPtr |
| { |
| |
| int (*SAD_MB_HalfPel[4])(uint8*, uint8*, int, void *); |
| int (*SAD_Macroblock)(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info); |
| |
| } AVCEncFuncPtr; |
| |
| /** |
| This structure contains information necessary for correct padding. |
| */ |
| typedef struct tagPadInfo |
| { |
| int i; |
| int width; |
| int j; |
| int height; |
| } AVCPadInfo; |
| |
| |
| #ifdef HTFM |
| typedef struct tagHTFM_Stat |
| { |
| int abs_dif_mad_avg; |
| uint countbreak; |
| int offsetArray[16]; |
| int offsetRef[16]; |
| } HTFM_Stat; |
| #endif |
| |
| |
| /** |
| This structure is the main object for AVC encoder library providing access to all |
| global variables. It is allocated at PVAVCInitEncoder and freed at PVAVCCleanUpEncoder. |
| @publishedAll |
| */ |
| typedef struct tagEncObject |
| { |
| |
| AVCCommonObj *common; |
| |
| AVCEncBitstream *bitstream; /* for current NAL */ |
| uint8 *overrunBuffer; /* extra output buffer to prevent current skip due to output buffer overrun*/ |
| int oBSize; /* size of allocated overrun buffer */ |
| |
| /* rate control */ |
| AVCRateControl *rateCtrl; /* pointer to the rate control structure */ |
| |
| /* encoding operation */ |
| AVCEnc_State enc_state; /* encoding state */ |
| |
| AVCFrameIO *currInput; /* pointer to the current input frame */ |
| |
| int currSliceGroup; /* currently encoded slice group id */ |
| |
| int level[24][16], run[24][16]; /* scratch memory */ |
| int leveldc[16], rundc[16]; /* for DC component */ |
| int levelcdc[16], runcdc[16]; /* for chroma DC component */ |
| int numcoefcdc[2]; /* number of coefficient for chroma DC */ |
| int numcoefdc; /* number of coefficients for DC component */ |
| |
| int qp_const; |
| int qp_const_c; |
| /********* intra prediction scratch memory **********************/ |
| uint8 pred_i16[AVCNumI16PredMode][256]; /* save prediction for MB */ |
| uint8 pred_i4[AVCNumI4PredMode][16]; /* save prediction for blk */ |
| uint8 pred_ic[AVCNumIChromaMode][128]; /* for 2 chroma */ |
| |
| int mostProbableI4Mode[16]; /* in raster scan order */ |
| /********* motion compensation related variables ****************/ |
| AVCMV *mot16x16; /* Saved motion vectors for 16x16 block*/ |
| AVCMV(*mot16x8)[2]; /* Saved motion vectors for 16x8 block*/ |
| AVCMV(*mot8x16)[2]; /* Saved motion vectors for 8x16 block*/ |
| AVCMV(*mot8x8)[4]; /* Saved motion vectors for 8x8 block*/ |
| |
| /********* subpel position **************************************/ |
| uint32 subpel_pred[SUBPEL_PRED_BLK_SIZE/*<<2*/]; /* all 16 sub-pel positions */ |
| uint8 *hpel_cand[9]; /* pointer to half-pel position */ |
| int best_hpel_pos; /* best position */ |
| uint8 qpel_cand[8][24*16]; /* pointer to quarter-pel position */ |
| int best_qpel_pos; |
| uint8 *bilin_base[9][4]; /* pointer to 4 position at top left of bilinear quarter-pel */ |
| |
| /* need for intra refresh rate */ |
| uint8 *intraSearch; /* Intra Array for MBs to be intra searched */ |
| uint firstIntraRefreshMBIndx; /* keep track for intra refresh */ |
| |
| int i4_sad; /* temporary for i4 mode SAD */ |
| int *min_cost; /* Minimum cost for the all MBs */ |
| int lambda_mode; /* Lagrange parameter for mode selection */ |
| int lambda_motion; /* Lagrange parameter for MV selection */ |
| |
| uint8 *mvbits_array; /* Table for bits spent in the cost funciton */ |
| uint8 *mvbits; /* An offset to the above array. */ |
| |
| /* to speedup the SAD calculation */ |
| void *sad_extra_info; |
| uint8 currYMB[256]; /* interleaved current macroblock in HTFM order */ |
| |
| #ifdef HTFM |
| int nrmlz_th[48]; /* Threshold for fast SAD calculation using HTFM */ |
| HTFM_Stat htfm_stat; /* For statistics collection */ |
| #endif |
| |
| /* statistics */ |
| int numIntraMB; /* keep track of number of intra MB */ |
| |
| /* encoding complexity control */ |
| uint fullsearch_enable; /* flag to enable full-pel full-search */ |
| |
| /* misc.*/ |
| bool outOfBandParamSet; /* flag to enable out-of-band param set */ |
| |
| AVCSeqParamSet extSPS; /* for external SPS */ |
| AVCPicParamSet extPPS; /* for external PPS */ |
| |
| /* time control */ |
| uint32 prevFrameNum; /* previous frame number starting from modTimeRef */ |
| uint32 modTimeRef; /* Reference modTime update every I-Vop*/ |
| uint32 wrapModTime; /* Offset to modTime Ref, rarely used */ |
| |
| uint prevProcFrameNum; /* previously processed frame number, could be skipped */ |
| uint prevCodedFrameNum; /* previously encoded frame number */ |
| /* POC related variables */ |
| uint32 dispOrdPOCRef; /* reference POC is displayer order unit. */ |
| |
| /* Function pointers */ |
| AVCEncFuncPtr *functionPointer; /* store pointers to platform specific functions */ |
| |
| /* Application control data */ |
| AVCHandle *avcHandle; |
| |
| |
| } AVCEncObject; |
| |
| |
| #endif /*AVCENC_INT_H_INCLUDED*/ |
| |