OSCL_EXPORT_REF PVMFStatus PVMp4FFComposerPort::Connect(PVMFPortInterface* aPort) { LOG_STACK_TRACE((0, "PVMp4FFComposerPort::Connect: aPort=0x%x", aPort)); if (!aPort) { LOG_ERR((0, "PVMp4FFComposerPort::Connect: Error - Connecting to invalid port")); return PVMFErrArgument; } if (iConnectedPort) { LOG_ERR((0, "PVMp4FFComposerPort::Connect: Error - Already connected")); return PVMFFailure; } OsclAny* temp = NULL; aPort->QueryInterface(PVMI_CAPABILITY_AND_CONFIG_PVUUID, temp); PvmiCapabilityAndConfig *config = OSCL_STATIC_CAST(PvmiCapabilityAndConfig*, temp); if (!config) { LOG_ERR((0, "PVMp4FFComposerPort::Connect: Error - Peer port does not support capability interface")); return PVMFFailure; } PVMFStatus status = PVMFSuccess; switch (iTag) { case PVMF_MP4FFCN_PORT_TYPE_SINK: status = NegotiateInputSettings(config); break; default: LOG_ERR((0, "PVMp4FFComposerPort::Connect: Error - Invalid port tag")); status = PVMFFailure; } if (status != PVMFSuccess) { LOG_ERR((0, "PVMp4FFComposerPort::Connect: Error - Settings negotiation failed. status=%d", status)); return status; } //Automatically connect the peer. if (aPort->PeerConnect(this) != PVMFSuccess) { LOG_ERR((0, "PVMp4FFComposerPort::Connect: Error - Peer Connect failed")); return PVMFFailure; } 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; }
OSCL_EXPORT_REF PVMFStatus PVMFAvcEncPort::getParametersSync(PvmiMIOSession session, PvmiKeyType identifier, PvmiKvp*& parameters, int& num_parameter_elements, PvmiCapabilityContext context) { LOG_STACK_TRACE((0, "PVMFAvcEncPort::getParametersSync")); OSCL_UNUSED_ARG(session); OSCL_UNUSED_ARG(context); parameters = NULL; num_parameter_elements = 0; PVMFStatus status = PVMFFailure; switch (iTag) { case PVMF_AVCENC_NODE_PORT_TYPE_INPUT: return GetInputParametersSync(identifier, parameters, num_parameter_elements); case PVMF_AVCENC_NODE_PORT_TYPE_OUTPUT: return GetOutputParametersSync(identifier, parameters, num_parameter_elements); default: LOG_ERR((0, "PVMFAvcEncPort::getParametersSync: Error - Invalid port tag")); break; } return status; }
PVMFStatus PVMFAvcEncPort::SetFormat(PVMFFormatType aFormat) { LOG_STACK_TRACE((0, "PVMFAvcEncPort::SetFormat: aFormat=%d", aFormat)); if (!IsFormatSupported(aFormat)) return PVMFFailure; iFormat = aFormat; return PVMFSuccess; }
PVMFStatus PVMFAvcEncPort::AllocateKvp(PvmiKvp*& aKvp, PvmiKeyType aKey, int32 aNumParams) { LOG_STACK_TRACE((0, "PVMFAvcEncPort::AllocateKvp")); uint8* buf = NULL; uint32 keyLen = oscl_strlen(aKey) + 1; int32 err = 0; OSCL_TRY(err, buf = (uint8*)iAlloc.allocate(aNumParams * (sizeof(PvmiKvp) + keyLen)); if (!buf) OSCL_LEAVE(OsclErrNoMemory); );
OSCL_EXPORT_REF PVMFStatus PVMp4FFComposerPort::getParametersSync(PvmiMIOSession session, PvmiKeyType identifier, PvmiKvp*& parameters, int& num_parameter_elements, PvmiCapabilityContext context) { LOG_STACK_TRACE((0, "PVMp4FFComposerPort::getParametersSync")); OSCL_UNUSED_ARG(session); OSCL_UNUSED_ARG(context); parameters = NULL; num_parameter_elements = 0; PVMFStatus status = PVMFFailure; //identifier is a key and is assumed to be null terminated if (oscl_strcmp(identifier, INPUT_FORMATS_CAP_QUERY) == 0) { num_parameter_elements = 9; status = AllocateKvp(parameters, (PvmiKeyType)INPUT_FORMATS_VALTYPE, num_parameter_elements); if (status != PVMFSuccess) { LOG_ERR((0, "PVMp4FFComposerPort::GetOutputParametersSync: Error - AllocateKvp failed. status=%d", status)); } else { parameters[0].value.pChar_value = (char*)PVMF_MIME_AMR_IETF; parameters[1].value.pChar_value = (char*)PVMF_MIME_MPEG4_AUDIO; parameters[2].value.pChar_value = (char*)PVMF_MIME_M4V; parameters[3].value.pChar_value = (char*)PVMF_MIME_H2631998; parameters[4].value.pChar_value = (char*)PVMF_MIME_H2632000; parameters[5].value.pChar_value = (char*)PVMF_MIME_H264_VIDEO_MP4; parameters[6].value.pChar_value = (char*)PVMF_MIME_3GPP_TIMEDTEXT; parameters[7].value.pChar_value = (char*)PVMF_MIME_AMRWB_IETF; parameters[8].value.pChar_value = (char*)PVMF_MIME_QCELP; } } else if (oscl_strcmp(identifier, INPUT_FORMATS_CUR_QUERY) == 0) { num_parameter_elements = 1; status = AllocateKvp(parameters, (PvmiKeyType)INPUT_FORMATS_VALTYPE, num_parameter_elements); if (status != PVMFSuccess) { LOG_ERR((0, "PVMp4FFComposerPort::GetOutputParametersSync: Error - AllocateKvp failed. status=%d", status)); } else { parameters[0].value.pChar_value = (char*)iFormat.getMIMEStrPtr(); } } return status; }
PVMFStatus PVAuthorEngineNodeUtility::Init(const PVAENodeContainer* aNode, OsclAny* aContext) { LOG_STACK_TRACE((0, "PVAuthorEngineNodeUtility::Init: aNode=0x%x, aContext=0x%x", aNode, aContext)); PVAENodeUtilCmd cmd; PVMFStatus status = cmd.ConstructInit((PVAENodeContainer*)aNode, aContext); if (status != PVMFSuccess) { LOG_ERR((0, "PVAuthorEngineNodeUtility::Init: Error - cmd.Construct failed. status=%d", status)); return status; } return AddCmdToQueue(cmd); }
PVMFStatus PVAuthorEngineNodeUtility::Connect(PVAENodeContainer* aMasterNode, int32 aTag1, PVAENodeContainer* aSlaveNode, int32 aTag2, const PvmfMimeString& aMimeString, OsclAny* aContext) { LOG_STACK_TRACE((0, "PVAuthorEngineNodeUtility::Connect: &aMasterNode=0x%x, aTag1=%d, &aSlaveNode=0x%x, aTag2=%d", &aMasterNode, aTag1, &aSlaveNode, aTag2)); PVAENodeUtilCmd cmd; PVMFStatus status = cmd.ConstructConnect(aMasterNode, aTag1, aSlaveNode, aTag2, aMimeString, aContext); if (status != PVMFSuccess) { LOG_ERR((0, "PVAuthorEngineNodeUtility::Connect: Error - cmd.ConstructConnect failed. status=%d", status)); return status; } return AddCmdToQueue(cmd); }
PVMFStatus PVAuthorEngineNodeUtility::QueryInterface(PVAENodeContainer* aNodeContainer, const PVUuid& aUuid, PVInterface*& aInterfacePtr, OsclAny* aContext) { LOG_STACK_TRACE((0, "PVAuthorEngineNodeUtility::QueryInterface: &aNodeContainer=0x%x, &aUuid=0x%x, aContext=0x%x", &aNodeContainer, &aUuid, aContext)); PVAENodeUtilCmd cmd; PVMFStatus status = cmd.ConstructQueryInterface(aNodeContainer, aUuid, aInterfacePtr, aContext); if (status != PVMFSuccess) { LOG_ERR((0, "PVAuthorEngineNodeUtility::QueryInterface: Error - cmd.ConstructQueryInterface failed. status=%d", status)); return status; } return AddCmdToQueue(cmd); }
PVMFStatus PVAuthorEngineNodeUtility::QueryUUID(PVAENodeContainer* aNodeContainer, const PvmfMimeString& aMimeType, Oscl_Vector<PVUuid, OsclMemAllocator>& aUuids, bool aExactUuidsOnly, OsclAny* aContext) { LOG_STACK_TRACE((0, "PVAuthorEngineNodeUtility::QueryUUID: &aNodeContainer=0x%x, aMimeType=%s, &aUuids=0x%x, aExactUuidsOnly=%d, aContext=0x%x", &aNodeContainer, aMimeType.get_cstr(), &aUuids, aExactUuidsOnly, aContext)); PVAENodeUtilCmd cmd; PVMFStatus status = cmd.ConstructQueryUUID(aNodeContainer, aMimeType, aUuids, aExactUuidsOnly, aContext); if (status != PVMFSuccess) { LOG_ERR((0, "PVAuthorEngineNodeUtility::QueryUUID: Error - cmd.ConstructQueryUUID failed. status=%d", status)); return status; } return AddCmdToQueue(cmd); }
//////////////////////////////////////////////////////////////////////////// // Pure virtuals from OsclActiveObject //////////////////////////////////////////////////////////////////////////// void PVMFAvcEncPort::Run() { LOG_STACK_TRACE((0, "PVMFAvcEncPort::Run")); PVMFStatus status = PVMFSuccess; // Process incoming messages if (iTag == PVMF_AVCENC_NODE_PORT_TYPE_INPUT) { if (IncomingMsgQueueSize() > 0) { //dispatch the incoming data. if (iNode->IsProcessIncomingMsgReady()) { status = iNode->ProcessIncomingMsg(this); if (status != PVMFSuccess) { LOG_ERR((0, "PVMFAvcEncPort::Run: Error - ProcessIncomingMsg failed. status=%d", status)); } } } if (iNode->IsFlushPending()) { if (IncomingMsgQueueSize() == 0 && OutgoingMsgQueueSize() == 0) { iNode->FlushComplete(); } else { RunIfNotReady(); } } } //Process outgoing messages if (iTag == PVMF_AVCENC_NODE_PORT_TYPE_OUTPUT) { if (OutgoingMsgQueueSize() > 0) { if (iNode->IsProcessOutgoingMsgReady()) { //Send data to connected port status = Send(); switch (status) { case PVMFSuccess: // Reschedule if there's more data to process and connected port did not become busy // after receiving the last msg if (OutgoingMsgQueueSize() > 0 && iNode->IsProcessOutgoingMsgReady()) { RunIfNotReady(); } break; case PVMFErrBusy: // Connected port busy. Don't schedule next data break; default: LOG_ERR((0, "PVMFAvcEncPort::Run: Error - Send() failed. status=%d", status)); iNode->ReportErrorEvent(PVMF_AVCENC_NODE_ERROR_ENCODE_ERROR, (OsclAny*)this); break; } if (iNode->IsFlushPending()) { if (IncomingMsgQueueSize() == 0 && OutgoingMsgQueueSize() == 0) iNode->FlushComplete(); } } } if (iNode->IsFlushPending()) { if (IncomingMsgQueueSize() == 0 && OutgoingMsgQueueSize() == 0) iNode->FlushComplete(); } } }
//////////////////////////////////////////////////////////////////////////// // Pure virtuals from PVMFPortActivityHandler //////////////////////////////////////////////////////////////////////////// void PVMFAvcEncPort::HandlePortActivity(const PVMFPortActivity& aActivity) { LOG_STACK_TRACE((0, "PVMFAvcEncPort::HandlePortActivity: type=%d", aActivity.iType)); if (aActivity.iPort != this) { LOG_ERR((0, "PVMFAvcEncPort::HandlePortActivity: Error - Activity is not on this port")); return; } switch (aActivity.iType) { case PVMF_PORT_ACTIVITY_CREATED: //Report port created info event to the node. iNode->ReportInfoEvent(PVMFInfoPortCreated, (OsclAny*)aActivity.iPort); break; case PVMF_PORT_ACTIVITY_DELETED: //Report port deleted info event to the node. iNode->ReportInfoEvent(PVMFInfoPortDeleted, (OsclAny*)aActivity.iPort); break; case PVMF_PORT_ACTIVITY_OUTGOING_MSG: // Wakeup the AO on the first message only. After that it re-schedules itself as needed. if (OutgoingMsgQueueSize() == 1 && !IsConnectedPortBusy()) { RunIfNotReady(); } break; case PVMF_PORT_ACTIVITY_INCOMING_MSG: //Wakeup the AO on the first message only. After that it re-schedules itself as needed. if (IncomingMsgQueueSize() == 1 && iNode->IsProcessIncomingMsgReady()) { RunIfNotReady(); } break; case PVMF_PORT_ACTIVITY_OUTGOING_QUEUE_BUSY: // This is handled in the input port side when IsProcessIncomingMsgReady call failed break; case PVMF_PORT_ACTIVITY_OUTGOING_QUEUE_READY: // Notifies the node that the output queue is ready, and the node would // resume encoding incoming data iNode->HandlePortActivity(aActivity); break; case PVMF_PORT_ACTIVITY_CONNECTED_PORT_READY: if (OutgoingMsgQueueSize() > 0) RunIfNotReady(); break; case PVMF_PORT_ACTIVITY_CONNECTED_PORT_BUSY: // This is handled when iNode->ProcessOutgoingMsg failed with busy break; case PVMF_PORT_ACTIVITY_CONNECT: case PVMF_PORT_ACTIVITY_DISCONNECT: default: break; } }
PVMFStatus PVAuthorEngineNodeUtility::AddCmdToQueue(PVAENodeUtilCmd& aCmd) { LOG_STACK_TRACE((0, "PVAuthorEngineNodeUtility::AddCmdToQueue")); int32 err = 0; OSCL_TRY(err, iCmdQueue.push_back(aCmd););
void PVAuthorEngineNodeUtility::Run() { LOG_STACK_TRACE((0, "PVAuthorEngineNodeUtility::Run: Enter")); if (iCmdQueue.empty()) return; PVAENodeUtilCmd cmd = iCmdQueue[0]; if (cmd.iNodes.empty()) { LOG_ERR((0, "PVAuthorEngineNodeUtility::Run: Error - cmd.iNodes is empty")); CompleteUtilityCmd(cmd, PVMFFailure); return; } PVMFStatus status = PVMFFailure; LOG_STACK_TRACE((0, "PVAuthorEngineNodeUtility::Run: cmd.iType=%d", cmd.iType)); switch (cmd.iType) { case PVAENU_CMD_CONNECT: status = DoConnect(cmd); break; case PVAENU_CMD_DISCONNECT: status = DoDisconnect(cmd); break; case PVAENU_CMD_QUERY_UUID: status = DoQueryUuid(cmd); break; case PVAENU_CMD_QUERY_INTERFACE: status = DoQueryInterface(cmd); break; case PVAENU_CMD_INIT: status = DoInit(cmd); break; case PVAENU_CMD_PREPARE: status = DoPrepare(cmd); break; case PVAENU_CMD_START: status = DoStart(cmd); break; case PVAENU_CMD_PAUSE: status = DoPause(cmd); break; case PVAENU_CMD_STOP: status = DoStop(cmd); break; case PVAENU_CMD_FLUSH: status = DoFlush(cmd); break; case PVAENU_CMD_RESET: status = DoReset(cmd); break; default: status = PVMFFailure; break; } if (status != PVMFPending) CompleteUtilityCmd(cmd, status); LOG_STACK_TRACE((0, "PVAuthorEngineNodeUtility::Run: Exit")); }