| /* ------------------------------------------------------------------ |
| * 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 declarations of internal functions for AVC decoder library. |
| @publishedAll |
| */ |
| #ifndef AVCENC_LIB_H_INCLUDED |
| #define AVCENC_LIB_H_INCLUDED |
| |
| #ifndef AVCLIB_COMMON_H_INCLUDED |
| #include "avclib_common.h" |
| #endif |
| #ifndef AVCENC_INT_H_INCLUDED |
| #include "avcenc_int.h" |
| #endif |
| |
| #ifdef __cplusplus |
| extern "C" |
| { |
| #endif |
| /*------------- block.c -------------------------*/ |
| |
| /** |
| This function perform residue calculation, transform, quantize, inverse quantize, |
| inverse transform and residue compensation on a 4x4 block. |
| \param "encvid" "Pointer to AVCEncObject." |
| \param "blkidx" "raster scan block index of the current 4x4 block." |
| \param "cur" "Pointer to the reconstructed block." |
| \param "org" "Pointer to the original block." |
| \param "coef_cost" "Pointer to the coefficient cost to be filled in and returned." |
| \return "Number of non-zero coefficients." |
| */ |
| int dct_luma(AVCEncObject *encvid, int blkidx, uint8 *cur, uint8 *org, int *coef_cost); |
| |
| /** |
| This function performs IDCT on an INTER macroblock. |
| \param "video" "Pointer to AVCCommonObj." |
| \param "curL" "Pointer to the origin of the macroblock on the current frame." |
| \param "currMB" "Pointer to the AVCMacroblock structure." |
| \param "picPitch" "Pitch of the current frame." |
| \return "void". |
| */ |
| void MBInterIdct(AVCCommonObj *video, uint8 *curL, AVCMacroblock *currMB, int picPitch); |
| |
| /** |
| This function perform residue calculation, transform, quantize, inverse quantize, |
| inverse transform and residue compensation on a macroblock. |
| \param "encvid" "Pointer to AVCEncObject." |
| \param "curL" "Pointer to the reconstructed MB." |
| \param "orgL" "Pointer to the original MB." |
| \return "void" |
| */ |
| void dct_luma_16x16(AVCEncObject *encvid, uint8 *curL, uint8 *orgL); |
| |
| /** |
| This function perform residue calculation, transform, quantize, inverse quantize, |
| inverse transform and residue compensation for chroma components of an MB. |
| \param "encvid" "Pointer to AVCEncObject." |
| \param "curC" "Pointer to the reconstructed MB." |
| \param "orgC" "Pointer to the original MB." |
| \param "cr" "Flag whether it is Cr or not." |
| \return "void" |
| */ |
| void dct_chroma(AVCEncObject *encvid, uint8 *curC, uint8 *orgC, int cr); |
| |
| /*----------- init.c ------------------*/ |
| /** |
| This function interprets the encoding parameters provided by users in encParam. |
| The results are kept in AVCEncObject, AVCSeqParamSet, AVCPicParamSet and AVCSliceHeader. |
| \param "encvid" "Pointer to AVCEncObject." |
| \param "encParam" "Pointer to AVCEncParam." |
| \param "extSPS" "External SPS template to be followed. NULL if not present." |
| \param "extPPS" "External PPS template to be followed. NULL if not present." |
| \return "see AVCEnc_Status." |
| */ |
| AVCEnc_Status SetEncodeParam(AVCHandle *avcHandle, AVCEncParams *encParam, |
| void *extSPS, void *extPPS); |
| |
| /** |
| This function verifies the encoding parameters whether they meet the set of supported |
| tool by a specific profile. If the profile is not set, it will just find the closest |
| profile instead of verifying it. |
| \param "video" "Pointer to AVCEncObject." |
| \param "seqParam" "Pointer to AVCSeqParamSet." |
| \param "picParam" "Pointer to AVCPicParamSet." |
| \return "AVCENC_SUCCESS if success, |
| AVCENC_PROFILE_NOT_SUPPORTED if the specified profile |
| is not supported by this version of the library, |
| AVCENC_TOOLS_NOT_SUPPORTED if any of the specified encoding tools are |
| not supported by the user-selected profile." |
| */ |
| AVCEnc_Status VerifyProfile(AVCEncObject *video, AVCSeqParamSet *seqParam, AVCPicParamSet *picParam); |
| |
| /** |
| This function verifies the encoding parameters whether they meet the requirement |
| for a specific level. If the level is not set, it will just find the closest |
| level instead of verifying it. |
| \param "video" "Pointer to AVCEncObject." |
| \param "seqParam" "Pointer to AVCSeqParamSet." |
| \param "picParam" "Pointer to AVCPicParamSet." |
| \return "AVCENC_SUCCESS if success, |
| AVCENC_LEVEL_NOT_SUPPORTED if the specified level |
| is not supported by this version of the library, |
| AVCENC_LEVEL_FAIL if any of the encoding parameters exceed |
| the range of the user-selected level." |
| */ |
| AVCEnc_Status VerifyLevel(AVCEncObject *video, AVCSeqParamSet *seqParam, AVCPicParamSet *picParam); |
| |
| /** |
| This funciton initializes the frame encoding by setting poc/frame_num related parameters. it |
| also performs motion estimation. |
| \param "encvid" "Pointer to the AVCEncObject." |
| \return "AVCENC_SUCCESS if success, AVCENC_NO_PICTURE if there is no input picture |
| in the queue to encode, AVCENC_POC_FAIL or AVCENC_CONSECUTIVE_NONREF for POC |
| related errors, AVCENC_NEW_IDR if new IDR is detected." |
| */ |
| AVCEnc_Status InitFrame(AVCEncObject *encvid); |
| |
| /** |
| This function initializes slice header related variables and other variables necessary |
| for decoding one slice. |
| \param "encvid" "Pointer to the AVCEncObject." |
| \return "AVCENC_SUCCESS if success." |
| */ |
| AVCEnc_Status InitSlice(AVCEncObject *encvid); |
| |
| /*----------- header.c ----------------*/ |
| /** |
| This function performs bitstream encoding of the sequence parameter set NAL. |
| \param "encvid" "Pointer to the AVCEncObject." |
| \param "stream" "Pointer to AVCEncBitstream." |
| \return "AVCENC_SUCCESS if success or AVCENC_SPS_FAIL or others for unexpected failure which |
| should not occur. The SPS parameters should all be verified before this function is called." |
| */ |
| AVCEnc_Status EncodeSPS(AVCEncObject *encvid, AVCEncBitstream *stream); |
| |
| /** |
| This function encodes the VUI parameters into the sequence parameter set bitstream. |
| \param "stream" "Pointer to AVCEncBitstream." |
| \param "vui" "Pointer to AVCVUIParams." |
| \return "nothing." |
| */ |
| void EncodeVUI(AVCEncBitstream* stream, AVCVUIParams* vui); |
| |
| /** |
| This function encodes HRD parameters into the sequence parameter set bitstream |
| \param "stream" "Pointer to AVCEncBitstream." |
| \param "hrd" "Pointer to AVCHRDParams." |
| \return "nothing." |
| */ |
| void EncodeHRD(AVCEncBitstream* stream, AVCHRDParams* hrd); |
| |
| |
| /** |
| This function performs bitstream encoding of the picture parameter set NAL. |
| \param "encvid" "Pointer to the AVCEncObject." |
| \param "stream" "Pointer to AVCEncBitstream." |
| \return "AVCENC_SUCCESS if success or AVCENC_PPS_FAIL or others for unexpected failure which |
| should not occur. The SPS parameters should all be verified before this function is called." |
| */ |
| AVCEnc_Status EncodePPS(AVCEncObject *encvid, AVCEncBitstream *stream); |
| |
| /** |
| This function encodes slice header information which has been initialized or fabricated |
| prior to entering this funciton. |
| \param "encvid" "Pointer to the AVCEncObject." |
| \param "stream" "Pointer to AVCEncBitstream." |
| \return "AVCENC_SUCCESS if success or bitstream fail statuses." |
| */ |
| AVCEnc_Status EncodeSliceHeader(AVCEncObject *encvid, AVCEncBitstream *stream); |
| |
| /** |
| This function encodes reference picture list reordering relted syntax. |
| \param "video" "Pointer to AVCCommonObj." |
| \param "stream" "Pointer to AVCEncBitstream." |
| \param "sliceHdr" "Pointer to AVCSliceHdr." |
| \param "slice_type" "Value of slice_type - 5 if greater than 5." |
| \return "AVCENC_SUCCESS for success and AVCENC_FAIL otherwise." |
| */ |
| AVCEnc_Status ref_pic_list_reordering(AVCCommonObj *video, AVCEncBitstream *stream, AVCSliceHeader *sliceHdr, int slice_type); |
| |
| /** |
| This function encodes dec_ref_pic_marking related syntax. |
| \param "video" "Pointer to AVCCommonObj." |
| \param "stream" "Pointer to AVCEncBitstream." |
| \param "sliceHdr" "Pointer to AVCSliceHdr." |
| \return "AVCENC_SUCCESS for success and AVCENC_FAIL otherwise." |
| */ |
| AVCEnc_Status dec_ref_pic_marking(AVCCommonObj *video, AVCEncBitstream *stream, AVCSliceHeader *sliceHdr); |
| |
| /** |
| This function initializes the POC related variables and the POC syntax to be encoded |
| to the slice header derived from the disp_order and is_reference flag of the original |
| input frame to be encoded. |
| \param "video" "Pointer to the AVCEncObject." |
| \return "AVCENC_SUCCESS if success, |
| AVCENC_POC_FAIL if the poc type is undefined or |
| AVCENC_CONSECUTIVE_NONREF if there are consecutive non-reference frame for POC type 2." |
| */ |
| AVCEnc_Status InitPOC(AVCEncObject *video); |
| |
| /** |
| This function performs POC related operation after a picture is decoded. |
| \param "video" "Pointer to AVCCommonObj." |
| \return "AVCENC_SUCCESS" |
| */ |
| AVCEnc_Status PostPOC(AVCCommonObj *video); |
| |
| /*----------- bitstream_io.c ----------------*/ |
| /** |
| This function initializes the bitstream structure with the information given by |
| the users. |
| \param "bitstream" "Pointer to the AVCEncBitstream structure." |
| \param "buffer" "Pointer to the unsigned char buffer for output." |
| \param "buf_size" "The size of the buffer in bytes." |
| \param "overrunBuffer" "Pointer to extra overrun buffer." |
| \param "oBSize" "Size of overrun buffer in bytes." |
| \return "AVCENC_SUCCESS if success, AVCENC_BITSTREAM_INIT_FAIL if fail" |
| */ |
| AVCEnc_Status BitstreamEncInit(AVCEncBitstream *bitstream, uint8 *buffer, int buf_size, |
| uint8 *overrunBuffer, int oBSize); |
| |
| /** |
| This function writes the data from the cache into the bitstream buffer. It also adds the |
| emulation prevention code if necessary. |
| \param "stream" "Pointer to the AVCEncBitstream structure." |
| \return "AVCENC_SUCCESS if success or AVCENC_BITSTREAM_BUFFER_FULL if fail." |
| */ |
| AVCEnc_Status AVCBitstreamSaveWord(AVCEncBitstream *stream); |
| |
| /** |
| This function writes the codeword into the cache which will eventually be written to |
| the bitstream buffer. |
| \param "stream" "Pointer to the AVCEncBitstream structure." |
| \param "nBits" "Number of bits in the codeword." |
| \param "code" "The codeword." |
| \return "AVCENC_SUCCESS if success or AVCENC_BITSTREAM_BUFFER_FULL if fail." |
| */ |
| AVCEnc_Status BitstreamWriteBits(AVCEncBitstream *stream, int nBits, uint code); |
| |
| /** |
| This function writes one bit of data into the cache which will eventually be written |
| to the bitstream buffer. |
| \param "stream" "Pointer to the AVCEncBitstream structure." |
| \param "code" "The codeword." |
| \return "AVCENC_SUCCESS if success or AVCENC_BITSTREAM_BUFFER_FULL if fail." |
| */ |
| AVCEnc_Status BitstreamWrite1Bit(AVCEncBitstream *stream, uint code); |
| |
| /** |
| This function adds trailing bits to the bitstream and reports back the final EBSP size. |
| \param "stream" "Pointer to the AVCEncBitstream structure." |
| \param "nal_size" "Output the final NAL size." |
| \return "AVCENC_SUCCESS if success or AVCENC_BITSTREAM_BUFFER_FULL if fail." |
| */ |
| AVCEnc_Status BitstreamTrailingBits(AVCEncBitstream *bitstream, uint *nal_size); |
| |
| /** |
| This function checks whether the current bit position is byte-aligned or not. |
| \param "stream" "Pointer to the bitstream structure." |
| \return "true if byte-aligned, false otherwise." |
| */ |
| bool byte_aligned(AVCEncBitstream *stream); |
| |
| |
| /** |
| This function checks the availability of overrun buffer and switches to use it when |
| normal bufffer is not big enough. |
| \param "stream" "Pointer to the bitstream structure." |
| \param "numExtraBytes" "Number of extra byte needed." |
| \return "AVCENC_SUCCESS or AVCENC_FAIL." |
| */ |
| AVCEnc_Status AVCBitstreamUseOverrunBuffer(AVCEncBitstream* stream, int numExtraBytes); |
| |
| |
| /*-------------- intra_est.c ---------------*/ |
| |
| /** This function performs intra/inter decision based on ABE. |
| \param "encvid" "Pointer to AVCEncObject." |
| \param "min_cost" "Best inter cost." |
| \param "curL" "Pointer to the current MB origin in reconstructed frame." |
| \param "picPitch" "Pitch of the reconstructed frame." |
| \return "Boolean for intra mode." |
| */ |
| |
| //bool IntraDecisionABE(AVCEncObject *encvid, int min_cost, uint8 *curL, int picPitch); |
| bool IntraDecision(int *min_cost, uint8 *cur, int pitch, bool ave); |
| |
| /** |
| This function performs intra prediction mode search. |
| \param "encvid" "Pointer to AVCEncObject." |
| \param "mbnum" "Current MB number." |
| \param "curL" "Pointer to the current MB origin in reconstructed frame." |
| \param "picPitch" "Pitch of the reconstructed frame." |
| \return "void." |
| */ |
| void MBIntraSearch(AVCEncObject *encvid, int mbnum, uint8 *curL, int picPitch); |
| |
| /** |
| This function generates all the I16 prediction modes for an MB and keep it in |
| encvid->pred_i16. |
| \param "encvid" "Pointer to AVCEncObject." |
| \return "void" |
| */ |
| void intrapred_luma_16x16(AVCEncObject *encvid); |
| |
| /** |
| This function calculate the cost of all I16 modes and compare them to get the minimum. |
| \param "encvid" "Pointer to AVCEncObject." |
| \param "orgY" "Pointer to the original luma MB." |
| \param "min_cost" "Pointer to the minimal cost so-far." |
| \return "void" |
| */ |
| void find_cost_16x16(AVCEncObject *encvid, uint8 *orgY, int *min_cost); |
| |
| /** |
| This function calculates the cost of each I16 mode. |
| \param "org" "Pointer to the original luma MB." |
| \param "org_pitch" "Stride size of the original frame." |
| \param "pred" "Pointer to the prediction values." |
| \param "min_cost" "Minimal cost so-far." |
| \return "Cost" |
| */ |
| |
| int cost_i16(uint8 *org, int org_pitch, uint8 *pred, int min_cost); |
| |
| /** |
| This function generates all the I4 prediction modes and select the best one |
| for all the blocks inside a macroblock.It also calls dct_luma to generate the reconstructed |
| MB, and transform coefficients to be encoded. |
| \param "encvid" "Pointer to AVCEncObject." |
| \param "min_cost" "Pointer to the minimal cost so-far." |
| \return "void" |
| */ |
| void mb_intra4x4_search(AVCEncObject *encvid, int *min_cost); |
| |
| /** |
| This function calculates the most probable I4 mode of a given 4x4 block |
| from neighboring informationaccording to AVC/H.264 standard. |
| \param "video" "Pointer to AVCCommonObj." |
| \param "blkidx" "The current block index." |
| \return "Most probable mode." |
| */ |
| int FindMostProbableI4Mode(AVCCommonObj *video, int blkidx); |
| |
| /** |
| This function is where a lot of actions take place in the 4x4 block level inside |
| mb_intra4x4_search. |
| \param "encvid" "Pointer to AVCEncObject." |
| \param "blkidx" "The current 4x4 block index." |
| \param "cur" "Pointer to the reconstructed block." |
| \param "org" "Pointer to the original block." |
| \return "Minimal cost, also set currMB->i4Mode" |
| */ |
| int blk_intra4x4_search(AVCEncObject *encvid, int blkidx, uint8 *cur, uint8 *org); |
| |
| /** |
| This function calculates the cost of a given I4 prediction mode. |
| \param "org" "Pointer to the original block." |
| \param "org_pitch" "Stride size of the original frame." |
| \param "pred" "Pointer to the prediction block. (encvid->pred_i4)" |
| \param "cost" "Pointer to the minimal cost (to be updated)." |
| \return "void" |
| */ |
| void cost_i4(uint8 *org, int org_pitch, uint8 *pred, uint16 *cost); |
| |
| /** |
| This function performs chroma intra search. Each mode is saved in encvid->pred_ic. |
| \param "encvid" "Pointer to AVCEncObject." |
| \return "void" |
| */ |
| void chroma_intra_search(AVCEncObject *encvid); |
| |
| /** |
| This function calculates the cost of a chroma prediction mode. |
| \param "orgCb" "Pointer to the original Cb block." |
| \param "orgCr" "Pointer to the original Cr block." |
| \param "org_pitch" "Stride size of the original frame." |
| \param "pred" "Pointer to the prediction block (encvid->pred_ic)" |
| \param "mincost" "Minimal cost so far." |
| \return "Cost." |
| */ |
| |
| int SATDChroma(uint8 *orgCb, uint8 *orgCr, int org_pitch, uint8 *pred, int mincost); |
| |
| /*-------------- motion_comp.c ---------------*/ |
| |
| /** |
| This is a main function to peform inter prediction. |
| \param "encvid" "Pointer to AVCEncObject." |
| \param "video" "Pointer to AVCCommonObj." |
| \return "void". |
| */ |
| void AVCMBMotionComp(AVCEncObject *encvid, AVCCommonObj *video); |
| |
| |
| /** |
| This function is called for luma motion compensation. |
| \param "ref" "Pointer to the origin of a reference luma." |
| \param "picwidth" "Width of the picture." |
| \param "picheight" "Height of the picture." |
| \param "x_pos" "X-coordinate of the predicted block in quarter pel resolution." |
| \param "y_pos" "Y-coordinate of the predicted block in quarter pel resolution." |
| \param "pred" "Pointer to the output predicted block." |
| \param "pred_pitch" "Width of pred." |
| \param "blkwidth" "Width of the current partition." |
| \param "blkheight" "Height of the current partition." |
| \return "void" |
| */ |
| void eLumaMotionComp(uint8 *ref, int picwidth, int picheight, |
| int x_pos, int y_pos, |
| uint8 *pred, int pred_pitch, |
| int blkwidth, int blkheight); |
| |
| void eFullPelMC(uint8 *in, int inwidth, uint8 *out, int outpitch, |
| int blkwidth, int blkheight); |
| |
| void eHorzInterp1MC(uint8 *in, int inpitch, uint8 *out, int outpitch, |
| int blkwidth, int blkheight, int dx); |
| |
| void eHorzInterp2MC(int *in, int inpitch, uint8 *out, int outpitch, |
| int blkwidth, int blkheight, int dx); |
| |
| void eHorzInterp3MC(uint8 *in, int inpitch, int *out, int outpitch, |
| int blkwidth, int blkheight); |
| |
| void eVertInterp1MC(uint8 *in, int inpitch, uint8 *out, int outpitch, |
| int blkwidth, int blkheight, int dy); |
| |
| void eVertInterp2MC(uint8 *in, int inpitch, int *out, int outpitch, |
| int blkwidth, int blkheight); |
| |
| void eVertInterp3MC(int *in, int inpitch, uint8 *out, int outpitch, |
| int blkwidth, int blkheight, int dy); |
| |
| void eDiagonalInterpMC(uint8 *in1, uint8 *in2, int inpitch, |
| uint8 *out, int outpitch, |
| int blkwidth, int blkheight); |
| |
| void eChromaMotionComp(uint8 *ref, int picwidth, int picheight, |
| int x_pos, int y_pos, uint8 *pred, int pred_pitch, |
| int blkwidth, int blkheight); |
| |
| void eChromaDiagonalMC_SIMD(uint8 *pRef, int srcPitch, int dx, int dy, |
| uint8 *pOut, int predPitch, int blkwidth, int blkheight); |
| |
| void eChromaHorizontalMC_SIMD(uint8 *pRef, int srcPitch, int dx, int dy, |
| uint8 *pOut, int predPitch, int blkwidth, int blkheight); |
| |
| void eChromaVerticalMC_SIMD(uint8 *pRef, int srcPitch, int dx, int dy, |
| uint8 *pOut, int predPitch, int blkwidth, int blkheight); |
| |
| void eChromaFullMC_SIMD(uint8 *pRef, int srcPitch, int dx, int dy, |
| uint8 *pOut, int predPitch, int blkwidth, int blkheight); |
| |
| void eChromaVerticalMC2_SIMD(uint8 *pRef, int srcPitch, int dx, int dy, |
| uint8 *pOut, int predPitch, int blkwidth, int blkheight); |
| |
| void eChromaHorizontalMC2_SIMD(uint8 *pRef, int srcPitch, int dx, int dy, |
| uint8 *pOut, int predPitch, int blkwidth, int blkheight); |
| |
| void eChromaDiagonalMC2_SIMD(uint8 *pRef, int srcPitch, int dx, int dy, |
| uint8 *pOut, int predPitch, int blkwidth, int blkheight); |
| |
| |
| /*-------------- motion_est.c ---------------*/ |
| |
| /** |
| Allocate and initialize arrays necessary for motion search algorithm. |
| \param "envid" "Pointer to AVCEncObject." |
| \return "AVC_SUCCESS or AVC_MEMORY_FAIL." |
| */ |
| AVCEnc_Status InitMotionSearchModule(AVCHandle *avcHandle); |
| |
| /** |
| Clean up memory allocated in InitMotionSearchModule. |
| \param "envid" "Pointer to AVCEncObject." |
| \return "void." |
| */ |
| void CleanMotionSearchModule(AVCHandle *avcHandle); |
| |
| |
| /** |
| This function performs motion estimation of all macroblocks in a frame during the InitFrame. |
| The goal is to find the best MB partition for inter and find out if intra search is needed for |
| any MBs. This intra MB tendency can be used for scene change detection. |
| \param "encvid" "Pointer to AVCEncObject." |
| \return "void" |
| */ |
| void AVCMotionEstimation(AVCEncObject *encvid); |
| |
| /** |
| This function performs repetitive edge padding to the reference picture by adding 16 pixels |
| around the luma and 8 pixels around the chromas. |
| \param "refPic" "Pointer to the reference picture." |
| \return "void" |
| */ |
| void AVCPaddingEdge(AVCPictureData *refPic); |
| |
| /** |
| This function keeps track of intra refresh macroblock locations. |
| \param "encvid" "Pointer to the global array structure AVCEncObject." |
| \param "mblock" "Pointer to the array of AVCMacroblock structures." |
| \param "totalMB" "Total number of MBs in a frame." |
| \param "numRefresh" "Number of MB to be intra refresh in a single frame." |
| \return "void" |
| */ |
| void AVCRasterIntraUpdate(AVCEncObject *encvid, AVCMacroblock *mblock, int totalMB, int numRefresh); |
| |
| #ifdef HTFM |
| void InitHTFM(VideoEncData *encvid, HTFM_Stat *htfm_stat, double *newvar, int *collect); |
| void UpdateHTFM(AVCEncObject *encvid, double *newvar, double *exp_lamda, HTFM_Stat *htfm_stat); |
| void CalcThreshold(double pf, double exp_lamda[], int nrmlz_th[]); |
| void HTFMPrepareCurMB_AVC(AVCEncObject *encvid, HTFM_Stat *htfm_stat, uint8 *cur, int pitch); |
| #endif |
| |
| /** |
| This function reads the input MB into a smaller faster memory space to minimize the cache miss. |
| \param "encvid" "Pointer to the global AVCEncObject." |
| \param "cur" "Pointer to the original input macroblock." |
| \param "pitch" "Stride size of the input frame (luma)." |
| \return "void" |
| */ |
| void AVCPrepareCurMB(AVCEncObject *encvid, uint8 *cur, int pitch); |
| |
| /** |
| Performs motion vector search for a macroblock. |
| \param "encvid" "Pointer to AVCEncObject structure." |
| \param "cur" "Pointer to the current macroblock in the input frame." |
| \param "best_cand" "Array of best candidates (to be filled in and returned)." |
| \param "i0" "X-coordinate of the macroblock." |
| \param "j0" "Y-coordinate of the macroblock." |
| \param "type_pred" "Indicates the type of operations." |
| \param "FS_en" "Flag for fullsearch enable." |
| \param "hp_guess" "Guess for half-pel search." |
| \return "void" |
| */ |
| void AVCMBMotionSearch(AVCEncObject *encvid, uint8 *cur, uint8 *best_cand[], |
| int i0, int j0, int type_pred, int FS_en, int *hp_guess); |
| |
| //AVCEnc_Status AVCMBMotionSearch(AVCEncObject *encvid, AVCMacroblock *currMB, int mbNum, |
| // int num_pass); |
| |
| /** |
| Perform full-pel exhaustive search around the predicted MV. |
| \param "encvid" "Pointer to AVCEncObject structure." |
| \param "prev" "Pointer to the reference frame." |
| \param "cur" "Pointer to the input macroblock." |
| \param "imin" "Pointer to minimal mv (x)." |
| \param "jmin" "Pointer to minimal mv (y)." |
| \param "ilow, ihigh, jlow, jhigh" "Lower bound on search range." |
| \param "cmvx, cmvy" "Predicted MV value." |
| |
| \return "The cost function of the best candidate." |
| */ |
| int AVCFullSearch(AVCEncObject *encvid, uint8 *prev, uint8 *cur, |
| int *imin, int *jmin, int ilow, int ihigh, int jlow, int jhigh, |
| int cmvx, int cmvy); |
| |
| /** |
| Select candidates from neighboring blocks according to the type of the |
| prediction selection. |
| \param "mvx" "Pointer to the candidate, x-coordinate." |
| \param "mvy" "Pointer to the candidate, y-coordinate." |
| \param "num_can" "Pointer to the number of candidates returned." |
| \param "imb" "The MB index x-coordinate." |
| \param "jmb" "The MB index y-coordinate." |
| \param "type_pred" "Type of the prediction." |
| \param "cmvx, cmvy" "Pointer to predicted MV (modified version)." |
| \return "void." |
| */ |
| void AVCCandidateSelection(int *mvx, int *mvy, int *num_can, int imb, int jmb, |
| AVCEncObject *encvid, int type_pred, int *cmvx, int *cmvy); |
| |
| /** |
| Utility function to move the values in the array dn according to the new |
| location to avoid redundant calculation. |
| \param "dn" "Array of integer of size 9." |
| \param "new_loc" "New location index." |
| \return "void." |
| */ |
| void AVCMoveNeighborSAD(int dn[], int new_loc); |
| |
| /** |
| Find minimum index of dn. |
| \param "dn" "Array of integer of size 9." |
| \return "The index of dn with the smallest dn[] value." |
| */ |
| int AVCFindMin(int dn[]); |
| |
| |
| /*------------- findhalfpel.c -------------------*/ |
| |
| /** |
| Search for the best half-pel resolution MV around the full-pel MV. |
| \param "encvid" "Pointer to the global AVCEncObject structure." |
| \param "cur" "Pointer to the current macroblock." |
| \param "mot" "Pointer to the AVCMV array of the frame." |
| \param "ncand" "Pointer to the origin of the fullsearch result." |
| \param "xpos" "The current MB position in x." |
| \param "ypos" "The current MB position in y." |
| \param "hp_guess" "Input to help speedup the search." |
| \param "cmvx, cmvy" "Predicted motion vector use for mvcost." |
| \return "Minimal cost (SATD) without MV cost. (for rate control purpose)" |
| */ |
| int AVCFindHalfPelMB(AVCEncObject *encvid, uint8 *cur, AVCMV *mot, uint8 *ncand, |
| int xpos, int ypos, int hp_guess, int cmvx, int cmvy); |
| |
| /** |
| This function generates sub-pel pixels required to do subpel MV search. |
| \param "subpel_pred" "Pointer to 2-D array, each array for each position." |
| \param "ncand" "Pointer to the full-pel center position in ref frame." |
| \param "lx" "Pitch of the ref frame." |
| \return "void" |
| */ |
| void GenerateHalfPelPred(uint8 *subpel_pred, uint8 *ncand, int lx); |
| |
| /** |
| This function calculate vertical interpolation at half-point of size 4x17. |
| \param "dst" "Pointer to destination." |
| \param "ref" "Pointer to the starting reference pixel." |
| \return "void." |
| */ |
| void VertInterpWClip(uint8 *dst, uint8 *ref); |
| |
| /** |
| This function generates quarter-pel pixels around the best half-pel result |
| during the sub-pel MV search. |
| \param "bilin_base" "Array of pointers to be used as basis for q-pel interp." |
| \param "qpel_pred" "Array of pointers pointing to quarter-pel candidates." |
| \param "hpel_pos" "Best half-pel position at the center." |
| \return "void" |
| */ |
| void GenerateQuartPelPred(uint8 **bilin_base, uint8 *qpel_pred, int hpel_pos); |
| |
| /** |
| This function calculates the SATD of a subpel candidate. |
| \param "cand" "Pointer to a candidate." |
| \param "cur" "Pointer to the current block." |
| \param "dmin" "Min-so-far SATD." |
| \return "Sum of Absolute Transformed Difference." |
| */ |
| int SATD_MB(uint8 *cand, uint8 *cur, int dmin); |
| |
| /*------------- rate_control.c -------------------*/ |
| |
| /** This function is a utility function. It returns average QP of the previously encoded frame. |
| \param "rateCtrl" "Pointer to AVCRateControl structure." |
| \return "Average QP." |
| */ |
| int GetAvgFrameQP(AVCRateControl *rateCtrl); |
| |
| /** |
| This function takes the timestamp of the input and determine whether it should be encoded |
| or skipped. |
| \param "encvid" "Pointer to the AVCEncObject structure." |
| \param "rateCtrl" "Pointer to the AVCRateControl structure." |
| \param "modTime" "The 32 bit timestamp of the input frame." |
| \param "frameNum" "Pointer to the frame number if to be encoded." |
| \return "AVC_SUCCESS or else." |
| */ |
| AVCEnc_Status RCDetermineFrameNum(AVCEncObject *encvid, AVCRateControl *rateCtrl, uint32 modTime, uint *frameNum); |
| |
| /** |
| This function updates the buffer fullness when frames are dropped either by the |
| rate control algorithm or by the users to make sure that target bit rate is still met. |
| \param "video" "Pointer to the common object structure." |
| \param "rateCtrl" "Pointer to rate control structure." |
| \param "frameInc" "Difference of the current frame number and previous frame number." |
| \return "void." |
| */ |
| void RCUpdateBuffer(AVCCommonObj *video, AVCRateControl *rateCtrl, int frameInc); |
| |
| /** |
| This function initializes rate control module and allocates necessary bufferes to do the job. |
| \param "avcHandle" "Pointer to the encoder handle." |
| \return "AVCENC_SUCCESS or AVCENC_MEMORY_FAIL." |
| */ |
| AVCEnc_Status InitRateControlModule(AVCHandle *avcHandle); |
| |
| /** |
| This function frees buffers allocated in InitRateControlModule. |
| \param "avcHandle" "Pointer to the encoder handle." |
| \return "void." |
| */ |
| void CleanupRateControlModule(AVCHandle *avcHandle); |
| |
| /** |
| This function is called at the beginning of each GOP or the first IDR frame. It calculates |
| target bits for a GOP. |
| \param "encvid" "Pointer to the encoder object." |
| \return "void." |
| */ |
| void RCInitGOP(AVCEncObject *encvid); |
| |
| /** |
| This function calculates target bits for a particular frame. |
| \param "video" "Pointer to the AVCEncObject structure." |
| \return "void" |
| */ |
| void RCInitFrameQP(AVCEncObject *video); |
| |
| /** |
| This function calculates QP for the upcoming frame or basic unit. |
| \param "encvid" "Pointer to the encoder object." |
| \param "rateCtrl" "Pointer to the rate control object." |
| \return "QP value ranging from 0-51." |
| */ |
| int RCCalculateQP(AVCEncObject *encvid, AVCRateControl *rateCtrl); |
| |
| /** |
| This function translates the luma QP to chroma QP and calculates lambda based on QP. |
| \param "video" "Pointer to the AVCEncObject structure." |
| \return "void" |
| */ |
| void RCInitChromaQP(AVCEncObject *encvid); |
| |
| /** |
| This function is called before encoding each macroblock. |
| \param "encvid" "Pointer to the encoder object." |
| \return "void." |
| */ |
| void RCInitMBQP(AVCEncObject *encvid); |
| |
| /** |
| This function updates bits usage stats after encoding an macroblock. |
| \param "video" "Pointer to AVCCommonObj." |
| \param "rateCtrl" "Pointer to AVCRateControl." |
| \param "num_header_bits" "Number of bits used for MB header." |
| \param "num_texture_bits" "Number of bits used for MB texture." |
| \return "void" |
| */ |
| void RCPostMB(AVCCommonObj *video, AVCRateControl *rateCtrl, int num_header_bits, int num_texture_bits); |
| |
| /** |
| This function calculates the difference between prediction and original MB. |
| \param "encvid" "Pointer to the encoder object." |
| \param "currMB" "Pointer to the current macroblock structure." |
| \param "orgL" "Pointer to the original MB." |
| \param "orgPitch" "Pointer to the original picture pitch." |
| \return "void." |
| */ |
| void RCCalculateMAD(AVCEncObject *encvid, AVCMacroblock *currMB, uint8 *orgL, int orgPitch); |
| |
| /** |
| Restore QP related parameters of previous MB when current MB is skipped. |
| \param "currMB" "Pointer to the current macroblock." |
| \param "video" "Pointer to the common video structure." |
| \param "encvid" "Pointer to the global encoding structure." |
| \return "void" |
| */ |
| void RCRestoreQP(AVCMacroblock *currMB, AVCCommonObj *video, AVCEncObject *encvid); |
| |
| /** |
| This function is called after done with a frame. |
| \param "encvid" "Pointer to the encoder object." |
| \return "AVCENC_SUCCESS or AVCENC_SKIPPED_PICTURE when bufer overflow (need to discard current frame)." |
| */ |
| AVCEnc_Status RCUpdateFrame(AVCEncObject *encvid); |
| |
| /*--------- residual.c -------------------*/ |
| |
| /** |
| This function encodes the intra pcm data and fill it in the corresponding location |
| on the current picture. |
| \param "video" "Pointer to AVCEncObject." |
| \return "AVCENC_SUCCESS if success, or else for bitstream errors." |
| */ |
| AVCEnc_Status EncodeIntraPCM(AVCEncObject *video); |
| |
| /** |
| This function performs CAVLC syntax encoding on the run and level information of the coefficients. |
| The level and run arrays are elements in AVCEncObject structure, populated by TransQuantZZ, |
| TransQuantIntraDC and TransQuantChromaDC functions. |
| \param "video" "Pointer to AVCEncObject." |
| \param "type" "One of AVCResidualType for a particular 4x4 block." |
| \param "bindx" "Block index or number of nonzero coefficients for AVC_Intra16DC and AVC_ChromaDC mode." |
| \param "currMB" "Pointer to the current macroblock structure." |
| \return "AVCENC_SUCCESS for success." |
| \Note "This function has 32-bit machine specific instruction!!!!" |
| */ |
| AVCEnc_Status enc_residual_block(AVCEncObject *encvid, AVCResidualType type, int bindx, AVCMacroblock *currMB); |
| |
| |
| /*------------- sad.c ---------------------------*/ |
| |
| |
| int AVCSAD_MB_HalfPel_Cxhyh(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info); |
| int AVCSAD_MB_HalfPel_Cyh(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info); |
| int AVCSAD_MB_HalfPel_Cxh(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info); |
| int AVCSAD_Macroblock_C(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info); |
| |
| #ifdef HTFM /* 3/2/1, Hypothesis Testing Fast Matching */ |
| int AVCSAD_MB_HP_HTFM_Collectxhyh(uint8 *ref, uint8 *blk, int dmin_x, void *extra_info); |
| int AVCSAD_MB_HP_HTFM_Collectyh(uint8 *ref, uint8 *blk, int dmin_x, void *extra_info); |
| int AVCSAD_MB_HP_HTFM_Collectxh(uint8 *ref, uint8 *blk, int dmin_x, void *extra_info); |
| int AVCSAD_MB_HP_HTFMxhyh(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info); |
| int AVCSAD_MB_HP_HTFMyh(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info); |
| int AVCSAD_MB_HP_HTFMxh(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info); |
| int AVCSAD_MB_HTFM_Collect(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info); |
| int AVCSAD_MB_HTFM(uint8 *ref, uint8 *blk, int dmin_lx, void *extra_info); |
| #endif |
| |
| |
| /*------------- slice.c -------------------------*/ |
| |
| /** |
| This function performs the main encoding loop for a slice. |
| \param "encvid" "Pointer to AVCEncObject." |
| \return "AVCENC_SUCCESS for success, AVCENC_PICTURE_READY for end-of-picture and |
| AVCENC_FAIL or AVCENC_SLICE_EMPTY otherwise." |
| */ |
| AVCEnc_Status AVCEncodeSlice(AVCEncObject *encvid); |
| |
| /** |
| This function performs the main encoding operation for one macroblock. |
| \param "video" "pointer to AVCEncObject." |
| \return "AVCENC_SUCCESS for success, or other bitstream related failure status." |
| */ |
| AVCEnc_Status EncodeMB(AVCEncObject *video); |
| |
| /** |
| This function calls prediction INTRA/INTER functions, transform, |
| quantization and zigzag scanning to get the run-level symbols. |
| \param "encvid" "pointer to AVCEncObject." |
| \param "curL" "pointer to Luma component of the current frame. |
| \param "curCb" "pointer to Cb component of the current frame. |
| \param "curCr" "pointer to Cr component of the current frame. |
| \return "void for now." |
| */ |
| void MBPredTransQuantZZ(AVCEncObject *encvid, uint8 *curL, uint8 *curCb, uint8 *curCr); |
| |
| /** |
| This function copies the content of the prediction MB into the reconstructed YUV |
| frame directly. |
| \param "curL" "Pointer to the destination Y component." |
| \param "curCb" "Pointer to the destination Cb component." |
| \param "curCr" "Pointer to the destination Cr component." |
| \param "predBlock" "Pointer to the prediction MB." |
| \param "picWidth" "The width of the frame." |
| \return "None." |
| */ |
| void Copy_MB(uint8 *curL, uint8 *curCb, uint8 *curCr, uint8 *predBlock, int picWidth); |
| |
| /** |
| This function encodes the mb_type, CBP, prediction mode, ref idx and MV. |
| \param "currMB" "Pointer to the current macroblock structure." |
| \param "video" "Pointer to the AVCEncObject structure." |
| \return "AVCENC_SUCCESS for success or else for fail." |
| */ |
| AVCEnc_Status EncodeMBHeader(AVCMacroblock *currMB, AVCEncObject *video); |
| |
| /** |
| This function finds the right mb_type for a macroblock given the mbMode, CBP, |
| NumPart, PredPartMode. |
| \param "currMB" "Pointer to the current macroblock structure." |
| \param "slice_type" "Value of the slice_type." |
| \return "mb_type." |
| */ |
| uint InterpretMBType(AVCMacroblock *currMB, int slice_type); |
| |
| /** |
| This function encodes the mb_pred part of the macroblock data. |
| \param "video" "Pointer to the AVCCommonObj structure." |
| \param "currMB" "Pointer to the current macroblock structure." |
| \param "stream" "Pointer to the AVCEncBitstream structure." |
| \return "AVCENC_SUCCESS for success or bitstream fail status." |
| */ |
| AVCEnc_Status mb_pred(AVCCommonObj *video, AVCMacroblock *currMB, AVCEncBitstream *stream); |
| |
| /** |
| This function encodes the sub_mb_pred part of the macroblock data. |
| \param "video" "Pointer to the AVCCommonObj structure." |
| \param "currMB" "Pointer to the current macroblock structure." |
| \param "stream" "Pointer to the AVCEncBitstream structure." |
| \return "AVCENC_SUCCESS for success or bitstream fail status." |
| */ |
| AVCEnc_Status sub_mb_pred(AVCCommonObj *video, AVCMacroblock *currMB, AVCEncBitstream *stream); |
| |
| /** |
| This function interprets the sub_mb_type and sets necessary information |
| when the slice type is AVC_P_SLICE. |
| in the macroblock structure. |
| \param "mblock" "Pointer to current AVCMacroblock." |
| \param "sub_mb_type" "From the syntax bitstream." |
| \return "void" |
| */ |
| void InterpretSubMBTypeP(AVCMacroblock *mblock, uint *sub_mb_type); |
| |
| /** |
| This function interprets the sub_mb_type and sets necessary information |
| when the slice type is AVC_B_SLICE. |
| in the macroblock structure. |
| \param "mblock" "Pointer to current AVCMacroblock." |
| \param "sub_mb_type" "From the syntax bitstream." |
| \return "void" |
| */ |
| void InterpretSubMBTypeB(AVCMacroblock *mblock, uint *sub_mb_type); |
| |
| /** |
| This function encodes intra 4x4 mode. It calculates the predicted I4x4 mode and the |
| remnant to be encoded. |
| \param "video" "Pointer to AVCEncObject structure." |
| \param "currMB" "Pointer to the AVCMacroblock structure." |
| \param "stream" "Pointer to AVCEncBitstream sructure." |
| \return "AVCENC_SUCCESS for success." |
| */ |
| AVCEnc_Status EncodeIntra4x4Mode(AVCCommonObj *video, AVCMacroblock *currMB, AVCEncBitstream *stream); |
| |
| /*------------- vlc_encode.c -----------------------*/ |
| /** |
| This function encodes and writes a value into an Exp-Golomb codeword. |
| \param "bitstream" "Pointer to AVCEncBitstream." |
| \param "codeNum" "Pointer to the value of the codeNum." |
| \return "AVCENC_SUCCESS for success or bitstream error messages for fail." |
| */ |
| AVCEnc_Status ue_v(AVCEncBitstream *bitstream, uint codeNum); |
| |
| /** |
| This function maps and encodes signed Exp-Golomb codes. |
| \param "bitstream" "Pointer to AVCEncBitstream." |
| \param "value" "Pointer to syntax element value." |
| \return "AVCENC_SUCCESS or AVCENC_FAIL." |
| */ |
| AVCEnc_Status se_v(AVCEncBitstream *bitstream, int value); |
| |
| /** |
| This function maps and encodes truncated Exp-Golomb codes. |
| \param "bitstream" "Pointer to AVCEncBitstream." |
| \param "value" "Pointer to syntax element value." |
| \param "range" "Range of the value as input to determine the algorithm." |
| \return "AVCENC_SUCCESS or AVCENC_FAIL." |
| */ |
| AVCEnc_Status te_v(AVCEncBitstream *bitstream, uint value, uint range); |
| |
| /** |
| This function creates Exp-Golomb codeword from codeNum. |
| \param "bitstream" "Pointer to AVCEncBitstream." |
| \param "codeNum" "Pointer to the codeNum value." |
| \return "AVCENC_SUCCESS for success or bitstream error messages for fail." |
| */ |
| AVCEnc_Status SetEGBitstring(AVCEncBitstream *bitstream, uint codeNum); |
| |
| /** |
| This function performs CAVLC encoding of the CBP (coded block pattern) of a macroblock |
| by calling ue_v() and then mapping the CBP to the corresponding VLC codeNum. |
| \param "currMB" "Pointer to the current AVCMacroblock structure." |
| \param "stream" "Pointer to the AVCEncBitstream." |
| \return "void" |
| */ |
| AVCEnc_Status EncodeCBP(AVCMacroblock *currMB, AVCEncBitstream *stream); |
| |
| /** |
| This function encodes trailing ones and total coefficient. |
| \param "stream" "Pointer to the AVCEncBitstream." |
| \param "TrailingOnes" "The trailing one variable output." |
| \param "TotalCoeff" "The total coefficient variable output." |
| \param "nC" "Context for number of nonzero coefficient (prediction context)." |
| \return "AVCENC_SUCCESS for success or else for bitstream failure." |
| */ |
| AVCEnc_Status ce_TotalCoeffTrailingOnes(AVCEncBitstream *stream, int TrailingOnes, int TotalCoeff, int nC); |
| |
| /** |
| This function encodes trailing ones and total coefficient for chroma DC block. |
| \param "stream" "Pointer to the AVCEncBitstream." |
| \param "TrailingOnes" "The trailing one variable output." |
| \param "TotalCoeff" "The total coefficient variable output." |
| \return "AVCENC_SUCCESS for success or else for bitstream failure." |
| */ |
| AVCEnc_Status ce_TotalCoeffTrailingOnesChromaDC(AVCEncBitstream *stream, int TrailingOnes, int TotalCoeff); |
| |
| /** |
| This function encodes total_zeros value as in Table 9-7 and 9-8. |
| \param "stream" "Pointer to the AVCEncBitstream." |
| \param "TotalZeros" "The total_zeros value." |
| \param "TotalCoeff" "The total coefficient variable output." |
| \return "AVCENC_SUCCESS for success or else for bitstream failure." |
| */ |
| AVCEnc_Status ce_TotalZeros(AVCEncBitstream *stream, int total_zeros, int TotalCoeff); |
| |
| /** |
| This function encodes total_zeros VLC syntax for chroma DC as in Table 9-9. |
| \param "stream" "Pointer to the AVCEncBitstream." |
| \param "TotalZeros" "The total_zeros value." |
| \param "TotalCoeff" "The total coefficient variable output." |
| \return "AVCENC_SUCCESS for success or else for bitstream failure." |
| */ |
| AVCEnc_Status ce_TotalZerosChromaDC(AVCEncBitstream *stream, int total_zeros, int TotalCoeff); |
| |
| /** |
| This function encodes run_before VLC syntax as in Table 9-10. |
| \param "stream" "Pointer to the AVCEncBitstream." |
| \param "run_before" "The run_before value." |
| \param "zerosLeft" "The context for number of zeros left." |
| \return "AVCENC_SUCCESS for success or else for bitstream failure." |
| */ |
| AVCEnc_Status ce_RunBefore(AVCEncBitstream *stream, int run_before, int zerosLeft); |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| |
| #endif /* _AVCENC_LIB_H_ */ |
| |
