| /* ------------------------------------------------------------------ |
| * 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. |
| * ------------------------------------------------------------------- |
| */ |
| #ifndef PVMF_AACFFPARSER_NODE_H_INCLUDED |
| #define PVMF_AACFFPARSER_NODE_H_INCLUDED |
| |
| |
| #ifndef OSCL_BASE_H_INCLUDED |
| #include "oscl_base.h" |
| #endif |
| #ifndef OSCL_SCHEDULER_AO_H_INCLUDED |
| #include "oscl_scheduler_ao.h" |
| #endif |
| #ifndef OSCL_FILE_IO_H_INCLUDED |
| #include "oscl_file_io.h" |
| #endif |
| #ifndef PVMF_FORMAT_TYPE_H_INCLUDED |
| #include "pvmf_format_type.h" |
| #endif |
| #ifndef PVMF_NODE_INTERFACE_H_INCLUDED |
| #include "pvmf_node_interface.h" |
| #endif |
| #ifndef PVMF_MEDIA_DATA_H_INCLUDED |
| #include "pvmf_media_data.h" |
| #endif |
| #ifndef OSCL_MEM_MEMPOOL_H_INCLUDED |
| #include "oscl_mem_mempool.h" |
| #endif |
| #ifndef PVMF_MEMPOOL_H_INCLUDED |
| #include "pvmf_mempool.h" |
| #endif |
| #ifndef PVMF_SIMPLE_MEDIA_BUFFER_H_INCLUDED |
| #include "pvmf_simple_media_buffer.h" |
| #endif |
| #ifndef PVMF_DATA_SOURCE_INIT_EXTENSION_H_INCLUDED |
| #include "pvmf_data_source_init_extension.h" |
| #endif |
| #ifndef PVMF_TRACK_SELECTION_EXTENSION_H_INCLUDED |
| #include "pvmf_track_selection_extension.h" |
| #endif |
| #ifndef PVMF_MEDIA_PRESENTATION_INFO_H_INCLUDED |
| #include "pvmf_media_presentation_info.h" |
| #endif |
| #ifndef PVMF_NODE_UTILS_H_INCLUDED |
| #include "pvmf_node_utils.h" |
| #endif |
| #ifndef PVMF_AACFFPARSER_DEFS_H_INCLUDED |
| #include "pvmf_aacffparser_defs.h" |
| #endif |
| #ifndef PVMF_META_DATA_EXTENSION_H_INCLUDED |
| #include "pvmf_meta_data_extension.h" |
| #endif |
| #ifndef PVMF_DATA_SOURCE_PLAYBACK_CONTROL_H_INCLUDED |
| #include "pvmf_data_source_playback_control.h" |
| #endif |
| #ifndef AACFILEPARSER_H_INCLUDED |
| #include "aacfileparser.h" |
| #endif |
| #ifndef PVMF_LOCAL_DATA_SOURCE_H_INCLUDED |
| #include "pvmf_local_data_source.h" |
| #endif |
| #ifndef PVMF_FORMAT_PROGDOWNLOAD_SUPPORT_EXTENSION_H_INCLUDED |
| #include "pvmf_format_progdownload_support_extension.h" |
| #endif |
| #ifndef PVMF_DOWNLOAD_PROGRESS_EXTENSION_H |
| #include "pvmf_download_progress_interface.h" |
| #endif |
| #ifndef PVMI_DATASTREAMUSER_INTERFACE_H_INCLUDED |
| #include "pvmi_datastreamuser_interface.h" |
| #endif |
| #ifndef PVMI_KVP_INCLUDED |
| #include "pvmi_kvp.h" |
| #endif |
| #ifndef PVMI_KVP_UTIL_H_INCLUDED |
| #include "pvmi_kvp_util.h" |
| #endif |
| #ifndef PVMF_TRACK_SELECTION_EXTENSION_H_INCLUDED |
| #include "pvmf_track_selection_extension.h" |
| #endif |
| #ifndef PVMF_MEDIA_PRESENTATION_INFO_H_INCLUDED |
| #include "pvmf_media_presentation_info.h" |
| #endif |
| #ifndef PVMF_TRACK_LEVEL_INFO_EXTENSION_H_INCLUDED |
| #include "pvmf_track_level_info_extension.h" |
| #endif |
| #ifndef PVMF_SIMPLE_MEDIA_BUFFER_H_INCLUDED |
| #include "pvmf_simple_media_buffer.h" |
| #endif |
| #ifndef PVMF_MEDIA_FRAG_GROUP_H_INCLUDED |
| #include "pvmf_media_frag_group.h" |
| #endif |
| #ifndef OSCL_PRIQUEUE_H_INCLUDED |
| #include "oscl_priqueue.h" |
| #endif |
| #ifndef PVLOGGER_H_INCLUDED |
| #include "pvlogger.h" |
| #endif |
| #ifndef CPM_H_INCLUDED |
| #include "cpm.h" |
| #endif |
| #ifndef PVMF_CPMPLUGIN_ACCESS_INTERFACE_H_INCLUDED |
| #include "pvmf_cpmplugin_access_interface.h" |
| #endif |
| #ifndef PVMF_AACFFPARSER_OUTPORT_H_INCLUDED |
| #include "pvmf_aacffparser_outport.h" |
| #endif |
| #ifndef PVMF_RESIZABLE_SIMPLE_MEDIAMSG_H_INCLUDED |
| #include "pvmf_resizable_simple_mediamsg.h" |
| #endif |
| #ifndef PVMF_CPMPLUGIN_LICENSE_INTERFACE_H_INCLUDED |
| #include "pvmf_cpmplugin_license_interface.h" |
| #endif |
| |
| /** |
| * Node command handling |
| */ |
| #define PVMF_AAC_PARSER_NODE_NEW(auditCB,T,params,ptr)\ |
| {\ |
| ptr = OSCL_NEW(T,params);\ |
| } |
| |
| #define PVMF_AAC_PARSER_NODE_DELETE(auditCB,T,ptr)\ |
| {\ |
| OSCL_DELETE(ptr);\ |
| } |
| |
| #define PVMF_AAC_PARSER_NODE_TEMPLATED_DELETE(auditCB, T, Tsimple, ptr)\ |
| {\ |
| OSCL_DELETE(ptre);\ |
| } |
| |
| #define PV_AAC_PARSER_NODE_ARRAY_NEW(auditCB, T, count, ptr)\ |
| {\ |
| ptr = OSCL_ARRAY_NEW(T, count);\ |
| } |
| |
| #define PV_AAC_PARSER_NODE_ARRAY_DELETE(auditCB, ptr)\ |
| {\ |
| OSCL_ARRAY_DELETE(ptr);\ |
| } |
| |
| |
| |
| /** Track info |
| */ |
| |
| // Allocator wrapper for the memory pool that saves the last block pointer allocated |
| // so it can be resized later |
| class TrackDataMemPoolProxyAlloc : public Oscl_DefAlloc |
| { |
| public: |
| TrackDataMemPoolProxyAlloc(OsclMemPoolResizableAllocator& aMemPool) |
| { |
| iMemPoolAllocPtr = &aMemPool; |
| iLastAllocatedBlockPtr = NULL; |
| } |
| |
| virtual ~TrackDataMemPoolProxyAlloc() |
| { |
| } |
| |
| OsclAny* allocate(const uint32 size) |
| { |
| OSCL_ASSERT(iMemPoolAllocPtr); |
| iLastAllocatedBlockPtr = iMemPoolAllocPtr->allocate(size); |
| return iLastAllocatedBlockPtr; |
| } |
| |
| void deallocate(OsclAny* p) |
| { |
| OSCL_ASSERT(iMemPoolAllocPtr); |
| iMemPoolAllocPtr->deallocate(p); |
| } |
| |
| bool trim(uint32 aBytesToFree) |
| { |
| OSCL_ASSERT(iMemPoolAllocPtr); |
| OSCL_ASSERT(iLastAllocatedBlockPtr); |
| return iMemPoolAllocPtr->trim(iLastAllocatedBlockPtr, aBytesToFree); |
| } |
| |
| OsclMemPoolResizableAllocator* iMemPoolAllocPtr; |
| OsclAny* iLastAllocatedBlockPtr; |
| }; |
| |
| class MediaClockConverter; |
| class PVMFAACFFParserNode; |
| class PVAACFFNodeTrackPortInfo : public OsclMemPoolFixedChunkAllocatorObserver, |
| public OsclMemPoolResizableAllocatorObserver |
| { |
| public: |
| |
| PVAACFFNodeTrackPortInfo() |
| { |
| oADTS = false; |
| iTrackId = -1; |
| iPort = NULL; |
| iClockConverter = NULL; |
| iTrackDataMemoryPool = NULL; |
| iTrackDataMemoryPoolProxy = NULL; |
| iMediaDataImplAlloc = NULL; |
| iMediaDataMemPool = NULL; |
| iResizableSimpleMediaMsgAlloc = NULL; |
| iNode = NULL; |
| iSeqNum = 0; |
| iTimestampOffset = 0; |
| iSendBOS = false; |
| |
| ///////////////////////////////////////////////////// |
| iFormatType = PVMF_MIME_FORMAT_UNKNOWN; |
| iSeqNum = 0; |
| oEOSReached = false; |
| oEOSSent = false; |
| oQueueOutgoingMessages = true; |
| oProcessOutgoingMessages = true; |
| iTrackBitRate = 0; |
| iTrackDuration = 0; |
| iContinuousTimeStamp = 0; |
| iPrevSampleTimeStamp = 0; |
| iTrackMaxSampleSize = 0; |
| |
| iLogger = PVLogger::GetLoggerObject("PVMFAACParserNode"); |
| iDataPathLogger = PVLogger::GetLoggerObject("datapath.sourcenode.aacparsernode"); |
| if (iDataPathLogger) |
| iDataPathLogger->DisableAppenderInheritance(); |
| iClockLogger = PVLogger::GetLoggerObject("clock"); |
| iPortLogger = NULL; |
| oFormatSpecificInfoLogged = false; |
| |
| iAudioSampleRate = 0; |
| iAudioNumChannels = 0; |
| iAudioBitsPerSample = 0; |
| iCodecName = NULL; |
| iCodecDescription = NULL; |
| iResizableSimpleMediaMsgAlloc = NULL; |
| ///////////////////////////////////////////////////////// |
| } |
| |
| PVAACFFNodeTrackPortInfo(const PVAACFFNodeTrackPortInfo& aSrc) : |
| OsclMemPoolFixedChunkAllocatorObserver(aSrc), |
| OsclMemPoolResizableAllocatorObserver(aSrc) |
| { |
| oADTS = aSrc.oADTS; |
| iTrackId = aSrc.iTrackId; |
| iPort = aSrc.iPort; |
| iClockConverter = aSrc.iClockConverter; |
| iFormatSpecificConfig = aSrc.iFormatSpecificConfig; |
| iMediaData = aSrc.iMediaData; |
| iTrackDataMemoryPool = aSrc.iTrackDataMemoryPool; |
| iTrackDataMemoryPoolProxy = aSrc.iTrackDataMemoryPoolProxy; |
| iMediaDataImplAlloc = aSrc.iMediaDataImplAlloc; |
| iMediaDataMemPool = aSrc.iMediaDataMemPool; |
| iNode = aSrc.iNode; |
| iSeqNum = aSrc.iSeqNum; |
| iTimestampOffset = aSrc.iTimestampOffset; |
| iSendBOS = aSrc.iSendBOS; |
| |
| ///////////////////////////////////////////////// |
| iSeqNum = aSrc.iSeqNum; |
| oEOSReached = aSrc.oEOSReached; |
| oEOSSent = aSrc.oEOSSent; |
| oQueueOutgoingMessages = aSrc.oQueueOutgoingMessages; |
| oProcessOutgoingMessages = aSrc.oProcessOutgoingMessages; |
| iTrackBitRate = aSrc.iTrackBitRate; |
| iTrackDuration = aSrc.iTrackDuration; |
| iContinuousTimeStamp = aSrc.iContinuousTimeStamp; |
| iPrevSampleTimeStamp = aSrc.iPrevSampleTimeStamp; |
| iTrackMaxSampleSize = aSrc.iTrackMaxSampleSize; |
| iLogger = aSrc.iLogger; |
| iDataPathLogger = aSrc.iDataPathLogger; |
| iClockLogger = aSrc.iClockLogger; |
| iPortLogger = aSrc.iPortLogger; |
| oFormatSpecificInfoLogged = aSrc.oFormatSpecificInfoLogged; |
| iAudioSampleRate = aSrc.iAudioSampleRate; |
| iAudioNumChannels = aSrc.iAudioNumChannels; |
| |
| iResizableSimpleMediaMsgAlloc = aSrc.iResizableSimpleMediaMsgAlloc; |
| iMediaDataMemPool = aSrc.iMediaDataMemPool; |
| |
| iAudioBitsPerSample = aSrc.iAudioBitsPerSample; |
| iCodecName = aSrc.iCodecName;; |
| iCodecDescription = aSrc.iCodecDescription; |
| } |
| |
| virtual ~PVAACFFNodeTrackPortInfo() |
| { |
| iLogger = NULL; |
| iDataPathLogger = NULL; |
| iClockLogger = NULL; |
| iPortLogger = NULL; |
| } |
| |
| // From OsclMemPoolFixedChunkAllocatorObserver |
| // Callback handler when mempool's deallocate() is called after |
| // calling notifyfreechunkavailable() on the mempool |
| void freechunkavailable(OsclAny* aContextData) |
| { |
| OSCL_UNUSED_ARG(aContextData); |
| PVMF_AACPARSERNODE_LOGINFO((0, "MimeType = %s, freeblockavailable#############", iTrackMimeType.get_cstr())); |
| oQueueOutgoingMessages = true; |
| if (iNode) |
| { |
| /* Activate the parent node if necessary */ |
| iNode->RunIfNotReady(); |
| } |
| } |
| |
| /* |
| * From OsclMemPoolResizableAllocatorObserver |
| * Callback handler when mempool's deallocate() is called after |
| * calling notifyfreeblockavailable() on the mempool |
| */ |
| void freeblockavailable(OsclAny* aContextData) |
| { |
| OSCL_UNUSED_ARG(aContextData); |
| PVMF_AACPARSERNODE_LOGINFO((0, "MimeType = %s, freeblockavailable", iTrackMimeType.get_cstr())); |
| oQueueOutgoingMessages = true; |
| if (iNode) |
| { |
| /* Activate the parent node if necessary */ |
| iNode->RunIfNotReady(); |
| } |
| } |
| bool oADTS; |
| |
| // Track ID number in AAC FF |
| int32 iTrackId; |
| /* Track Bitrate */ |
| uint32 iTrackBitRate; |
| /* Track Duration */ |
| uint64 iTrackDuration; |
| // Output port to send the data downstream |
| PVMFPortInterface* iPort; |
| |
| /* PVMF mime type for track */ |
| OSCL_HeapString<PVMFAACParserNodeAllocator> iTrackMimeType; |
| |
| /* Format type for the port */ |
| PVMFFormatType iFormatType; |
| |
| /* bos flag */ |
| bool iSendBOS; |
| |
| // Settings for the output port |
| // Converter to convert from track timescale to milliseconds |
| MediaClockConverter* iClockConverter; |
| // Shared memory pointer holding the decoder specific config info for this track |
| OsclRefCounterMemFrag iFormatSpecificConfig; |
| |
| // Shared memory pointer holding the currently retrieved track data |
| PVMFSharedMediaDataPtr iMediaData; |
| // Output buffer memory pool |
| OsclMemPoolResizableAllocator *iTrackDataMemoryPool; |
| // Allocator wrapper for the output buffer memory pool |
| TrackDataMemPoolProxyAlloc* iTrackDataMemoryPoolProxy; |
| // Allocator for simple media data buffer impl |
| PVMFSimpleMediaBufferCombinedAlloc *iMediaDataImplAlloc; |
| |
| /* Allocator for simple media buffer impl */ |
| PVMFResizableSimpleMediaMsgAlloc* iResizableSimpleMediaMsgAlloc; |
| |
| // Memory pool for simple media data |
| PVMFMemPoolFixedChunkAllocator *iMediaDataMemPool; |
| // AAC FF parser node handle |
| OsclTimerObject* iNode; |
| // Sequence number |
| uint32 iSeqNum; |
| // An offset for timestamps after repositioning. |
| int32 iTimestampOffset; |
| |
| /* port flow control */ |
| bool oQueueOutgoingMessages; |
| bool oProcessOutgoingMessages; |
| /* End of Track */ |
| bool oEOSReached; |
| bool oEOSSent; |
| /* Continuous timestamp */ |
| uint64 iContinuousTimeStamp; |
| uint64 iPrevSampleTimeStamp; |
| /* Mem pool size */ |
| uint32 iTrackDataMemoryPoolSize; |
| /* Track Max Sample Size */ |
| uint32 iTrackMaxSampleSize; |
| |
| /* Loggers */ |
| PVLogger* iLogger; |
| PVLogger* iDataPathLogger; |
| PVLogger* iClockLogger; |
| /* bitstream logging */ |
| PVLogger* iPortLogger; |
| OSCL_HeapString<PVMFAACParserNodeAllocator> iLogFile; |
| bool oFormatSpecificInfoLogged; |
| OsclSharedPtr<PVLoggerAppender> iBinAppenderPtr; |
| |
| /* Audio - specfic info */ |
| uint32 iAudioSampleRate; |
| uint32 iAudioNumChannels; |
| uint32 iAudioBitsPerSample; |
| OSCL_wHeapString<OsclMemAllocator> iCodecName; |
| OSCL_wHeapString<OsclMemAllocator> iCodecDescription; |
| }; |
| |
| |
| |
| /** |
| * Node command handling |
| */ |
| |
| |
| /* Default vector reserve size */ |
| #define PVMF_AAC_PARSER_NODE_VECTOR_RESERVE 10 |
| /* Starting value for command IDs */ |
| #define PVMF_AAC_PARSER_NODE_COMMAND_ID_START 9000 |
| |
| enum TPVMFAACParserNodeCommand |
| { |
| PVMF_AAC_PARSER_NODE_QUERYUUID, |
| PVMF_AAC_PARSER_NODE_QUERYINTERFACE, |
| PVMF_AAC_PARSER_NODE_REQUESTPORT, |
| PVMF_AAC_PARSER_NODE_RELEASEPORT, |
| PVMF_AAC_PARSER_NODE_INIT, |
| PVMF_AAC_PARSER_NODE_PREPARE, |
| PVMF_AAC_PARSER_NODE_START, |
| PVMF_AAC_PARSER_NODE_STOP, |
| PVMF_AAC_PARSER_NODE_FLUSH, |
| PVMF_AAC_PARSER_NODE_PAUSE, |
| PVMF_AAC_PARSER_NODE_RESET, |
| PVMF_AAC_PARSER_NODE_CANCELALLCOMMANDS, |
| PVMF_AAC_PARSER_NODE_CANCELCOMMAND, |
| PVMF_AAC_PARSER_NODE_SET_DATASOURCE_POSITION, |
| PVMF_AAC_PARSER_NODE_QUERY_DATASOURCE_POSITION, |
| PVMF_AAC_PARSER_NODE_SET_DATASOURCE_RATE, |
| PVMF_AAC_PARSER_NODE_GETNODEMETADATAKEYS, |
| PVMF_AAC_PARSER_NODE_GETNODEMETADATAVALUES, |
| PVMF_AAC_PARSER_NODE_SET_DATASOURCE_DIRECTION, |
| PVMF_AAC_PARSER_NODE_GET_LICENSE_W, |
| PVMF_AAC_PARSER_NODE_CANCEL_GET_LICENSE, |
| PVMF_AAC_PARSER_NODE_GET_LICENSE, |
| PVMF_AAC_PARSER_NODE_COMMAND_LAST |
| }; |
| |
| |
| typedef PVMFGenericNodeCommand<OsclMemAllocator> PVMFAACFFParserNodeCommandBase; |
| |
| enum PVMFAACFFParserNodeCommandType |
| { |
| PVAACFF_NODE_CMD_SETDATASOURCEPOSITION = PVMF_GENERIC_NODE_COMMAND_LAST |
| , PVAACFF_NODE_CMD_QUERYDATASOURCEPOSITION |
| , PVAACFF_NODE_CMD_SETDATASOURCERATE |
| , PVAACFF_NODE_CMD_GETNODEMETADATAKEYS |
| , PVAACFF_NODE_CMD_GETNODEMETADATAVALUES |
| }; |
| |
| class PVMFAACFFParserNodeCommand : public PVMFAACFFParserNodeCommandBase |
| { |
| public: |
| |
| // Constructor and parser for GetNodeMetadataKeys |
| void Construct(PVMFSessionId s, int32 cmd |
| , PVMFMetadataList& aKeyList |
| , uint32 aStartingIndex |
| , int32 aMaxEntries |
| , char* aQueryKey |
| , const OsclAny* aContext) |
| { |
| PVMFAACFFParserNodeCommandBase::Construct(s, cmd, aContext); |
| iParam1 = (OsclAny*) & aKeyList; |
| iParam2 = (OsclAny*)aStartingIndex; |
| iParam3 = (OsclAny*)aMaxEntries; |
| if (aQueryKey) |
| { |
| //allocate a copy of the query key string. |
| Oscl_TAlloc<OSCL_HeapString<OsclMemAllocator>, OsclMemAllocator> str; |
| iParam4 = str.ALLOC_AND_CONSTRUCT(aQueryKey); |
| } |
| } |
| void Parse(PVMFMetadataList*& MetaDataListPtr, uint32 &aStartingIndex, int32 &aMaxEntries, char*& aQueryKey) |
| { |
| MetaDataListPtr = (PVMFMetadataList*)iParam1; |
| aStartingIndex = (uint32)iParam2; |
| aMaxEntries = (int32)iParam3; |
| aQueryKey = NULL; |
| if (iParam4) |
| { |
| OSCL_HeapString<OsclMemAllocator>* keystring = (OSCL_HeapString<OsclMemAllocator>*)iParam4; |
| aQueryKey = keystring->get_str(); |
| } |
| } |
| |
| // Constructor and parser for GetNodeMetadataValue |
| void Construct(PVMFSessionId s, int32 cmd, PVMFMetadataList& aKeyList, Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList, uint32 aStartIndex, int32 aMaxEntries, const OsclAny* aContext) |
| { |
| PVMFAACFFParserNodeCommandBase::Construct(s, cmd, aContext); |
| iParam1 = (OsclAny*) & aKeyList; |
| iParam2 = (OsclAny*) & aValueList; |
| iParam3 = (OsclAny*)aStartIndex; |
| iParam4 = (OsclAny*)aMaxEntries; |
| |
| } |
| void Parse(PVMFMetadataList* &aKeyList, Oscl_Vector<PvmiKvp, OsclMemAllocator>* &aValueList, uint32 &aStartingIndex, int32 &aMaxEntries) |
| { |
| aKeyList = (PVMFMetadataList*)iParam1; |
| aValueList = (Oscl_Vector<PvmiKvp, OsclMemAllocator>*)iParam2; |
| aStartingIndex = (uint32)iParam3; |
| aMaxEntries = (int32)iParam4; |
| } |
| |
| // Constructor and parser for SetDataSourcePosition |
| void Construct(PVMFSessionId s, int32 cmd, PVMFTimestamp aTargetNPT, PVMFTimestamp& aActualNPT, PVMFTimestamp& aActualMediaDataTS, |
| bool aSeekToSyncPoint, uint32 aStreamID, const OsclAny*aContext) |
| { |
| PVMFAACFFParserNodeCommandBase::Construct(s, cmd, aContext); |
| iParam1 = (OsclAny*)aTargetNPT; |
| iParam2 = (OsclAny*) & aActualNPT; |
| iParam3 = (OsclAny*) & aActualMediaDataTS; |
| iParam4 = (OsclAny*)aSeekToSyncPoint; |
| iParam5 = (OsclAny*)aStreamID; |
| } |
| void Parse(PVMFTimestamp& aTargetNPT, PVMFTimestamp*& aActualNPT, PVMFTimestamp*& aActualMediaDataTS, bool& aSeekToSyncPoint, uint32& aStreamID) |
| { |
| aTargetNPT = (PVMFTimestamp)iParam1; |
| aActualNPT = (PVMFTimestamp*)iParam2; |
| aActualMediaDataTS = (PVMFTimestamp*)iParam3; |
| aSeekToSyncPoint = (iParam4) ? true : false; |
| aStreamID = (uint32)iParam5; |
| } |
| |
| // Constructor and parser for QueryDataSourcePosition |
| void Construct(PVMFSessionId s, int32 cmd, PVMFTimestamp aTargetNPT, PVMFTimestamp& aActualNPT, |
| bool aSeekToSyncPoint, const OsclAny*aContext) |
| { |
| PVMFAACFFParserNodeCommandBase::Construct(s, cmd, aContext); |
| iParam1 = (OsclAny*)aTargetNPT; |
| iParam2 = (OsclAny*) & aActualNPT; |
| iParam3 = (OsclAny*)aSeekToSyncPoint; |
| iParam4 = NULL; |
| iParam5 = NULL; |
| } |
| void Parse(PVMFTimestamp& aTargetNPT, PVMFTimestamp*& aActualNPT, bool& aSeekToSyncPoint) |
| { |
| aTargetNPT = (PVMFTimestamp)iParam1; |
| aActualNPT = (PVMFTimestamp*)iParam2; |
| aSeekToSyncPoint = (iParam3) ? true : false; |
| } |
| |
| // Constructor and parser for SetDataSourceRate |
| void Construct(PVMFSessionId s, int32 cmd, int32 aRate, PVMFTimebase* aTimebase, const OsclAny*aContext) |
| { |
| PVMFAACFFParserNodeCommandBase::Construct(s, cmd, aContext); |
| iParam1 = (OsclAny*)aRate; |
| iParam2 = (OsclAny*)aTimebase; |
| iParam3 = NULL; |
| iParam4 = NULL; |
| iParam5 = NULL; |
| } |
| void Parse(int32& aRate, PVMFTimebase*& aTimebase) |
| { |
| aRate = (int32)iParam1; |
| aTimebase = (PVMFTimebase*)iParam2; |
| } |
| |
| /* Constructor and parser for GetLicenseW */ |
| void Construct(PVMFSessionId s, |
| int32 cmd, |
| OSCL_wString& aContentName, |
| OsclAny* aLicenseData, |
| uint32 aDataSize, |
| int32 aTimeoutMsec, |
| OsclAny* aContext) |
| { |
| PVMFAACFFParserNodeCommandBase::Construct(s, cmd, aContext); |
| iParam1 = (OsclAny*) & aContentName; |
| iParam2 = (OsclAny*)aLicenseData; |
| iParam3 = (OsclAny*)aDataSize; |
| iParam4 = (OsclAny*)aTimeoutMsec; |
| iParam5 = NULL; |
| } |
| void Parse(OSCL_wString*& aContentName, |
| OsclAny*& aLicenseData, |
| uint32& aDataSize, |
| int32& aTimeoutMsec) |
| { |
| aContentName = (OSCL_wString*)iParam1; |
| aLicenseData = (PVMFTimestamp*)iParam2; |
| aDataSize = (uint32)iParam3; |
| aTimeoutMsec = (int32)iParam4; |
| } |
| |
| /* Constructor and parser for GetLicense */ |
| void Construct(PVMFSessionId s, |
| int32 cmd, |
| OSCL_String& aContentName, |
| OsclAny* aLicenseData, |
| uint32 aDataSize, |
| int32 aTimeoutMsec, |
| OsclAny* aContext) |
| { |
| PVMFAACFFParserNodeCommandBase::Construct(s, cmd, aContext); |
| iParam1 = (OsclAny*) & aContentName; |
| iParam2 = (OsclAny*)aLicenseData; |
| iParam3 = (OsclAny*)aDataSize; |
| iParam4 = (OsclAny*)aTimeoutMsec; |
| iParam5 = NULL; |
| } |
| void Parse(OSCL_String*& aContentName, |
| OsclAny*& aLicenseData, |
| uint32& aDataSize, |
| int32& aTimeoutMsec) |
| { |
| aContentName = (OSCL_String*)iParam1; |
| aLicenseData = (PVMFTimestamp*)iParam2; |
| aDataSize = (uint32)iParam3; |
| aTimeoutMsec = (int32)iParam4; |
| } |
| |
| |
| //need to overlaod the base Destroy routine to cleanup metadata key. |
| void Destroy() |
| { |
| PVMFGenericNodeCommand<OsclMemAllocator>::Destroy(); |
| switch (iCmd) |
| { |
| case PVMF_AAC_PARSER_NODE_GETNODEMETADATAKEYS: |
| if (iParam4) |
| { |
| //cleanup the allocated string |
| Oscl_TAlloc<OSCL_HeapString<OsclMemAllocator>, OsclMemAllocator> str; |
| str.destruct_and_dealloc(iParam4); |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| |
| //need to overlaod the base Copy routine to copy metadata key. |
| void Copy(const PVMFGenericNodeCommand<OsclMemAllocator>& aCmd) |
| { |
| PVMFGenericNodeCommand<OsclMemAllocator>::Copy(aCmd); |
| switch (aCmd.iCmd) |
| { |
| case PVMF_AAC_PARSER_NODE_GETNODEMETADATAKEYS: |
| if (aCmd.iParam4) |
| { |
| //copy the allocated string |
| OSCL_HeapString<OsclMemAllocator>* aStr = (OSCL_HeapString<OsclMemAllocator>*)aCmd.iParam4; |
| Oscl_TAlloc<OSCL_HeapString<OsclMemAllocator>, OsclMemAllocator> str; |
| iParam4 = str.ALLOC_AND_CONSTRUCT(*aStr); |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| |
| }; |
| |
| typedef PVMFNodeCommandQueue<PVMFAACFFParserNodeCommand, OsclMemAllocator> PVMFAACFFParserNodeCmdQ; |
| |
| |
| |
| /** The memory allocator for this node |
| */ |
| typedef OsclMemAllocator PVMFAACFFParserNodeAllocator; |
| |
| /** The AAC file parser node class |
| */ |
| class CAACFileParser; |
| class PVMFAACFFParserOutPort; |
| class PVLogger; |
| class PVMFLocalDataSource; |
| |
| class PVMFAACFFParserNode : public OsclTimerObject |
| , public PVMFNodeInterface |
| , public PVMFDataSourceInitializationExtensionInterface |
| , public PVMFTrackSelectionExtensionInterface |
| , public PvmfDataSourcePlaybackControlInterface |
| , public PVMFMetadataExtensionInterface |
| , public PVMFCPMStatusObserver |
| , public PVMIDatastreamuserInterface |
| , public PvmiDataStreamObserver |
| , public PVMFFormatProgDownloadSupportInterface |
| , public PVMFCPMPluginLicenseInterface |
| { |
| public: |
| PVMFAACFFParserNode(int32 aPriority); |
| ~PVMFAACFFParserNode(); |
| |
| // From PVMFNodeInterface |
| PVMFStatus ThreadLogon(); |
| PVMFStatus ThreadLogoff(); |
| PVMFStatus GetCapability(PVMFNodeCapability& aNodeCapability); |
| PVMFPortIter* GetPorts(const PVMFPortFilter* aFilter = NULL); |
| PVMFCommandId QueryUUID(PVMFSessionId, const PvmfMimeString& aMimeType, |
| Oscl_Vector<PVUuid, PVMFAACFFParserNodeAllocator>& aUuids, |
| bool aExactUuidsOnly = false, |
| const OsclAny* aContext = NULL); |
| PVMFCommandId QueryInterface(PVMFSessionId, const PVUuid& aUuid, |
| PVInterface*& aInterfacePtr, |
| const OsclAny* aContext = NULL); |
| PVMFCommandId RequestPort(PVMFSessionId |
| , int32 aPortTag, const PvmfMimeString* aPortConfig = NULL, const OsclAny* aContext = NULL); |
| PVMFCommandId ReleasePort(PVMFSessionId, PVMFPortInterface& aPort, const OsclAny* aContext = NULL); |
| PVMFCommandId Init(PVMFSessionId, const OsclAny* aContext = NULL); |
| PVMFCommandId Prepare(PVMFSessionId, const OsclAny* aContext = NULL); |
| PVMFCommandId Start(PVMFSessionId, const OsclAny* aContext = NULL); |
| PVMFCommandId Stop(PVMFSessionId, const OsclAny* aContext = NULL); |
| PVMFCommandId Flush(PVMFSessionId, const OsclAny* aContext = NULL); |
| PVMFCommandId Pause(PVMFSessionId, const OsclAny* aContext = NULL); |
| PVMFCommandId Reset(PVMFSessionId, const OsclAny* aContext = NULL); |
| PVMFCommandId CancelAllCommands(PVMFSessionId, const OsclAny* aContextData = NULL); |
| PVMFCommandId CancelCommand(PVMFSessionId, PVMFCommandId aCmdId, const OsclAny* aContextData = NULL); |
| PVMFStatus QueryInterfaceSync(PVMFSessionId aSession, |
| const PVUuid& aUuid, |
| PVInterface*& aInterfacePtr); |
| |
| //From PVMFDataSourceInitializationExtensionInterface |
| void addRef(); |
| void removeRef(); |
| bool queryInterface(const PVUuid& uuid, PVInterface *& iface); |
| |
| PVMFStatus SetSourceInitializationData(OSCL_wString& aSourceURL, PVMFFormatType& aSourceFormat, OsclAny* aSourceData); |
| PVMFStatus SetClientPlayBackClock(PVMFMediaClock* aClientClock); |
| PVMFStatus SetEstimatedServerClock(PVMFMediaClock* aClientClock); |
| |
| //From PVMFTrackSelectionExtensionInterface |
| PVMFStatus GetMediaPresentationInfo(PVMFMediaPresentationInfo& aInfo); |
| PVMFStatus SelectTracks(PVMFMediaPresentationInfo& aInfo); |
| |
| /* From PVMFCPMStatusObserver */ |
| void CPMCommandCompleted(const PVMFCmdResp& aResponse); |
| |
| /* From PVMIDatastreamuserInterface */ |
| void PassDatastreamFactory(PVMFDataStreamFactory& aFactory, |
| int32 aFactoryTag, |
| const PvmfMimeString* aFactoryConfig = NULL); |
| |
| void PassDatastreamReadCapacityObserver(PVMFDataStreamReadCapacityObserver* aObserver); |
| |
| /* From PVMFFormatProgDownloadSupportInterface */ |
| int32 convertSizeToTime(uint32 fileSize, uint32& aNPTInMS); |
| void setFileSize(const uint32 aFileSize); |
| void setDownloadProgressInterface(PVMFDownloadProgressInterface*); |
| void playResumeNotification(bool aDownloadComplete); |
| void notifyDownloadComplete() {}; |
| |
| |
| // From PVMFMetadataExtensionInterface |
| uint32 GetNumMetadataKeys(char* aQueryKeyString = NULL); |
| uint32 GetNumMetadataValues(PVMFMetadataList& aKeyList); |
| PVMFCommandId GetNodeMetadataKeys(PVMFSessionId aSessionId, PVMFMetadataList& aKeyList, |
| uint32 aStartingKeyIndex, int32 aMaxKeyEntries, char* aQueryKeyString = NULL, const OsclAny* aContextData = NULL); |
| PVMFCommandId GetNodeMetadataValues(PVMFSessionId aSessionId, PVMFMetadataList& aKeyList, Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList, |
| uint32 aStartingKeyIndex, int32 aMaxKeyEntries, const OsclAny* aContextData = NULL); |
| PVMFStatus ReleaseNodeMetadataKeys(PVMFMetadataList& aKeyList, uint32 aStartingKeyIndex, uint32 aEndKeyIndex); |
| PVMFStatus ReleaseNodeMetadataValues(Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList, uint32 aStartingValueIndex, uint32 aEndValueIndex); |
| |
| /* From PvmiDataStreamObserver */ |
| void DataStreamCommandCompleted(const PVMFCmdResp& aResponse); |
| void DataStreamInformationalEvent(const PVMFAsyncEvent& aEvent); |
| void DataStreamErrorEvent(const PVMFAsyncEvent& aEvent); |
| |
| // From PvmfDataSourcePlaybackControlInterface |
| PVMFCommandId SetDataSourcePosition(PVMFSessionId aSessionId |
| , PVMFTimestamp aTargetNPT |
| , PVMFTimestamp& aActualNPT |
| , PVMFTimestamp& aActualMediaDataTS |
| , bool aSeekToSyncPoint = true |
| , uint32 aStreamID = -1 |
| , OsclAny* aContext = NULL); |
| PVMFCommandId QueryDataSourcePosition(PVMFSessionId aSessionId |
| , PVMFTimestamp aTargetNPT |
| , PVMFTimestamp& aActualNPT |
| , bool aSeekToSyncPoint = true |
| , OsclAny* aContext = NULL); |
| PVMFCommandId QueryDataSourcePosition(PVMFSessionId aSessionId |
| , PVMFTimestamp aTargetNPT |
| , PVMFTimestamp& aSeekPointBeforeTargetNPT |
| , PVMFTimestamp& aSeekPointAfterTargetNPT |
| , OsclAny* aContext = NULL |
| , bool aSeekToSyncPoint = true); |
| PVMFCommandId SetDataSourceRate(PVMFSessionId aSession |
| , int32 aRate |
| , PVMFTimebase* aTimebase = NULL |
| , OsclAny* aContext = NULL); |
| |
| /* From PVMFCPMPluginLicenseInterface */ |
| PVMFStatus GetLicenseURL(PVMFSessionId aSessionId, |
| OSCL_wString& aContentName, |
| OSCL_wString& aLicenseURL) |
| { |
| //must use Async method. |
| OSCL_UNUSED_ARG(aSessionId); |
| OSCL_UNUSED_ARG(aContentName); |
| OSCL_UNUSED_ARG(aLicenseURL); |
| return PVMFErrNotSupported; |
| } |
| PVMFStatus GetLicenseURL(PVMFSessionId aSessionId, |
| OSCL_String& aContentName, |
| OSCL_String& aLicenseURL) |
| { |
| //must use Async method. |
| OSCL_UNUSED_ARG(aSessionId); |
| OSCL_UNUSED_ARG(aContentName); |
| OSCL_UNUSED_ARG(aLicenseURL); |
| return PVMFErrNotSupported; |
| } |
| |
| PVMFCommandId GetLicense(PVMFSessionId aSessionId, |
| OSCL_wString& aContentName, |
| OsclAny* aData, |
| uint32 aDataSize, |
| int32 aTimeoutMsec, |
| OsclAny* aContextData) ; |
| |
| PVMFCommandId GetLicense(PVMFSessionId aSessionId, |
| OSCL_String& aContentName, |
| OsclAny* aData, |
| uint32 aDataSize, |
| int32 aTimeoutMsec, |
| OsclAny* aContextData); |
| |
| PVMFCommandId CancelGetLicense(PVMFSessionId aSessionId |
| , PVMFCommandId aCmdId |
| , OsclAny* aContextData); |
| PVMFStatus GetLicenseStatus( |
| PVMFCPMLicenseStatus& aStatus) ; |
| |
| private: |
| |
| //from PVMFPortActivityHandler |
| void HandlePortActivity(const PVMFPortActivity& aActivity); |
| |
| //from OsclTimerObject |
| void Run(); |
| |
| // Port processing |
| /////////////////////////////////////////////////////////////////////////////////// |
| bool ProcessPortActivity(PVAACFFNodeTrackPortInfo*); |
| PVMFStatus RetrieveMediaSample(PVAACFFNodeTrackPortInfo* aTrackInfoPtr, |
| PVMFSharedMediaDataPtr& aSharedPtr); |
| PVMFStatus QueueMediaSample(PVAACFFNodeTrackPortInfo* aTrackInfoPtr); |
| PVMFStatus ProcessOutgoingMsg(PVAACFFNodeTrackPortInfo* aTrackInfoPtr); |
| bool GetTrackInfo(PVMFPortInterface* aPort, |
| PVAACFFNodeTrackPortInfo*& aTrackInfoPtr); |
| bool GetTrackInfo(int32 aTrackID, |
| PVAACFFNodeTrackPortInfo*& aTrackInfoPtr); |
| PVMFStatus GenerateAndSendEOSCommand(PVAACFFNodeTrackPortInfo* aTrackInfoPtr); |
| bool SendBeginOfMediaStreamCommand(PVAACFFNodeTrackPortInfo* aTrackPortInfo); |
| bool CheckForPortRescheduling(); |
| bool CheckForPortActivityQueues(); |
| //////////////////////////////////////////////////////////////////////////////////// |
| |
| |
| /* Command processing */ |
| void MoveCmdToCurrentQueue(PVMFAACFFParserNodeCommand& aCmd); |
| void MoveCmdToCancelQueue(PVMFAACFFParserNodeCommand& aCmd); |
| void CommandComplete(PVMFAACFFParserNodeCmdQ& aCmdQueue, |
| PVMFAACFFParserNodeCommand& aCmd, |
| PVMFStatus aStatus, |
| OsclAny* aData = NULL, |
| PVUuid* aEventUUID = NULL, |
| int32* aEventCode = NULL, |
| PVInterface* aExtMsg = NULL); |
| PVMFCommandId QueueCommandL(PVMFAACFFParserNodeCommand&); |
| void ProcessCommand(); |
| bool FlushPending(); |
| PVMFAACFFParserNodeCmdQ iInputCommands; |
| PVMFAACFFParserNodeCmdQ iCurrentCommand; |
| PVMFAACFFParserNodeCmdQ iCancelCommand; |
| |
| //Command handlers. |
| void DoReset(PVMFAACFFParserNodeCommand&); |
| void CompleteReset(); |
| |
| void DoQueryUuid(PVMFAACFFParserNodeCommand&); |
| void DoQueryInterface(PVMFAACFFParserNodeCommand&); |
| void DoRequestPort(PVMFAACFFParserNodeCommand&, PVMFPortInterface*&); |
| void DoReleasePort(PVMFAACFFParserNodeCommand&); |
| void DoInit(PVMFAACFFParserNodeCommand&); |
| void CompleteInit(); |
| |
| void DoPrepare(PVMFAACFFParserNodeCommand&); |
| void DoStart(PVMFAACFFParserNodeCommand&); |
| void DoStop(PVMFAACFFParserNodeCommand&); |
| void DoFlush(PVMFAACFFParserNodeCommand&); |
| void DoPause(PVMFAACFFParserNodeCommand&); |
| void DoCancelAllCommands(PVMFAACFFParserNodeCommand&); |
| void DoCancelCommand(PVMFAACFFParserNodeCommand&); |
| // For metadata extention interface |
| PVMFStatus DoGetMetadataKeys(PVMFAACFFParserNodeCommand& aCmd); |
| PVMFStatus DoGetMetadataValues(PVMFAACFFParserNodeCommand& aCmd); |
| |
| void CompleteGetMetaDataValues(); |
| int32 AddToValueList(Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList, PvmiKvp& aNewValue); |
| PVMFStatus CompleteGetMetadataKeys(PVMFAACFFParserNodeCommand& aCmd); |
| |
| // For data source position extension interface |
| PVMFStatus DoSetDataSourcePosition(PVMFAACFFParserNodeCommand& aCmd); |
| PVMFStatus DoQueryDataSourcePosition(PVMFAACFFParserNodeCommand& aCmd); |
| PVMFStatus DoSetDataSourceRate(PVMFAACFFParserNodeCommand& aCmd); |
| |
| // Event reporting |
| void ReportAACFFParserErrorEvent(PVMFEventType aEventType, OsclAny* aEventData = NULL, PVUuid* aEventUUID = NULL, int32* aEventCode = NULL); |
| void ReportAACFFParserInfoEvent(PVMFEventType aEventType, OsclAny* aEventData = NULL, PVUuid* aEventUUID = NULL, int32* aEventCode = NULL); |
| void SetState(TPVMFNodeInterfaceState); |
| |
| // Track data processing |
| bool RetrieveTrackConfigInfo(PVAACFFNodeTrackPortInfo& aTrackPortInfo); |
| bool RetrieveTrackData(PVAACFFNodeTrackPortInfo& aTrackPortInfo); |
| bool SendEndOfTrackCommand(PVAACFFNodeTrackPortInfo& aTrackPortInfo); |
| |
| void ResetAllTracks(); |
| bool ReleaseTrack(); |
| void CleanupFileSource(); |
| void ReleaseMetadataValue(PvmiKvp& aValueKVP); |
| |
| |
| private: // private data members |
| void ConstructL(); |
| |
| PVMFNodeCapability iCapability; |
| PVLogger* iLogger; |
| PVLogger* iDataPathLogger; |
| PVLogger* iClockLogger; |
| |
| |
| void ReleaseAllPorts(); |
| void RemoveAllCommands(); |
| |
| // ports contained in this node |
| PVMFAACFFParserOutPort* iOutPort; |
| friend class PVMFAACFFParserOutPort; |
| |
| PVMFCommandId iCurrentCmdId; |
| |
| //Source data |
| OSCL_wHeapString<OsclMemAllocator> iSourceURL; |
| PVMFFormatType iSourceFormat; |
| bool iUseCPMPluginRegistry; |
| OsclFileHandle* iFileHandle; |
| PVMFLocalDataSource iCPMSourceData; |
| |
| Oscl_Vector<PVAACFFNodeTrackPortInfo, OsclMemAllocator> iSelectedTrackList; |
| |
| Oscl_FileServer iFileServer; |
| CAACFileParser* iAACParser; |
| |
| PVAACFFNodeTrackPortInfo iTrack; |
| bool iFirstFrame; |
| |
| PVMFMediaClock* iClientClock; |
| void ResetSourceFile(); |
| bool oSourceIsCurrent; |
| |
| // Reference counter for extension |
| uint32 iExtensionRefCount; |
| |
| //for meta-data |
| PVMFMetadataList iAvailableMetadataKeys; |
| bool iID3DataValid; |
| TPVAacFileInfo iAACFileInfo; |
| bool iAACFileInfoValid; |
| |
| /* Meta data related */ |
| void PushToAvailableMetadataKeysList(const char* aKeystr, char* aOptionalParam = NULL); |
| PVMFStatus InitMetaData(); |
| Oscl_Vector<OSCL_HeapString<PVMFAACParserNodeAllocator>, PVMFAACParserNodeAllocator> iCPMMetadataKeys; |
| PVMFStatus GetIndexParamValues(char* aString, |
| uint32& aStartIndex, |
| uint32& aEndIndex); |
| PVMFStatus GetMaxSizeValue(char* aString, uint32& aMaxSize); |
| PVMFStatus GetTruncateFlagValue(char* aString, uint32& aTruncateFlag); |
| |
| |
| uint32 iAACParserNodeMetadataValueCount; |
| uint32 iGenreIndex; |
| uint32 iLyricsIndex; |
| |
| //bos flag |
| bool iSendBOS; |
| //stream id |
| uint32 iStreamID; |
| |
| //for CPM |
| |
| /* Content Policy Manager related */ |
| bool iPreviewMode; |
| PVMFCPM* iCPM; |
| PVMFSessionId iCPMSessionID; |
| PVMFCPMContentType iCPMContentType; |
| PVMFCPMPluginAccessInterfaceFactory* iCPMContentAccessFactory; |
| PVMFMetadataExtensionInterface* iCPMMetaDataExtensionInterface; |
| PVMFCPMPluginLicenseInterface* iCPMLicenseInterface; |
| PVInterface* iCPMLicenseInterfacePVI; |
| PvmiKvp iRequestedUsage; |
| PvmiKvp iApprovedUsage; |
| PvmiKvp iAuthorizationDataKvp; |
| PVMFCPMUsageID iUsageID; |
| PVMFCommandId iCPMInitCmdId; |
| PVMFCommandId iCPMOpenSessionCmdId; |
| PVMFCommandId iCPMRegisterContentCmdId; |
| PVMFCommandId iCPMRequestUsageId; |
| PVMFCommandId iCPMUsageCompleteCmdId; |
| PVMFCommandId iCPMCloseSessionCmdId; |
| PVMFCommandId iCPMResetCmdId; |
| PVMFCommandId iCPMGetMetaDataKeysCmdId; |
| PVMFCommandId iCPMGetMetaDataValuesCmdId; |
| PVMFCommandId iCPMGetLicenseInterfaceCmdId; |
| PVMFCommandId iCPMGetLicenseCmdId; |
| PVMFCommandId iCPMCancelGetLicenseCmdId; |
| |
| void InitCPM(); |
| void OpenCPMSession(); |
| void CPMRegisterContent(); |
| bool GetCPMContentAccessFactory(); |
| bool GetCPMMetaDataExtensionInterface(); |
| void GetCPMLicenseInterface(); |
| void RequestUsage(); |
| void SendUsageComplete(); |
| void CloseCPMSession(); |
| void ResetCPM(); |
| void PopulateDRMInfo(); |
| void GetCPMMetaDataKeys(); |
| void GetCPMMetaDataValues(); |
| PVMFStatus CheckCPMCommandCompleteStatus(PVMFCommandId, PVMFStatus); |
| int32 CreateNewArray(char*& aPtr, char *aKey); |
| int32 CreateNewArray(char*& aPtr, int32 aLen); |
| int32 CreateNewArray(oscl_wchar*& aPtr, int32 aLen); |
| int32 PushBackKeyVal(Oscl_Vector<PvmiKvp, OsclMemAllocator>*& aValueListPtr, PvmiKvp &aKeyVal); |
| PVMFStatus PushValueToList(Oscl_Vector<OSCL_HeapString<OsclMemAllocator>, OsclMemAllocator> &aRefMetadataKeys, |
| PVMFMetadataList *&aKeyListPtr, |
| uint32 aLcv); |
| PVMFStatus iCPMRequestUsageCommandStatus; |
| |
| PVMFStatus DoGetLicense(PVMFAACFFParserNodeCommand& aCmd, |
| bool aWideCharVersion = false); |
| void CompleteGetLicense(); |
| void DoCancelGetLicense(PVMFAACFFParserNodeCommand& aCmd); |
| |
| /* Progressive download related */ |
| PVMFStatus CheckForAACHeaderAvailability(); |
| void PauseAllMediaRetrieval(); |
| uint64 iAACHeaderSize; |
| bool iAutoPaused; |
| bool iDownloadComplete; |
| PVMFDownloadProgressInterface* iDownloadProgressInterface; |
| uint32 iDownloadFileSize; |
| PVMIDataStreamSyncInterface* iDataStreamInterface; |
| PVMFDataStreamFactory* iDataStreamFactory; |
| PVMFDataStreamReadCapacityObserver* iDataStreamReadCapacityObserver; |
| PvmiDataStreamSession iDataStreamSessionID; |
| PvmiDataStreamCommandId iRequestReadCapacityNotificationID; |
| uint32 iLastNPTCalcInConvertSizeToTime; |
| uint32 iFileSizeLastConvertedToTime; |
| |
| /* bitstream logging */ |
| void LogMediaData(PVMFSharedMediaDataPtr data, |
| PVMFPortInterface* aPort); |
| bool iPortDataLog; |
| char iLogFileIndex; |
| OSCL_HeapString<PVMFAACParserNodeAllocator> portLogPath; |
| |
| PVMFStatus ParseAACFile(); |
| }; |
| |
| #endif // PVMF_AACFFPARSER_NODE_H_INCLUDED |
| |
