diff options
Diffstat (limited to 'media/libstagefright/codecs/avc/enc/src/avcenc_api.cpp')
| -rw-r--r-- | media/libstagefright/codecs/avc/enc/src/avcenc_api.cpp | 744 |
1 files changed, 744 insertions, 0 deletions
diff --git a/media/libstagefright/codecs/avc/enc/src/avcenc_api.cpp b/media/libstagefright/codecs/avc/enc/src/avcenc_api.cpp new file mode 100644 index 0000000..d39885d --- /dev/null +++ b/media/libstagefright/codecs/avc/enc/src/avcenc_api.cpp @@ -0,0 +1,744 @@ +/* ------------------------------------------------------------------ + * 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. + * ------------------------------------------------------------------- + */ +#include "avcenc_api.h" +#include "avcenc_lib.h" + +/* ======================================================================== */ +/* Function : PVAVCGetNALType() */ +/* Date : 11/4/2003 */ +/* Purpose : Sniff NAL type from the bitstream */ +/* In/out : */ +/* Return : AVCENC_SUCCESS if succeed, AVCENC_FAIL if fail. */ +/* Modified : */ +/* ======================================================================== */ +OSCL_EXPORT_REF AVCEnc_Status PVAVCEncGetNALType(unsigned char *bitstream, int size, + int *nal_type, int *nal_ref_idc) +{ + int forbidden_zero_bit; + if (size > 0) + { + forbidden_zero_bit = bitstream[0] >> 7; + if (forbidden_zero_bit != 0) + return AVCENC_FAIL; + *nal_ref_idc = (bitstream[0] & 0x60) >> 5; + *nal_type = bitstream[0] & 0x1F; + return AVCENC_SUCCESS; + } + + return AVCENC_FAIL; +} + + +/* ======================================================================== */ +/* Function : PVAVCEncInitialize() */ +/* Date : 3/18/2004 */ +/* Purpose : Initialize the encoder library, allocate memory and verify */ +/* the profile/level support/settings. */ +/* In/out : Encoding parameters. */ +/* Return : AVCENC_SUCCESS for success. */ +/* Modified : */ +/* ======================================================================== */ +OSCL_EXPORT_REF AVCEnc_Status PVAVCEncInitialize(AVCHandle *avcHandle, AVCEncParams *encParam, + void* extSPS, void* extPPS) +{ + AVCEnc_Status status; + AVCEncObject *encvid; + AVCCommonObj *video; + uint32 *userData = (uint32*) avcHandle->userData; + int framesize; + + if (avcHandle->AVCObject != NULL) + { + return AVCENC_ALREADY_INITIALIZED; /* It's already initialized, need to cleanup first */ + } + + /* not initialized */ + + /* allocate videoObject */ + avcHandle->AVCObject = (void*)avcHandle->CBAVC_Malloc(userData, sizeof(AVCEncObject), DEFAULT_ATTR); + if (avcHandle->AVCObject == NULL) + { + return AVCENC_MEMORY_FAIL; + } + + encvid = (AVCEncObject*) avcHandle->AVCObject; + memset(encvid, 0, sizeof(AVCEncObject)); /* reset everything */ + + encvid->enc_state = AVCEnc_Initializing; + + encvid->avcHandle = avcHandle; + + encvid->common = (AVCCommonObj*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCCommonObj), DEFAULT_ATTR); + if (encvid->common == NULL) + { + return AVCENC_MEMORY_FAIL; + } + + video = encvid->common; + memset(video, 0, sizeof(AVCCommonObj)); + + /* allocate bitstream structure */ + encvid->bitstream = (AVCEncBitstream*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCEncBitstream), DEFAULT_ATTR); + if (encvid->bitstream == NULL) + { + return AVCENC_MEMORY_FAIL; + } + encvid->bitstream->encvid = encvid; /* to point back for reallocation */ + + /* allocate sequence parameter set structure */ + video->currSeqParams = (AVCSeqParamSet*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCSeqParamSet), DEFAULT_ATTR); + if (video->currSeqParams == NULL) + { + return AVCENC_MEMORY_FAIL; + } + memset(video->currSeqParams, 0, sizeof(AVCSeqParamSet)); + + /* allocate picture parameter set structure */ + video->currPicParams = (AVCPicParamSet*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCPicParamSet), DEFAULT_ATTR); + if (video->currPicParams == NULL) + { + return AVCENC_MEMORY_FAIL; + } + memset(video->currPicParams, 0, sizeof(AVCPicParamSet)); + + /* allocate slice header structure */ + video->sliceHdr = (AVCSliceHeader*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCSliceHeader), DEFAULT_ATTR); + if (video->sliceHdr == NULL) + { + return AVCENC_MEMORY_FAIL; + } + memset(video->sliceHdr, 0, sizeof(AVCSliceHeader)); + + /* allocate encoded picture buffer structure*/ + video->decPicBuf = (AVCDecPicBuffer*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCDecPicBuffer), DEFAULT_ATTR); + if (video->decPicBuf == NULL) + { + return AVCENC_MEMORY_FAIL; + } + memset(video->decPicBuf, 0, sizeof(AVCDecPicBuffer)); + + /* allocate rate control structure */ + encvid->rateCtrl = (AVCRateControl*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCRateControl), DEFAULT_ATTR); + if (encvid->rateCtrl == NULL) + { + return AVCENC_MEMORY_FAIL; + } + memset(encvid->rateCtrl, 0, sizeof(AVCRateControl)); + + /* reset frame list, not really needed */ + video->currPic = NULL; + video->currFS = NULL; + encvid->currInput = NULL; + video->prevRefPic = NULL; + + /* now read encParams, and allocate dimension-dependent variables */ + /* such as mblock */ + status = SetEncodeParam(avcHandle, encParam, extSPS, extPPS); /* initialized variables to be used in SPS*/ + if (status != AVCENC_SUCCESS) + { + return status; + } + + if (encParam->use_overrun_buffer == AVC_ON) + { + /* allocate overrun buffer */ + encvid->oBSize = encvid->rateCtrl->cpbSize; + if (encvid->oBSize > DEFAULT_OVERRUN_BUFFER_SIZE) + { + encvid->oBSize = DEFAULT_OVERRUN_BUFFER_SIZE; + } + encvid->overrunBuffer = (uint8*) avcHandle->CBAVC_Malloc(userData, encvid->oBSize, DEFAULT_ATTR); + if (encvid->overrunBuffer == NULL) + { + return AVCENC_MEMORY_FAIL; + } + } + else + { + encvid->oBSize = 0; + encvid->overrunBuffer = NULL; + } + + /* allocate frame size dependent structures */ + framesize = video->FrameHeightInMbs * video->PicWidthInMbs; + + video->mblock = (AVCMacroblock*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCMacroblock) * framesize, DEFAULT_ATTR); + if (video->mblock == NULL) + { + return AVCENC_MEMORY_FAIL; + } + + video->MbToSliceGroupMap = (int*) avcHandle->CBAVC_Malloc(userData, sizeof(uint) * video->PicSizeInMapUnits * 2, DEFAULT_ATTR); + if (video->MbToSliceGroupMap == NULL) + { + return AVCENC_MEMORY_FAIL; + } + + encvid->mot16x16 = (AVCMV*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCMV) * framesize, DEFAULT_ATTR); + if (encvid->mot16x16 == NULL) + { + return AVCENC_MEMORY_FAIL; + } + memset(encvid->mot16x16, 0, sizeof(AVCMV)*framesize); + + encvid->intraSearch = (uint8*) avcHandle->CBAVC_Malloc(userData, sizeof(uint8) * framesize, DEFAULT_ATTR); + if (encvid->intraSearch == NULL) + { + return AVCENC_MEMORY_FAIL; + } + + encvid->min_cost = (int*) avcHandle->CBAVC_Malloc(userData, sizeof(int) * framesize, DEFAULT_ATTR); + if (encvid->min_cost == NULL) + { + return AVCENC_MEMORY_FAIL; + } + + /* initialize motion search related memory */ + if (AVCENC_SUCCESS != InitMotionSearchModule(avcHandle)) + { + return AVCENC_MEMORY_FAIL; + } + + if (AVCENC_SUCCESS != InitRateControlModule(avcHandle)) + { + return AVCENC_MEMORY_FAIL; + } + + /* intialize function pointers */ + encvid->functionPointer = (AVCEncFuncPtr*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCEncFuncPtr), DEFAULT_ATTR); + if (encvid->functionPointer == NULL) + { + return AVCENC_MEMORY_FAIL; + } + encvid->functionPointer->SAD_Macroblock = &AVCSAD_Macroblock_C; + encvid->functionPointer->SAD_MB_HalfPel[0] = NULL; + encvid->functionPointer->SAD_MB_HalfPel[1] = &AVCSAD_MB_HalfPel_Cxh; + encvid->functionPointer->SAD_MB_HalfPel[2] = &AVCSAD_MB_HalfPel_Cyh; + encvid->functionPointer->SAD_MB_HalfPel[3] = &AVCSAD_MB_HalfPel_Cxhyh; + + /* initialize timing control */ + encvid->modTimeRef = 0; /* ALWAYS ASSUME THAT TIMESTAMP START FROM 0 !!!*/ + video->prevFrameNum = 0; + encvid->prevCodedFrameNum = 0; + encvid->dispOrdPOCRef = 0; + + if (encvid->outOfBandParamSet == TRUE) + { + encvid->enc_state = AVCEnc_Encoding_SPS; + } + else + { + encvid->enc_state = AVCEnc_Analyzing_Frame; + } + + return AVCENC_SUCCESS; +} + +/* ======================================================================== */ +/* Function : PVAVCEncGetMaxOutputSize() */ +/* Date : 11/29/2008 */ +/* Purpose : Return max output buffer size that apps should allocate for */ +/* output buffer. */ +/* In/out : */ +/* Return : AVCENC_SUCCESS for success. */ +/* Modified : size */ +/* ======================================================================== */ + +OSCL_EXPORT_REF AVCEnc_Status PVAVCEncGetMaxOutputBufferSize(AVCHandle *avcHandle, int* size) +{ + AVCEncObject *encvid = (AVCEncObject*)avcHandle->AVCObject; + + if (encvid == NULL) + { + return AVCENC_UNINITIALIZED; + } + + *size = encvid->rateCtrl->cpbSize; + + return AVCENC_SUCCESS; +} + +/* ======================================================================== */ +/* Function : PVAVCEncSetInput() */ +/* Date : 4/18/2004 */ +/* Purpose : To feed an unencoded original frame to the encoder library. */ +/* In/out : */ +/* Return : AVCENC_SUCCESS for success. */ +/* Modified : */ +/* ======================================================================== */ +OSCL_EXPORT_REF AVCEnc_Status PVAVCEncSetInput(AVCHandle *avcHandle, AVCFrameIO *input) +{ + AVCEncObject *encvid = (AVCEncObject*)avcHandle->AVCObject; + AVCCommonObj *video = encvid->common; + AVCRateControl *rateCtrl = encvid->rateCtrl; + + AVCEnc_Status status; + uint frameNum; + + if (encvid == NULL) + { + return AVCENC_UNINITIALIZED; + } + + if (encvid->enc_state == AVCEnc_WaitingForBuffer) + { + goto RECALL_INITFRAME; + } + else if (encvid->enc_state != AVCEnc_Analyzing_Frame) + { + return AVCENC_FAIL; + } + + if (input->pitch > 0xFFFF) + { + return AVCENC_NOT_SUPPORTED; // we use 2-bytes for pitch + } + + /***********************************/ + + /* Let's rate control decide whether to encode this frame or not */ + /* Also set video->nal_unit_type, sliceHdr->slice_type, video->slice_type */ + if (AVCENC_SUCCESS != RCDetermineFrameNum(encvid, rateCtrl, input->coding_timestamp, &frameNum)) + { + return AVCENC_SKIPPED_PICTURE; /* not time to encode, thus skipping */ + } + + /* we may not need this line */ + //nextFrmModTime = (uint32)((((frameNum+1)*1000)/rateCtrl->frame_rate) + modTimeRef); /* rec. time */ + //encvid->nextModTime = nextFrmModTime - (encvid->frameInterval>>1) - 1; /* between current and next frame */ + + encvid->currInput = input; + encvid->currInput->coding_order = frameNum; + +RECALL_INITFRAME: + /* initialize and analyze the frame */ + status = InitFrame(encvid); + + if (status == AVCENC_SUCCESS) + { + encvid->enc_state = AVCEnc_Encoding_Frame; + } + else if (status == AVCENC_NEW_IDR) + { + if (encvid->outOfBandParamSet == TRUE) + { + encvid->enc_state = AVCEnc_Encoding_Frame; + } + else // assuming that in-band paramset keeps sending new SPS and PPS. + { + encvid->enc_state = AVCEnc_Encoding_SPS; + //video->currSeqParams->seq_parameter_set_id++; + //if(video->currSeqParams->seq_parameter_set_id > 31) // range check + { + video->currSeqParams->seq_parameter_set_id = 0; // reset + } + } + + video->sliceHdr->idr_pic_id++; + if (video->sliceHdr->idr_pic_id > 65535) // range check + { + video->sliceHdr->idr_pic_id = 0; // reset + } + } + /* the following logics need to be revisited */ + else if (status == AVCENC_PICTURE_READY) // no buffers returned back to the encoder + { + encvid->enc_state = AVCEnc_WaitingForBuffer; // Input accepted but can't continue + // need to free up some memory before proceeding with Encode + } + + return status; // return status, including the AVCENC_FAIL case and all 3 above. +} + +/* ======================================================================== */ +/* Function : PVAVCEncodeNAL() */ +/* Date : 4/29/2004 */ +/* Purpose : To encode one NAL/slice. */ +/* In/out : */ +/* Return : AVCENC_SUCCESS for success. */ +/* Modified : */ +/* ======================================================================== */ +OSCL_EXPORT_REF AVCEnc_Status PVAVCEncodeNAL(AVCHandle *avcHandle, unsigned char *buffer, unsigned int *buf_nal_size, int *nal_type) +{ + AVCEncObject *encvid = (AVCEncObject*)avcHandle->AVCObject; + AVCCommonObj *video = encvid->common; + AVCEncBitstream *bitstream = encvid->bitstream; + AVCEnc_Status status; + + if (encvid == NULL) + { + return AVCENC_UNINITIALIZED; + } + + switch (encvid->enc_state) + { + case AVCEnc_Initializing: + return AVCENC_UNINITIALIZED; + case AVCEnc_Encoding_SPS: + /* initialized the structure */ + BitstreamEncInit(bitstream, buffer, *buf_nal_size, NULL, 0); + BitstreamWriteBits(bitstream, 8, (1 << 5) | AVC_NALTYPE_SPS); + + /* encode SPS */ + status = EncodeSPS(encvid, bitstream); + if (status != AVCENC_SUCCESS) + { + return status; + } + + /* closing the NAL with trailing bits */ + status = BitstreamTrailingBits(bitstream, buf_nal_size); + if (status == AVCENC_SUCCESS) + { + encvid->enc_state = AVCEnc_Encoding_PPS; + video->currPicParams->seq_parameter_set_id = video->currSeqParams->seq_parameter_set_id; + video->currPicParams->pic_parameter_set_id++; + *nal_type = AVC_NALTYPE_SPS; + *buf_nal_size = bitstream->write_pos; + } + break; + case AVCEnc_Encoding_PPS: + /* initialized the structure */ + BitstreamEncInit(bitstream, buffer, *buf_nal_size, NULL, 0); + BitstreamWriteBits(bitstream, 8, (1 << 5) | AVC_NALTYPE_PPS); + + /* encode PPS */ + status = EncodePPS(encvid, bitstream); + if (status != AVCENC_SUCCESS) + { + return status; + } + + /* closing the NAL with trailing bits */ + status = BitstreamTrailingBits(bitstream, buf_nal_size); + if (status == AVCENC_SUCCESS) + { + if (encvid->outOfBandParamSet == TRUE) // already extract PPS, SPS + { + encvid->enc_state = AVCEnc_Analyzing_Frame; + } + else // SetInput has been called before SPS and PPS. + { + encvid->enc_state = AVCEnc_Encoding_Frame; + } + + *nal_type = AVC_NALTYPE_PPS; + *buf_nal_size = bitstream->write_pos; + } + break; + + case AVCEnc_Encoding_Frame: + /* initialized the structure */ + BitstreamEncInit(bitstream, buffer, *buf_nal_size, encvid->overrunBuffer, encvid->oBSize); + BitstreamWriteBits(bitstream, 8, (video->nal_ref_idc << 5) | (video->nal_unit_type)); + + /* Re-order the reference list according to the ref_pic_list_reordering() */ + /* We don't have to reorder the list for the encoder here. This can only be done + after we encode this slice. We can run thru a second-pass to see if new ordering + would save more bits. Too much delay !! */ + /* status = ReOrderList(video);*/ + status = InitSlice(encvid); + if (status != AVCENC_SUCCESS) + { + return status; + } + + /* when we have everything, we encode the slice header */ + status = EncodeSliceHeader(encvid, bitstream); + if (status != AVCENC_SUCCESS) + { + return status; + } + + status = AVCEncodeSlice(encvid); + + video->slice_id++; + + /* closing the NAL with trailing bits */ + BitstreamTrailingBits(bitstream, buf_nal_size); + + *buf_nal_size = bitstream->write_pos; + + encvid->rateCtrl->numFrameBits += ((*buf_nal_size) << 3); + + *nal_type = video->nal_unit_type; + + if (status == AVCENC_PICTURE_READY) + { + status = RCUpdateFrame(encvid); + if (status == AVCENC_SKIPPED_PICTURE) /* skip current frame */ + { + DPBReleaseCurrentFrame(avcHandle, video); + encvid->enc_state = AVCEnc_Analyzing_Frame; + + return status; + } + + /* perform loop-filtering on the entire frame */ + DeblockPicture(video); + + /* update the original frame array */ + encvid->prevCodedFrameNum = encvid->currInput->coding_order; + + /* store the encoded picture in the DPB buffer */ + StorePictureInDPB(avcHandle, video); + + if (video->currPic->isReference) + { + video->PrevRefFrameNum = video->sliceHdr->frame_num; + } + + /* update POC related variables */ + PostPOC(video); + + encvid->enc_state = AVCEnc_Analyzing_Frame; + status = AVCENC_PICTURE_READY; + + } + break; + default: + status = AVCENC_WRONG_STATE; + } + + return status; +} + +/* ======================================================================== */ +/* Function : PVAVCEncGetOverrunBuffer() */ +/* Purpose : To retrieve the overrun buffer. Check whether overrun buffer */ +/* is used or not before returning */ +/* In/out : */ +/* Return : Pointer to the internal overrun buffer. */ +/* Modified : */ +/* ======================================================================== */ +OSCL_EXPORT_REF uint8* PVAVCEncGetOverrunBuffer(AVCHandle* avcHandle) +{ + AVCEncObject *encvid = (AVCEncObject*)avcHandle->AVCObject; + AVCEncBitstream *bitstream = encvid->bitstream; + + if (bitstream->overrunBuffer == bitstream->bitstreamBuffer) /* OB is used */ + { + return encvid->overrunBuffer; + } + else + { + return NULL; + } +} + + +/* ======================================================================== */ +/* Function : PVAVCEncGetRecon() */ +/* Date : 4/29/2004 */ +/* Purpose : To retrieve the most recently encoded frame. */ +/* assume that user will make a copy if they want to hold on */ +/* to it. Otherwise, it is not guaranteed to be reserved. */ +/* Most applications prefer to see original frame rather than */ +/* reconstructed frame. So, we are staying aware from complex */ +/* buffering mechanism. If needed, can be added later. */ +/* In/out : */ +/* Return : AVCENC_SUCCESS for success. */ +/* Modified : */ +/* ======================================================================== */ +OSCL_EXPORT_REF AVCEnc_Status PVAVCEncGetRecon(AVCHandle *avcHandle, AVCFrameIO *recon) +{ + AVCEncObject *encvid = (AVCEncObject*)avcHandle->AVCObject; + AVCCommonObj *video = encvid->common; + AVCFrameStore *currFS = video->currFS; + + if (encvid == NULL) + { + return AVCENC_UNINITIALIZED; + } + + recon->YCbCr[0] = currFS->frame.Sl; + recon->YCbCr[1] = currFS->frame.Scb; + recon->YCbCr[2] = currFS->frame.Scr; + recon->height = currFS->frame.height; + recon->pitch = currFS->frame.pitch; + recon->disp_order = currFS->PicOrderCnt; + recon->coding_order = currFS->FrameNum; + recon->id = (uint32) currFS->base_dpb; /* use the pointer as the id */ + + currFS->IsOutputted |= 1; + + return AVCENC_SUCCESS; +} + +OSCL_EXPORT_REF AVCEnc_Status PVAVCEncReleaseRecon(AVCHandle *avcHandle, AVCFrameIO *recon) +{ + OSCL_UNUSED_ARG(avcHandle); + OSCL_UNUSED_ARG(recon); + + return AVCENC_SUCCESS; //for now +} + +/* ======================================================================== */ +/* Function : PVAVCCleanUpEncoder() */ +/* Date : 4/18/2004 */ +/* Purpose : To clean up memories allocated by PVAVCEncInitialize() */ +/* In/out : */ +/* Return : AVCENC_SUCCESS for success. */ +/* Modified : */ +/* ======================================================================== */ +OSCL_EXPORT_REF void PVAVCCleanUpEncoder(AVCHandle *avcHandle) +{ + AVCEncObject *encvid = (AVCEncObject*) avcHandle->AVCObject; + AVCCommonObj *video; + uint32 *userData = (uint32*) avcHandle->userData; + + if (encvid != NULL) + { + CleanMotionSearchModule(avcHandle); + + CleanupRateControlModule(avcHandle); + + if (encvid->functionPointer != NULL) + { + avcHandle->CBAVC_Free(userData, (int)encvid->functionPointer); + } + + if (encvid->min_cost) + { + avcHandle->CBAVC_Free(userData, (int)encvid->min_cost); + } + + if (encvid->intraSearch) + { + avcHandle->CBAVC_Free(userData, (int)encvid->intraSearch); + } + + if (encvid->mot16x16) + { + avcHandle->CBAVC_Free(userData, (int)encvid->mot16x16); + } + + if (encvid->rateCtrl) + { + avcHandle->CBAVC_Free(userData, (int)encvid->rateCtrl); + } + + if (encvid->overrunBuffer) + { + avcHandle->CBAVC_Free(userData, (int)encvid->overrunBuffer); + } + + video = encvid->common; + if (video != NULL) + { + if (video->MbToSliceGroupMap) + { + avcHandle->CBAVC_Free(userData, (int)video->MbToSliceGroupMap); + } + if (video->mblock != NULL) + { + avcHandle->CBAVC_Free(userData, (int)video->mblock); + } + if (video->decPicBuf != NULL) + { + CleanUpDPB(avcHandle, video); + avcHandle->CBAVC_Free(userData, (int)video->decPicBuf); + } + if (video->sliceHdr != NULL) + { + avcHandle->CBAVC_Free(userData, (int)video->sliceHdr); + } + if (video->currPicParams != NULL) + { + if (video->currPicParams->slice_group_id) + { + avcHandle->CBAVC_Free(userData, (int)video->currPicParams->slice_group_id); + } + + avcHandle->CBAVC_Free(userData, (int)video->currPicParams); + } + if (video->currSeqParams != NULL) + { + avcHandle->CBAVC_Free(userData, (int)video->currSeqParams); + } + if (encvid->bitstream != NULL) + { + avcHandle->CBAVC_Free(userData, (int)encvid->bitstream); + } + if (video != NULL) + { + avcHandle->CBAVC_Free(userData, (int)video); + } + } + + avcHandle->CBAVC_Free(userData, (int)encvid); + + avcHandle->AVCObject = NULL; + } + + return ; +} + +OSCL_EXPORT_REF AVCEnc_Status PVAVCEncUpdateBitRate(AVCHandle *avcHandle, uint32 bitrate) +{ + OSCL_UNUSED_ARG(avcHandle); + OSCL_UNUSED_ARG(bitrate); + + return AVCENC_FAIL; +} + +OSCL_EXPORT_REF AVCEnc_Status PVAVCEncUpdateFrameRate(AVCHandle *avcHandle, uint32 num, uint32 denom) +{ + OSCL_UNUSED_ARG(avcHandle); + OSCL_UNUSED_ARG(num); + OSCL_UNUSED_ARG(denom); + + return AVCENC_FAIL; +} + +OSCL_EXPORT_REF AVCEnc_Status PVAVCEncUpdateIDRInterval(AVCHandle *avcHandle, int IDRInterval) +{ + OSCL_UNUSED_ARG(avcHandle); + OSCL_UNUSED_ARG(IDRInterval); + + return AVCENC_FAIL; +} + +OSCL_EXPORT_REF AVCEnc_Status PVAVCEncIDRRequest(AVCHandle *avcHandle) +{ + OSCL_UNUSED_ARG(avcHandle); + + return AVCENC_FAIL; +} + +OSCL_EXPORT_REF AVCEnc_Status PVAVCEncUpdateIMBRefresh(AVCHandle *avcHandle, int numMB) +{ + OSCL_UNUSED_ARG(avcHandle); + OSCL_UNUSED_ARG(numMB); + + return AVCENC_FAIL; +} + +void PVAVCEncGetFrameStats(AVCHandle *avcHandle, AVCEncFrameStats *avcStats) +{ + AVCEncObject *encvid = (AVCEncObject*) avcHandle->AVCObject; + AVCRateControl *rateCtrl = encvid->rateCtrl; + + avcStats->avgFrameQP = GetAvgFrameQP(rateCtrl); + avcStats->numIntraMBs = encvid->numIntraMB; + + return ; +} + + + |