PvmfMediaInputNodeOutPort::PvmfMediaInputNodeOutPort(PvmfMediaInputNode* aNode, const char* aName) : OsclTimerObject(OsclActiveObject::EPriorityNominal, "PvmfMediaInputNodeOutPort") , PvmfPortBaseImpl(PVMF_MEDIAIO_NODE_OUTPUT_PORT_TAG //this port handles its own port activity , this, aName) , iNode(aNode) , iState(PvmfMediaInputNodeOutPort::PORT_STATE_BUFFERING) , inum_text_sample(0) , imax_num_sample(0) { iNALType = 0; iCmdId = 0; iMioInfoErrorCmdId = 0; AddToScheduler(); iFormatType = PVMF_MIME_FORMAT_UNKNOWN; iPeer = NULL; iWriteState = EWriteOK; iMediaDataAllocMemPool = OSCL_NEW(OsclMemPoolFixedChunkAllocator, (PVMIO_MEDIADATA_POOLNUM)); iMediaDataMemPool = OSCL_NEW(OsclMemPoolFixedChunkAllocator, (PVMIO_MEDIADATA_POOLNUM)); iMediaDataAlloc = OSCL_NEW(PvmfMediaInputDataBufferAlloc, (iMediaDataAllocMemPool)); iDataPathLogger = PVLogger::GetLoggerObject("datapath.sourcenode"); #ifdef _TEST_AE_EROR_HANDLING iTimeStampJunk = 0x000FFFFF; #endif }
H223LowerLayer::H223LowerLayer(int32 aPortTag, TPVLoopbackMode aLoopbackMode) : PvmfPortBaseImpl(aPortTag, this), OsclTimerObject(OsclActiveObject::EPriorityHigh, "H223AO"), iTimerIntervalNum(0), iMinTimerResolution(TIMER_RES), iObserver(NULL), iMemFragmentAlloc(NULL), iDispatchPacketAlloc(NULL), iMediaDataImplMemAlloc(NULL), iMediaMsgPoolAlloc(NULL), iSendPduSz(0), iPduSize(H223_DEFAULT_PDU_SIZE), iStuffingSize(0), iTimer("H223LL"), iLoopbackMode(aLoopbackMode), iTimerCnt(0), iBytesSent(0), iMediaDataAlloc(&iMemAlloc), iLogger(NULL), iDemuxBuffer(NULL), iDemuxBufferPos(NULL), iIdleSyncCheckBuffer(NULL) { iLogger = PVLogger::GetLoggerObject("3g324m.h223.lowerlayer"); AddToScheduler(); InitParams(); ResetStats(); }
PVAuthorEngineNodeUtility::PVAuthorEngineNodeUtility() : OsclTimerObject(OsclActiveObject::EPriorityNominal, "PVAuthorEngineNodeUtility"), iObserver(NULL), iCmdQueue(PVAE_CMD_VECTOR_RESERVE) { iLogger = PVLogger::GetLoggerObject("PVAuthorEngineNodeUtility"); AddToScheduler(); }
PvmfJBJitterBufferDurationTimer::PvmfJBJitterBufferDurationTimer(PvmfJBJitterBufferDurationTimerObserver* aObserver) : OsclTimerObject(OsclActiveObject::EPriorityNominal, "PvmfJBJitterBufferDurationTimer"), iJitterBufferDurationInMS(0), iObserver(aObserver), iStarted(false) { iLogger = PVLogger::GetLoggerObject("PvmfJBJitterBufferDurationTimer"); AddToScheduler(); }
PvmfFirewallPacketTimer::PvmfFirewallPacketTimer(PvmfFirewallPacketTimerObserver* aObserver) : OsclTimerObject(OsclActiveObject::EPriorityNominal, "PvmfFirewallPacketTimer"), iFirewallPacketRecvTimeOutInMS(0), iObserver(aObserver), iStarted(false) { iLogger = PVLogger::GetLoggerObject("PvmfFirewallPacketTimer"); AddToScheduler(); }
///////////////////////////////////////////////////////////////////////////// // Add AO to the scheduler ///////////////////////////////////////////////////////////////////////////// OSCL_EXPORT_REF void ThreadSafeCallbackAO::ThreadLogon() { if (!IsAdded()) { AddToScheduler(); } iLogger = PVLogger::GetLoggerObject(iLoggerString); }
PvmfJBInactivityTimer::PvmfJBInactivityTimer(PvmfJBInactivityTimerObserver* aObserver) : OsclTimerObject(OsclActiveObject::EPriorityNominal, "PvmfJBInactivityTimer"), iInactivityDurationInMS(DEFAULT_MAX_INACTIVITY_DURATION_IN_MS), iObserver(aObserver), iStarted(false) { iLogger = PVLogger::GetLoggerObject("PvmfJBInactivityTimer"); AddToScheduler(); }
void PVMFLoopbackIOPort::Construct(PVMFLoopbackNode*aNode) { iNode = aNode; iWaiting = false; iLogger = PVLogger::GetLoggerObject("PVMFLoopbackPort"); PvmiCapabilityAndConfigPortFormatImpl::Construct( PVMF_LOOPBACK_PORT_INPUT_FORMATS , PVMF_LOOPBACK_PORT_INPUT_FORMATS_VALTYPE); AddToScheduler(); }
// // pv_metadata_engine_test section // void pv_metadata_engine_test::StartTest() { AddToScheduler(); iState = STATE_CREATE; // Retrieve the logger object iLogger = PVLogger::GetLoggerObject("PVMetadataEngineTest"); iPerfLogger = PVLogger::GetLoggerObject("pvmetestdiagnostics"); RunIfNotReady(); }
PVMFAvcEncPort::PVMFAvcEncPort(int32 aTag, PVMFAvcEncNode* aNode, int32 aPriority, const char* aName) : PvmfPortBaseImpl(aTag, this, PVMF_AVCENC_PORT_CAPACITY, PVMF_AVCENC_PORT_RESERVE, PVMF_AVCENC_PORT_THRESHOLD, PVMF_AVCENC_PORT_CAPACITY, PVMF_AVCENC_PORT_RESERVE, PVMF_AVCENC_PORT_THRESHOLD, aName), OsclActiveObject(aPriority, "PVMFAvcEncPort"), iFormat(PVMF_FORMAT_UNKNOWN), iNode(aNode) { AddToScheduler(); iLogger = PVLogger::GetLoggerObject("PVMFAvcEncPort"); #if PVMF_PORT_BASE_IMPL_STATS oscl_memset((OsclAny*)&(PvmfPortBaseImpl::iStats), 0, sizeof(PvmfPortBaseImplStats)); #endif }
OSCL_EXPORT_REF ThreadSafeQueue::ThreadSafeQueue() : OsclActiveObject(OsclActiveObject::EPriorityNominal, "ThreadSafeQueue") { iObserver = NULL; iCounter = 1; if (OsclThread::GetId(iThreadId) != OsclProcStatus::SUCCESS_ERROR) OsclError::Leave(OsclErrSystemCallFailed); #if USE_SEM_WAIT iQueueReadySem.Create(); #endif iQueueMut.Create(); AddToScheduler(); PendForExec(); iQueueReadySem.Signal(); }
void OmxDecTestBase::StartTestApp() { if (!IsAdded()) { AddToScheduler(); } RunIfNotReady(); OsclExecScheduler* sched = OsclExecScheduler::Current(); if (sched) { sched->StartScheduler(); } }
PvmfJBSessionDurationTimer::PvmfJBSessionDurationTimer(PvmfJBSessionDurationTimerObserver* aObserver) : OsclTimerObject(OsclActiveObject::EPriorityNominal, "PvmfJBSessionDurationTimer"), iCurrentMonitoringIntervalInMS(0), iSessionDurationInMS(0), iElapsedSessionDurationInMS(0), iObserver(aObserver), iStarted(false), iTimerStartTimeInMS(0), iMonitoringIntervalElapsed(0), iEstimatedServerClock(NULL), iEstimatedServClockValAtLastCancel(0), iExpectedEstimatedServClockValAtSessionEnd(0) { iLogger = PVLogger::GetLoggerObject("PvmfJBSessionDurationTimer"); iClockLoggerSessionDuration = PVLogger::GetLoggerObject("clock.streaming_manager.sessionduration"); AddToScheduler(); iClock.SetClockTimebase(iClockTimeBase); }
PVMp4FFComposerPort::PVMp4FFComposerPort(int32 aTag, PVMp4FFComposerNode* aNode, int32 aPriority, const char* aName) : PvmfPortBaseImpl(aTag, this, PVMF_MP4FFCN_PORT_CAPACITY, PVMF_MP4FFCN_PORT_RESERVE, PVMF_MP4FFCN_PORT_THRESHOLD, PVMF_MP4FFCN_PORT_CAPACITY, PVMF_MP4FFCN_PORT_RESERVE, PVMF_MP4FFCN_PORT_THRESHOLD, aName), OsclActiveObject(aPriority, "PVMp4FFComposerPort"), iNode(aNode), iTrackId(0), iFormat(PVMF_MIME_FORMAT_UNKNOWN), iCodecType(0), iReferencePort(NULL), iLastTS(0), iEndOfDataReached(false) { AddToScheduler(); iLogger = PVLogger::GetLoggerObject("PVMp4FFComposerPort"); oscl_memset((OsclAny*)&iFormatSpecificConfig, 0, sizeof(PVMP4FFCNFormatSpecificConfig)); memfrag_pps = NULL; }
/* ///////////////////////////////////////////////////////////////////////// */ bool CPVM4VEncoder::Construct(int32 aThreadId) { oscl_memset((void *)&iEncoderControl, 0, sizeof(VideoEncControls)); iInitialized = false; iObserver = NULL; iNumOutputData = 0; iYUVIn = NULL; for (int i = 0; i < KCVEIMaxOutputBuffer; i++) { iOutputData[i] = NULL; } iState = EIdle; if (aThreadId >= 0) AddToScheduler(); return true; }
bool OsclDNSMethod::StartMethod(int32 aTimeoutMsec) { //make sure there's not already a request //in progress if (IsAdded() || iDNSRequestAO->IsAdded()) return false; AddToScheduler(); iDNSRequestAO->AddToScheduler(); //set the timeout if (aTimeoutMsec > 0) After(aTimeoutMsec*1000); iDNSRequestAO->iSocketError = 0; return true; }
PVMFRecognizerRegistryImpl::PVMFRecognizerRegistryImpl() : OsclTimerObject(OsclActiveObject::EPriorityNominal, "PVMFRecognizerRegistryImpl") { AddToScheduler(); iRefCount = 1; iNextSessionId = 0; iRecognizerSessionList.reserve(1); iNextCommandId = 0; iRecognizerPendingCmdList.reserve(2); iRecognizerCurrentCmd.reserve(1); iRecognizerCmdToCancel.reserve(1); iDataStreamFactory = NULL; iDataStream = NULL; oRecognizePending = false; iDataStreamCallBackStatus = PVMFSuccess; iLogger = PVLogger::GetLoggerObject("PVMFRecognizer"); }
OSCL_EXPORT_REF PVMIExternalDownloadSimulator::PVMIExternalDownloadSimulator(PVMIExternalDownloadSimulatorParams& aParams) : OsclTimerObject(OsclActiveObject::EPriorityNominal, "PVMIExternalDownloadSimulator") { if ((aParams.iSizeUpdateIntervalInMS == 0) || (aParams.iDownloadRateInKbps == 0) || (aParams.iFileSizeInBytes == 0)) { OSCL_ASSERT(false); OSCL_LEAVE(OsclErrArgument); } iExtensionRefCount = 0; iFileSizeInBytes = aParams.iFileSizeInBytes; iDownloadRateInKbps = aParams.iDownloadRateInKbps; iSizeUpdateIntervalInMS = aParams.iSizeUpdateIntervalInMS; iObserverVec.reserve(128); iDownloadedFileSizeInBytes = 0; iDownloadComplete = false; iLogger = PVLogger::GetLoggerObject("PVMIExternalDownloadSimulator"); iDownloadClock.SetClockTimebase(iDownloadClockTimebase); AddToScheduler(); }
bool OsclSocketMethod::StartMethod(int32 aTimeoutMsec) { //make sure there's not already a request //in progress if (iSocketRequestAO->IsBusy() || IsBusy()) return false; if (!iSocketRequestAO->IsAdded()) iSocketRequestAO->AddToScheduler(); //set the timeout if any. Timeout <= 0 indicates infinite wait. if (aTimeoutMsec > 0) { if (!IsAdded()) AddToScheduler(); After(aTimeoutMsec*MSEC_TO_MICROSEC); } iSocketRequestAO->iSocketError = 0; return true; }
OSCL_EXPORT_REF void PVMIExternalDownloadFileMonitor::MonitorFile ( const char* aFileName, uint32 aTimeOutms ) { if (iState == STATE_MONITORING) { //Already monitoring a file. OSCL_LEAVE(OsclErrGeneral); } iDownloadComplete = false; iBytesDownloaded = 0; iState = STATE_OPENING; iLastChange = OsclTickCount::TicksToMsec(OsclTickCount::TickCount()); iTimeOutms = aTimeOutms; iFileServer.Connect(); iFileName = aFileName; //Run immediately. AddToScheduler(); RunIfNotReady(); }
void pv_mediainput_async_test_delete::StartTest() { AddToScheduler(); iState = PVAE_CMD_CREATE; RunIfNotReady(); }
// Stream-in ctor CompositionOffsetAtom::CompositionOffsetAtom(MP4_FF_FILE *fp, uint32 mediaType, uint32 size, uint32 type, OSCL_wString& filename, uint32 parsingMode): FullAtom(fp, size, type), OsclTimerObject(OsclActiveObject::EPriorityNominal, "CompositionOffsetAtom") { _psampleCountVec = NULL; _psampleOffsetVec = NULL; MT_SampleCount = NULL; MT_EntryCount = NULL; iMarkerTableCreation = false; MT_Table_Size = 0; _currGetSampleCount = 0; _currGetIndex = -1; _currGetTimeOffset = 0; _currPeekSampleCount = 0; _currPeekIndex = -1; _currPeekTimeOffset = 0; MT_Counter = 1; addSampleCount = 0; prevSampleCount = 0; entrycountTraversed = 0; refSample = MT_SAMPLECOUNT_INCREMENT; MT_j = 1; _mediaType = mediaType; _parsed_entry_cnt = 0; _fileptr = NULL; _parsing_mode = 0; _parsing_mode = parsingMode; _stbl_buff_size = CTTS_MIN_SAMPLE_TABLE_SIZE; _next_buff_number = 0; _curr_buff_number = 0; _curr_entry_point = 0; _stbl_fptr_vec = NULL; iLogger = PVLogger::GetLoggerObject("mp4ffparser"); iStateVarLogger = PVLogger::GetLoggerObject("mp4ffparser_mediasamplestats"); iParsedDataLogger = PVLogger::GetLoggerObject("mp4ffparser_parseddata"); iMarkerTableCreation = false; /* Add this AO to the scheduler */ if (OsclExecScheduler::Current() != NULL) { if (!IsAdded()) { AddToScheduler(); } } if (_success) { if (!AtomUtils::read32(fp, _entryCount)) { _success = false; } PVMF_MP4FFPARSER_LOGPARSEDINFO((0, "CompositionOffsetAtom::CompositionOffsetAtom- _entryCount =%d", _entryCount)); uint32 dataSize = _size - (DEFAULT_FULL_ATOM_SIZE + 4); uint32 entrySize = (4 + 4); if ((_entryCount*entrySize) > dataSize) { _success = false; } if (_success) { if (_entryCount > 0) { if (parsingMode == 1) { // cache size is 4K so that optimization // should work if entry_count is greater than 4K if (_entryCount > _stbl_buff_size) { uint32 fptrBuffSize = (_entryCount / _stbl_buff_size) + 1; PV_MP4_FF_ARRAY_NEW(NULL, uint32, (fptrBuffSize), _stbl_fptr_vec); if (_stbl_fptr_vec == NULL) { _success = false; _mp4ErrorCode = MEMORY_ALLOCATION_FAILED; return; } PV_MP4_FF_ARRAY_NEW(NULL, uint32, (_stbl_buff_size), _psampleCountVec); if (_psampleCountVec == NULL) { _success = false; _mp4ErrorCode = MEMORY_ALLOCATION_FAILED; return; } PV_MP4_FF_ARRAY_NEW(NULL, uint32, (_stbl_buff_size), _psampleOffsetVec); if (_psampleOffsetVec == NULL) { PV_MP4_ARRAY_DELETE(NULL, _psampleOffsetVec); _psampleOffsetVec = NULL; _success = false; _mp4ErrorCode = MEMORY_ALLOCATION_FAILED; return; } for (uint32 idx = 0; idx < _stbl_buff_size; idx++) //initialization { _psampleCountVec[idx] = 0; _psampleOffsetVec[idx] = 0; } OsclAny* ptr = (MP4_FF_FILE *)(oscl_malloc(sizeof(MP4_FF_FILE))); if (ptr == NULL) { _success = false; _mp4ErrorCode = MEMORY_ALLOCATION_FAILED; return; } _fileptr = OSCL_PLACEMENT_NEW(ptr, MP4_FF_FILE()); _fileptr->_fileServSession = fp->_fileServSession; _fileptr->_pvfile.SetCPM(fp->_pvfile.GetCPM()); _fileptr->_pvfile.SetFileHandle(fp->_pvfile.iFileHandle); if (AtomUtils::OpenMP4File(filename, Oscl_File::MODE_READ | Oscl_File::MODE_BINARY, _fileptr) != 0) { _success = false; _mp4ErrorCode = FILE_OPEN_FAILED; } _fileptr->_fileSize = fp->_fileSize; int32 _head_offset = AtomUtils::getCurrentFilePosition(fp); AtomUtils::seekFromCurrPos(fp, dataSize); AtomUtils::seekFromStart(_fileptr, _head_offset); return; } else { _parsing_mode = 0; _stbl_buff_size = _entryCount; } } else { _stbl_buff_size = _entryCount; } PV_MP4_FF_ARRAY_NEW(NULL, uint32, (_entryCount), _psampleCountVec); if (_psampleCountVec == NULL) { _success = false; _mp4ErrorCode = MEMORY_ALLOCATION_FAILED; return; } PV_MP4_FF_ARRAY_NEW(NULL, uint32, (_entryCount), _psampleOffsetVec); if (_psampleOffsetVec == NULL) { PV_MP4_ARRAY_DELETE(NULL, _psampleOffsetVec); _psampleOffsetVec = NULL; _success = false; _mp4ErrorCode = MEMORY_ALLOCATION_FAILED; return; } for (uint32 idx = 0; idx < _entryCount; idx++) //initialization { _psampleCountVec[idx] = 0; _psampleOffsetVec[idx] = 0; } uint32 number = 0; uint32 offset = 0; for (_parsed_entry_cnt = 0; _parsed_entry_cnt < _entryCount; _parsed_entry_cnt++) { if (!AtomUtils::read32(fp, number)) { _success = false; break; } if (!AtomUtils::read32(fp, offset)) { _success = false; break; } _psampleCountVec[_parsed_entry_cnt] = (number); _psampleOffsetVec[_parsed_entry_cnt] = (offset); } } } if (!_success) { _mp4ErrorCode = READ_TIME_TO_SAMPLE_ATOM_FAILED; } } else { if (_mp4ErrorCode != ATOM_VERSION_NOT_SUPPORTED) _mp4ErrorCode = READ_TIME_TO_SAMPLE_ATOM_FAILED; } }
int32 OsclSocketServI::StartServImp() { #if(PV_SOCKET_SERVER_IS_THREAD) //setup the loopback socket and/or polling interval. iLoopbackSocket.iEnable = false; iSelectPollIntervalMsec = 0; //check the select timeout in the configuration. int32 selectTimeoutMsec = PV_SOCKET_SERVER_SELECT_TIMEOUT_MSEC; if (selectTimeoutMsec <= 0) { //non-polling option selected. //create the select cancel pipe. iLoopbackSocket.Init(this); //if loopback socket isn't available, we must poll. if (!iLoopbackSocket.iEnable) iSelectPollIntervalMsec = 10; } else { //polling option selected. iSelectPollIntervalMsec = selectTimeoutMsec; #if(PV_SOCKET_SERVER_SELECT_LOOPBACK_SOCKET) //create the loopback socket. iLoopbackSocket.Init(this); #endif } //Start the server thread. OsclThread thread; OsclProcStatus::eOsclProcError err = thread.Create((TOsclThreadFuncPtr)sockthreadmain, 1024, (TOsclThreadFuncArg)this); if (err != OsclErrNone) return OsclErrGeneral; thread.SetPriority(PV_SOCKET_SERVER_THREAD_PRIORITY); //wait til thread starts iStart.Wait(); return OsclErrNone; #else//PV_SOCKET_SERVER_IS_THREAD //Socket server AO startup. iLoopbackSocket.iEnable = false; ServerEntry(); if (!IsAdded()) { AddToScheduler(); } return OsclErrNone; #endif //PV_SOCKET_SERVER_IS_THREAD }