SRTParser::~SRTParser()
{
if(mBuffer)
FSL_FREE(mBuffer);
if(mSource)
FSL_DELETE(mSource);
if(mTimeTable)
FSL_DELETE(mTimeTable);
}
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 WmaDec::DeInitComponent()
{
if (libMgr) {
if (hLib)
libMgr->unload(hLib);
FSL_DELETE(libMgr);
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE PlatformResourceMgr::DeInit()
{
if(PlatformDataList != NULL)
FSL_DELETE(PlatformDataList);
if(lock != NULL)
fsl_osal_mutex_destroy(lock);
return OMX_ErrorNone;
}
OMX_STREAMING_PIPE_API CPresult RtpsPipe_Close(CPhandle hContent)
{
StreamingPipe *hPipe = (StreamingPipe *)hContent;
LOG_DEBUG("%s\n", __FUNCTION__);
hPipe->DeInit();
FSL_DELETE(hPipe);
return STREAMING_PIPE_SUCESS;
}
QUEUE_ERRORTYPE DeleteQueue(
fsl_osal_ptr hQHandle)
{
Queue *pQueue = NULL;
pQueue = (Queue*) hQHandle;
pQueue->Free();
FSL_DELETE(pQueue);
return QUEUE_SUCCESS;
}
OMX_ERRORTYPE UnloadParserMetadata(OMX_PTR handle)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
Mp3Parser *obj = (Mp3Parser *)handle;
obj->InstanceDeInit();
obj->UnloadParserMetadata();
FSL_DELETE(obj);
return ret;
}
OMX_ERRORTYPE AacEnc::AudioFilterInstanceDeInit()
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
if (mEncoderHandle) {
mApiHandle->Uninit(mEncoderHandle);
mEncoderHandle = NULL;
}
FSL_DELETE(mApiHandle);
FSL_DELETE(mMemOperator);
if (libMgr) {
if (hLibStagefright)
libMgr->unload(hLibStagefright);
hLibStagefright = NULL;
FSL_DELETE(libMgr);
}
return ret;
}
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_STREAMING_PIPE_API CPresult RtpsPipe_Open(CPhandle* hContent, CPstring url, CP_ACCESSTYPE eAccess)
{
OMX_ERRORTYPE err;
StreamingPipe *hPipe;
const CPuint CACHE_SIZE=10*1024*1024;
LOG_DEBUG("%s hContent %p, url: %s\n", __FUNCTION__, hContent, url);
if(hContent == NULL || url == NULL)
return KD_EINVAL;
if(eAccess != CP_AccessRead)
return KD_EINVAL;
RtpsProtocol *pProtocol = FSL_NEW(RtpsProtocol, (url));
if(pProtocol == NULL){
LOG_ERROR("[HttpsPipe] Failed to create RtpsProtocol for %s\n", url);
return KD_EINVAL;
}
hPipe = FSL_NEW(StreamingPipe, (pProtocol));
if(hPipe == NULL){
LOG_ERROR("[HttpsPipe] Failed to create StreamingPipe for %s\n", url);
FSL_DELETE(pProtocol);
return KD_EINVAL;
}
err = hPipe->Init(CACHE_SIZE);
if(err != OMX_ErrorNone){
FSL_DELETE(hPipe);
FSL_DELETE(pProtocol);
return KD_EINVAL;
}
*hContent = hPipe;
return STREAMING_PIPE_SUCESS;
}
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;
}
fsl_osal_s32 ShareLibarayMgr::unload(fsl_osal_ptr hlib)
{
LIB_INFO *pLibInfo;
if (hlib == NULL)
{
LOG_ERROR("Library handle is NULL.\n");
return 0;
}
/** Check if the library already loaded */
for (fsl_osal_s32 i = 0; ; i ++)
{
pLibInfo = lib_info.GetNode(i);
if(pLibInfo == NULL)
{
break;
}
if (pLibInfo->hlib == hlib)
{
pLibInfo->refCount --;
LOG_DEBUG("The reference times of the library: %s is: %d\n", pLibInfo->lib_name, \
pLibInfo->refCount);
if (pLibInfo->refCount == 0)
{
LOG_DEBUG("Unload the librayr: %s\n", pLibInfo->lib_name);
dlclose(pLibInfo->hlib);
lib_info.Remove(pLibInfo);
FSL_DELETE(pLibInfo);
return 0;
}
return pLibInfo->refCount;
}
}
return 0;
}
OMX_ERRORTYPE WmaDec::InitComponent()
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_PARAM_PORTDEFINITIONTYPE sPortDef;
hLib = NULL;
pWmaDecConfig = NULL;
libMgr = NULL;
OMX_INIT_STRUCT(&sPortDef, OMX_PARAM_PORTDEFINITIONTYPE);
sPortDef.nPortIndex = AUDIO_FILTER_INPUT_PORT;
sPortDef.eDir = OMX_DirInput;
sPortDef.eDomain = OMX_PortDomainAudio;
sPortDef.format.audio.eEncoding = OMX_AUDIO_CodingWMA;
sPortDef.bPopulated = OMX_FALSE;
sPortDef.bEnabled = OMX_TRUE;
sPortDef.nBufferCountMin = 1;
sPortDef.nBufferCountActual = 3;
sPortDef.nBufferSize = 1024;
ret = ports[AUDIO_FILTER_INPUT_PORT]->SetPortDefinition(&sPortDef);
if(ret != OMX_ErrorNone) {
LOG_ERROR("Set port definition for port[%d] failed.\n", AUDIO_FILTER_INPUT_PORT);
return ret;
}
sPortDef.nPortIndex = AUDIO_FILTER_OUTPUT_PORT;
sPortDef.eDir = OMX_DirOutput;
sPortDef.eDomain = OMX_PortDomainAudio;
sPortDef.format.audio.eEncoding = OMX_AUDIO_CodingPCM;
sPortDef.bPopulated = OMX_FALSE;
sPortDef.bEnabled = OMX_TRUE;
sPortDef.nBufferCountMin = 1;
sPortDef.nBufferCountActual = 3;
sPortDef.nBufferSize = WMA10D_OUTBUFF_SIZE;
ret = ports[AUDIO_FILTER_OUTPUT_PORT]->SetPortDefinition(&sPortDef);
if(ret != OMX_ErrorNone) {
LOG_ERROR("Set port definition for port[%d] failed.\n", 0);
return ret;
}
OMX_INIT_STRUCT(&WmaType, OMX_AUDIO_PARAM_WMATYPE);
OMX_INIT_STRUCT(&WmaTypeExt, OMX_AUDIO_PARAM_WMATYPE_EXT);
OMX_INIT_STRUCT(&PcmMode, OMX_AUDIO_PARAM_PCMMODETYPE);
WmaTypeExt.nPortIndex = AUDIO_FILTER_INPUT_PORT;
WmaTypeExt.nBitsPerSample = 16;
WmaType.nPortIndex = AUDIO_FILTER_INPUT_PORT;
WmaType.nChannels = 2;
WmaType.nSamplingRate = 44100;
WmaType.nBitRate = 64000;
WmaType.eFormat = OMX_AUDIO_WMAFormat9;
PcmMode.nPortIndex = AUDIO_FILTER_OUTPUT_PORT;
PcmMode.nChannels = 2;
PcmMode.nSamplingRate = 44100;
PcmMode.nBitPerSample = 16;
PcmMode.bInterleaved = OMX_TRUE;
PcmMode.eNumData = OMX_NumericalDataSigned;
PcmMode.ePCMMode = OMX_AUDIO_PCMModeLinear;
PcmMode.eEndian = OMX_EndianLittle;
PcmMode.eChannelMapping[0] = OMX_AUDIO_ChannelNone;
dwChannelMask = 0;
nAdvancedEncodeOpt = 0;
nAdvancedEncodeOpt2 = 0;
libMgr = FSL_NEW(ShareLibarayMgr, ());
if(libMgr == NULL)
return OMX_ErrorInsufficientResources;
hLib = libMgr->load((OMX_STRING)"lib_wma10_dec_v2_arm12_elinux.so");
if(hLib == NULL) {
LOG_WARNING("Can't load library lib_wma10_dec_v2_arm12_elinux.\n");
FSL_DELETE(libMgr);
return OMX_ErrorComponentNotFound;
}
pWMADQueryMem = (tWMAFileStatus (*)( WMADDecoderConfig *))libMgr->getSymbol(hLib, (OMX_STRING)"eWMADQueryMem");
pInitWMADecoder = (tWMAFileStatus (*)(WMADDecoderConfig *, WMADDecoderParams *, WMAD_UINT8 *, WMAD_INT32 ))libMgr->getSymbol(hLib, (OMX_STRING)"eInitWMADecoder");
pWMADecodeFrame = (tWMAFileStatus (*)(WMADDecoderConfig *,
WMADDecoderParams *,
WMAD_INT16 *,
WMAD_INT32))libMgr->getSymbol(hLib,(OMX_STRING)"eWMADecodeFrame");
if(pWMADQueryMem == NULL || pInitWMADecoder == NULL || pWMADecodeFrame == NULL) {
libMgr->unload(hLib);
FSL_DELETE(libMgr);
return OMX_ErrorComponentNotFound;
}
return ret;
}
GMOutbandSubtitleSource::~GMOutbandSubtitleSource()
{
if(mSubtitleParser)
FSL_DELETE(mSubtitleParser);
}
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;
}
