blob: 3d0ac8bf086e6a065ebf9c0c0d5491160ad73664 [file] [log] [blame]
/* ------------------------------------------------------------------
* 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.
* -------------------------------------------------------------------
*/
#include "oscl_base.h"
#include "oscl_mem.h"
#include "osclconfig_compiler_warnings.h"
#include "tscmain.h"
#include "h223types.h"
#include "h223_api.h"
#include "h223.h"
#include "cpvh223multiplex.h"
#include "layer.h"
#include "tsc_eventreceive.h"
#include "tsc_h324m_config.h"
#include "tsc_statemanager.h"
#include "tsc_lc.h"
#include "tsc_blc.h"
#include "tsc_clc.h"
#include "tsc_constants.h"
#include "tsc_mt.h"
#include "tsc_component.h"
#include "tsc_capability.h"
#include "tsc_channelcontrol.h"
#ifdef MEM_TRACK
#include "oscl_mem.h"
#include "oscl_mem_audit.h"
#endif
#define PV_2WAY_TSC_TIMER_ID "PV_2WAY_TSC_TIMER"
#define PV_2WAY_TSC_TIMER_INTERVAL 1 /* 1 second */
#define PV_2WAY_TSC_NUM_CMD_Q_ELEMENTS 10
#define PV_2WAY_TSC_NUM_PENDING_CMD_Q_ELEMENTS 10
#define TSC_MAX_CONTROL_CHANNEL_BITRATE_BPS 64000
#define TSC_BIG_UINT32 0XFFFFFFFF
#define TSC_H223_LEVEL_DEFAULT H223_LEVEL2
#define DEFAULT_TCS_RECEIVE_TIMEOUT_SECONDS 20
#define DEFAULT_TCS_LEVEL_SETUP_TIMEOUT_SECONDS 6
#define DEFAULT_RTD_TIMER_SECONDS 7
// Default command queue reserve size
#define PVMF_CMD_QUEUE_RESERVE 10
// Starting value for command IDs
#define PVMF_CMD_ID_START 10000
// the assumed minimum T401 timer interval for sizing memory pools
#define PV2WAY_TSC_MIN_T401_INCOMING 100
OSCL_EXPORT_REF TSC_324m::TSC_324m(TPVLoopbackMode aLoopbackMode)
: TSC(),
OsclActiveObject(OsclActiveObject::EPriorityHigh, "TSC"),
Msd(NULL),
Ce(NULL),
iSrp(NULL),
iH245(NULL),
iH223(NULL),
iVendor(NULL),
iProductNumber(NULL),
iVersionNumber(NULL),
iVendorR(NULL),
iProductNumberR(NULL),
iVersionNumberR(NULL),
iTransmitCaps(NULL),
iSuppInfo(NULL),
iSuppInfoLen(0),
iLoopbackMode(aLoopbackMode),
iTimer(NULL),
iOutgoingSrpPort(NULL),
iIncomingSrpPort(NULL),
iTscSrpBuffer(NULL),
iLogger(NULL),
iTSC_324mObserver(NULL),
iTSCcomponent(NULL),
iTSCblc(iTSCstatemanager),
iTSClc(iTSCstatemanager),
iTSCcapability(iTSCstatemanager),
iComponentRegistry(iTSCstatemanager,
iTSCcapability,
iTSClc,
iTSCblc,
iTSCclc,
iTSCmt)
{
iLogger = PVLogger::GetLoggerObject("3g324m.h245user");
iTSCcomponent = NULL;
AddToScheduler();
SetDispatchTable();
iDisconnectInitiator = EPVT_NONE;
iConnectFailReason = EPVT_Failed;
iOutgoingSrpPort = NULL;
iIncomingSrpPort = NULL;
iTscSrpBuffer = NULL;
iCurrentCmdId = 1;
iInitialized = false;
iInitializedComponent = false;
iEnableWnsrp = true;
iCmdQueue.Construct(PVMF_CMD_ID_START, PVMF_CMD_QUEUE_RESERVE);
iPendingCmdQueue.Construct(PVMF_CMD_ID_START, PVMF_CMD_QUEUE_RESERVE);
}
TSC_324m::~TSC_324m()
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::~TSC_324m"));
ResetTsc();
}
void TSC_324m::SetInitialValues()
{
initVarsLocal();
initVarsSession();
iInitialized = true;
}
void TSC_324m::initVarsLocal()
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::initVarsLocal"));
if (iTransmitCaps)
{
OSCL_DEFAULT_FREE(iTransmitCaps);
iTransmitCaps = NULL;
}
iSendRme = false;
iCsupSeq = 0;
iRequestMaxMuxPduSize = H223_MAX_DEMUX_PDU_SIZE;
iPendingCmdQueue.Construct(1, 5);
iOutgoingPduType = H223_PDU_COMBINED;
iEndSessionTimeout = DEFAULT_END_SESSION_TIMEOUT;
iTimerValues.iT101 = iTimerValues.iT103 = iTimerValues.iT104 =
iTimerValues.iT105 = iTimerValues.iT106 = iTimerValues.iT107 =
iTimerValues.iT108 = iTimerValues.iT109 = TSC_SE_TIMEOUT_DEFAULT;
iT401 = T401_DEFAULT; /* SRP */
iN100 = N100_DEFAULT; /* H245 */
iN401 = N401_DEFAULT; /* SRP */
iCeRetries = iN100; /* Num CE retries left */
iEnableWnsrp = true;
iMultiplexingDelayMs = 0;
iInLogicalChannelBufferingMs = 0;
iOutLogicalChannelBufferingMs = 0;
iTSCstatemanager.InitVarsLocal();
iTSCcapability.InitVarsLocal();
if (iTSCcomponent)
{
iTSCcomponent->InitVarsLocal();
}
}
void TSC_324m::initVarsSession()
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::initVarsSession"));
iTerminalStatus = Phase0_Idle; /* Terminal Status */
iDisconnectInitiator = EPVT_NONE;
iConnectFailReason = EPVT_Failed;
iMaxMuxPduCapabilityR = false;
/* Terminal ID for vendor identification */
/* Local terminal id */
if (iVendorR)
{
OSCL_DELETE(iVendorR);
}
if (iProductNumberR)
{
OSCL_DEFAULT_FREE(iProductNumberR);
}
if (iVersionNumberR)
{
OSCL_DEFAULT_FREE(iVersionNumberR);
}
iVendorR = NULL;
iProductNumberR = NULL;
iProductNumberLenR = 0;
iVersionNumberR = NULL;
iVersionNumberLenR = 0;
iH223Level = TSC_H223_LEVEL_DEFAULT;
iMuxTableUpdateRequired = false;
if (iSuppInfo)
{
OSCL_DEFAULT_FREE(iSuppInfo);
iSuppInfo = NULL;
iSuppInfoLen = 0;
}
iCeRetries = iN100; /* Num CE retries left */
/* Initialized RTD values */
iNumRtdRequests = 0;
iRtdMin = TSC_BIG_UINT32;
iRtdMax = 0;
iRtdAve = 0;
iTSCstatemanager.InitVarsSession();
iTSCmt.InitVarsSession();
iTSCcapability.InitVarsSession();
if (iTSCcomponent)
{
iTSCcomponent->InitVarsSession();
}
}
void TSC_324m::IgnoreH245Callbacks()
{
if (!iH245)
{
return;
}
iH245->SetObserver(NULL);
Msd->SetObserver(NULL);
Ce->SetObserver(NULL);
}
void TSC_324m::InitComponent()
{
#ifdef MEM_TRACK
printf("\nMemory Stats before TSC Component Init\n");
MemStats();
#endif
if (!iTSCcomponent)
{
PVInterface *componentInterface;
// QueryInterface sets iTSCcomponent
QueryInterface(0, PVUuidH324ComponentInterface, (PVInterface*&)componentInterface);
if (!iTSCcomponent)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::InitComponent- unable to create component"));
OSCL_LEAVE(PVMFFailure);
}
iTSCcomponent->InitVarsLocal();
iTSCcomponent->InitVarsSession();
}
if (iTSCcomponent &&
!iInitializedComponent &&
iH245 &&
iH223)
{
iTSCcomponent->SetMembers(iH245, iH223, iObserver);
iTSCcomponent->InitTsc();
iInitializedComponent = true;
}
#ifdef MEM_TRACK
printf("\nMemory Stats after TSC Component Init\n");
MemStats();
#endif
}
TPVStatusCode TSC_324m::InitTsc()
{
#ifdef MEM_TRACK
printf("\nMemory Stats before TSC Init\n");
MemStats();
#endif
int error;
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC: InitTsc"));
if (!iInitialized)
{
SetInitialValues();
}
// Allocate stack elements.
iH245 = OSCL_NEW(H245, ());
iH245->SetObserver(this);
iSrp = OSCL_NEW(SRP, ());
iSrp->SetObserver(this);
iH223 = OSCL_NEW(CPVH223Multiplex, (iLoopbackMode));
iH223->SetObserver(this);
iTSClc.SetH245(iH245);
iTSCblc.SetH245(iH245);
iTSCclc.SetH245(iH245);
InitComponent();
iTSCcapability.SetMembers(iTSCcomponent);
iTSCmt.SetMembers(iH245, iH223, iTSCcomponent);
iH223->SetClock(iClock);
iH223->Open();
// set direct connection to MSD SE
Msd = iH245->GetMSD();
Msd->SetObserver(this);
// set direct connection to CE SE
Ce = iH245->GetCE();
Ce->SetObserver(this);
OSCL_TRY(error, iTscSrpBuffer = TscSrpBuffer::NewL());
if (error)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR,
(0, "TSC: InitTsc, tscsrpbuffer allocation failed", error));
}
iTimer = OSCL_NEW(OsclTimer<OsclMemAllocator>,
(PV_2WAY_TSC_TIMER_ID, PV_2WAY_TSC_TIMER_INTERVAL));
//OSCL_TRAP_NEW(iTimer, OsclTimer<OsclMemAllocator>, (PV_2WAY_TSC_TIMER_ID, PV_2WAY_TSC_TIMER_INTERVAL) );
iTimer->SetObserver(this);
#ifdef MEM_TRACK
printf("\nMemory Stats after TSC Init\n");
MemStats();
#endif
return EPVT_Success;
}
TPVStatusCode TSC_324m::ResetTsc()
{
TPVStatusCode ret = EPVT_Success;
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC: Reset request."));
if (iTSCcomponent)
{
iTSCcomponent->ResetTsc();
iTSCstatemanager.WriteState(TSC_CE_RECEIVE, NOT_STARTED);
iTSCstatemanager.WriteState(TSC_CE_SEND, NOT_STARTED);
iInitializedComponent = false; // TSC Component
}
if (iSrp)
{
if (iSrp->RequestULPort(SRP_INPUT_PORT_TAG))
iSrp->RequestULPort(SRP_INPUT_PORT_TAG)->Disconnect();
if (iSrp->RequestULPort(SRP_OUTPUT_PORT_TAG))
iSrp->RequestULPort(SRP_OUTPUT_PORT_TAG)->Disconnect();
iSrp->SrpStop();
}
if (iTscSrpBuffer)
{
iTscSrpBuffer->GetLLPort(TSCSRPBUFFER_INPUT_PORT_TAG)->Disconnect();
iTscSrpBuffer->GetLLPort(TSCSRPBUFFER_OUTPUT_PORT_TAG)->Disconnect();
}
if (iH245)
{
iH245->UnBind();
}
if (iIncomingSrpPort)
{
iIncomingSrpPort->Disconnect();
iIncomingSrpPort = NULL;
}
if (iOutgoingSrpPort)
{
iOutgoingSrpPort->Disconnect();
iOutgoingSrpPort = NULL;
}
if (iH223)
{
H223IncomingChannelPtr incoming_control_channel;
PVMFStatus aStatus = iH223->GetIncomingChannel((TPVChannelId)0,
incoming_control_channel);
if (aStatus == PVMFSuccess)
{
incoming_control_channel->Disconnect();
}
else
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::ResetTsc Error - Failed to lookup incoming logical channel %d", 0));
}
H223OutgoingChannelPtr outgoing_control_channel;
aStatus = iH223->GetOutgoingChannel((TPVChannelId)0, outgoing_control_channel);
if (aStatus == PVMFSuccess)
{
outgoing_control_channel->Disconnect();
}
else
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::ResetTsc Error - Failed to lookup outgoing logical channel %d", 0));
}
}
//Shutdown stack elements.
if (iTransmitCaps)
{
OSCL_DEFAULT_FREE(iTransmitCaps);
iTransmitCaps = NULL;
}
if (iVendor)
{
delete iVendor;
iVendor = NULL;
}
if (iVendorR)
{
delete iVendorR;
iVendorR = NULL;
}
if (iProductNumber)
{
OSCL_DEFAULT_FREE(iProductNumber);
iProductNumber = NULL;
}
if (iProductNumberR)
{
OSCL_DEFAULT_FREE(iProductNumberR);
iProductNumberR = NULL;
}
if (iVersionNumber)
{
OSCL_DEFAULT_FREE(iVersionNumber);
iVersionNumber = NULL;
}
if (iVersionNumberR)
{
OSCL_DEFAULT_FREE(iVersionNumberR);
iVersionNumberR = NULL;
}
if (iTimer)
{
iTimer->Clear();
OSCL_DELETE(iTimer);
iTimer = NULL;
}
if (iTSCcomponent)
{
OSCL_DELETE(iTSCcomponent);
iTSCcomponent = NULL;
}
if (iH223)
{
iH223->Close();
DeallocateH223Mux(iH223);
iH223 = NULL;
}
if (iTscSrpBuffer)
{
OSCL_DELETE(iTscSrpBuffer);
iTscSrpBuffer = NULL;
}
if (iSrp)
{
iSrp->SrpReset();
OSCL_DELETE(iSrp);
iSrp = NULL;
}
if (iH245)
{
OSCL_DELETE(iH245);
iH245 = NULL;
}
iInitialized = false; //TSC node
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC: Reset request - done"));
#ifdef MEM_TRACK
printf("\nMemory Stats after TSC Reset\n");
MemStats();
#endif
return ret;
}
TPVStatusCode TSC_324m::SetOutgoingBitrate(int32 bitrate)
{
iH223->SetBitrate(bitrate);
return EPVT_Success;
}
TPVStatusCode TSC_324m::SetTimerRes(uint32 timer_res)
{
return iH223->SetTimerRes(timer_res);
}
TPVStatusCode TSC_324m::SetTerminalParam(CPVTerminalParam* params)
{
CPVH324MParam* h324params = (CPVH324MParam*)params;
iSendRme = h324params->iSendRme;
iRequestMaxMuxPduSize = h324params->iRequestMaxMuxPduSize;
iTSCcomponent->SetTerminalParam(*h324params);
iTSCstatemanager.SetTerminalParam(params);
return EPVT_Success;
}
CPVTerminalParam* TSC_324m::GetTerminalParam()
{
CPVH223MuxParam h223Param;
CPVH324MParam* h324param = new CPVH324MParam();
iTSCcomponent->GetTerminalParam(*h324param);
h324param->iMasterSlave = (TPVMasterSlave)iTSCstatemanager.ReadState(TSC_MSD_DECISION);
h324param->SetH223Param(&h223Param);
return h324param;
}
TPVStatusCode
TSC_324m::Connect(uint16 info_len, uint8* info_buf)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_NOTICE,
(0, "TSC_324m::Connect"));
TPVStatusCode ret = EPVT_Pending;
iMuxTableUpdateRequired = false;
iStopCmd = NULL;
iTerminalStatus = Phase0_Idle;
iTSCmt.ClearVars();
// moved stuff to component
if (!iTSCcomponent->Connect1LevelKnown())
{
iH223Level = H223_LEVEL_UNKNOWN;
}
ResetStats();
iH245->Reset();
iH245->SetTimers(iTimerValues);
// set direct connection to MSD SE
Msd = iH245->GetMSD();
Msd->SetObserver(this);
// set direct connection to CE SE
Ce = iH245->GetCE();
Ce->SetObserver(this);
if (iSuppInfo)
{
OSCL_DEFAULT_FREE(iSuppInfo);
iSuppInfo = NULL;
iSuppInfoLen = 0;
}
if (info_len)
{
iSuppInfo = (uint8*)OSCL_DEFAULT_MALLOC(info_len);
iSuppInfoLen = info_len;
oscl_memcpy(iSuppInfo, info_buf, info_len);
}
iTimer->Clear();
CPVH223MuxParam level_set;
// Initialize the mux and wait for completion. Performs level setup
if (iH223Level != H223_LEVEL_UNKNOWN)
{
iH223->SetMultiplexLevel(iH223Level);
}
iH223->SetMultiplexingDelayMs((uint16)iMultiplexingDelayMs);
iH223->SetLogicalChannelBufferingMs(iInLogicalChannelBufferingMs,
iOutLogicalChannelBufferingMs);
iH223->SetClock(iClock);
S_H223LogicalChannelParameters lcnParams;
lcnParams.segmentableFlag = true;
lcnParams.adaptationLayerType.index = 1;
H223ChannelParam in_channel_params(0,
&lcnParams,
TSC_MAX_CONTROL_CHANNEL_BITRATE_BPS,
PV2WAY_TSC_MIN_T401_INCOMING);
H223ChannelParam out_channel_params(0,
&lcnParams,
TSC_MAX_CONTROL_CHANNEL_BITRATE_BPS,
iT401*100);
iH223->OpenChannel(OUTGOING, 0, &out_channel_params);
iH223->OpenChannel(INCOMING, 0, &in_channel_params);
ConfigureSrp(iH223Level);
// Reset global states (RAN-MS)
iTSCstatemanager.StateInitialize(); // Reset call-setup states
iTerminalStatus = PhaseD_CSUP;
iTSCcomponent->Connect2();
return ret;
}
void TSC_324m::SetClock(PVMFMediaClock* aClock)
{
iClock = aClock;
}
void TSC_324m::DataReceptionStart()
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::DataReceptionStart"));
/* Start timer for Level Setup countdown */
int32 levelSetupTimeoutInfo = 0;
if (iTSCcomponent->IsEnabled())
{
levelSetupTimeoutInfo = 1; // Level setup can commence again if it fails the first time
}
iTimer->Request(PV_TSC_LEVEL_SETUP_TIMER_ID, levelSetupTimeoutInfo,
DEFAULT_TCS_LEVEL_SETUP_TIMEOUT_SECONDS, this);
}
void TSC_324m::MuxSetupComplete(PVMFStatus status, TPVH223Level level)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::MuxSetupComplete status=%d, level=%d",
status, level));
iTimer->Cancel(PV_TSC_LEVEL_SETUP_TIMER_ID);
/* Reconfigure SRP if multiplex level 0 is negotiated starting from a higher level */
if (level == H223_LEVEL0 && level != iH223Level)
{
ConfigureSrp(level);
}
iH223Level = level;
if (status == PVMFPending)
{
return;
}
if (status != PVMFSuccess)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::MuxSetupComplete Mux setup failed."));
SignalCsupComplete(status);
return;
}
iTSCcomponent->MuxSetupComplete(status, level);
OpenSession();
iTimer->Request(PV_TSC_RTD_TIMER_ID, PV_TSC_RTD_TIMER_ID, DEFAULT_RTD_TIMER_SECONDS, this, false);
/* Start timer for TCS countdown */
if (iTSCstatemanager.ReadState(TSC_CE_RECEIVE) != COMPLETE)
{
iTimer->Request(PV_TSC_TCS_RECEIVE_TIMER_ID, PV_TSC_TCS_RECEIVE_TIMER_ID,
DEFAULT_TCS_RECEIVE_TIMEOUT_SECONDS, this);
}
else
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::MuxSetupComplete TCS received before MuxSetupComplete."));
}
}
void TSC_324m::MuxCloseComplete()
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m: Mux close complete - status(%d).", iTerminalStatus));
/* All logical channels closed */
iTerminalStatus = PhaseF_End;
iH245->Reset();
// set direct connection to MSD SE
Msd = iH245->GetMSD();
Msd->SetObserver(this);
// set direct connection to CE SE
Ce = iH245->GetCE();
Ce->SetObserver(this);
iH223->CloseChannel(OUTGOING, 0);
iH223->CloseChannel(INCOMING, 0);
}
void TSC_324m::MuxErrorOccurred(TPVDirection direction,
TPVMuxComponent component,
PVMFStatus error,
uint8* info,
uint info_len)
{
OSCL_UNUSED_ARG(info_len);
OSCL_UNUSED_ARG(info);
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::MuxErrorOccurred - direction(%d), component(%d), error(%d)",
direction, component, error));
TPVChannelId id = CHANNEL_ID_UNKNOWN;
if (info && component == PV_MUX_COMPONENT_LOGICAL_CHANNEL)
{
id = *((TPVChannelId*)info);
if (!iTSCcomponent->HasOlc(direction, id))
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::MuxErrorOccurred - Failed to lookup channel info, lcn=%d",
id));
return;
}
if (direction == INCOMING)
{
H223IncomingChannelPtr incoming_lcn;
PVMFStatus aStatus = iH223->GetIncomingChannel(id, incoming_lcn);
if (aStatus == PVMFSuccess)
{
if (!incoming_lcn->IsConnected())
{
RequestFrameUpdate(incoming_lcn);
}
}
else
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::MuxErrorOccurred - Failed to lookup incoming channel, lcn=%d",
id));
return;
}
}
}
PVMFAsyncEvent aEvent(PVMFInfoEvent, error, this, NULL);
uint8* buf = aEvent.GetLocalBuffer();
buf[0] = (uint8)PV_H324COMPONENT_H223;
buf[1] = (uint8)component;
buf[2] = (uint8)direction;
if (component == PV_MUX_COMPONENT_LOGICAL_CHANNEL)
{
*((TPVChannelId*)(buf + 4)) = id;
}
//iInfoObserver->HandleNodeInformationalEvent(aEvent);
}
void TSC_324m::SkewDetected(TPVChannelId lcn1, TPVChannelId lcn2, uint32 skew)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SkewDetected - lcn1=%d, lcn2=%d, skew=%d",
lcn1, lcn2, skew));
Tsc_IdcSkew(lcn1, lcn2, (uint16)skew);
}
void TSC_324m::LcnDataDetected(TPVChannelId lcn)
{
iTSCcomponent->LcnDataDetected(lcn);
}
void TSC_324m::ReceivedFormatSpecificInfo(TPVChannelId channel_id,
uint8* fsi,
uint32 fsi_len)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::ReceivedFormatSpecificInfo lcn=%d, len=%d",
channel_id, fsi_len));
iTSCcomponent->ReceivedFormatSpecificInfo(channel_id, fsi, fsi_len);
}
TPVStatusCode TSC_324m::Disconnect()
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC: Disconnect request."));
//LogStats(OUTGOING);
//LogStats(INCOMING);
TPVStatusCode ret = EPVT_Success;
iDisconnectInitiator |= EPVT_LOCAL;
iTimer->Clear();
StopSrp();
iH223->Stop();
MuxCloseComplete();
while (iIncomingChannels.size())
{
H223ChannelParam* param = iIncomingChannels.back();
iIncomingChannels.pop_back();
delete param;
}
initVarsSession();
return ret;
}
TPVStatusCode TSC_324m::Abort()
{
// iMutex->Lock();
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC: Abort."));
//LogStats(OUTGOING);
//LogStats(INCOMING);
TPVStatusCode ret = EPVT_Success;
iDisconnectInitiator |= EPVT_LOCAL;
if (iSuppInfo)
{
OSCL_DEFAULT_FREE(iSuppInfo);
iSuppInfo = NULL;
iSuppInfoLen = 0;
iTimer->Clear();
}
SessionClose_Comm();
iSrp->SrpStop();
/* All logical channels closed */
iTerminalStatus = PhaseF_End;
iH245->Reset();
// set direct connection to MSD SE
Msd = iH245->GetMSD();
Msd->SetObserver(this);
// set direct connection to CE SE
Ce = iH245->GetCE();
Ce->SetObserver(this);
initVarsSession();
// iMutex->Unlock();
return ret;
}
/* Handle control events depending on state */
/*
Phase0_Idle = 1 ,
PhaseA ,
PhaseB ,
PhaseC ,
PhaseD_CSUP , // Call Setup
PhaseE_Comm , // Ongoing Communication
PhaseF_Clc , // Closing all outgoing LCNs
PhaseF_End , // End of Session
PhaseG_Dis
*/
void TSC_324m::Handle(PS_ControlMsgHeader msg)
{
uint32 EventNo; /* EventNo */
uint32 Cnt; /* Counter */
DISPATCH_PTR func_ptr = NULL;
bool handled = false;
// iMutex->Lock();
/* Event Receive; a non blocking call */
EventNo = Tsc_EventReceive(msg);
for (Cnt = 0; iDispatchTable[Cnt].Module != NULL; Cnt++)
{
if (iDispatchTable[Cnt].Status == iTerminalStatus && iDispatchTable[Cnt].Event == EventNo)
{
func_ptr = iDispatchTable[Cnt].Module;
handled = true;
(this->*func_ptr)(msg);
break;
}
}
if (!handled)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m: Failed to handle control message - state(%d), event no(%d).",
iTerminalStatus, EventNo));
}
return;
}
TPVStatusCode TSC_324m::RequestFrameUpdate(PVMFPortInterface* port)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::RequestFrameUpdate"));
if (iTSCstatemanager.ReadState(TSC_CE_SEND) == NOT_STARTED)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::RequestFrameUpdate ERROR - TCS not yet requested, tcs state=NOT_STARTED"));
return EPVT_ErrorInvalidState;
}
H223IncomingChannel *channel = OSCL_STATIC_CAST(H223IncomingChannel *, port);
if (channel == NULL)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC: RequestFrameUpdate - Null port"));
return EPVT_Failed;
}
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::RequestFrameUpdate lcn=%d", channel->GetLogicalChannelNumber()));
OlcParam* param = iTSCcomponent->FindOlcGivenChannel(INCOMING, channel->GetLogicalChannelNumber());
if (param == NULL)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m: RequestFrameUpdate - Failed to lookup channel param"));
return EPVT_Failed;
}
if (param->GetState() != OLC_ESTABLISHED)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m: RequestFrameUpdate - Channel not in established state. Not sending request."));
return EPVT_Failed;
}
CmdMisc(EVideoFastUpdatePicture, channel->GetLogicalChannelNumber());
return EPVT_Success;
}
TPVStatusCode TSC_324m::RequestMaxMuxPduSize(unsigned aPduSize)
{
if ((iTerminalStatus != PhaseD_CSUP) && (iTerminalStatus != PhaseE_Comm))
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m: ERROR - RequestMaxMuxPduSize - invalid state(%d)",
iTerminalStatus));
return EPVT_ErrorInvalidState;
}
CmdMisc(EMaxH223MUXPDUsize, CHANNEL_ID_UNKNOWN&0xFFFF, aPduSize);
return EPVT_Success;
}
OSCL_EXPORT_REF TPVStatusCode TSC_324m::SetTerminalType(uint8 aTType)
{
if (Msd)
{
Msd->SetTerminalType(aTType);
return EPVT_Success;
}
else
{
return EPVT_Failed;
}
}
OSCL_EXPORT_REF void TSC_324m::SetEndSessionTimeout(uint32 timeout)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetEndSessionTimeout timeout(%d)", timeout));
iEndSessionTimeout = timeout;
if (iStopCmd != 0)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::SetEndSessionTimeout Already disconnectiing",
timeout));
}
}
OSCL_EXPORT_REF void TSC_324m::SetTimerCounter(TPVH324TimerCounter aTimerCounter,
uint8 aSeries, uint32 aSeriesOffset, uint32 aValue)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetTimerCounter timer/counter(%d), series(%d), offset(%d), value(%d)",
aTimerCounter, aSeries, aSeriesOffset, aValue));
if (aTimerCounter == EH324Timer)
{
switch (aSeries)
{
case 1:
{
switch (aSeriesOffset)
{
case 1:
iTimerValues.iT101 = aValue;
break;
case 3:
iTimerValues.iT103 = aValue;
break;
case 4:
iTimerValues.iT104 = aValue;
break;
case 5:
iTimerValues.iT105 = aValue;
break;
case 6:
iTimerValues.iT106 = aValue;
break;
case 7:
iTimerValues.iT107 = aValue;
break;
case 8:
iTimerValues.iT108 = aValue;
break;
case 9:
iTimerValues.iT109 = aValue;
break;
default:
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetTimerCounter Error - Offset not supported for series"));
}
}
break;
case 4:
{
switch (aSeriesOffset)
{
case 1:
iT401 = aValue;
break;
default:
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetTimerCounter Error - Offset not supported for series"));
}
}
break;
default:
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetTimerCounter Error - Series not supported"));
}
}
else if (aTimerCounter == EH324Counter)
{
switch (aSeries)
{
case 1:
{
switch (aSeriesOffset)
{
case 0:
iN100 = aValue;
iTSCstatemanager.SetN100(iN100);
break;
default:
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetTimerCounter Error - Offset not supported for series"));
}
}
break;
case 4:
{
switch (aSeriesOffset)
{
case 1:
iN401 = aValue;
break;
default:
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetTimerCounter Error - Offset not supported for series"));
}
}
break;
default:
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetTimerCounter Error - Series not supported"));
}
}
}
OSCL_EXPORT_REF void TSC_324m::SetVideoResolutions(TPVDirection dir,
Oscl_Vector<PVMFVideoResolutionRange, OsclMemAllocator>& resolutions)
{
iTSCcapability.SetVideoResolutions(dir, resolutions);
}
void TSC_324m::SetDispatchTable()
{
const uint16 sizeofDispatchTable = 56;
S_DispatchTable aDispatchTable[sizeofDispatchTable] =
{
/* ----------------------------------------- */
/* ---------- CALL SETUP EVENTS ------------ */
/* ----------------------------------------- */
{ OSCL_FUNCTION_PTR(TSC_324m::Status04Event22) , PhaseD_CSUP , 22 }, //E_PtvId_Mt_Trf_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::Status04Event23) , PhaseD_CSUP , 23 }, //E_PtvId_Mt_Trf_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::Status04Event24) , PhaseD_CSUP , 24 }, //E_PtvId_Mt_Rjt_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::ModeRequestIndication) , PhaseD_CSUP , 28 }, //E_PtvId_Mr_Trf_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::EndSessionRecv) , PhaseD_CSUP , 37 }, //E_PtvId_Cmd_Es_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::VendorIdRecv) , PhaseD_CSUP, 56},
{ OSCL_FUNCTION_PTR(TSC_324m::UserInputIndicationRecv), PhaseD_CSUP, 57}, //E_PtvId_Idc_Ui_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::LcEtbIdc) , PhaseD_CSUP , 9 }, //E_PtvId_Lc_Etb_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::LcRlsIdc) , PhaseD_CSUP , 11 }, //E_PtvId_Lc_Rls_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::BlcEtbIdc) , PhaseD_CSUP , 14 }, //E_PtvId_Lc_Etb_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::BlcRlsIdc) , PhaseD_CSUP , 16 }, //E_PtvId_Lc_Rls_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::FunctionNotSupportedIndicationReceived) , PhaseD_CSUP , 49}, //E_PtvId_Idc_Fns_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::FlowControlCommandReceived) , PhaseD_CSUP , 53 }, //E_PtvId_Cmd_Fc
{ OSCL_FUNCTION_PTR(TSC_324m::SendTerminalCapabilitySet) , PhaseD_CSUP , 52 }, //E_PtvId_Cmd_Stcs_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::MiscCmdRecv) , PhaseD_CSUP , 54 }, //E_PtvId_Cmd_Mscl_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::MiscIndicationRecv), PhaseD_CSUP, 58}, //E_PtvId_Idc_Mscl_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::SkewIndicationRecv), PhaseD_CSUP, 59}, //E_PtvId_Idc_H223skw_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::FlowControlIndicationReceived) , PhaseD_CSUP , 60 }, //E_PtvId_Cmd_Fc
// { InternalError_CSUP, PhaseD_CSUP , 38 }, //H245_INTERNAL_ERROR
/* ----------------------------------------- */
/* --------- ONGOING COMM EVENTS ----------- */
/* ----------------------------------------- */
{ OSCL_FUNCTION_PTR(TSC_324m::LcEtbIdc) , PhaseE_Comm , 9 }, //E_PtvId_Lc_Etb_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::LcRlsIdc) , PhaseE_Comm , 11 }, //E_PtvId_Lc_Rls_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::LcEtbCfm) , PhaseE_Comm , 10 }, //E_PtvId_Lc_Etb_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::LcRlsCfm) , PhaseE_Comm , 12 }, //E_PtvId_Lc_Rls_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::LcErrIdc) , PhaseE_Comm , 13 }, //E_PtvId_Lc_Err_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::BlcEtbIdc) , PhaseE_Comm , 14 }, //E_PtvId_Blc_Etb_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::BlcEtbCfm) , PhaseE_Comm , 15 }, //E_PtvId_Blc_Etb_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::BlcEtbCfm2) , PhaseE_Comm , 50 }, //E_PtvId_Blc_Etb_Cfm2
{ OSCL_FUNCTION_PTR(TSC_324m::BlcErrIdc) , PhaseE_Comm , 18 }, //E_PtvId_Blc_Err_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::BlcRlsIdc) , PhaseE_Comm , 16 }, //E_PtvId_Blc_Rls_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::BlcRlsCfm) , PhaseE_Comm , 17 }, //E_PtvId_Blc_Rls_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::Status08Event19) , PhaseE_Comm , 19 }, //E_PtvId_Clc_Cls_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::Status08Event20) , PhaseE_Comm , 20 }, //E_PtvId_Clc_Cls_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::Status08Event21) , PhaseE_Comm , 21 }, //E_PtvId_Clc_Rjt_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::Status04Event22) , PhaseE_Comm , 22 }, //E_PtvId_Mt_Trf_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::Status04Event23) , PhaseE_Comm , 23 }, //E_PtvId_Mt_Trf_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::Status04Event24) , PhaseE_Comm , 24 }, //E_PtvId_Mt_Rjt_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::Status08Event25) , PhaseE_Comm , 25 }, //E_PtvId_Rme_Send_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::Status08Event26) , PhaseE_Comm , 26 }, //E_PtvId_Rme_Send_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::Status08Event27) , PhaseE_Comm , 27 }, //E_PtvId_Rme_Rjt_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::ModeRequestIndication) , PhaseE_Comm , 28 }, //E_PtvId_Mr_Trf_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::Status08Event29) , PhaseE_Comm , 29 }, //E_PtvId_Mr_Trf_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::Status08Event30) , PhaseE_Comm , 30 }, //E_PtvId_Mr_Rjt_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::Status08Event31) , PhaseE_Comm , 31 }, //E_PtvId_Rtd_Trf_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::Status08Event32) , PhaseE_Comm , 32 }, //E_PtvId_Rtd_Exp_Idc
{ OSCL_FUNCTION_PTR(TSC_324m::FunctionNotSupportedIndicationReceived) , PhaseE_Comm , 49}, //E_PtvId_Idc_Fns_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::SendTerminalCapabilitySet) , PhaseE_Comm , 52 }, //E_PtvId_Cmd_Stcs_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::FlowControlCommandReceived) , PhaseE_Comm , 53 }, //E_PtvId_Cmd_Fc_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::MiscCmdRecv) , PhaseE_Comm , 54 }, //E_PtvId_Cmd_Mscl_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::Status08Event55) , PhaseE_Comm , 55 }, //E_PtvId_Cmd_Hmr_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::EndSessionRecv) , PhaseE_Comm , 37 }, //E_PtvId_Cmd_Es_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::VendorIdRecv) , PhaseE_Comm , 56},
{ OSCL_FUNCTION_PTR(TSC_324m::UserInputIndicationRecv), PhaseE_Comm, 57}, //E_PtvId_Idc_Ui_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::MiscIndicationRecv), PhaseE_Comm, 58}, //E_PtvId_Idc_Mscl_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::SkewIndicationRecv), PhaseE_Comm, 59}, //E_PtvId_Idc_H223skw_Cfm
{ OSCL_FUNCTION_PTR(TSC_324m::FlowControlIndicationReceived) , PhaseE_Comm, 60 }, //E_PtvId_Cmd_Fc
/* ----------------------------------------- */
/* --------- CLOSE and END EVENTS ---------- */
/* ----------------------------------------- */
{ OSCL_FUNCTION_PTR(TSC_324m::EndSessionRecv) , PhaseF_End , 37 }, //E_PtvId_Cmd_Es_Cfm
{ NULL , 0 , 0 }
};
for (int n = 0; n < sizeofDispatchTable; n++)
{
iDispatchTable[n] = aDispatchTable[n];
}
}
OSCL_EXPORT_REF TPVStatusCode TSC_324m::SetVendorIdInfo(TPVH245Vendor* vendor,
const uint8* pn,
uint16 pn_len,
const uint8* vn,
uint16 vn_len)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetVendorIdInfo vendor(%x), pn_len(%d), vn_len(%d)", vendor, pn_len, vn_len));
if (pn && pn_len && (pn[pn_len-1] == '\0'))
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetVendorIdInfo pn(%s)", pn));
}
if (vn && vn_len && (vn[vn_len-1] == '\0'))
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetVendorIdInfo vn(%s)", vn));
}
if (iVendor)
{
OSCL_DELETE(iVendor);
iVendor = NULL;
}
if (iProductNumber)
{
OSCL_DEFAULT_FREE(iProductNumber);
iProductNumber = NULL;
}
if (iVersionNumber)
{
OSCL_DEFAULT_FREE(iVersionNumber);
iVersionNumber = NULL;
}
iProductNumberLen = pn_len;
iVersionNumberLen = vn_len;
if (vendor)
{
iVendor = vendor->Copy();
}
if (iProductNumberLen)
{
iProductNumber = (uint8*)OSCL_DEFAULT_MALLOC(iProductNumberLen);
oscl_memcpy(iProductNumber, pn, iProductNumberLen);
}
if (iVersionNumberLen)
{
iVersionNumber = (uint8*)OSCL_DEFAULT_MALLOC(iVersionNumberLen);
oscl_memcpy(iVersionNumber, vn, iVersionNumberLen);
}
return EPVT_Success;
}
OSCL_EXPORT_REF TSC* Allocate324mTSC(TPVLoopbackMode aLoopbackMode)
{
return OSCL_NEW(TSC_324m, (aLoopbackMode));
}
OSCL_EXPORT_REF void Deallocate324mTSC(TSC* tsc)
{
TSC_324m* tsc_324m = (TSC_324m*)tsc;
OSCL_DELETE(tsc_324m);
}
void TSC_324m::TimeoutOccurred(int32 timerID, int32 timeoutInfo)
{
OSCL_UNUSED_ARG(timeoutInfo);
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::TimeoutOccurred"));
if (timerID == PV_TSC_RTD_TIMER_ID)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::TimeoutOccurred - Sending RTD"));
iTscSrpBuffer->EnableBuffering(false);
RtdTrfReq();
}
else if (timerID == PV_TSC_LEVEL_SETUP_TIMER_ID)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::TimeoutOccurred Level setup timeout out, timeoutInfo=%d",
timeoutInfo));
if (!timeoutInfo)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::TimeoutOccurred Level Setup Failed."));
SignalCsupComplete(PVMFErrTimeout);
}
else
{
/* We timed out waiting for TCS. */
iTSCcomponent->Timeout();
/* Start timer to receive TCS */
iTimer->Request(PV_TSC_TCS_RECEIVE_TIMER_ID, PV_TSC_TCS_RECEIVE_TIMER_ID,
DEFAULT_TCS_RECEIVE_TIMEOUT_SECONDS, this);
iH223->EnableStuffing(true);
iH223->SetInterleavingMultiplexFlags(0, NULL);
iH223->SetMuxLevel(TSC_H223_LEVEL_DEFAULT);
/* Start timer to receive TCS */
iTimer->Request(PV_TSC_LEVEL_SETUP_TIMER_ID, 0,
DEFAULT_TCS_LEVEL_SETUP_TIMEOUT_SECONDS, this);
}
}
else if (timerID == PV_TSC_TCS_RECEIVE_TIMER_ID)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::TimeoutOccurred Timed out on TCS receive. Connect failed."));
SignalCsupComplete(PVMFErrTimeout);
}
else
{
iTSCcomponent->TimeoutOccurred(timerID, timeoutInfo);
}
}
void TSC_324m::ResetStats()
{
iH223->ResetStats();
}
void TSC_324m::LogStats(TPVDirection dir)
{
if (iH223)
iH223->LogStats(dir);
}
// Node virtuals
// Node virtuals
// Sync requests that will NOT trigger callback events
OSCL_EXPORT_REF PVMFStatus TSC_324m::GetCapability(PVMFNodeCapability& aNodeCapability)
{
aNodeCapability.iCanSupportMultipleInputPorts = true;
aNodeCapability.iCanSupportMultipleOutputPorts = true;
aNodeCapability.iHasMaxNumberOfPorts = true;
aNodeCapability.iMaxNumberOfPorts = 5;
aNodeCapability.iInputFormatCapability.push_back(PVMF_MIME_H223);
aNodeCapability.iInputFormatCapability.push_back(PVMF_MIME_M4V);
aNodeCapability.iInputFormatCapability.push_back(PVMF_MIME_H2631998);
aNodeCapability.iInputFormatCapability.push_back(PVMF_MIME_H2632000);
aNodeCapability.iOutputFormatCapability.push_back(PVMF_MIME_H223);
aNodeCapability.iOutputFormatCapability.push_back(PVMF_MIME_M4V);
aNodeCapability.iOutputFormatCapability.push_back(PVMF_MIME_H2631998);
aNodeCapability.iOutputFormatCapability.push_back(PVMF_MIME_H2632000);
return PVMFSuccess;
}
OSCL_EXPORT_REF PVMFCommandId TSC_324m::Init(PVMFSessionId aSession, const OsclAny* aContext)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::Init(%x)", aContext));
if (iInterfaceState != EPVMFNodeIdle)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::Init Invalid state(%d)", iInterfaceState));
OSCL_LEAVE(PVMFErrInvalidState);
}
// Add command to queue
Tsc324mNodeCommand cmd;
cmd.Construct(aSession, PVMF_GENERIC_NODE_INIT, aContext);
return QueueCommandL(cmd);
}
// Async requests that will trigger callback events
/**
This should establish the comm server session. Thread specific initialization happens here */
void TSC_324m::DoInit(Tsc324mNodeCommand& cmd)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::DoInit(%x)", cmd.iId));
PVMFStatus pvmfStatus = PVMFSuccess;
// Initialize TSC
int leave_status = 0;
OSCL_TRY(leave_status, InitTsc());
OSCL_FIRST_CATCH_ANY(leave_status, void());
if (leave_status == 0)
{
iInterfaceState = EPVMFNodeInitialized;
}
else
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::Init - failed to initialize"));
pvmfStatus = PVMFFailure;
iInterfaceState = EPVMFNodeError;
}
CommandComplete(iCmdQueue, cmd, pvmfStatus, NULL);
}
PVMFCommandId TSC_324m::Prepare(PVMFSessionId aSession
, const OsclAny* aContext)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::Prepare aSession=%x, aContext=%x",
aSession, aContext));
if (iInterfaceState != EPVMFNodeInitialized)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::Prepare Invalid state(%d)", iInterfaceState));
OSCL_LEAVE(PVMFErrInvalidState);
}
// Add command to queue
Tsc324mNodeCommand cmd;
cmd.Construct(aSession, PVMF_GENERIC_NODE_PREPARE, aContext);
return QueueCommandL(cmd);
}
void TSC_324m::DoPrepare(Tsc324mNodeCommand& cmd)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::DoPrepare"));
iInterfaceState = EPVMFNodePrepared;
CommandComplete(iCmdQueue, cmd, PVMFSuccess);
}
OSCL_EXPORT_REF PVMFCommandId TSC_324m::Start(PVMFSessionId aSession, const OsclAny* aContext)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::Start aSession=%x, aContext=%x", aSession, aContext));
iTSCcomponent->Start();
if (iInterfaceState != EPVMFNodePrepared || iTerminalStatus != Phase0_Idle)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::Start Init Invalid state iInterfaceState=%d, iTerminalStatus=%d",
iInterfaceState, iTerminalStatus));
OSCL_LEAVE(PVMFErrInvalidState);
}
// Add command to queue
Tsc324mNodeCommand cmd;
cmd.Construct(aSession, PVMF_GENERIC_NODE_START, aContext);
return QueueCommandL(cmd);
}
void TSC_324m::DoStart(Tsc324mNodeCommand& cmd)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::DoStart"));
TPVStatusCode stat = EPVT_Failed;
int leave_status = 0;
PVMFStatus pvmfStatus = PVMFFailure;
OSCL_TRY(leave_status, stat = Connect());
OSCL_FIRST_CATCH_ANY(leave_status, Disconnect());
if (stat == EPVT_Success || stat == EPVT_Pending)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::DoStart Connect complete"));
pvmfStatus = PVMFSuccess;
iInterfaceState = EPVMFNodeStarted;
}
else
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::DoStart Connect failed leave_status=%d",
leave_status));
iInterfaceState = EPVMFNodePrepared;
}
CommandComplete(iCmdQueue, cmd, pvmfStatus);
return;
}
/**
* Causes the node to stop servicing one or all disconnected ports.
* TBD: Should we add an API or modify this to take an arbitrary subset of ports ?
* @exception port_connected leaves if any of the ports are not disconnected.
**/
OSCL_EXPORT_REF PVMFCommandId TSC_324m::Stop(PVMFSessionId aSession,
const OsclAny* aContext)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::Stop aSession=%x, aContext=%x",
aSession, aContext));
switch (iInterfaceState)
{
case EPVMFNodeInitialized:
case EPVMFNodePrepared:
case EPVMFNodeStarted:
case EPVMFNodePaused:
// ok to call stop
break;
default:
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::Stop Invalid state(%d)", iInterfaceState));
OSCL_LEAVE(PVMFErrInvalidState);
}
while (!iCmdQueue.empty())
{
CommandComplete(iCmdQueue, iCmdQueue.front(), PVMFErrCancelled);
iCmdQueue.Erase(&iCmdQueue.front());
}
iPendingCmdQueue.clear();
// Add command to queue
Tsc324mNodeCommand cmd;
cmd.Construct(aSession, PVMF_GENERIC_NODE_STOP, aContext);
return QueueCommandL(cmd);
}
void TSC_324m::DoStop(Tsc324mNodeCommand& cmd)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::DoStop"));
switch (iInterfaceState)
{
case EPVMFNodeInitialized:
case EPVMFNodePrepared:
case EPVMFNodeStarted:
case EPVMFNodePaused:
break;
default:
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::DoStop Ignoring stop due to invalid state(%d)",
iInterfaceState));
CommandComplete(iCmdQueue, cmd, PVMFErrInvalidState);
return;
}
if (iTSCcomponent)
{
iTSCcomponent->StartDisconnect(true);
}
iTerminalStatus = PhaseF_Clc;
Disconnect();
if (iNumRtdRequests)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::DoStop iNumRtdRequests=%d, iRtdMin=%d, iRtdmax=%d, iRtdAve=%d",
iNumRtdRequests, iRtdMin, iRtdMax, iRtdAve / iNumRtdRequests));
}
else
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::DoStop No RTD requests issued"));
}
iInterfaceState = EPVMFNodePrepared;
CommandComplete(iCmdQueue, cmd, PVMFSuccess);
}
/**
* Causes the node to pause servicing one or all connected and started ports.
* Ports are to be resumed using the Start command ?
* TBD: Should we add an API or modify this to take an arbitrary subset of ports ?
* @exception port_disconnected leaves if any of the ports are not connected.
**/
OSCL_EXPORT_REF PVMFCommandId TSC_324m::Pause(PVMFSessionId aSession,
const OsclAny* aContext)
{
OSCL_UNUSED_ARG(aSession);
OSCL_UNUSED_ARG(aContext);
OSCL_LEAVE(PVMFErrNotSupported);
return -1;
}
/**
* Resets the node. The node should relinquish all resources that is has acquired as part of the
* initialization process and should be ready to be deleted when this completes.
* @exception port_disconnected leaves if any of the ports are not connected.
**/
OSCL_EXPORT_REF PVMFCommandId TSC_324m::Reset(PVMFSessionId aSession,
const OsclAny* aContext)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::Reset(%d)", iInterfaceState));
switch (iInterfaceState)
{
case EPVMFNodeInitialized:
case EPVMFNodePrepared:
case EPVMFNodeError:
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::Reset Ok to reset"));
break;
default:
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::Reset Invalid state for Reset"));
OSCL_LEAVE(PVMFErrInvalidState);
break;
}
while (!iCmdQueue.empty())
{
CommandComplete(iCmdQueue, iCmdQueue.front(), PVMFErrCancelled);
iCmdQueue.Erase(&iCmdQueue.front());
}
iPendingCmdQueue.clear();
// Add command to queue
Tsc324mNodeCommand cmd;
cmd.Construct(aSession, PVMF_GENERIC_NODE_RESET, aContext);
return QueueCommandL(cmd);
}
void TSC_324m::DoReset(Tsc324mNodeCommand& cmd)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::DoReset"));
iInterfaceState = EPVMFNodeIdle;
ResetTsc();
CommandComplete(iCmdQueue, cmd, PVMFSuccess);
}
OSCL_EXPORT_REF PVMFCommandId TSC_324m::RequestPort(PVMFSessionId aSession
, int32 aPortTag
, const PvmfMimeString* aPortConfig
, const OsclAny* aContext)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::RequestPort"));
// Add command to queue
Tsc324mNodeCommand cmd;
cmd.Construct(aSession, PVMF_GENERIC_NODE_REQUESTPORT, aPortTag,
aPortConfig, aContext);
return QueueCommandL(cmd);
}
PVMFPortInterface* TSC_324m::FindOutgoingPort(TPVMediaType_t mediaType)
{
PVMFPortInterface* port = NULL;
OlcParam* param = iTSCcomponent->FindOlc(OUTGOING,
mediaType, OLC_ESTABLISHED | OLC_PENDING);
if (param)
{
uint32 channelID = param->GetChannelId();
H223OutgoingChannelPtr outgoing_lcn;
PVMFStatus pvmfStatus = iH223->GetOutgoingChannel(channelID,
outgoing_lcn);
if (pvmfStatus == PVMFSuccess)
{
port = outgoing_lcn;
iRequestedOutgoingChannels[port] = outgoing_lcn;
}
}
return port;
}
void TSC_324m::DoRequestPort(Tsc324mNodeCommand& cmd)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::DoRequestPort"));
PVMFStatus pvmfStatus = PVMFSuccess;
int32 aPortTag = (int32)cmd.iParam1;
PvmfMimeString* aPortConfig = (PvmfMimeString*)cmd.iParam2;
PVMFPortInterface* port = NULL;
if (aPortConfig)
{
PVMFFormatType formatType(aPortConfig->get_str());
if (formatType.isFile())
{
// Multiplexed PV_MULTIPLEXED
// x-pvmf/multiplexed: to identify the lowerlayer port
// Is the port already requested ?
if (iH223->GetLowerLayer()->IsConnected())
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::RequestPort - Port is in use"));
pvmfStatus = PVMFErrBusy;
}
else
{
port = iH223->GetLowerLayer();
}
}
else if (*aPortConfig == PVMF_AUDIO_OUTGOING_MIMETYPE)
{
// Audio x-pvmf/audio;dir=outgoing to identify the outgoing audio channel
port = FindOutgoingPort(PV_AUDIO);
if (port == NULL)
{
pvmfStatus = PVMFFailure;
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::DoRequestPort Error - Failed to lookup outgoing channel %d",
aPortTag));
}
}
else if (*aPortConfig == PVMF_VIDEO_OUTGOING_MIMETYPE)
{
// Video x-pvmf/video;dir=outgoing to identify the outgoing video channel
port = FindOutgoingPort(PV_VIDEO);
if (port == NULL)
{
pvmfStatus = PVMFFailure;
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::DoRequestPort Error - Failed to lookup outgoing channel %d",
aPortTag));
}
}
else if (*aPortConfig == PVMF_INCOMING_MIMETYPE || (aPortTag < 0))
{
if (aPortTag < 0)
{
aPortTag = -aPortTag;
}
// just use the channel id
//x-pvmf/dir=incoming
// Incoming
H223IncomingChannelPtr incoming_lcn;
pvmfStatus = iH223->GetIncomingChannel(aPortTag, incoming_lcn);
if (pvmfStatus == PVMFSuccess)
{
port = incoming_lcn;
iRequestedIncomingChannels[port] = incoming_lcn;
}
else
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::DoRequestPort Error - Failed to lookup incoming channel %d",
aPortTag));
}
}
else //if (*aPortConfig == PVMF_OUTGOING_MIMETYPE || aPortTag >=0)
{
//x-pvmf/dir=outgoing
// Outgoing
H223OutgoingChannelPtr outgoing_lcn;
pvmfStatus = iH223->GetOutgoingChannel(aPortTag, outgoing_lcn);
if (pvmfStatus == PVMFSuccess)
{
port = outgoing_lcn;
iRequestedOutgoingChannels[port] = outgoing_lcn;
}
else
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::DoRequestPort Error - Failed to lookup outgoing channel %d",
aPortTag));
}
}
}
if (pvmfStatus != PVMFPending)
{
CommandComplete(iCmdQueue, cmd, pvmfStatus, port);
return;
}
// queue up the command in the pending queue
iPendingCmdQueue.StoreL(cmd);
iCmdQueue.Erase(&cmd);
}
OSCL_EXPORT_REF PVMFCommandId TSC_324m::ReleasePort(PVMFSessionId aSession,
PVMFPortInterface& aPort,
const OsclAny* aContext)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::ReleasePort"));
// Add command to queue
Tsc324mNodeCommand cmd;
cmd.Construct(aSession, PVMF_GENERIC_NODE_RELEASEPORT, aPort, aContext);
return QueueCommandL(cmd);
}
void TSC_324m::DoReleasePort(Tsc324mNodeCommand& cmd)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::DoReleasePort"));
PVMFPortInterface* port = (PVMFPortInterface*)cmd.iParam1;
if (port->GetPortTag() == PV_MULTIPLEXED)
{
CommandComplete(iCmdQueue, cmd, PVMFSuccess, port);
return;
}
H223LogicalChannel* lcn = OSCL_STATIC_CAST(H223LogicalChannel*, port);
if (lcn)
{
TPVDirection aDirection = port->GetPortTag() < 0 ? INCOMING : OUTGOING;
if (aDirection == INCOMING)
{
Oscl_Map<PVMFPortInterface*, H223IncomingChannelPtr, OsclMemAllocator>::iterator iter;
iter = iRequestedIncomingChannels.find(port);
if (iter != iRequestedIncomingChannels.end())
{
iRequestedIncomingChannels[port]->Flush();
iH223->CloseChannel(INCOMING,
iRequestedIncomingChannels[port]->GetLogicalChannelNumber());
iRequestedIncomingChannels.erase(iter);
}
else
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::DoReleasePort - Incoming channel not requested"));
}
}
else
{
Oscl_Map<PVMFPortInterface*, H223OutgoingChannelPtr, OsclMemAllocator>::iterator iter;
iter = iRequestedOutgoingChannels.find(port);
if (iter != iRequestedOutgoingChannels.end())
{
iH223->FlushChannel(OUTGOING,
iRequestedOutgoingChannels[port]->GetLogicalChannelNumber());
iH223->CloseChannel(OUTGOING,
iRequestedOutgoingChannels[port]->GetLogicalChannelNumber());
iRequestedOutgoingChannels.erase(iter);
}
}
}
CommandComplete(iCmdQueue, cmd, PVMFSuccess, port);
return;
}
/**
* Returns a list of ports currently available in the node that meet the filter criteria
* We can add fancier iterators and filters as needed. For now we return all the ports.
**/
OSCL_EXPORT_REF PVMFPortIter* TSC_324m::GetPorts(const PVMFPortFilter* aFilter)
{
OSCL_UNUSED_ARG(aFilter);
return NULL;
}
void TSC_324m::DoCancel()
{
}
void TSC_324m::Run()
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, " TSC_324m::Run()"));
if (!iCmdQueue.empty())
{
ProcessCommand(iCmdQueue.front());
}
if (!iCmdQueue.empty())
{
// Run again if there are more things to process
RunIfNotReady();
}
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, " TSC_324m::Run() - done"));
}
bool TSC_324m::ProcessCommand(Tsc324mNodeCommand& aCmd)
{
switch (aCmd.iCmd)
{
case PVMF_GENERIC_NODE_QUERYUUID:
DoQueryUuid(aCmd);
break;
case PVMF_GENERIC_NODE_QUERYINTERFACE:
DoQueryInterface(aCmd);
break;
case PVMF_GENERIC_NODE_REQUESTPORT:
DoRequestPort(aCmd);
break;
case PVMF_GENERIC_NODE_RELEASEPORT:
DoReleasePort(aCmd);
break;
case PVMF_GENERIC_NODE_INIT:
DoInit(aCmd);
break;
case PVMF_GENERIC_NODE_PREPARE:
DoPrepare(aCmd);
break;
case PVMF_GENERIC_NODE_START:
DoStart(aCmd);
break;
case PVMF_GENERIC_NODE_STOP:
DoStop(aCmd);
break;
case PVMF_GENERIC_NODE_FLUSH:
DoFlush(aCmd);
break;
case PVMF_GENERIC_NODE_PAUSE:
DoPause(aCmd);
break;
case PVMF_GENERIC_NODE_RESET:
DoReset(aCmd);
break;
case PVMF_GENERIC_NODE_CANCELALLCOMMANDS:
DoCancelAllCommands(aCmd);
break;
case PVMF_GENERIC_NODE_CANCELCOMMAND:
DoCancelCommand(aCmd);
break;
default://unknown command type
if (iTSCcomponent->ProcessCommand(aCmd))
{
CommandComplete(iCmdQueue, aCmd, PVMFSuccess);
}
else
{
CommandComplete(iCmdQueue, aCmd, PVMFFailure);
}
break;
}
return true;
}
int32 TSC_324m::FindPendingPortCmd(TPVMFGenericNodeCommand aCmdType,
int32 aPortTag,
Tsc324mNodeCommand& cmd)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::FindPendingRequestPortCmd aCmdType=%d, aPortTag=%d",
aCmdType, aPortTag));
int32 cmdIndex = -1;
for (uint32 i = 0; i < iPendingCmdQueue.size(); i++)
{
if ((TPVMFGenericNodeCommand)iPendingCmdQueue[i].iCmd == aCmdType)
{
if (aPortTag == (int32)iPendingCmdQueue[i].iParam1)
{
cmd = iPendingCmdQueue[i];
cmdIndex = i;
break;
}
}
}
if (cmdIndex < 0)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::FindPendingPortCmd Error - command not found"));
return 0;
}
// Destroy command object
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::FindPendingPortCmd : Deleting cmd from iPendingQueue. cmdIndex=%d",
cmdIndex));
iPendingCmdQueue.Erase(&iPendingCmdQueue[cmdIndex]);
return cmdIndex;
}
OSCL_EXPORT_REF void TSC_324m::SetMultiplexLevel(TPVH223Level muxLevel)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetMultiplexLevel level(%d)\n", muxLevel));
iH223Level = muxLevel;
if (iH223)
{
iH223->SetMultiplexLevel(muxLevel);
}
}
OSCL_EXPORT_REF void TSC_324m::SetSduSize(TPVDirection direction,
uint16 size,
TPVAdaptationLayer al)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetSduSize direction(%d), size(%d), al(%d)\n",
direction, size, al));
if (iH223)
{
iH223->SetSduSize(direction, size, EplForAdaptationLayer(al));
}
}
OSCL_EXPORT_REF void TSC_324m::SetAl2Sn(int width)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetAl2Sn on/off(%d)\n", width));
iTSCcomponent->SetAl2Sn(width);
}
OSCL_EXPORT_REF void TSC_324m::SetAl3ControlFieldOctets(unsigned cfo)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetAl3ControlFieldOctets cfo(%d)\n", cfo));
iTSCcomponent->SetAl3ControlFieldOctets(cfo);
}
OSCL_EXPORT_REF void TSC_324m::SetMaxOutgoingPduSize(uint16 size)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetMaxOutgoingPduSize size(%d)\n", size));
if (iH223)
{
iH223->SetMaxOutgoingPduSize(size);
}
}
OSCL_EXPORT_REF void TSC_324m::SetMaxMuxPduSize(uint16 size)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetMaxMuxPduSize size(%d)\n", size));
iRequestMaxMuxPduSize = size;
}
OSCL_EXPORT_REF void TSC_324m::SetMaxCcsrlSduSize(int size)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetMaxCcsrlSduSize size(%d)\n", size));
if (iSrp)
{
iSrp->SetCCSRLSduSize(size);
}
else
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetMaxCcsrlSduSize - Invalid state: SRP == NULL"));
}
}
OSCL_EXPORT_REF void TSC_324m::SetOutgoingMuxPduType(TPVH223MuxPduType outgoingPduType)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetOutgoingMuxPduType type(%d)\n",
outgoingPduType));
iOutgoingPduType = outgoingPduType;
}
OSCL_EXPORT_REF void TSC_324m::SetOutgoingChannelConfig(
Oscl_Vector<H324ChannelParameters, PVMFTscAlloc>& out_channel_config)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetOutgoingChannelConfig size(%d)\n",
out_channel_config.size()));
if (iInterfaceState != EPVMFNodeInitialized)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetOutgoingChannelConfig Error: Invalid state."));
OSCL_LEAVE(PVMFErrInvalidState);
}
iTSCcomponent->SetOutgoingChannelConfig(out_channel_config);
}
OSCL_EXPORT_REF void TSC_324m::SetIncomingChannelConfig(
Oscl_Vector<H324ChannelParameters, PVMFTscAlloc>& in_channel_config)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetIncomingChannelConfig size(%d)\n",
in_channel_config.size()));
iTSCcomponent->SetIncomingChannelConfig(in_channel_config);
}
OSCL_EXPORT_REF void TSC_324m::SetAlConfig(PV2WayMediaType media_type,
TPVAdaptationLayer layer,
bool allow)
{
iTSCcomponent->SetAlConfig(media_type, layer, allow);
}
PVMFCommandId TSC_324m::QueryUUID(PVMFSessionId aSession,
const PvmfMimeString& aMimeType,
Oscl_Vector<PVUuid, OsclMemAllocator>& aUuids,
bool aExactUuidsOnly,
const OsclAny* aContext)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::QueryUUID"));
// create message to be completed later - depending on what it is...
Tsc324mNodeCommand cmd;
cmd.Construct(aSession, PVMF_GENERIC_NODE_QUERYUUID, aMimeType,
aUuids, aExactUuidsOnly, aContext);
iComponentRegistry.QueryRegistry(cmd);
//return QueueCommandL(cmd);
return 0;
}
PVMFCommandId TSC_324m::QueryInterface(PVMFSessionId aSession,
const PVUuid& aUuid,
PVInterface*& aInterfacePtr,
const OsclAny* aContext)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::QueryInterface()"));
if (aUuid == PVH324MConfigUuid)
{
aInterfacePtr = OSCL_NEW(H324MConfig, (this, true));
}
else if (aUuid == PVUidProxiedInterface)
{
H324MProxiedInterface* proxied_interface_ptr = NULL;
proxied_interface_ptr = OSCL_NEW(H324MProxiedInterface, ());
proxied_interface_ptr->SetH324M(this);
aInterfacePtr = proxied_interface_ptr;
}
else
{
TSC_component* backup = iTSCcomponent;
// send onto TSCComponentRegistry::Create to let it finish
iTSCcomponent = iComponentRegistry.Create(aSession, aUuid,
aInterfacePtr, aContext);
if (iTSCcomponent)
{
InitComponent();
if (backup)
{
OSCL_DELETE(backup);
}
}
}
// Add command to queue
/*Tsc324mNodeCommand cmd;
cmd.Construct(aSession, PVMF_GENERIC_NODE_QUERYINTERFACE, aUuid, aInterfacePtr, aContext) ;
return QueueCommandL(cmd);
*/
return 0;
}
void TSC_324m::DoQueryInterface(Tsc324mNodeCommand& cmd)
{
OSCL_UNUSED_ARG(cmd);
//CommandComplete(iCmdQueue, cmd, PVMFSuccess);
}
void TSC_324m::DoQueryUuid(Tsc324mNodeCommand& cmd)
{
OSCL_UNUSED_ARG(cmd);
//CommandComplete(iCmdQueue, cmd, PVMFSuccess);
}
PVMFCommandId TSC_324m::CancelAllCommands(PVMFSessionId aSession,
const OsclAny* aContext)
{
OSCL_UNUSED_ARG(aSession);
OSCL_UNUSED_ARG(aContext);
OSCL_LEAVE(PVMFErrNotSupported);
return -1;
}
OSCL_EXPORT_REF PVMFCommandId TSC_324m::CancelCommand(PVMFSessionId aSession,
PVMFCommandId aCommandId,
const OsclAny* aContext)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::CancelCommand id(%d)", aCommandId));
// Add command to queue
Tsc324mNodeCommand cmd;
cmd.Construct(aSession, PVMF_GENERIC_NODE_CANCELCOMMAND, aCommandId, aContext);
return QueueCommandL(cmd);
}
void TSC_324m::DoCancelCommand(Tsc324mNodeCommand& cmd)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::DoCancelCommand cmd(%x)", &cmd));
PVMFStatus status = PVMFSuccess;
int cmdIndex = FindPendingCmd((PVMFCommandId)cmd.iParam1);
if (cmdIndex < 0)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::DoCancelCommand Failed to lookup command(%d)",
(PVMFCommandId)cmd.iParam1));
Tsc324mNodeCommand* found_cmd = iCmdQueue.FindById((PVMFCommandId)cmd.iParam1);
if (found_cmd)
{
iCmdQueue.Erase(found_cmd);
}
else
status = PVMFErrArgument;
}
else
{
// Destroy command object
Tsc324mNodeCommand to_be_deleted_cmd = iPendingCmdQueue[cmdIndex];
iPendingCmdQueue.Erase(&iPendingCmdQueue[cmdIndex]);
}
CommandComplete(iCmdQueue, cmd, status);
}
int TSC_324m::FindPendingCmd(PVMFCommandId aCommandId)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::FindPendingCmd id(%d)", aCommandId));
int32 cmdIndex = -1;
for (uint32 i = 0; i < iPendingCmdQueue.size(); i++)
{
if (iPendingCmdQueue[i].iId == aCommandId)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::FindPendingCmd - command found in iPendingCmdQueue"));
cmdIndex = i;
break;
}
}
return cmdIndex;
}
const uint8* TSC_324m::GetFormatSpecificInfo(PVMFPortInterface* port,
uint32* len)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::GetFormatSpecificInfo port(%x)", port));
return ((H223LogicalChannel*)port)->GetFormatSpecificInfo(len);
}
LogicalChannelInfo* TSC_324m::GetLogicalChannelInfo(PVMFPortInterface& port)
{
return iTSCcomponent->GetLogicalChannelInfo(port);
}
bool TSC_324m::IsEstablishedLogicalChannel(TPVDirection aDir,
TPVChannelId aChannelId)
{
return iTSCcomponent->IsEstablishedLogicalChannel(aDir, aChannelId);
}
void TSC_324m::SetSkewReference(PVMFPortInterface* aPort,
PVMFPortInterface* aReferencePort)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetSkewReference"));
H223OutgoingChannel* lcn2 = OSCL_STATIC_CAST(H223OutgoingChannel*,
aPort);
H223OutgoingChannel* lcn1 = OSCL_STATIC_CAST(H223OutgoingChannel*,
aReferencePort);
lcn2->SetSkewReference(lcn1);
}
void TSC_324m::SendVideoTemporalSpatialTradeoffCommand(TPVChannelId aLogicalChannel,
uint8 aTradeoff)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SendVideoTemporalSpatialTradeoffCommand aLogicalChannel=%d, aTradeoff=%d", aLogicalChannel, aTradeoff));
if (iTerminalStatus != PhaseE_Comm)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SendVideoTemporalSpatialTradeoffCommand Ignoring due to invalid state."));
return;
}
CmdMisc(EVideoTemporalSpatialTradeOff, aLogicalChannel, aTradeoff);
}
void TSC_324m::SendVideoTemporalSpatialTradeoffIndication(TPVChannelId aLogicalChannel,
uint8 aTradeoff)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SendVideoTemporalSpatialTradeoffIndication aLogicalChannel=%d, aTradeoff=%d", aLogicalChannel, aTradeoff));
if (iTerminalStatus != PhaseE_Comm)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SendVideoTemporalSpatialTradeoffIndication Ignoring due to invalid state."));
return;
}
IndicationMisc(EVideoTemporalSpatialTradeOffIdc, aLogicalChannel,
aTradeoff);
}
void TSC_324m::SetDatapathLatency(TPVDirection aDir, PVMFPortInterface* aPort,
uint32 aLatency)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetDatapathLatency aDir=%d, aPort=%x, aLatency=%d", aDir, aPort, aLatency));
OSCL_UNUSED_ARG(aDir);
H223LogicalChannel* lcn = OSCL_STATIC_CAST(H223LogicalChannel* , aPort);
if (lcn == NULL)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::SetDatapathLatency WARNING lcn==NULL"));
return;
}
lcn->SetDatapathLatency(aLatency);
}
void TSC_324m::SendSkewIndication(TPVChannelId aLogicalChannel1,
TPVChannelId aLogicalChannel2,
uint16 aSkew)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SendSkewIndication aLogicalChannel1=%d, aLogicalChannel2=%d, aSkew=%d",
aLogicalChannel1, aLogicalChannel2, aSkew));
if (iTerminalStatus != PhaseE_Comm)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SendSkewIndication Ignoring due to invalid state."));
return;
}
Tsc_IdcSkew(aLogicalChannel1, aLogicalChannel2, aSkew);
}
OSCL_EXPORT_REF void TSC_324m::SetMultiplexingDelayMs(uint16 aDelay)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetMultiplexingDelayMs,aDelay=%d", aDelay));
iMultiplexingDelayMs = aDelay;
if (iH223)
iH223->SetMultiplexingDelayMs((uint16)iMultiplexingDelayMs);
}
void TSC_324m::ConfigureSrp(TPVH223Level aLevel)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::ConfigureSrp aLevel=%d", aLevel));
iTscSrpBuffer->Stop();
iSrp->SrpStop();
iSrp->SrpReset();
iSrp->SrpInitL();
iSrp->SetSRPTimeoutValue(iT401);
iSrp->SetNumSRPRetries(iN401);
/* We will enable NSRP for level 0 if the remote terminal signals capability */
if (aLevel == H223_LEVEL0)
{
iSrp->SetCCSRLSduSize(0);
iSrp->UseNSRP(false);
}
else
{
iSrp->UseNSRP(true);
}
if (!iEnableWnsrp || aLevel == H223_LEVEL0)
{
iSrp->DisableWNSRPSupport();
}
H223IncomingChannelPtr incoming_control_channel;
PVMFStatus aStatus = iH223->GetIncomingChannel((TPVChannelId)0,
incoming_control_channel);
if (aStatus == PVMFSuccess)
{
incoming_control_channel->Disconnect();
}
else
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::ConfigureSrp Error - Failed to lookup incoming logical channel %d", 0));
return;
}
H223OutgoingChannelPtr outgoing_control_channel;
aStatus = iH223->GetOutgoingChannel((TPVChannelId)0,
outgoing_control_channel);
if (aStatus == PVMFSuccess)
{
outgoing_control_channel->Disconnect();
}
else
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::ConfigureSrp Error - Failed to lookup outgoing logical channel %d", 0));
return;
}
PVMFPortInterface *port;
port = iSrp->RequestULPort(SRP_INPUT_PORT_TAG);
iTscSrpBuffer->GetLLPort(TSCSRPBUFFER_OUTPUT_PORT_TAG)->Connect(port);
port = iSrp->RequestULPort(SRP_OUTPUT_PORT_TAG);
port->Connect(iTscSrpBuffer->GetLLPort(TSCSRPBUFFER_INPUT_PORT_TAG));
iTscSrpBuffer->GetUpperLayer()->Bind(iH245);
iOutgoingSrpPort = iSrp->RequestLLPort(SRP_INPUT_PORT_TAG);
iIncomingSrpPort = iSrp->RequestLLPort(SRP_OUTPUT_PORT_TAG);
iOutgoingSrpPort->Connect(incoming_control_channel);
// incoming_control_channel->Connect(iOutgoingSrpPort);
iIncomingSrpPort->Connect(outgoing_control_channel);
// outgoing_control_channel->Connect(iIncomingSrpPort);
iTscSrpBuffer->Start();
iSrp->SrpStart();
}
void TSC_324m::StopSrp()
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::StopSrp "));
iSrp->SrpStop();
iTscSrpBuffer->Stop();
H223IncomingChannelPtr incoming_control_channel;
PVMFStatus aStatus = iH223->GetIncomingChannel((TPVChannelId)0,
incoming_control_channel);
if (aStatus == PVMFSuccess)
{
incoming_control_channel->Disconnect();
}
else
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::ConfigureSrp Error - Failed to lookup incoming logical channel %d", 0));
}
H223OutgoingChannelPtr outgoing_control_channel;
aStatus = iH223->GetOutgoingChannel((TPVChannelId)0,
outgoing_control_channel);
if (aStatus == PVMFSuccess)
{
outgoing_control_channel->Disconnect();
}
else
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
(0, "TSC_324m::ConfigureSrp Error - Failed to lookup outgoing logical channel %d", 0));
}
PVMFPortInterface *port = NULL;
port = iSrp->RequestULPort(SRP_INPUT_PORT_TAG);
if (port)
port->Disconnect();
port = iTscSrpBuffer->GetLLPort(TSCSRPBUFFER_OUTPUT_PORT_TAG);
if (port)
port->Disconnect();
port = iSrp->RequestULPort(SRP_OUTPUT_PORT_TAG);
if (port)
port->Disconnect();
port = iTscSrpBuffer->GetLLPort(TSCSRPBUFFER_INPUT_PORT_TAG);
if (port)
port->Disconnect();
iTscSrpBuffer->GetUpperLayer()->UnBind();
if (iOutgoingSrpPort)
iOutgoingSrpPort->Disconnect();
if (iIncomingSrpPort)
iIncomingSrpPort->Disconnect();
}
OSCL_EXPORT_REF void TSC_324m::GetChannelFormatAndCapabilities(TPVDirection dir,
Oscl_Vector<FormatCapabilityInfo, OsclMemAllocator>& formats)
{
iTSCcomponent->GetChannelFormatAndCapabilities(dir, formats);
}
OSCL_EXPORT_REF void TSC_324m::SetLogicalChannelBufferingMs(uint32 aInBufferingMs,
uint32 aOutBufferingMs)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::SetLogicalChannelBufferingMs aInBufferingMs=%d, aOutBufferingMs=%d",
aInBufferingMs, aOutBufferingMs));
iInLogicalChannelBufferingMs = aInBufferingMs;
iOutLogicalChannelBufferingMs = aOutBufferingMs;
}
void TSC_324m::UseWNSRP(bool aUse)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::UseWNSRP %d", aUse));
SetWnsrp(aUse);
PS_MultiplexEntryDescriptor desc = iH223->GetIncomingMuxDescriptor(TSC_WNSRP_MUX_ENTRY_NUMBER);
if (desc &&
desc->size_of_elementList &&
desc->elementList->muxType.index == 0 &&
desc->elementList->muxType.logicalChannelNumber == 0)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m::UseWNSRP Deleting incoming descriptor for WNSRP"));
iH223->RemoveIncomingMuxDescriptor(TSC_WNSRP_MUX_ENTRY_NUMBER);
}
}
void TSC_324m::SetTSC_324mObserver(TSC_324mObserver* aObserver)
{
if (aObserver == NULL)
return;
iTSC_324mObserver = aObserver;
}
PVMFCommandId TSC_324m::QueueCommandL(Tsc324mNodeCommand& aCmd)
{
PVMFCommandId id;
id = iCmdQueue.AddL(aCmd);
//wakeup the AO
RunIfNotReady();
return id;
}
void TSC_324m::CommandComplete(Tsc324mNodeCmdQ& aCmdQ, Tsc324mNodeCommand& aCmd,
PVMFStatus aStatus, OsclAny* aEventData)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
(0, "TSC_324m:CommandComplete Id %d Cmd %d Status %d Context %d Data %d",
aCmd.iId, aCmd.iCmd, aStatus, aCmd.iContext, aEventData));
//create response
PVMFCmdResp resp(aCmd.iId, aCmd.iContext, aStatus, aEventData);
PVMFSessionId session = aCmd.iSession;
//Erase the command from the queue.
aCmdQ.Erase(&aCmd);
//Report completion to the session observer.
ReportCmdCompleteEvent(session, resp);
}
int32 TSC_324m::GetPortTagForLcn(TPVDirection aDir, TPVChannelId aId,
PVCodecType_t aCodecType)
{
if (aDir == INCOMING)
return -aId;
return GetMediaType(aCodecType);
}
PVMFStatus TSC_324m::ThreadLogon()
{
AddToScheduler();
SetState(EPVMFNodeIdle);
return PVMFSuccess;
}
PVMFStatus TSC_324m::ThreadLogoff()
{
SetState(EPVMFNodeCreated);
RemoveFromScheduler();
return PVMFSuccess;
}
void TSC_324m::HandlePortActivity(const PVMFPortActivity& aActivity)
{
OSCL_UNUSED_ARG(aActivity);
}
PVMFCommandId TSC_324m::Flush(PVMFSessionId aSession,
const OsclAny* aContext)
{
OSCL_UNUSED_ARG(aSession);
OSCL_UNUSED_ARG(aContext);
OSCL_LEAVE(PVMFErrNotSupported);
return 0;
}
void TSC_324m::SetMioLatency(int32 aLatency, bool aAudio)
{
iH223->SetMioLatency(aLatency, aAudio);
}
#ifdef MEM_TRACK
void TSC_324m::MemStats()
{
#if !(OSCL_BYPASS_MEMMGT)
OsclAuditCB auditCB;
OsclMemInit(auditCB);
if (auditCB.pAudit)
{
MM_Stats_t* stats = auditCB.pAudit->MM_GetStats("");
if (stats)
{
printf("\n###################Memory Stats Start#################\n");
printf(" numBytes %d\n", stats->numBytes);
printf(" peakNumBytes %d\n", stats->peakNumBytes);
printf(" numAllocs %d\n", stats->numAllocs);
printf(" peakNumAllocs %d\n", stats->peakNumAllocs);
printf(" numAllocFails %d\n", stats->numAllocFails);
printf(" totalNumAllocs %d\n", stats->totalNumAllocs);
printf(" totalNumBytes %d\n", stats->totalNumBytes);
printf("\n###################Memory Stats End###################\n");
}
}
#endif
}
#endif