void TextSource::DeInit()
{
if(mBuffer)
FSL_FREE(mBuffer);
if(mCache)
FSL_FREE(mCache);
if(mHandle)
mPipe->Close(mHandle);
}
QUEUE_ERRORTYPE Queue::Free()
{
if(pQNodeMem != NULL)
FSL_FREE(pQNodeMem);
if(pQMsgMem != NULL)
FSL_FREE(pQMsgMem);
if(lock != NULL)
fsl_osal_mutex_destroy(lock);
if(usedNodesSem != NULL)
fsl_osal_sem_destroy(usedNodesSem);
if(freeNodesSem != NULL)
fsl_osal_sem_destroy(freeNodesSem);
return QUEUE_SUCCESS;
}
OMX_ERRORTYPE WbAmrEncWrapper::InstanceDeInit()
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_S32 MemoryCnt = pAmrEncConfig->wbamre_mem_info.wbamre_num_reqs;
OMX_S32 i;
for (i = 0; i < MemoryCnt; i ++)
{
FSL_FREE(pAmrEncConfig->wbamre_mem_info.mem_info_sub[i].wbappe_base_ptr);
}
FSL_FREE(pAmrEncConfig);
return ret;
}
OMX_ERRORTYPE WmaDec::AudioFilterInstanceDeInit()
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
if(pWmaDecConfig){
OMX_S32 MemoryCnt = pWmaDecConfig->sWMADMemInfo.s32NumReqs;
for (OMX_S32 i = 0; i < MemoryCnt; i ++)
{
FSL_FREE(pWmaDecConfig->sWMADMemInfo.sMemInfoSub[i].app_base_ptr);
}
FSL_FREE(pWmaDecConfig);
FSL_FREE(pWmaDecParams);
}
return ret;
}
OMX_ERRORTYPE free_port_buffers(HCOMPONENT *component, OMX_U32 nPortIndex)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *hComponent;
OMX_U32 i;
hComponent = component->hComponent;
for(i=0; i<component->nBufferHdr[nPortIndex]; i++)
{
OMX_U8 *ptr = component->pBufferHdr[nPortIndex][i]->pBuffer;
while(1)
{
ret = OMX_FreeBuffer(hComponent, nPortIndex, component->pBufferHdr[nPortIndex][i]);
if(ret == OMX_ErrorNotReady)
usleep(10000);
else
break;
}
component->pBufferHdr[nPortIndex][i] = 0;
if(component->bAllocater[nPortIndex] == OMX_FALSE)
FSL_FREE(ptr);
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE GMInbandSubtitleSource::SetType(OMX_STRING type)
{
SUBTITLE_TYPE mType1;
OMX_S32 nLen = 0;
LOG_DEBUG("GMInbandSubtitleSource set type: %s\n", type);
mType1 = GetSubtitleType(type);
switch(mType1) {
case TYPE_3GPP:
nLen = BUFFER_SIZE_3GP;
case TYPE_SRT:
nLen = BUFFER_SIZE_SRT;
default:
break;
}
if(mType1 == TYPE_UNKNOWN)
return OMX_ErrorNotImplemented;
if(mType != mType1) {
if(pBuffer)
FSL_FREE(pBuffer);
pBuffer = (OMX_U8*)FSL_MALLOC(nLen);
if(pBuffer == NULL)
return OMX_ErrorInsufficientResources;
mType = mType1;
}
fsl_osal_memset(pBuffer, 0, nLen);
return OMX_ErrorNone;
}
OMX_ERRORTYPE Mp3Parser::UnloadParserMetadata()
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
if (pMediaName)
{
FSL_FREE(pMediaName);
pMediaName = NULL;
}
for (OMX_U32 i = 0; i < MAX_MATADATA_NUM; i ++)
{
FSL_FREE(psMatadataItem[i]);;
}
return ret;
}
RINGBUFFER_ERRORTYPE RingBuffer::BufferFree()
{
RINGBUFFER_ERRORTYPE ret = RINGBUFFER_SUCCESS;
LOG_DEBUG("TS queue free\n");
if(TS_Queue != NULL)
TS_Queue->Free();
LOG_DEBUG("TS queue delete\n");
FSL_DELETE(TS_Queue);
LOG_DEBUG("Free ring buffer\n");
FSL_FREE(RingBufferPtr);
LOG_DEBUG("Free reserved buffer\n");
FSL_FREE(Reserved);
LOG_DEBUG("Ring buffer free finished.\n");
return ret;
}
OMX_ERRORTYPE delete_test(HTEST *hTest)
{
fclose(hTest->pInFile);
fclose(hTest->pOutFile);
hTest->pMsgQ->Free();
FSL_FREE(hTest);
return OMX_ErrorNone;
}
OMX_ERRORTYPE DestroyPMeoryContext(OMX_PTR Context)
{
if(Context != NULL) {
DeInitPMemAllocator((PMCONTEXT*)Context);
FSL_FREE(Context);
}
return OMX_ErrorNone;
}
SRTParser::~SRTParser()
{
if(mBuffer)
FSL_FREE(mBuffer);
if(mSource)
FSL_DELETE(mSource);
if(mTimeTable)
FSL_DELETE(mTimeTable);
}
OMX_ERRORTYPE VideoFilter::DoIdle2Loaded()
{
if(bInit == OMX_TRUE)
DeInitFilter();
if(pCodecData != NULL)
FSL_FREE(pCodecData);
return OMX_ErrorNone;
}
RINGBUFFER_ERRORTYPE RingBuffer::BufferCreate(fsl_osal_u32 nPushModeLen, fsl_osal_u32 nRingBufferScale)
{
RINGBUFFER_ERRORTYPE ret = RINGBUFFER_SUCCESS;
nPushModeInputLen = nPushModeLen;
nRingBufferLen = nPushModeInputLen * nRingBufferScale;
/** Create queue for TS. */
TS_Queue = FSL_NEW(Queue, ());
if (TS_Queue == NULL)
{
LOG_ERROR("Can't get memory.\n");
return RINGBUFFER_INSUFFICIENT_RESOURCES;
}
if (TS_Queue->Create(TS_QUEUE_SIZE, sizeof(TS_QUEUE), E_FSL_OSAL_FALSE) != QUEUE_SUCCESS)
{
FSL_DELETE(TS_Queue);
LOG_ERROR("Can't create audio ts queue.\n");
return RINGBUFFER_INSUFFICIENT_RESOURCES;
}
/** Create ring buffer for audio decoder input stream. */
LOG_DEBUG("Ring buffer len: %d\n", nRingBufferLen);
RingBufferPtr = (fsl_osal_u8 *)FSL_MALLOC(nRingBufferLen+8);
if (RingBufferPtr == NULL)
{
FSL_DELETE(TS_Queue);
TS_Queue->Free();
LOG_ERROR("Can't get memory.\n");
return RINGBUFFER_INSUFFICIENT_RESOURCES;
}
Reserved = (fsl_osal_u8 *)FSL_MALLOC(nPushModeInputLen);
if (Reserved == NULL)
{
FSL_DELETE(TS_Queue);
TS_Queue->Free();
FSL_FREE(RingBufferPtr);
LOG_ERROR("Can't get memory.\n");
return RINGBUFFER_INSUFFICIENT_RESOURCES;
}
CurrentTS = 0;
bHaveTS = E_FSL_OSAL_FALSE;
TotalConsumeLen = 0;
RingBufferBeginPre = -1;
ReservedLen = nPushModeInputLen;
Begin = RingBufferPtr;
End = RingBufferPtr;
Consumered = RingBufferPtr;
nPrevOffset = 0;
return ret;
}
OMX_ERRORTYPE AudioSource::DoIdle2Loaded()
{
CloseDevice();
LOG_DEBUG("Audio source ring buffer free.\n");
AudioRenderRingBuffer.BufferFree();
FSL_FREE(pDeviceReadBuffer);
return OMX_ErrorNone;
}
OMX_ERRORTYPE delete_test(HTEST *hTest)
{
fsl_osal_sem_destroy(hTest->sParserFormatSem);
fclose(hTest->pOutFile0);
fclose(hTest->pOutFile1);
hTest->pMsgQ->Free();
FSL_FREE(hTest);
return OMX_ErrorNone;
}
OMX_ERRORTYPE UniaDecoder::DeInitComponent()
{
if (libMgr) {
if (hLib)
libMgr->unload(hLib);
hLib = NULL;
FSL_FREE(IDecoder);
FSL_DELETE(libMgr);
}
LOG_DEBUG("UniaDec::DeInitComponent inputFrameCount=%d,consumeFrameCount=%d",inputFrameCount,consumeFrameCount);
return OMX_ErrorNone;
}
OMX_ERRORTYPE UniaDecoder::AudioFilterInstanceDeInit(){
LOG_DEBUG("UniaDecoder::AudioDecoderBaseInstanceDeInit");
FSL_FREE(codecConfig.buf);
codecConfig.buf = NULL;
if(IDecoder != NULL && uniaHandle != NULL){
IDecoder->DeleteDecoder(uniaHandle);
uniaHandle = NULL;
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE VideoFilter::DoIdle2Loaded()
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
if(bInit == OMX_TRUE)
DeInitFilter();
if(pCodecData != NULL)
FSL_FREE(pCodecData);
tsmDestroy(hTsHandle);
ret=SetDefaultSetting(); //restore default to support following switch from loaded to idle
if(ret != OMX_ErrorNone)
return ret;
return OMX_ErrorNone;
}
OMX_ERRORTYPE PlatformResourceMgr::RemoveHwBuffer(
OMX_PTR pVirtualAddr)
{
PLATFORM_DATA *pData = NULL;
fsl_osal_mutex_lock(lock);
pData = (PLATFORM_DATA*) SearchData(pVirtualAddr);
if(pData == NULL) {
fsl_osal_mutex_unlock(lock);
return OMX_ErrorUndefined;
}
PlatformDataList->Remove(pData);
FSL_FREE(pData);
fsl_osal_mutex_unlock(lock);
return OMX_ErrorNone;
}
OMX_ERRORTYPE free_port_buffers(HTEST *hTest, OMX_U32 nPortIndex)
{
OMX_COMPONENTTYPE *hComponent;
OMX_U32 i;
hComponent = hTest->hComponent;
for(i=0; i<hTest->nBufferHdr[nPortIndex]; i++) {
OMX_U8 *ptr = NULL;
if(hTest->pBufferHdr[nPortIndex][i] == NULL)
continue;
ptr = hTest->pBufferHdr[nPortIndex][i]->pBuffer;
OMX_FreeBuffer(hComponent, nPortIndex, hTest->pBufferHdr[nPortIndex][i]);
hTest->pBufferHdr[nPortIndex][i] = 0;
if(hTest->bAllocater[nPortIndex] == OMX_FALSE)
FSL_FREE(ptr);
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE PlatformResourceMgr::AddHwBuffer(
OMX_PTR pPhyiscAddr,
OMX_PTR pVirtualAddr)
{
PLATFORM_DATA *pData = NULL;
pData = (PLATFORM_DATA*)FSL_MALLOC(sizeof(PLATFORM_DATA));
if(pData == NULL)
return OMX_ErrorInsufficientResources;
pData->pVirtualAddr = pVirtualAddr;
pData->pPhyiscAddr = pPhyiscAddr;
fsl_osal_mutex_lock(lock);
if(LIST_SUCCESS != PlatformDataList->Add(pData)) {
FSL_FREE(pData);
fsl_osal_mutex_unlock(lock);
return OMX_ErrorUndefined;
}
fsl_osal_mutex_unlock(lock);
return OMX_ErrorNone;
}
GMInbandSubtitleSource::~GMInbandSubtitleSource()
{
if(pBuffer)
FSL_FREE(pBuffer);
}
OMX_ERRORTYPE WmaDec::AudioFilterCodecInit()
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
tWMAFileStatus WmaRet;
pWmaDecConfig->psWMADecodeInfoStructPtr = NULL;
pWmaDecParams->bDropPacket = 0;
pWmaDecParams->nDRCSetting = 0;
pWmaDecParams->nDecoderFlags =0;
pWmaDecParams->nDstChannelMask = 0;
pWmaDecParams->nInterpResampRate = 0;
pWmaDecParams->nMBRTargetStream = 1;
pWmaDecParams->bIsRawDecoder = WMAD_TRUE;
pWmaDecParams->us16Version = WmaType.eFormat;
pWmaDecParams->us16Channels = WmaType.nChannels;
pWmaDecParams->us32SamplesPerSec = WmaType.nSamplingRate;
pWmaDecParams->us32AvgBytesPerSec = WmaType.nBitRate >> 3;
pWmaDecParams->us16EncodeOpt = WmaType.nEncodeOptions;
if (WmaType.eFormat == OMX_AUDIO_WMAFormat7)
pWmaDecParams->us16wFormatTag = 0x160;
else if (WmaType.eFormat == OMX_AUDIO_WMAFormat8)
pWmaDecParams->us16wFormatTag = 0x161;
else if (WmaType.eFormat == OMX_AUDIO_WMAFormat9)
pWmaDecParams->us16wFormatTag = 0x162;
pWmaDecParams->us32nBlockAlign = WmaType.nBlockAlign;
pWmaDecParams->us32ChannelMask = dwChannelMask;
pWmaDecParams->us16AdvancedEncodeOpt = nAdvancedEncodeOpt;
pWmaDecParams->us32AdvancedEncodeOpt2 = nAdvancedEncodeOpt2;
pWmaDecParams->us32ValidBitsPerSample = WmaTypeExt.nBitsPerSample;
if((pWmaDecParams->us32ValidBitsPerSample!=16)&&(pWmaDecParams->us32ValidBitsPerSample!=24))
{
pWmaDecParams->us32ValidBitsPerSample = 16;
}
if(pWmaDecParams->us16Channels > 2)
{
pWmaDecParams->nDecoderFlags |= DECOPT_CHANNEL_DOWNMIXING;
pWmaDecParams->nDstChannelMask = 0x03;
}
pWmaDecConfig->app_swap_buf = (tWMAFileStatus (*)(void*, WMAD_UINT64, WMAD_UINT32*, WMAD_UINT8**, void*, WMAD_UINT32*))WMA10FileCBGetNewPayload;
pWmaDecConfig->pContext = (OMX_PTR)(this);
pWmaDecConfig->sDecodeParams = pWmaDecParams;
fsl_osal_memset(&sWfx,0,sizeof(WAVEFORMATEXTENSIBLE));
pWmaDecParams->pWfx = &sWfx;
OMX_S32 MemoryCnt = pWmaDecConfig->sWMADMemInfo.s32NumReqs;
for (OMX_S32 i = 0; i < MemoryCnt; i ++)
{
FSL_FREE(pWmaDecConfig->sWMADMemInfo.sMemInfoSub[i].app_base_ptr);
}
LOG_DEBUG("nVersion=%d,wFormatTag=%p,nSamplesPerSec=%d,nAvgBytesPerSec=%d,nBlockAlign=%d,nChannels=%d,nEncodeOpt=%p,wBitsPerSample=%d,dwChannelMask=%p,nAdvancedEncodeOpt=%p,nAdvancedEncodeOpt2=%p\n",pWmaDecConfig->sDecodeParams->us16Version,pWmaDecConfig->sDecodeParams->us16wFormatTag,pWmaDecConfig->sDecodeParams->us32SamplesPerSec,pWmaDecConfig->sDecodeParams->us32AvgBytesPerSec,pWmaDecConfig->sDecodeParams->us32nBlockAlign,pWmaDecConfig->sDecodeParams->us16Channels,pWmaDecConfig->sDecodeParams->us16EncodeOpt,pWmaDecConfig->sDecodeParams->us32ValidBitsPerSample,pWmaDecConfig->sDecodeParams->us32ChannelMask,pWmaDecConfig->sDecodeParams->us16AdvancedEncodeOpt,pWmaDecConfig->sDecodeParams->us32AdvancedEncodeOpt2);
WmaRet = pWMADQueryMem(pWmaDecConfig);
if (WmaRet != cWMA_NoErr)
{
LOG_ERROR("Wma decoder query memory fail.\n");
return OMX_ErrorUndefined;
}
MemoryCnt = pWmaDecConfig->sWMADMemInfo.s32NumReqs;
for (OMX_S32 i = 0; i < MemoryCnt; i ++)
{
OMX_U32 BufferSize;
OMX_U8 *pBuffer;
BufferSize = pWmaDecConfig->sWMADMemInfo.sMemInfoSub[i].s32WMADSize;
pBuffer = (OMX_U8 *)FSL_MALLOC(BufferSize);
if (pBuffer == NULL)
{
LOG_ERROR("Can't get memory.\n");
return OMX_ErrorInsufficientResources;
}
fsl_osal_memset(pBuffer, 0, BufferSize);
pWmaDecConfig->sWMADMemInfo.sMemInfoSub[i].app_base_ptr = pBuffer;
}
WmaRet = pInitWMADecoder(pWmaDecConfig, pWmaDecParams, NULL, 0);
if (WmaRet != cWMA_NoErr)
{
LOG_ERROR("Wma decoder initialize fail.\n");
return OMX_ErrorUnsupportedSetting;
}
AudioRingBuffer.nPrevOffset = 0;
return ret;
}
/*****************************************************************************
* Function: appLocalFree
*
* Description: Implements to Free the memory.
*
* Return: Void
*
****************************************************************************/
static void appLocalFree (void *MemoryBlock)
{
if(MemoryBlock)
FSL_FREE(MemoryBlock);
}
OMX_ERRORTYPE VideoFilter::FreeOutputBuffer(OMX_PTR pBuffer)
{
FSL_FREE(pBuffer);
return OMX_ErrorNone;
}
VO_U32 cmnMemFree (VO_S32 uID, VO_PTR pMem)
{
FSL_FREE (pMem);
return 0;
}
OMX_ERRORTYPE SRTParser::BuildSeekTable()
{
TextSource::TEXT_LINE sLine;
OMX_BOOL bEOS = OMX_FALSE;
while(1) {
OMX_S64 nPos = 0;
mSource->GetCurPosition(nPos);
mSource->GetNextLine(sLine, bEOS);
if(bEOS != OMX_FALSE) {
LOG_DEBUG("%s, EOS.\n", __FUNCTION__);
break;
}
if(sLine.pData == NULL)
continue;
int hour1, hour2, min1, min2, sec1, sec2, msec1, msec2;
if(sscanf((OMX_STRING)sLine.pData, "%02d:%02d:%02d,%03d --> %02d:%02d:%02d,%03d",
&hour1, &min1, &sec1, &msec1, &hour2, &min2, &sec2, &msec2) != 8) {
continue;
}
TIME_NODE *node = mTimeTable + mTimeTableEntrySize;
node->nTime = TIME2US(hour1, min1, sec1, msec1);
node->nOffset = nPos;
mTimeTableEntrySize++;
if(mTimeTableEntrySize >= mTimeTableSize) {
OMX_PTR temp = FSL_MALLOC(sizeof(TIME_NODE)*(mTimeTableSize + SRT_TIME_TABLE_SIZE));
if(!temp) {
LOG_ERROR("failed to allocate time table size to %d\n", mTimeTableSize + SRT_TIME_TABLE_SIZE);
break;
}
fsl_osal_memcpy(temp, mTimeTable, mTimeTableEntrySize*sizeof(TIME_NODE));
FSL_FREE(mTimeTable);
mTimeTable = (TIME_NODE*)temp;
mTimeTableSize += SRT_TIME_TABLE_SIZE;
}
LOG_DEBUG("[%d], time: %lld, offset: %lld\n", mTimeTableEntrySize, node->nTime, node->nOffset);
}
LOG_DEBUG("mTimeTableEntrySize: %d\n", mTimeTableEntrySize);
OMX_BOOL needSort = OMX_FALSE;
if(mTimeTableEntrySize > 1){
for(OMX_U32 i = 0; i < mTimeTableEntrySize -2; i++){
if(mTimeTable[i].nTime > mTimeTable[i+1].nTime){
needSort = OMX_TRUE;
break;
}
}
}
if(needSort == OMX_TRUE){
for(OMX_U32 roundEnd = mTimeTableEntrySize - 1; roundEnd >0; roundEnd--){
// search for biggest one from 0 to roundEnd
OMX_U32 biggest = 0;
for(OMX_U32 i = 1; i <= roundEnd; i++){
if(mTimeTable[i].nTime > mTimeTable[biggest].nTime)
biggest = i;
}
if(biggest != roundEnd){
// exchange biggest with roundEnd
TIME_NODE node;
fsl_osal_memcpy(&node, mTimeTable + biggest, sizeof(TIME_NODE));
fsl_osal_memcpy(mTimeTable + biggest, mTimeTable + roundEnd, sizeof(TIME_NODE));
fsl_osal_memcpy(mTimeTable + roundEnd, &node, sizeof(TIME_NODE));
}
}
}
mSource->SeekTo(0);
return OMX_ErrorNone;
}
OMX_ERRORTYPE UniaDecoder::CreateDecoderInterface()
{
OMX_S32 ret = OMX_ErrorNone;
do{
tUniACodecQueryInterface myQueryInterface;
if(NULL == role || decoderLibName == NULL){
ret = OMX_ErrorInsufficientResources;
break;
}
if(optionaDecoderlLibName){
hLib = libMgr->load((fsl_osal_char *)optionaDecoderlLibName);
LOG_DEBUG("Audio Decoder library name 1: %s\n", optionaDecoderlLibName);
}
if(hLib == NULL){
hLib = libMgr->load((fsl_osal_char *)decoderLibName);
LOG_DEBUG("Audio Decoder library name 2: %s\n", decoderLibName);
}
if(NULL == hLib){
LOG_ERROR("Fail to open Decoder library for %s\n", role);
ret = OMX_ErrorComponentNotFound;
break;
}
IDecoder = (UniaDecInterface *)FSL_MALLOC(sizeof(UniaDecInterface));
if(IDecoder == NULL){
ret = OMX_ErrorUndefined;
}
fsl_osal_memset(IDecoder,0 ,sizeof(UniaDecInterface));
myQueryInterface = (tUniACodecQueryInterface)libMgr->getSymbol(hLib, (fsl_osal_char *)"UniACodecQueryInterface");
if(NULL == myQueryInterface)
{
LOG_ERROR("Fail to query decoder interface\n");
ret = OMX_ErrorNotImplemented;
break;
}
ret = myQueryInterface(ACODEC_API_GET_VERSION_INFO, (void **)&IDecoder->GetVersionInfo);
ret |= myQueryInterface(ACODEC_API_CREATE_CODEC, (void **)&IDecoder->CreateDecoder);
ret |= myQueryInterface(ACODEC_API_DELETE_CODEC, (void **)&IDecoder->DeleteDecoder);
ret |= myQueryInterface(ACODEC_API_RESET_CODEC, (void **)&IDecoder->ResetDecoder);
ret |= myQueryInterface(ACODEC_API_SET_PARAMETER, (void **)&IDecoder->SetParameter);
ret |= myQueryInterface(ACODEC_API_GET_PARAMETER, (void **)&IDecoder->GetParameter);
ret |= myQueryInterface(ACODEC_API_DEC_FRAME, (void **)&IDecoder->DecodeFrame);
ret |= myQueryInterface(ACODEC_API_GET_LAST_ERROR, (void **)&IDecoder->GetLastError);
if(ret != OMX_ErrorNone){
LOG_ERROR("Fail to query decoder API\n");
ret = OMX_ErrorNotImplemented;
break;
}
}while(0);
if(ret != OMX_ErrorNone){
LOG_ERROR("UniaDecoder::CreateDecoderInterface ret=%d",ret);
if (hLib)
libMgr->unload(hLib);
hLib = NULL;
FSL_FREE(IDecoder);
FSL_DELETE(libMgr);
}
return (OMX_ERRORTYPE)ret;
}
