diff options
Diffstat (limited to 'media/libstagefright/codecs/avc/enc/src/avcenc_lib.h')
| -rw-r--r-- | media/libstagefright/codecs/avc/enc/src/avcenc_lib.h | 1020 |
1 files changed, 1020 insertions, 0 deletions
diff --git a/media/libstagefright/codecs/avc/enc/src/avcenc_lib.h b/media/libstagefright/codecs/avc/enc/src/avcenc_lib.h new file mode 100644 index 0000000..17e28ef --- /dev/null +++ b/media/libstagefright/codecs/avc/enc/src/avcenc_lib.h @@ -0,0 +1,1020 @@ +/* ------------------------------------------------------------------ + * 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_ */ + |