| /* ------------------------------------------------------------------ |
| * Copyright (C) 2008 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 "pvmf_omx_videodec_factory.h" |
| |
| #include "pvmf_omx_audiodec_factory.h" |
| |
| #include "pvmf_amrffparser_factory.h" |
| |
| #include "pvmf_aacffparser_factory.h" |
| |
| #include "pvmf_wavffparser_factory.h" |
| |
| #include "pvmf_mp3ffparser_factory.h" |
| |
| #include "pv_player_node_registry.h" |
| |
| // For recognizer registry |
| #include "pvmf_recognizer_registry.h" |
| |
| #include "pvmi_datastreamsyncinterface_ref_factory.h" |
| #include "pvmf_recognizer_plugin.h" |
| |
| #include "pvmp3ffrec_factory.h" |
| |
| #include "pvwavffrec_factory.h" |
| |
| #include "pvamrffrec_factory.h" |
| |
| #ifdef HAS_OSCL_LIB_SUPPORT |
| #include "oscl_shared_library.h" |
| |
| #include "pvmf_node_shared_lib_interface.h" |
| #endif |
| |
| PVPlayerNodeRegistry::PVPlayerNodeRegistry() |
| { |
| PVPlayerNodeInfo nodeinfo; |
| iType.reserve(20); |
| |
| //For PVMFOMXVideoDecNode |
| nodeinfo.iInputTypes.clear(); |
| nodeinfo.iInputTypes.push_back(PVMF_H263); |
| nodeinfo.iInputTypes.push_back(PVMF_M4V); |
| nodeinfo.iInputTypes.push_back(PVMF_H264); |
| nodeinfo.iInputTypes.push_back(PVMF_H264_RAW); |
| nodeinfo.iInputTypes.push_back(PVMF_H264_MP4); |
| nodeinfo.iInputTypes.push_back(PVMF_WMV); |
| nodeinfo.iNodeUUID = KPVMFOMXVideoDecNodeUuid; |
| nodeinfo.iOutputType.clear(); |
| nodeinfo.iOutputType.push_back(PVMF_YUV420); |
| nodeinfo.iNodeCreateFunc = PVMFOMXVideoDecNodeFactory::CreatePVMFOMXVideoDecNode; |
| nodeinfo.iNodeReleaseFunc = PVMFOMXVideoDecNodeFactory::DeletePVMFOMXVideoDecNode; |
| iType.push_back(nodeinfo); |
| |
| nodeinfo.iInputTypes.clear(); |
| // AAC FORMATS |
| nodeinfo.iInputTypes.push_back(PVMF_MPEG4_AUDIO); |
| nodeinfo.iInputTypes.push_back(PVMF_ADIF); |
| nodeinfo.iInputTypes.push_back(PVMF_ADTS); |
| nodeinfo.iInputTypes.push_back(PVMF_LATM); |
| nodeinfo.iInputTypes.push_back(PVMF_ASF_MPEG4_AUDIO); |
| // AMR FORMATS |
| nodeinfo.iInputTypes.push_back(PVMF_AMR_IETF); |
| nodeinfo.iInputTypes.push_back(PVMF_AMR_IETF_COMBINED); |
| nodeinfo.iInputTypes.push_back(PVMF_AMRWB_IETF); |
| nodeinfo.iInputTypes.push_back(PVMF_AMRWB_IETF_PAYLOAD); |
| nodeinfo.iInputTypes.push_back(PVMF_AMR_IF2); |
| |
| // MP3 FORMAT |
| nodeinfo.iInputTypes.push_back(PVMF_MP3); |
| |
| nodeinfo.iNodeUUID = KPVMFOMXAudioDecNodeUuid;; |
| nodeinfo.iOutputType.clear(); |
| nodeinfo.iOutputType.push_back(PVMF_PCM16); |
| nodeinfo.iNodeCreateFunc = PVMFOMXAudioDecNodeFactory::CreatePVMFOMXAudioDecNode; |
| nodeinfo.iNodeReleaseFunc = PVMFOMXAudioDecNodeFactory::DeletePVMFOMXAudioDecNode; |
| iType.push_back(nodeinfo); |
| |
| //For PVMFMP3FFParserNode |
| nodeinfo.iInputTypes.clear(); |
| nodeinfo.iInputTypes.push_back(PVMF_MP3FF); |
| nodeinfo.iNodeUUID = KPVMFMP3FFParserNodeUuid; |
| nodeinfo.iOutputType.clear(); |
| nodeinfo.iOutputType.push_back(PVMF_FORMAT_UNKNOWN); |
| nodeinfo.iNodeCreateFunc = PVMFMP3FFParserNodeFactory::CreatePVMFMP3FFParserNode; |
| nodeinfo.iNodeReleaseFunc = PVMFMP3FFParserNodeFactory::DeletePVMFMP3FFParserNode; |
| iType.push_back(nodeinfo); |
| |
| //For PVMFAMRFFParserNode |
| nodeinfo.iInputTypes.clear(); |
| nodeinfo.iInputTypes.push_back(PVMF_AMRFF); |
| nodeinfo.iNodeUUID = KPVMFAmrFFParserNodeUuid; |
| nodeinfo.iOutputType.clear(); |
| nodeinfo.iOutputType.push_back(PVMF_FORMAT_UNKNOWN); |
| nodeinfo.iNodeCreateFunc = PVMFAMRFFParserNodeFactory::CreatePVMFAMRFFParserNode; |
| nodeinfo.iNodeReleaseFunc = PVMFAMRFFParserNodeFactory::DeletePVMFAMRFFParserNode; |
| iType.push_back(nodeinfo); |
| |
| //For PVMFAACFFParserNode |
| nodeinfo.iInputTypes.clear(); |
| nodeinfo.iInputTypes.push_back(PVMF_AACFF); |
| nodeinfo.iNodeUUID = KPVMFAacFFParserNodeUuid; |
| nodeinfo.iOutputType.clear(); |
| nodeinfo.iOutputType.push_back(PVMF_FORMAT_UNKNOWN); |
| nodeinfo.iNodeCreateFunc = PVMFAACFFParserNodeFactory::CreatePVMFAACFFParserNode; |
| nodeinfo.iNodeReleaseFunc = PVMFAACFFParserNodeFactory::DeletePVMFAACFFParserNode; |
| iType.push_back(nodeinfo); |
| |
| //For PVMFWAVFFParserNode |
| nodeinfo.iInputTypes.clear(); |
| nodeinfo.iInputTypes.push_back(PVMF_WAVFF); |
| nodeinfo.iNodeUUID = KPVMFWavFFParserNodeUuid; |
| nodeinfo.iOutputType.clear(); |
| nodeinfo.iOutputType.push_back(PVMF_FORMAT_UNKNOWN); |
| nodeinfo.iNodeCreateFunc = PVMFWAVFFParserNodeFactory::CreatePVMFWAVFFParserNode; |
| nodeinfo.iNodeReleaseFunc = PVMFWAVFFParserNodeFactory::DeletePVMFWAVFFParserNode; |
| iType.push_back(nodeinfo); |
| } |
| |
| |
| PVPlayerNodeRegistry::~PVPlayerNodeRegistry() |
| { |
| iType.clear(); |
| } |
| |
| |
| PVMFStatus PVPlayerNodeRegistry::QueryRegistry(PVMFFormatType& aInputType, PVMFFormatType& aOutputType, Oscl_Vector<PVUuid, OsclMemAllocator>& aUuids) |
| { |
| uint32 SearchCount = 0; |
| bool matchfound = false; |
| |
| // Find all nodes that support the specified input and ouput format pair |
| while (SearchCount < iType.size()) |
| { |
| uint32 inputsearchcount = 0, outputsearchcount = 0; |
| bool iInputFoundFlag = false, iOutputFoundFlag = false; |
| |
| while (inputsearchcount < iType[SearchCount].iInputTypes.size()) |
| { |
| // Check if the input format matches |
| if (iType[SearchCount].iInputTypes[inputsearchcount] == aInputType) |
| { |
| // Set the the input flag to true since we found the match in the search |
| iInputFoundFlag = true; |
| break; |
| } |
| inputsearchcount++; |
| } |
| |
| //Check the flag of input format if it is true check for the output format, if not return failure |
| if (iInputFoundFlag) |
| { |
| while (outputsearchcount < iType[SearchCount].iOutputType.size()) |
| { |
| if (iType[SearchCount].iOutputType[outputsearchcount] == aOutputType) |
| { |
| //set the the output flag to true since we found the match in the search |
| iOutputFoundFlag = true; |
| break; |
| } |
| |
| outputsearchcount++; |
| } |
| |
| if (iOutputFoundFlag) |
| { |
| // There's a match so add this node UUID to the list. |
| aUuids.push_back(iType[SearchCount].iNodeUUID); |
| matchfound = true; |
| } |
| } |
| |
| SearchCount++; |
| } |
| |
| if (matchfound) |
| { |
| return PVMFSuccess; |
| } |
| else |
| { |
| return PVMFFailure; |
| } |
| } |
| |
| |
| PVMFNodeInterface* PVPlayerNodeRegistry::CreateNode(PVUuid& aUuid) |
| { |
| PVMFNodeInterface* nodeInterface = NULL; |
| bool iFoundFlag = false; |
| uint32 NodeSearchCount = 0; |
| |
| while (NodeSearchCount < iType.size()) |
| { |
| //Search if the UUID's will match |
| if (iType[NodeSearchCount].iNodeUUID == aUuid) |
| { |
| //Since the UUID's match set the flag to true |
| iFoundFlag = true; |
| break; |
| } |
| |
| NodeSearchCount++; |
| |
| } |
| |
| if (iFoundFlag) |
| { |
| OsclActiveObject::OsclActivePriority priority = OsclActiveObject::EPriorityNominal; |
| PVPlayerNodeInfo* nodeInfo = &iType[NodeSearchCount]; |
| |
| //Call the appropriate Node creation function & return Node pointer |
| if (KPVMFOMXVideoDecNodeUuid == aUuid) |
| { |
| priority = OsclActiveObject::EPriorityLow; |
| } |
| else |
| { |
| priority = OsclActiveObject::EPriorityNominal; |
| } |
| |
| #ifdef HAS_OSCL_LIB_SUPPORT |
| // If the node has a corresponding shared library, load that |
| // first. If not, the node is assumed to be already completely |
| // linked. |
| if (NULL != nodeInfo->iSharedLibrary |
| && (OsclLibSuccess == (nodeInfo->iSharedLibrary)->LoadLib())) |
| { |
| // Need to load the library for the node and query for the |
| // create and release functions. If the library is already |
| // loaded, the system should avoid opening the same library |
| // again on its own. |
| OsclAny* interfacePtr = NULL; |
| (nodeInfo->iSharedLibrary)->QueryInterface(PV_NODE_INTERFACE, |
| (OsclAny*&)interfacePtr); |
| NodeSharedLibraryInterface* nodeIntPtr = |
| OSCL_DYNAMIC_CAST(NodeSharedLibraryInterface*, interfacePtr); |
| |
| OsclAny* createFuncTemp = |
| nodeIntPtr->QueryNodeInterface(nodeInfo->iNodeUUID, PV_CREATE_NODE_INTERFACE); |
| OsclAny* releaseFuncTemp = |
| nodeIntPtr->QueryNodeInterface(nodeInfo->iNodeUUID, PV_RELEASE_NODE_INTERFACE); |
| |
| nodeInfo->iNodeCreateFunc = |
| OSCL_DYNAMIC_CAST(PVMFNodeInterface * (*)(int32), createFuncTemp); |
| nodeInfo->iNodeReleaseFunc = |
| OSCL_DYNAMIC_CAST(bool (*)(PVMFNodeInterface*), releaseFuncTemp); |
| } |
| #endif |
| |
| if (NULL != nodeInfo->iNodeCreateFunc) |
| { |
| nodeInterface = (*(iType[NodeSearchCount].iNodeCreateFunc))(priority); |
| } |
| } |
| |
| return nodeInterface; |
| } |
| |
| bool PVPlayerNodeRegistry::ReleaseNode(PVUuid& aUuid, PVMFNodeInterface* aNode) |
| { |
| bool iFoundFlag = false; |
| uint32 NodeSearchCount = 0; |
| |
| while (NodeSearchCount < iType.size()) |
| { |
| //Search if the UUID's will match |
| if (iType[NodeSearchCount].iNodeUUID == aUuid) |
| { |
| //Since the UUID's match set the flag to true |
| iFoundFlag = true; |
| break; |
| } |
| |
| NodeSearchCount++; |
| |
| } |
| |
| if (iFoundFlag) |
| { |
| //Call the appropriate Node delete function |
| bool del_stat = (*(iType[NodeSearchCount].iNodeReleaseFunc))(aNode); |
| |
| #ifdef HAS_OSCL_LIB_SUPPORT |
| // If a library needs to be loaded to use this node, close the library |
| if (NULL != iType[NodeSearchCount].iSharedLibrary) |
| { |
| (iType[NodeSearchCount].iSharedLibrary)->Close(); |
| } |
| #endif |
| |
| return del_stat; |
| } |
| return false; |
| } |
| |
| // Player engine with recognizers for MP3, MP4, WAV, and AMR |
| PVPlayerRecognizerRegistry::PVPlayerRecognizerRegistry() |
| : OsclTimerObject(OsclActiveObject::EPriorityNominal, "PVPlayerRecognizerRegistry") |
| { |
| AddToScheduler(); |
| |
| iRecSessionId = 0; |
| iRecognizerResult.reserve(4); |
| iFileDataStreamFactory = NULL; |
| iSourceFormatType = PVMF_FORMAT_UNKNOWN; |
| iObserver = NULL; |
| iCmdContext = NULL; |
| iCancelQuery = false; |
| iCancelCmdContext = NULL; |
| |
| if (PVMFRecognizerRegistry::Init() != PVMFSuccess) |
| { |
| OSCL_ASSERT(false); |
| return; |
| } |
| |
| PVMFRecognizerPluginFactory* tmpfac = NULL; |
| tmpfac = OSCL_STATIC_CAST(PVMFRecognizerPluginFactory*, OSCL_NEW(PVMP3FFRecognizerFactory, ())); |
| if (PVMFRecognizerRegistry::RegisterPlugin(*tmpfac) == PVMFSuccess) |
| { |
| iRecognizerList.push_back(tmpfac); |
| } |
| else |
| { |
| OSCL_DELETE(((PVMP3FFRecognizerFactory*)tmpfac)); |
| tmpfac = NULL; |
| return; |
| } |
| |
| tmpfac = OSCL_STATIC_CAST(PVMFRecognizerPluginFactory*, OSCL_NEW(PVWAVFFRecognizerFactory, ())); |
| if (PVMFRecognizerRegistry::RegisterPlugin(*tmpfac) == PVMFSuccess) |
| { |
| iRecognizerList.push_back(tmpfac); |
| } |
| else |
| { |
| OSCL_DELETE(((PVWAVFFRecognizerFactory*)tmpfac)); |
| tmpfac = NULL; |
| return; |
| } |
| |
| tmpfac = OSCL_STATIC_CAST(PVMFRecognizerPluginFactory*, OSCL_NEW(PVAMRFFRecognizerFactory, ())); |
| if (PVMFRecognizerRegistry::RegisterPlugin(*tmpfac) == PVMFSuccess) |
| { |
| iRecognizerList.push_back(tmpfac); |
| } |
| else |
| { |
| OSCL_DELETE(((PVAMRFFRecognizerFactory*)tmpfac)); |
| tmpfac = NULL; |
| return; |
| } |
| |
| } |
| |
| |
| |
| PVPlayerRecognizerRegistry::~PVPlayerRecognizerRegistry() |
| { |
| if (iFileDataStreamFactory) |
| { |
| OSCL_DELETE(OSCL_STATIC_CAST(PVMIDataStreamSyncInterfaceRefFactory*, iFileDataStreamFactory)); |
| iFileDataStreamFactory = NULL; |
| } |
| PVMFRecognizerPluginFactory* tmpfac = NULL; |
| |
| if (iRecognizerList.empty() == false) |
| { |
| tmpfac = iRecognizerList[0]; |
| iRecognizerList.erase(iRecognizerList.begin()); |
| PVMFRecognizerRegistry::RemovePlugin(*tmpfac); |
| OSCL_DELETE(((PVMP3FFRecognizerFactory*)tmpfac)); |
| } |
| |
| if (iRecognizerList.empty() == false) |
| { |
| tmpfac = iRecognizerList[0]; |
| iRecognizerList.erase(iRecognizerList.begin()); |
| PVMFRecognizerRegistry::RemovePlugin(*tmpfac); |
| OSCL_DELETE(((PVWAVFFRecognizerFactory*)tmpfac)); |
| } |
| |
| if (iRecognizerList.empty() == false) |
| { |
| tmpfac = iRecognizerList[0]; |
| iRecognizerList.erase(iRecognizerList.begin()); |
| PVMFRecognizerRegistry::RemovePlugin(*tmpfac); |
| OSCL_DELETE(((PVAMRFFRecognizerFactory*)tmpfac)); |
| } |
| PVMFRecognizerRegistry::Cleanup(); |
| } |
| |
| |
| PVMFStatus PVPlayerRecognizerRegistry::QueryFormatType(OSCL_wString& aSourceURL, PVPlayerRecognizerRegistryObserver& aObserver, OsclAny* aCmdContext) |
| { |
| if (iObserver != NULL) |
| { |
| // Previous query still ongoing |
| return PVMFErrBusy; |
| } |
| iObserver = &aObserver; |
| iCmdContext = aCmdContext; |
| |
| // Create a datastream wrapper factory for standard file |
| if (iFileDataStreamFactory) |
| { |
| OSCL_DELETE(OSCL_STATIC_CAST(PVMIDataStreamSyncInterfaceRefFactory*, iFileDataStreamFactory)); |
| iFileDataStreamFactory = NULL; |
| } |
| int32 leavecode = 0; |
| OSCL_TRY(leavecode, iFileDataStreamFactory = OSCL_STATIC_CAST(PVMFDataStreamFactory*, OSCL_NEW(PVMIDataStreamSyncInterfaceRefFactory, (aSourceURL)))); |
| OSCL_FIRST_CATCH_ANY(leavecode, |
| return PVMFErrNoMemory; |
| ); |
| |
| // Open the session with recognizer |
| PVMFRecognizerRegistry::OpenSession(iRecSessionId, *this); |
| |
| // Request file recognition |
| iRecognizerResult.clear(); |
| iRecognizeCmdId = PVMFRecognizerRegistry::Recognize(iRecSessionId, *iFileDataStreamFactory, NULL, iRecognizerResult, NULL); |
| |
| return PVMFSuccess; |
| } |
| |
| |
| void PVPlayerRecognizerRegistry::CancelQuery(OsclAny* aContext) |
| { |
| if (iObserver == NULL) |
| { |
| // No pending recognize request |
| OSCL_LEAVE(OsclErrInvalidState); |
| return; |
| } |
| |
| iCancelQuery = true; |
| iCancelCmdContext = aContext; |
| |
| if (!IsBusy()) |
| { |
| // The recognition pending so cancel it |
| PVMFRecognizerRegistry::CancelCommand(iRecSessionId, iRecognizeCmdId); |
| } |
| // Else the recognition already completed so just cancel it in the Run() |
| } |
| |
| |
| void PVPlayerRecognizerRegistry::Run() |
| { |
| // Close the session with recognizer |
| PVMFRecognizerRegistry::CloseSession(iRecSessionId); |
| |
| // Destroy the data stream wrapper factory for standard file |
| if (iFileDataStreamFactory) |
| { |
| OSCL_DELETE(OSCL_STATIC_CAST(PVMIDataStreamSyncInterfaceRefFactory*, iFileDataStreamFactory)); |
| iFileDataStreamFactory = NULL; |
| } |
| |
| // Tell the engine the result |
| if (iObserver) |
| { |
| iObserver->RecognizeCompleted(iSourceFormatType, iCmdContext); |
| |
| if (iCancelQuery) |
| { |
| iObserver->RecognizeCompleted(iSourceFormatType, iCancelCmdContext); |
| iCancelQuery = false; |
| iCancelCmdContext = NULL; |
| } |
| } |
| iObserver = NULL; |
| iCmdContext = NULL; |
| } |
| |
| void PVPlayerRecognizerRegistry::RecognizerCommandCompleted(const PVMFCmdResp& aResponse) |
| { |
| iSourceFormatType = PVMF_FORMAT_UNKNOWN; |
| |
| if (aResponse.GetCmdId() == iRecognizeCmdId) |
| { |
| // Recognize() command completed |
| if (aResponse.GetCmdStatus() == PVMFSuccess) |
| { |
| Oscl_Vector<PVMFRecognizerResult, OsclMemAllocator>::iterator it; |
| for (it = iRecognizerResult.begin(); it != iRecognizerResult.end(); it++) |
| { |
| if (it->iRecognitionConfidence == PVMFRecognizerConfidenceCertain) |
| { |
| // Current implementation does not support the case where multiple |
| // recognizer plugins can recognize the file with certainty |
| iSourceFormatType = GetFormatIndex(it->iRecognizedFormat.get_str()); |
| break; |
| } |
| if (it->iRecognitionConfidence == PVMFRecognizerConfidencePossible) |
| { |
| iSourceFormatType = GetFormatIndex(it->iRecognizedFormat.get_str()); |
| } |
| } |
| } |
| |
| if (aResponse.GetCmdStatus() == PVMFErrCancelled) |
| { |
| // If cancelled, need to wait for the cancel command to complete before |
| // calling Run |
| return; |
| } |
| } |
| |
| RunIfNotReady(); |
| } |
| |
| |
