OSCL_EXPORT_REF PVMFStatus PvmfPortBaseImpl::PeerDisconnect() { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "0x%x PvmfPortBaseImpl::PeerDisconnect", this)); if (!iConnectedPort) { PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, (0, "0x%x PvmfPortBaseImpl::PeerDisconnect: Error - Port not connected", this)); return PVMFFailure; } //reset busy flags - this would prevent any queue / port ready //events from being generated as we clear the message queues iIncomingQueue.iBusy = false; iOutgoingQueue.iBusy = false; ClearMsgQueues(); iConnectedPort = NULL; #if PVMF_PORT_BASE_IMPL_STATS PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "0x%x PvmfPortBaseImpl::PeerDisconnect: Stats: OutMsgQd=%d, OutMsgSent=%d, OutBusy=%d, ConnectedPortBusy=%d", this, iStats.iOutgoingMsgQueued, iStats.iOutgoingMsgSent, iStats.iOutgoingQueueBusy, iStats.iConnectedPortBusy)); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "0x%x PvmfPortBaseImpl::PeerDisconnect: Stats: InMsgRecv=%d, InMsgConsumed=%d, InBusy=%d", this, iStats.iIncomingMsgRecv, iStats.iIncomingMsgConsumed, iStats.iIncomingQueueBusy)); #endif PortActivity(PVMF_PORT_ACTIVITY_DISCONNECT); return PVMFSuccess; }
OMX_BOOL OmxDecTestBase::VerifyAllBuffersReturned() { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestBase::VerifyAllBuffersReturned() - IN")); OMX_U32 ii; OMX_BOOL AllBuffersReturned = OMX_TRUE; //check here to verify whether all the ip/op buffers are returned back by the component or not for (ii = 0; ii < iInBufferCount; ii++) { if (OMX_FALSE == ipInputAvail[ii]) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestBase::VerifyAllBuffersReturned() - Not all the input buffers returned by component yet, rescheduling")); AllBuffersReturned = OMX_FALSE; break; } } for (ii = 0; ii < iOutBufferCount; ii++) { if (OMX_FALSE == ipOutReleased[ii]) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestBase::VerifyAllBuffersReturned() - Not all the input buffers returned by component yet, rescheduling")); AllBuffersReturned = OMX_FALSE; break; } } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestBase::VerifyAllBuffersReturned() - OUT")); return AllBuffersReturned; }
uint32 TSC_324m::MiscIndicationRecv(PS_ControlMsgHeader pReceiveInf) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "TSC_324m::MiscIndicationRecv")); PS_MiscellaneousIndication indication = (PS_MiscellaneousIndication)pReceiveInf->pParameter; PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "TSC_324m::MiscIndicationRecv lcn(%d),index(%d)", indication->logicalChannelNumber, indication->miType.index)); switch (indication->miType.index) { case 9: PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "TSC_324m::MiscIndicationRecv videoSpatialTemporalTradeoff(%d)", indication->miType.videoTemporalSpatialTradeOff)); if (iTSC_324mObserver) { iTSC_324mObserver->VideoSpatialTemporalTradeoffIndicationReceived(indication->logicalChannelNumber, indication->miType.videoTemporalSpatialTradeOff); } break; default: PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "TSC_324m::MiscIndicationRecv Indication not handled")); break; } return iTerminalStatus; }
OSCL_EXPORT_REF PVMFStatus PvmfPortBaseImpl::PeerConnect(PVMFPortInterface* aPort) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "0x%x PvmfPortBaseImpl::PeerConnect: aPort=0x%x", this, aPort)); if (!aPort) { PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, (0, "0x%x PvmfPortBaseImpl::PeerConnect: Error - Connecting to invalid port", this)); return PVMFErrArgument; } if (iConnectedPort) { PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, (0, "0x%x PvmfPortBaseImpl::PeerConnect: Error - Already connected", this)); return PVMFFailure; } iConnectedPort = aPort; #if PVMF_PORT_BASE_IMPL_STATS // Reset statistics oscl_memset(&iStats, 0, sizeof(PvmfPortBaseImplStats)); #endif PortActivity(PVMF_PORT_ACTIVITY_CONNECT); return PVMFSuccess; }
OSCL_EXPORT_REF PVMFStatus PvmfPortBaseImpl::DequeueIncomingMsg(PVMFSharedMediaMsgPtr& aMsg) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "0x%x PvmfPortBaseImpl::DequeueIncomingMsg", this)); if (iIncomingQueue.iQ.empty()) { PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, (0, "0x%x PvmfPortBaseImpl::DequeueIncomingMsg: Error - Incoming queue is empty", this)); return PVMFFailure; } // Save message to output parameter and remove it from queue aMsg = iIncomingQueue.iQ.front(); iIncomingQueue.iQ.pop(); #if (PVLOGGER_INST_LEVEL > PVLOGMSG_INST_LLDBG) if (iDatapathLogger) LogMediaMsgInfo(aMsg, "In Msg De-Q'd", iIncomingQueue); #endif #if PVMF_PORT_BASE_IMPL_STATS ++iStats.iIncomingMsgConsumed; #endif // Notify the sender port if the queue was busy and the queue size has just dropped // below the threshold. Sender port can resume calling Receive. if (iIncomingQueue.iBusy) EvaluateIncomingBusy(); return PVMFSuccess; }
PVMFStatus PVMFSocketPort::getParametersSync(PvmiMIOSession aSession, PvmiKeyType aIdentifier, PvmiKvp*& aParameters, int& num_parameter_elements, PvmiCapabilityContext aContext) { OSCL_UNUSED_ARG(aSession); OSCL_UNUSED_ARG(aContext); PVLOGGER_LOGMSG(PVLOGMSG_INST_MLDBG, iLogger, PVLOGMSG_INFO, (0, "PVMFSocketPort::getParametersSync: aSession=0x%x, aIdentifier=%s, aParameters=0x%x, num_parameters_elements=%d, aContext=0x%x", aSession, aIdentifier, aParameters, num_parameter_elements, aContext)); if (pv_mime_strcmp(aIdentifier, PVMI_PORT_CONFIG_INPLACE_DATA_PROCESSING_KEY) != 0) { PVLOGGER_LOGMSG(PVLOGMSG_INST_MLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFSocketPort::getParametersSync: Error - Unsupported PvmiKeyType")); return PVMFErrNotSupported; } num_parameter_elements = 0; if (!pvmiGetPortInPlaceDataProcessingInfoSync(PVMI_PORT_CONFIG_INPLACE_DATA_PROCESSING_VALUE, aParameters)) { return PVMFFailure; } num_parameter_elements = 1; return PVMFSuccess; }
void CPV2WayRecDatapath::CheckPause() { uint32 i; int32 error; PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "CPV2WayDatapath::CheckPause state %d\n", iState)); for (i = 0; i < iNodeList.size(); i++) { if (!iNodeList[i].iCanNodePause) continue; PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "CPV2WayDatapath::CheckPause node %d state %d\n", i, iNodeList[i].iNode.node->GetState())); switch (iNodeList[i].iNode.node->GetState()) { case EPVMFNodeStarted: OSCL_TRY(error, i2Way->SendNodeCmdL(PV2WAY_NODE_CMD_PAUSE, iNodeList[i].iNode.node, iNodeList[i].iNode.session, this)); OSCL_FIRST_CATCH_ANY(error, PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "CPV2WayDatapath::CheckPause unable to pause node\n")); DatapathError(); return;); break; default: PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_NOTICE, (0, "CPV2WayDatapath::CheckPause transitional node state!\n")); break; } }
OsclReturnCode OmxDecTestBase::ProcessCallbackEventHandler(OsclAny* P) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestBase::ProcessCallbackEventHandler() - Processing the EventHandler Callback IN")); // re-cast the pointer EventHandlerSpecificData* ED = (EventHandlerSpecificData*) P; OMX_HANDLETYPE aComponent = ED->hComponent; OMX_PTR aAppData = ED->pAppData; OMX_EVENTTYPE aEvent = ED->eEvent; OMX_U32 aData1 = ED->nData1; OMX_U32 aData2 = ED->nData2; OMX_PTR aEventData = ED->pEventData; EventHandler(aComponent, aAppData, aEvent, aData1, aData2, aEventData); // release the allocated memory when no longer needed ED->hComponent = NULL; ED->nData1 = 0; ED->nData2 = 0; ED->pAppData = NULL; ED->pEventData = NULL; ipThreadSafeHandlerEventHandler->iMemoryPool->deallocate(ED); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestBase::ProcessCallbackEventHandler() - OUT")); return OsclSuccess; }
OsclReturnCode OmxDecTestBase::ProcessCallbackFillBufferDone(OsclAny* P) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestBase::ProcessCallbackFillBufferDone() - Processing the FillBufferDone Callback IN")); // re-cast the pointer FillBufferDoneSpecificData* ED = (FillBufferDoneSpecificData*) P; OMX_HANDLETYPE aComponent = ED->hComponent; OMX_PTR aAppData = ED->pAppData; OMX_BUFFERHEADERTYPE* aBuffer = ED->pBuffer; FillBufferDone(aComponent, aAppData, aBuffer); ED->hComponent = NULL; ED->pAppData = NULL; ED->pBuffer = NULL; ipThreadSafeHandlerFillBufferDone->iMemoryPool->deallocate(ED); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestBase::ProcessCallbackFillBufferDone() - OUT")); return OsclSuccess; }
/** * SetCachePosition * * Flush any updated data in current cache and reset * the cache location and current virtual position to the * input file position. * * On return, cache is empty. * * @param [in] aNewPos: file position. * * return 0 on success. * */ int32 OsclFileCache::SetCachePosition(TOsclFileOffset aNewPos) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OsclFileCache(0x%x)::SetCachePosition curpos %d newpos %d", this, _cacheFilePosition, aNewPos)); //flush any updated data currently in cache. if (_cacheUpdateEnd > _cacheUpdateStart) { int32 result = WriteCacheToFile(); if (result != 0) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OsclFileCache(0x%x)::SetCachePosition ERROR WriteCacheToFile failed", this)); return result;//error! } } //reset the virtual position and the cache location. _cacheFilePosition = aNewPos; _currentCachePos = 0; //cache is empty _endCachePos = 0; _cacheUpdateStart = _cacheUpdateEnd = 0; return 0;//success }
static void ShowSummaryStats(PVServiStats* aArray) { //lump this logging with Oscl scheduler perf logging. uint32 index = 0; PVLogger* logger = PVLogger::GetLoggerObject("OsclSchedulerPerfStats"); PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, logger, PVLOGMSG_INFO, (0, "Session Breakdown:")); while (index < EServiSession_Last) { aArray[index].ShowStats(logger, index, aArray[EServiSession_All]); index++; } PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, logger, PVLOGMSG_INFO, (0, "Run Breakdown:")); while (index < EServiRun_Last) { aArray[index].ShowStats(logger, index, aArray[EServiSession_All]); index++; } PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, logger, PVLOGMSG_INFO, (0, "ProcessRequests Breakdown:")); while (index < EServiProc_Last) { aArray[index].ShowStats(logger, index, aArray[EServiSession_All]); index++; } PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, logger, PVLOGMSG_INFO, (0, "ProcessRequests Loop Breakdown:")); while (index < EServiProcLoop_Last) { aArray[index].ShowStats(logger, index, aArray[EServiSession_All]); index++; } }
OSCL_EXPORT_REF PVMFStatus PvmfPortBaseImpl::Receive(PVMFSharedMediaMsgPtr aMsg) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "0x%x PvmfPortBaseImpl::Receive", this)); // Incoming queue is in flush state. Do not receive more messages. if (iInputSuspended) { PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, (0, "0x%x PvmfPortBaseImpl::Receive: Incoming queue is flushing", this)); return PVMFErrInvalidState; } // Incoming queue is in busy state. Do not receive more messages until the queue // is not busy, i.e. queue size drops below specified threshold. if (iIncomingQueue.iBusy) { PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_DEBUG, (0, "0x%x PvmfPortBaseImpl::Receive: Incoming queue is busy", this)); return PVMFErrBusy; } // Add message to queue and notify the node of the activity // There is no need to trap the push_back, since it cannot leave in this usage // Reason being that we do a reserve in the constructor and we do not let the // port queues grow indefinitely (we either a connected port busy or outgoing Q busy // before we reach the reserved limit iIncomingQueue.iQ.push(aMsg); PortActivity(PVMF_PORT_ACTIVITY_INCOMING_MSG); #if PVMF_PORT_BASE_IMPL_STATS ++iStats.iIncomingMsgRecv; #endif // Incoming queue size is at capacity and goes into busy state. if (iIncomingQueue.iThreshold != 0 && iIncomingQueue.iQ.size() >= iIncomingQueue.iCapacity) { iIncomingQueue.iBusy = true; #if (PVLOGGER_INST_LEVEL > PVLOGMSG_INST_LLDBG) //log transitions to Full state if (iDatapathLogger) { LOGDATAPATH( (0, "PORT %s Incoming Q Busy, Q-depth %d/%d", iPortName.get_cstr() , iIncomingQueue.iQ.size() , iIncomingQueue.iCapacity)); } #endif #if PVMF_PORT_BASE_IMPL_STATS ++iStats.iIncomingQueueBusy; #endif PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_DEBUG, (0, "0x%x PvmfPortBaseImpl::Receive: Incoming queue is full. Goes into busy state.", this)); } return PVMFSuccess; }
int32 OsclFileCache::Open(uint32 mode, uint32 size) //Called to open the cache for a newly opened file. //The NativeOpen was just called prior to this and was successful. { //should not be called with zero-size cache. OSCL_ASSERT(size > 0); //Save the mode _mode = mode; //open logger object only if logging is enabled on this //file if (iContainer.iLogger) iLogger = PVLogger::GetLoggerObject("OsclFileCache"); else iLogger = NULL; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OsclFileCache(0x%x)::Open mode %d size %d", this, mode, size)); // Create the movable cache. // Re-allocate it if the size has changed. if (_movableCache.pBuffer && size != _movableCache.capacity) { OSCL_FREE(_movableCache.pBuffer); _movableCache.pBuffer = NULL; } if (!_movableCache.pBuffer && size > 0) { _movableCache.pBuffer = (uint8*)OSCL_MALLOC(size); } if (!_movableCache.pBuffer) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OsclFileCache(0x%x)::Open ERROR no memory %d", this)); return (-1);//error } _movableCache.capacity = _movableCache.usableSize = size; _movableCache.filePosition = 0; _movableCache.updateStart = _movableCache.updateEnd = 0; _movableCache.currentPos = _movableCache.endPos = 0; //Position the cache at zero. SetCachePosition(0); //get initial file size & native position PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OsclFileCache(0x%x)::Open CallingNativeSize", this)); _fileSize = iContainer.CallNativeSize(); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OsclFileCache(0x%x)::Open CallingNativeTell", this)); _nativePosition = iContainer.CallNativeTell(); return 0; }
int32 OsclFileCache::UpdateFixedCaches() //Process any queued requests to remove or add fixed caches. { int32 error = 0; if (iContainer.iRemoveFixedCache.size()) { for (uint32 i = 0; i < iContainer.iRemoveFixedCache.size(); i++) { for (uint32 j = 0; j < _fixedCaches.size(); j++) { if (_fixedCaches[j].filePosition < iContainer.iRemoveFixedCache[i]) { //fixed cache list is sorted, so we can end search now. break; } else if (_fixedCaches[j].filePosition == iContainer.iRemoveFixedCache[i]) { //found it if (_fixedCaches[j].IsUpdated()) { int32 result = _fixedCaches[j].WriteUpdatesToFile(); if (result != 0) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OsclFileCache(0x%x)::UpdateFixedCaches ERROR in WriteUpdatesToFile", this)); error = result; } } if (_fixedCaches[j].pBuffer) { OSCL_FREE(_fixedCaches[j].pBuffer); _fixedCaches[j].pBuffer = NULL; } _fixedCaches.erase(&_fixedCaches[j]); break; } } } iContainer.iRemoveFixedCache.clear(); } if (iContainer.iAddFixedCache.size()) { for (uint32 i = 0; i < iContainer.iAddFixedCache.size(); i++) { if (!AddFixedCache(iContainer.iAddFixedCache[i])) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OsclFileCache(0x%x)::UpdateFixedCaches ERROR in AddFixedCache", this)); error = (-1); } } iContainer.iAddFixedCache.clear(); } return error; }
// same as base-class DeQueue method, except no RunIfNotReady/PendForExec is called (since all events are processed in a loop) // (i.e. PendForExec control is done in the loop in Run) OsclAny* OmxEventHandlerThreadSafeCallbackAO::DeQueue(OsclReturnCode &stat) { OsclAny *pData; OsclProcStatus::eOsclProcError sema_status; stat = OsclSuccess; // Protect the queue while accessing it: Mutex.Lock(); if (Q->NumElem == 0) { // nothing to de-queue stat = OsclFailure; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxEventHandlerThreadSafeCallbackAO::DeQueue() - No events in the queue - return ()")); Mutex.Unlock(); return NULL; } pData = (Q->pFirst[Q->index_out]).pData; Q->index_out++; // roll-over the index if (Q->index_out == Q->MaxNumElements) Q->index_out = 0; Q->NumElem--; // check if there is need to call waitforevent if ((Q->NumElem) == 0) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxEventHandlerThreadSafeCallbackAO::Run() - No more events, call PendForExec()")); PendForExec(); stat = OsclPending; // let the Run know that the last event was pulled out of the queue // so that it can get out of the loop } //release queue access Mutex.Unlock(); // Signal the semaphore that controls the remote thread. // The remote thread might be blocked and waiting for an event to be processed in case the event queue is full sema_status = RemoteThreadCtrlSema.Signal(); if (sema_status != OsclProcStatus::SUCCESS_ERROR) { stat = OsclFailure; return NULL; } return pData; }
unsigned H223LowerLayer::SetPduSize(unsigned pdu_size) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "SetPduSize - current(%d), new(%d)!\n", iPduSize, pdu_size)); if (pdu_size < iPduSize) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "SetPduSize - setting pdu size to (%d)", pdu_size)); iPduSize = pdu_size; } else { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "SetPduSize - not setting pdu size ")); } return iPduSize; }
OSCL_EXPORT_REF PVMFStatus PVMp4FFComposerPort::PeerConnect(PVMFPortInterface* aPort) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "0x%x PVMp4FFComposerPort::PeerConnect: aPort=0x%x", this, aPort)); if (!aPort) { PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, (0, "0x%x PVMp4FFComposerPort::PeerConnect: Error - Connecting to invalid port", this)); return PVMFErrArgument; } if (iConnectedPort) { PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, (0, "0x%x PVMp4FFComposerPort::PeerConnect: Error - Already connected", this)); return PVMFFailure; } // When connection is initiated by peer, this port still needs to query the peer // for input format configuration data OsclAny* temp = NULL; aPort->QueryInterface(PVMI_CAPABILITY_AND_CONFIG_PVUUID, temp); PvmiCapabilityAndConfig *config = OSCL_STATIC_CAST(PvmiCapabilityAndConfig*, temp); if (!config) { LOG_ERR((0, "PVMp4FFComposerPort::PeerConnect: Error - Peer port does not support capability interface")); return PVMFFailure; } PVMFStatus status = GetInputParametersFromPeer(config); if (status != PVMFSuccess) { LOG_ERR((0, "PVMp4FFComposerPort::PeerConnect: Error - GetVideoInputParametersFromPeer failed. status=%d", status)); return status; } iConnectedPort = aPort; #if PVMF_PORT_BASE_IMPL_STATS // Reset statistics oscl_memset((OsclAny*)&(PvmfPortBaseImpl::iStats), 0, sizeof(PvmfPortBaseImplStats)); #endif PortActivity(PVMF_PORT_ACTIVITY_CONNECT); return PVMFSuccess; }
PVMFStatus PVMFSocketPort::QueueOutgoingMsg(PVMFSharedMediaMsgPtr aMsg) //In this node, we skip the outgoing queue and go directly to the connected port's //incoming queue. { PVLOGGER_LOGMSG(PVLOGMSG_INST_MLDBG, iLogger, PVLOGMSG_INFO, (0, "PVMFSocketPort::QueueOutgoingMsg")); //If port is not connected, don't accept data on the //outgoing queue. if (!iConnectedPort) { PVLOGGER_LOGMSG(PVLOGMSG_INST_MLDBG, iLogger, PVLOGMSG_INFO, (0, "PVMFSocketPort::QueueOutgoingMsg: Error - Port not connected")); return PVMFFailure; } PvmfPortBaseImpl* cpPort = OSCL_STATIC_CAST(PvmfPortBaseImpl*, iConnectedPort); // Connected Port incoming Queue is in busy / flushing state. Do not accept more outgoing messages // until the queue is not busy, i.e. queue size drops below specified threshold or FlushComplete // is called. if (cpPort->iIncomingQueue.iBusy) { PVLOGGER_LOGMSG(PVLOGMSG_INST_MLDBG, iLogger, PVLOGMSG_INFO, (0, "PVMFSocketPort::QueueOutgoingMsg: Connected Port Incoming queue in busy / flushing state - Attempting to Q in output port's outgoing msg q")); return (PvmfPortBaseImpl::QueueOutgoingMsg(aMsg)); } // Add message to outgoing queue and notify the node of the activity // There is no need to trap the push_back, since it cannot leave in this usage // Reason being that we do a reserve in the constructor and we do not let the // port queues grow indefinitely (we either a connected port busy or outgoing Q busy // before we reach the reserved limit PVMFStatus status = cpPort->Receive(aMsg); if (status != PVMFSuccess) { return PVMFFailure; } // Outgoing queue size is at capacity and goes into busy state. The owner node is // notified of this transition into busy state. if (cpPort->isIncomingFull()) { PVLOGGER_LOGMSG(PVLOGMSG_INST_MLDBG, iLogger, PVLOGMSG_INFO, (0, "PVMFSocketPort::QueueOutgoingMsg: Connected Port incoming queue is full. Goes into busy state")); cpPort->iIncomingQueue.iBusy = true; PvmfPortBaseImpl::PortActivity(PVMF_PORT_ACTIVITY_CONNECTED_PORT_BUSY); } return PVMFSuccess; }
bool PVMFSocketPort::pvmiGetPortInPlaceDataProcessingInfoSync(const char* aFormatValType, PvmiKvp*& aKvp) { /* * Create PvmiKvp for capability settings */ aKvp = NULL; OsclMemAllocator alloc; uint32 strLen = oscl_strlen(aFormatValType) + 1; uint8* ptr = (uint8*)alloc.allocate(sizeof(PvmiKvp) + strLen); if (!ptr) { PVLOGGER_LOGMSG(PVLOGMSG_INST_MLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFSocketPort::pvmiGetPortInPlaceDataProcessingInfoSync: Error - No memory. Cannot allocate PvmiKvp")); return false; } aKvp = new(ptr) PvmiKvp; ptr += sizeof(PvmiKvp); aKvp->key = (PvmiKeyType)ptr; oscl_strncpy(aKvp->key, aFormatValType, strLen); aKvp->length = aKvp->capacity = strLen; #if SNODE_ENABLE_UDP_MULTI_PACKET if (iTag == PVMF_SOCKET_NODE_PORT_TYPE_SOURCE) aKvp->value.bool_value = false;//for the multiple UDP recv feature else #endif aKvp->value.bool_value = true; return true; }
void TSC_blc::BlcEtbRps(TPVChannelId incoming_lcn, TPVChannelId outgoing_lcn) { S_ControlMsgHeader infHeader; S_ReverseData parameter; PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "TSC_blc::BlcEtbRps incoming(%d), outgoing(%d)\n", incoming_lcn, outgoing_lcn)); // Buffer Allocate oscl_memset(¶meter, 0, sizeof(S_ReverseData)); // ESTABLISH.response primitive - Parameter(REVERSE_DATA) parameter.option_of_reverseLogicalChannelParameters = true; parameter.reverseLogicalChannelParameters.reverseLogicalChannelNumber = (uint16)incoming_lcn; // WWU_BLC: change 0->3 parameter.reverseLogicalChannelParameters.option_of_portNumber = false; parameter.reverseLogicalChannelParameters.option_of_ackMultiplexParameters = false; parameter.reverseLogicalChannelParameters.option_of_replacementFor = false; Tsc_SendDataSet(&infHeader, H245_PRIMITIVE, E_PtvId_Blc_Etb_Rps, incoming_lcn, outgoing_lcn, (uint8*)¶meter, sizeof(S_ReverseData)); // Primitive Send iH245->DispatchControlMessage(&infHeader); }
void pv_mediainput_async_test_delete::HandleErrorEvent(const PVAsyncErrorEvent& aEvent) { OSCL_UNUSED_ARG(aEvent); PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, (0, "pv_mediainput_async_test_delete::HandleErrorEvent")); iState = PVAE_CMD_RESET; RunIfNotReady(); }
uint32 TSC_324m::FlowControlIndicationReceived(PS_ControlMsgHeader pReceiveInf) { OSCL_UNUSED_ARG(pReceiveInf); PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "TSC_324m::FlowControlIndicationReceived")); return iTerminalStatus; }
void TSC_324m::IndicationMisc(TIndicationMisc type, TPVChannelId channelId, uint32 param, OsclAny* param1) { OSCL_UNUSED_ARG(param1); PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "TSC_324m::IndicationMisc type(%d), channelId(%d), param(%d), param1(%x)", type, channelId, param, param1)); S_ControlMsgHeader infHeader; S_MiscellaneousIndication miscellaneousIndication; oscl_memset(&miscellaneousIndication, 0, sizeof(S_MiscellaneousIndication)); switch (type) { case EVideoTemporalSpatialTradeOffIdc: miscellaneousIndication.logicalChannelNumber = (uint16)channelId; miscellaneousIndication.miType.index = 9; miscellaneousIndication.miType.videoTemporalSpatialTradeOff = (uint8)param; break; default: return; } Tsc_SendDataSet(&infHeader, H245_PRIMITIVE, E_PtvId_Idc_Mscl, 0, 0, (uint8*)&miscellaneousIndication, sizeof(S_MiscellaneousIndication)); iH245->DispatchControlMessage(&infHeader); }
void OsclFileStats::LogAll(PVLogger* aLogger, uint32 aLogLevel) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, aLogger, aLogLevel , (0, "OsclFileStats(0x%x): +++++++++++++++++++++ Begin", iContainer)); for (uint32 op = 0;op < EOsclFileOp_Last;op++) { if (iStats[op].iOpCount > 0) { Log((TOsclFileOp)op, aLogger, aLogLevel); } } //clear all stats once they've been dumped. oscl_memset(iStats, 0, sizeof(iStats)); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, aLogger, aLogLevel , (0, "OsclFileStats(0x%x): +++++++++++++++++++++ End", iContainer)); }
void pv_mediainput_async_test_errorhandling::HandleInformationalEvent(const PVAsyncInformationalEvent& aEvent) { OSCL_UNUSED_ARG(aEvent); PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_STACK_TRACE, (0, "pv_mediainput_async_test_errorhandling::HandleInformationalEvent")); }
TPVStatusCode H223LowerLayer::SetBitrate(uint32 bitRate) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "Mux[LL]: SetBitrate Request(%d)\n", bitRate)); iBitrate = bitRate; UpdatePduSize(); return EPVT_Success; }
OSCL_EXPORT_REF PVMFStatus PvmfPortBaseImpl::ClearMsgQueues() { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "0x%x PvmfPortBaseImpl::ClearMsgQueues", this)); while (!iIncomingQueue.iQ.empty()) { PVMFSharedMediaMsgPtr msg = iIncomingQueue.iQ.front(); iIncomingQueue.iQ.pop(); #if (PVLOGGER_INST_LEVEL > PVLOGMSG_INST_LLDBG) if (iDatapathLogger) LogMediaMsgInfo(msg, "In Msg Cleared", iIncomingQueue); #endif } if (iIncomingQueue.iBusy) EvaluateIncomingBusy(); while (!iOutgoingQueue.iQ.empty()) { PVMFSharedMediaMsgPtr msg = iOutgoingQueue.iQ.front(); iOutgoingQueue.iQ.pop(); #if (PVLOGGER_INST_LEVEL > PVLOGMSG_INST_LLDBG) if (iDatapathLogger) LogMediaMsgInfo(msg, "Out Msg Cleared", iOutgoingQueue); #endif } if (iOutgoingQueue.iBusy) EvaluateOutgoingBusy(); return PVMFSuccess; }
OSCL_EXPORT_REF bool PvmfPortBaseImpl::isIncomingFull() //derived class can override this to redefine "queue full" condition. { if (iIncomingQueue.iThreshold == 0) { //should never happen PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, (0, "0x%x PvmfPortBaseImpl::isIncomingFull: Zero Threshold", this)); OSCL_ASSERT(false); return true; } if (iIncomingQueue.iQ.size() == iIncomingQueue.iCapacity) { return true; } if (iIncomingQueue.iBusy == true) { //this implies that we were at capacity previously //wait for occupancy to fall below threshold before //treating the queue as "not-full" if (iIncomingQueue.iQ.size() >= iIncomingQueue.iThreshold) { return true; } } //this means that we are below capacity and are approaching //capacity, or that we have fallen below threshold. in either //case treat queue as "not-full" return false; }
void TSC_324m::Tsc_UII_Alphanumeric(const uint8* str, uint16 str_len) { S_ControlMsgHeader infHeader; PS_UserInputIndication pUserInputIndication; PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "TSC_324m:Tsc_UII_Alphanumeric - len(%d)", str_len)); // Allocate the UII structure pUserInputIndication = (PS_UserInputIndication)OSCL_DEFAULT_MALLOC(sizeof(S_UserInputIndication)); // Fill in the 'signal' pUserInputIndication->index = 1; /* alphanumeric */ pUserInputIndication->alphanumeric = (PS_int8STRING) OSCL_DEFAULT_MALLOC(sizeof(S_int8STRING)); pUserInputIndication->alphanumeric->size = str_len; pUserInputIndication->alphanumeric->data = (uint8*) OSCL_DEFAULT_MALLOC(str_len * sizeof(uint8)); oscl_memcpy(pUserInputIndication->alphanumeric->data, str, str_len); // Send the message Tsc_SendDataSet(&infHeader, H245_PRIMITIVE, E_PtvId_Idc_Ui, 0, 0, (uint8*)pUserInputIndication, sizeof(S_UserInputIndication)); iH245->DispatchControlMessage(&infHeader); Delete_UserInputIndication(pUserInputIndication); OSCL_DEFAULT_FREE(pUserInputIndication); return; }
/** * Seek * * @param [in] offset from origin * @param [in] origin: either SEEKSET, SEEKCUR, or SEEKEND * * @return 0 for success. */ int32 OsclFileCache::Seek(TOsclFileOffset offset, Oscl_File::seek_type origin) { //figure out the file position we're trying to seek to TOsclFileOffset pos; switch (origin) { case Oscl_File::SEEKCUR: pos = Tell() + offset; break; case Oscl_File::SEEKSET: pos = 0 + offset; break; case Oscl_File::SEEKEND: pos = FileSize() + offset; break; default: PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OsclFileCache(0x%x)::Seek ERROR invalid origin %d", this, origin)); return (-1);//error-- invalid origin! } //don't allow seeking outside valid file size if (pos < 0 || pos > FileSize()) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OsclFileCache(0x%x)::Seek ERROR invalid seek position %d", this, pos)); return -1;//error } if (_curCache->Contains(pos)) { //Seek in cur cache _curCache->currentPos = (uint32)(pos - _curCache->filePosition); } else { //Seek outside cache int32 retval = SetCachePosition(pos); if (retval != 0) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OsclFileCache(0x%x)::Seek ERROR SetPosition error %d", this, retval)); return retval;//error } } return 0; }