Home | History | Annotate | Download | only in src 
      1 /* ------------------------------------------------------------------
      2  * Copyright (C) 1998-2009 PacketVideo
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
     13  * express or implied.
     14  * See the License for the specific language governing permissions
     15  * and limitations under the License.
     16  * -------------------------------------------------------------------
     17  */
     18 #include "oscl_base.h"
     19 #include "oscl_mem.h"
     20 #include "osclconfig_compiler_warnings.h"
     21 #include "tscmain.h"
     22 #include "h223types.h"
     23 #include "h223_api.h"
     24 #include "h223.h"
     25 #include "cpvh223multiplex.h"
     26 #include "layer.h"
     27 #include "tsc_eventreceive.h"
     28 #include "tsc_h324m_config.h"
     29 #include "tsc_statemanager.h"
     30 #include "tsc_lc.h"
     31 #include "tsc_blc.h"
     32 #include "tsc_clc.h"
     33 #include "tsc_constants.h"
     34 #include "tsc_mt.h"
     35 #include "tsc_component.h"
     36 #include "tsc_capability.h"
     37 #include "tsc_channelcontrol.h"
     38 #ifdef MEM_TRACK
     39 #include "oscl_mem.h"
     40 #include "oscl_mem_audit.h"
     41 #endif
     42 #define PV_2WAY_TSC_TIMER_ID "PV_2WAY_TSC_TIMER"
     43 #define PV_2WAY_TSC_TIMER_INTERVAL 1 /* 1 second */
     44 
     45 #define PV_2WAY_TSC_NUM_CMD_Q_ELEMENTS 10
     46 #define PV_2WAY_TSC_NUM_PENDING_CMD_Q_ELEMENTS 10
     47 
     48 #define TSC_MAX_CONTROL_CHANNEL_BITRATE_BPS 64000
     49 #define TSC_BIG_UINT32 0XFFFFFFFF
     50 #define TSC_H223_LEVEL_DEFAULT H223_LEVEL2
     51 #define DEFAULT_TCS_RECEIVE_TIMEOUT_SECONDS 20
     52 #define DEFAULT_TCS_LEVEL_SETUP_TIMEOUT_SECONDS 6
     53 #define DEFAULT_RTD_TIMER_SECONDS 7
     54 
     55 
     56 // Default command queue reserve size
     57 #define PVMF_CMD_QUEUE_RESERVE 10
     58 
     59 // Starting value for command IDs
     60 #define PVMF_CMD_ID_START 10000
     61 
     62 // the assumed minimum T401 timer interval for sizing memory pools
     63 #define PV2WAY_TSC_MIN_T401_INCOMING 100
     64 
     65 OSCL_EXPORT_REF TSC_324m::TSC_324m(TPVLoopbackMode aLoopbackMode)
     66         :   TSC(),
     67         OsclActiveObject(OsclActiveObject::EPriorityHigh, "TSC"),
     68         Msd(NULL),
     69         Ce(NULL),
     70         iSrp(NULL),
     71         iH245(NULL),
     72         iH223(NULL),
     73         iVendor(NULL),
     74         iProductNumber(NULL),
     75         iVersionNumber(NULL),
     76         iVendorR(NULL),
     77         iProductNumberR(NULL),
     78         iVersionNumberR(NULL),
     79         iTransmitCaps(NULL),
     80         iSuppInfo(NULL),
     81         iSuppInfoLen(0),
     82         iLoopbackMode(aLoopbackMode),
     83         iTimer(NULL),
     84         iOutgoingSrpPort(NULL),
     85         iIncomingSrpPort(NULL),
     86         iTscSrpBuffer(NULL),
     87         iLogger(NULL),
     88         iTSC_324mObserver(NULL),
     89         iTSCcomponent(NULL),
     90         iTSCblc(iTSCstatemanager),
     91         iTSClc(iTSCstatemanager),
     92         iTSCcapability(iTSCstatemanager),
     93         iComponentRegistry(iTSCstatemanager,
     94                            iTSCcapability,
     95                            iTSClc,
     96                            iTSCblc,
     97                            iTSCclc,
     98                            iTSCmt)
     99 {
    100     iLogger = PVLogger::GetLoggerObject("3g324m.h245user");
    101 
    102     iTSCcomponent = NULL;
    103 
    104     AddToScheduler();
    105 
    106     SetDispatchTable();
    107 
    108     iDisconnectInitiator = EPVT_NONE;
    109     iConnectFailReason = EPVT_Failed;
    110 
    111     iOutgoingSrpPort = NULL;
    112     iIncomingSrpPort = NULL;
    113 
    114     iTscSrpBuffer = NULL;
    115     iCurrentCmdId = 1;
    116     iInitialized = false;
    117     iInitializedComponent = false;
    118     iEnableWnsrp = true;
    119     iCmdQueue.Construct(PVMF_CMD_ID_START, PVMF_CMD_QUEUE_RESERVE);
    120     iPendingCmdQueue.Construct(PVMF_CMD_ID_START, PVMF_CMD_QUEUE_RESERVE);
    121 }
    122 
    123 TSC_324m::~TSC_324m()
    124 {
    125     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    126                     (0, "TSC_324m::~TSC_324m"));
    127     ResetTsc();
    128 }
    129 
    130 void TSC_324m::SetInitialValues()
    131 {
    132     initVarsLocal();
    133     initVarsSession();
    134     iInitialized = true;
    135 }
    136 
    137 void TSC_324m::initVarsLocal()
    138 {
    139     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    140                     (0, "TSC_324m::initVarsLocal"));
    141 
    142     if (iTransmitCaps)
    143     {
    144         OSCL_DEFAULT_FREE(iTransmitCaps);
    145         iTransmitCaps = NULL;
    146     }
    147 
    148 
    149     iSendRme = false;
    150     iCsupSeq = 0;
    151     iRequestMaxMuxPduSize = H223_MAX_DEMUX_PDU_SIZE;
    152 
    153     iPendingCmdQueue.Construct(1, 5);
    154 
    155     iOutgoingPduType = H223_PDU_COMBINED;
    156 
    157     iEndSessionTimeout = DEFAULT_END_SESSION_TIMEOUT;
    158 
    159     iTimerValues.iT101 = iTimerValues.iT103 = iTimerValues.iT104 =
    160                              iTimerValues.iT105 = iTimerValues.iT106 = iTimerValues.iT107 =
    161                                                       iTimerValues.iT108 = iTimerValues.iT109 = TSC_SE_TIMEOUT_DEFAULT;
    162     iT401 = T401_DEFAULT; /* SRP */
    163     iN100 = N100_DEFAULT; /* H245 */
    164     iN401 = N401_DEFAULT; /* SRP */
    165     iCeRetries = iN100; /* Num CE retries left */
    166 
    167     iEnableWnsrp = true;
    168 
    169     iMultiplexingDelayMs = 0;
    170     iInLogicalChannelBufferingMs = 0;
    171     iOutLogicalChannelBufferingMs = 0;
    172 
    173     iTSCstatemanager.InitVarsLocal();
    174     iTSCcapability.InitVarsLocal();
    175     if (iTSCcomponent)
    176     {
    177         iTSCcomponent->InitVarsLocal();
    178     }
    179 }
    180 
    181 void TSC_324m::initVarsSession()
    182 {
    183     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    184                     (0, "TSC_324m::initVarsSession"));
    185     iTerminalStatus = Phase0_Idle;      /* Terminal Status */
    186 
    187 
    188     iDisconnectInitiator = EPVT_NONE;
    189     iConnectFailReason = EPVT_Failed;
    190 
    191     iMaxMuxPduCapabilityR = false;
    192 
    193     /* Terminal ID for vendor identification */
    194     /* Local terminal id */
    195     if (iVendorR)
    196     {
    197         OSCL_DELETE(iVendorR);
    198     }
    199     if (iProductNumberR)
    200     {
    201         OSCL_DEFAULT_FREE(iProductNumberR);
    202     }
    203     if (iVersionNumberR)
    204     {
    205         OSCL_DEFAULT_FREE(iVersionNumberR);
    206     }
    207     iVendorR = NULL;
    208     iProductNumberR = NULL;
    209     iProductNumberLenR = 0;
    210     iVersionNumberR = NULL;
    211     iVersionNumberLenR = 0;
    212 
    213     iH223Level = TSC_H223_LEVEL_DEFAULT;
    214 
    215     iMuxTableUpdateRequired = false;
    216 
    217     if (iSuppInfo)
    218     {
    219         OSCL_DEFAULT_FREE(iSuppInfo);
    220         iSuppInfo = NULL;
    221         iSuppInfoLen = 0;
    222     }
    223 
    224 
    225     iCeRetries = iN100; /* Num CE retries left */
    226 
    227 
    228     /* Initialized RTD values */
    229     iNumRtdRequests = 0;
    230     iRtdMin = TSC_BIG_UINT32;
    231     iRtdMax = 0;
    232     iRtdAve = 0;
    233 
    234     iTSCstatemanager.InitVarsSession();
    235     iTSCmt.InitVarsSession();
    236     iTSCcapability.InitVarsSession();
    237     if (iTSCcomponent)
    238     {
    239         iTSCcomponent->InitVarsSession();
    240     }
    241 }
    242 
    243 void TSC_324m::IgnoreH245Callbacks()
    244 {
    245     if (!iH245)
    246     {
    247         return;
    248     }
    249     iH245->SetObserver(NULL);
    250     Msd->SetObserver(NULL);
    251     Ce->SetObserver(NULL);
    252 }
    253 
    254 void TSC_324m::InitComponent()
    255 {
    256 #ifdef MEM_TRACK
    257     printf("\nMemory Stats before TSC Component Init\n");
    258     MemStats();
    259 #endif
    260     if (!iTSCcomponent)
    261     {
    262         PVInterface *componentInterface;
    263         // QueryInterface sets iTSCcomponent
    264         QueryInterface(0, PVUuidH324ComponentInterface, (PVInterface*&)componentInterface);
    265         if (!iTSCcomponent)
    266         {
    267             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
    268                             (0, "TSC_324m::InitComponent- unable to create component"));
    269             OSCL_LEAVE(PVMFFailure);
    270         }
    271         iTSCcomponent->InitVarsLocal();
    272         iTSCcomponent->InitVarsSession();
    273     }
    274     if (iTSCcomponent &&
    275             !iInitializedComponent &&
    276             iH245 &&
    277             iH223)
    278     {
    279         iTSCcomponent->SetMembers(iH245, iH223, iObserver);
    280         iTSCcomponent->InitTsc();
    281         iInitializedComponent = true;
    282     }
    283 #ifdef MEM_TRACK
    284     printf("\nMemory Stats after TSC Component Init\n");
    285     MemStats();
    286 #endif
    287 }
    288 
    289 TPVStatusCode TSC_324m::InitTsc()
    290 {
    291 #ifdef MEM_TRACK
    292     printf("\nMemory Stats before TSC Init\n");
    293     MemStats();
    294 #endif
    295     int error;
    296     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    297                     (0, "TSC: InitTsc"));
    298 
    299     if (!iInitialized)
    300     {
    301         SetInitialValues();
    302     }
    303 
    304     // Allocate stack elements.
    305     iH245 = OSCL_NEW(H245, ());
    306     iH245->SetObserver(this);
    307 
    308     iSrp = OSCL_NEW(SRP, ());
    309     iSrp->SetObserver(this);
    310 
    311     iH223 = OSCL_NEW(CPVH223Multiplex, (iLoopbackMode));
    312     iH223->SetObserver(this);
    313 
    314 
    315 
    316     iTSClc.SetH245(iH245);
    317     iTSCblc.SetH245(iH245);
    318     iTSCclc.SetH245(iH245);
    319 
    320     InitComponent();
    321 
    322 
    323     iTSCcapability.SetMembers(iTSCcomponent);
    324     iTSCmt.SetMembers(iH245, iH223, iTSCcomponent);
    325     iH223->SetClock(iClock);
    326     iH223->Open();
    327 
    328     // set direct connection to MSD SE
    329     Msd = iH245->GetMSD();
    330     Msd->SetObserver(this);
    331 
    332     // set direct connection to CE SE
    333     Ce = iH245->GetCE();
    334     Ce->SetObserver(this);
    335 
    336     OSCL_TRY(error, iTscSrpBuffer = TscSrpBuffer::NewL());
    337     if (error)
    338     {
    339         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR,
    340                         (0, "TSC: InitTsc, tscsrpbuffer allocation failed", error));
    341     }
    342 
    343     iTimer = OSCL_NEW(OsclTimer<OsclMemAllocator>,
    344                       (PV_2WAY_TSC_TIMER_ID, PV_2WAY_TSC_TIMER_INTERVAL));
    345     //OSCL_TRAP_NEW(iTimer, OsclTimer<OsclMemAllocator>, (PV_2WAY_TSC_TIMER_ID, PV_2WAY_TSC_TIMER_INTERVAL) );
    346     iTimer->SetObserver(this);
    347 
    348 #ifdef MEM_TRACK
    349     printf("\nMemory Stats after TSC Init\n");
    350     MemStats();
    351 #endif
    352 
    353     return EPVT_Success;
    354 }
    355 
    356 TPVStatusCode TSC_324m::ResetTsc()
    357 {
    358     TPVStatusCode ret = EPVT_Success;
    359     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    360                     (0, "TSC: Reset request."));
    361 
    362     if (iTSCcomponent)
    363     {
    364         iTSCcomponent->ResetTsc();
    365         iTSCstatemanager.WriteState(TSC_CE_RECEIVE, NOT_STARTED);
    366         iTSCstatemanager.WriteState(TSC_CE_SEND, NOT_STARTED);
    367         iInitializedComponent = false; // TSC Component
    368     }
    369 
    370     if (iSrp)
    371     {
    372         if (iSrp->RequestULPort(SRP_INPUT_PORT_TAG))
    373             iSrp->RequestULPort(SRP_INPUT_PORT_TAG)->Disconnect();
    374 
    375         if (iSrp->RequestULPort(SRP_OUTPUT_PORT_TAG))
    376             iSrp->RequestULPort(SRP_OUTPUT_PORT_TAG)->Disconnect();
    377 
    378         iSrp->SrpStop();
    379     }
    380 
    381     if (iTscSrpBuffer)
    382     {
    383         iTscSrpBuffer->GetLLPort(TSCSRPBUFFER_INPUT_PORT_TAG)->Disconnect();
    384         iTscSrpBuffer->GetLLPort(TSCSRPBUFFER_OUTPUT_PORT_TAG)->Disconnect();
    385     }
    386 
    387     if (iH245)
    388     {
    389         iH245->UnBind();
    390     }
    391 
    392     if (iIncomingSrpPort)
    393     {
    394         iIncomingSrpPort->Disconnect();
    395         iIncomingSrpPort = NULL;
    396     }
    397 
    398     if (iOutgoingSrpPort)
    399     {
    400         iOutgoingSrpPort->Disconnect();
    401         iOutgoingSrpPort = NULL;
    402     }
    403 
    404     if (iH223)
    405     {
    406         H223IncomingChannelPtr incoming_control_channel;
    407         PVMFStatus aStatus = iH223->GetIncomingChannel((TPVChannelId)0,
    408                              incoming_control_channel);
    409         if (aStatus == PVMFSuccess)
    410         {
    411             incoming_control_channel->Disconnect();
    412         }
    413         else
    414         {
    415             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
    416                             (0, "TSC_324m::ResetTsc Error - Failed to lookup incoming logical channel %d", 0));
    417         }
    418 
    419         H223OutgoingChannelPtr outgoing_control_channel;
    420         aStatus = iH223->GetOutgoingChannel((TPVChannelId)0, outgoing_control_channel);
    421         if (aStatus == PVMFSuccess)
    422         {
    423             outgoing_control_channel->Disconnect();
    424         }
    425         else
    426         {
    427             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
    428                             (0, "TSC_324m::ResetTsc Error - Failed to lookup outgoing logical channel %d", 0));
    429         }
    430     }
    431 
    432     //Shutdown stack elements.
    433 
    434     if (iTransmitCaps)
    435     {
    436         OSCL_DEFAULT_FREE(iTransmitCaps);
    437         iTransmitCaps = NULL;
    438     }
    439 
    440     if (iVendor)
    441     {
    442         delete iVendor;
    443         iVendor = NULL;
    444     }
    445 
    446     if (iVendorR)
    447     {
    448         delete iVendorR;
    449         iVendorR = NULL;
    450     }
    451 
    452     if (iProductNumber)
    453     {
    454         OSCL_DEFAULT_FREE(iProductNumber);
    455         iProductNumber = NULL;
    456     }
    457 
    458     if (iProductNumberR)
    459     {
    460         OSCL_DEFAULT_FREE(iProductNumberR);
    461         iProductNumberR = NULL;
    462     }
    463 
    464     if (iVersionNumber)
    465     {
    466         OSCL_DEFAULT_FREE(iVersionNumber);
    467         iVersionNumber = NULL;
    468     }
    469 
    470     if (iVersionNumberR)
    471     {
    472         OSCL_DEFAULT_FREE(iVersionNumberR);
    473         iVersionNumberR = NULL;
    474     }
    475 
    476 
    477     if (iTimer)
    478     {
    479         iTimer->Clear();
    480         OSCL_DELETE(iTimer);
    481         iTimer = NULL;
    482     }
    483 
    484 
    485     if (iTSCcomponent)
    486     {
    487         OSCL_DELETE(iTSCcomponent);
    488         iTSCcomponent = NULL;
    489     }
    490 
    491 
    492     if (iH223)
    493     {
    494         iH223->Close();
    495         DeallocateH223Mux(iH223);
    496         iH223 = NULL;
    497     }
    498 
    499     if (iTscSrpBuffer)
    500     {
    501         OSCL_DELETE(iTscSrpBuffer);
    502         iTscSrpBuffer = NULL;
    503     }
    504 
    505     if (iSrp)
    506     {
    507         iSrp->SrpReset();
    508         OSCL_DELETE(iSrp);
    509         iSrp = NULL;
    510     }
    511 
    512     if (iH245)
    513     {
    514         OSCL_DELETE(iH245);
    515         iH245 = NULL;
    516     }
    517 
    518     iInitialized = false; //TSC node
    519 
    520     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    521                     (0, "TSC: Reset request - done"));
    522 #ifdef MEM_TRACK
    523     printf("\nMemory Stats after TSC Reset\n");
    524     MemStats();
    525 #endif
    526     return ret;
    527 }
    528 
    529 TPVStatusCode TSC_324m::SetOutgoingBitrate(int32 bitrate)
    530 {
    531     iH223->SetBitrate(bitrate);
    532     return EPVT_Success;
    533 }
    534 
    535 TPVStatusCode TSC_324m::SetTimerRes(uint32 timer_res)
    536 {
    537     return iH223->SetTimerRes(timer_res);
    538 }
    539 
    540 TPVStatusCode TSC_324m::SetTerminalParam(CPVTerminalParam* params)
    541 {
    542     CPVH324MParam* h324params = (CPVH324MParam*)params;
    543 
    544     iSendRme = h324params->iSendRme;
    545     iRequestMaxMuxPduSize = h324params->iRequestMaxMuxPduSize;
    546     iTSCcomponent->SetTerminalParam(*h324params);
    547     iTSCstatemanager.SetTerminalParam(params);
    548     return EPVT_Success;
    549 }
    550 
    551 CPVTerminalParam* TSC_324m::GetTerminalParam()
    552 {
    553     CPVH223MuxParam h223Param;
    554     CPVH324MParam* h324param = new CPVH324MParam();
    555     iTSCcomponent->GetTerminalParam(*h324param);
    556     h324param->iMasterSlave = (TPVMasterSlave)iTSCstatemanager.ReadState(TSC_MSD_DECISION);
    557     h324param->SetH223Param(&h223Param);
    558     return  h324param;
    559 }
    560 
    561 TPVStatusCode
    562 TSC_324m::Connect(uint16 info_len, uint8* info_buf)
    563 {
    564     PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_NOTICE,
    565                     (0, "TSC_324m::Connect"));
    566     TPVStatusCode ret = EPVT_Pending;
    567 
    568     iMuxTableUpdateRequired = false;
    569     iStopCmd = NULL;
    570     iTerminalStatus = Phase0_Idle;
    571 
    572     iTSCmt.ClearVars();
    573 
    574     // moved stuff to component
    575 
    576     if (!iTSCcomponent->Connect1LevelKnown())
    577     {
    578         iH223Level = H223_LEVEL_UNKNOWN;
    579     }
    580     ResetStats();
    581 
    582     iH245->Reset();
    583     iH245->SetTimers(iTimerValues);
    584 
    585 
    586     // set direct connection to MSD SE
    587     Msd = iH245->GetMSD();
    588     Msd->SetObserver(this);
    589 
    590     // set direct connection to CE SE
    591     Ce = iH245->GetCE();
    592     Ce->SetObserver(this);
    593 
    594     if (iSuppInfo)
    595     {
    596         OSCL_DEFAULT_FREE(iSuppInfo);
    597         iSuppInfo = NULL;
    598         iSuppInfoLen = 0;
    599     }
    600 
    601     if (info_len)
    602     {
    603         iSuppInfo = (uint8*)OSCL_DEFAULT_MALLOC(info_len);
    604         iSuppInfoLen = info_len;
    605         oscl_memcpy(iSuppInfo, info_buf, info_len);
    606     }
    607     iTimer->Clear();
    608 
    609     CPVH223MuxParam level_set;
    610 
    611     // Initialize the mux and wait for completion.  Performs level setup
    612     if (iH223Level != H223_LEVEL_UNKNOWN)
    613     {
    614         iH223->SetMultiplexLevel(iH223Level);
    615     }
    616     iH223->SetMultiplexingDelayMs((uint16)iMultiplexingDelayMs);
    617     iH223->SetLogicalChannelBufferingMs(iInLogicalChannelBufferingMs,
    618                                         iOutLogicalChannelBufferingMs);
    619     iH223->SetClock(iClock);
    620 
    621     S_H223LogicalChannelParameters lcnParams;
    622     lcnParams.segmentableFlag = true;
    623     lcnParams.adaptationLayerType.index = 1;
    624     H223ChannelParam in_channel_params(0,
    625                                        &lcnParams,
    626                                        TSC_MAX_CONTROL_CHANNEL_BITRATE_BPS,
    627                                        PV2WAY_TSC_MIN_T401_INCOMING);
    628     H223ChannelParam out_channel_params(0,
    629                                         &lcnParams,
    630                                         TSC_MAX_CONTROL_CHANNEL_BITRATE_BPS,
    631                                         iT401*100);
    632 
    633     iH223->OpenChannel(OUTGOING, 0, &out_channel_params);
    634     iH223->OpenChannel(INCOMING, 0, &in_channel_params);
    635 
    636 
    637     ConfigureSrp(iH223Level);
    638 
    639     // Reset global states (RAN-MS)
    640     iTSCstatemanager.StateInitialize();    // Reset call-setup states
    641 
    642     iTerminalStatus = PhaseD_CSUP;
    643 
    644     iTSCcomponent->Connect2();
    645     return ret;
    646 }
    647 
    648 void TSC_324m::SetClock(PVMFMediaClock* aClock)
    649 {
    650     iClock = aClock;
    651 }
    652 
    653 void TSC_324m::DataReceptionStart()
    654 {
    655     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    656                     (0, "TSC_324m::DataReceptionStart"));
    657     /* Start timer for Level Setup countdown */
    658     int32 levelSetupTimeoutInfo = 0;
    659     if (iTSCcomponent->IsEnabled())
    660     {
    661         levelSetupTimeoutInfo = 1; // Level setup can commence again if it fails the first time
    662     }
    663     iTimer->Request(PV_TSC_LEVEL_SETUP_TIMER_ID, levelSetupTimeoutInfo,
    664                     DEFAULT_TCS_LEVEL_SETUP_TIMEOUT_SECONDS, this);
    665 }
    666 
    667 void TSC_324m::MuxSetupComplete(PVMFStatus status, TPVH223Level level)
    668 {
    669     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    670                     (0, "TSC_324m::MuxSetupComplete status=%d, level=%d",
    671                      status, level));
    672     iTimer->Cancel(PV_TSC_LEVEL_SETUP_TIMER_ID);
    673 
    674     /* Reconfigure SRP if multiplex level 0 is negotiated starting from a higher level */
    675     if (level == H223_LEVEL0 && level != iH223Level)
    676     {
    677         ConfigureSrp(level);
    678     }
    679     iH223Level = level;
    680     if (status == PVMFPending)
    681     {
    682         return;
    683     }
    684     if (status != PVMFSuccess)
    685     {
    686         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    687                         (0, "TSC_324m::MuxSetupComplete Mux setup failed."));
    688         SignalCsupComplete(status);
    689         return;
    690     }
    691 
    692     iTSCcomponent->MuxSetupComplete(status, level);
    693 
    694     OpenSession();
    695     iTimer->Request(PV_TSC_RTD_TIMER_ID, PV_TSC_RTD_TIMER_ID, DEFAULT_RTD_TIMER_SECONDS, this, false);
    696     /* Start timer for TCS countdown */
    697     if (iTSCstatemanager.ReadState(TSC_CE_RECEIVE) != COMPLETE)
    698     {
    699         iTimer->Request(PV_TSC_TCS_RECEIVE_TIMER_ID, PV_TSC_TCS_RECEIVE_TIMER_ID,
    700                         DEFAULT_TCS_RECEIVE_TIMEOUT_SECONDS, this);
    701     }
    702     else
    703     {
    704         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    705                         (0, "TSC_324m::MuxSetupComplete TCS received before MuxSetupComplete."));
    706     }
    707 }
    708 
    709 void TSC_324m::MuxCloseComplete()
    710 {
    711     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    712                     (0, "TSC_324m: Mux close complete - status(%d).", iTerminalStatus));
    713 
    714     /* All logical channels closed */
    715     iTerminalStatus = PhaseF_End;
    716 
    717     iH245->Reset();
    718     // set direct connection to MSD SE
    719     Msd = iH245->GetMSD();
    720     Msd->SetObserver(this);
    721 
    722     // set direct connection to CE SE
    723     Ce = iH245->GetCE();
    724     Ce->SetObserver(this);
    725 
    726     iH223->CloseChannel(OUTGOING, 0);
    727     iH223->CloseChannel(INCOMING, 0);
    728 }
    729 
    730 void TSC_324m::MuxErrorOccurred(TPVDirection direction,
    731                                 TPVMuxComponent component,
    732                                 PVMFStatus error,
    733                                 uint8* info,
    734                                 uint info_len)
    735 {
    736     OSCL_UNUSED_ARG(info_len);
    737     OSCL_UNUSED_ARG(info);
    738     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    739                     (0, "TSC_324m::MuxErrorOccurred - direction(%d), component(%d), error(%d)",
    740                      direction, component, error));
    741     TPVChannelId id = CHANNEL_ID_UNKNOWN;
    742     if (info && component == PV_MUX_COMPONENT_LOGICAL_CHANNEL)
    743     {
    744         id = *((TPVChannelId*)info);
    745 
    746         if (!iTSCcomponent->HasOlc(direction, id))
    747         {
    748             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    749                             (0, "TSC_324m::MuxErrorOccurred - Failed to lookup channel info, lcn=%d",
    750                              id));
    751             return;
    752         }
    753         if (direction == INCOMING)
    754         {
    755             H223IncomingChannelPtr incoming_lcn;
    756             PVMFStatus aStatus = iH223->GetIncomingChannel(id, incoming_lcn);
    757             if (aStatus == PVMFSuccess)
    758             {
    759                 if (!incoming_lcn->IsConnected())
    760                 {
    761                     RequestFrameUpdate(incoming_lcn);
    762                 }
    763             }
    764             else
    765             {
    766                 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    767                                 (0, "TSC_324m::MuxErrorOccurred - Failed to lookup incoming channel, lcn=%d",
    768                                  id));
    769                 return;
    770             }
    771         }
    772     }
    773 
    774     PVMFAsyncEvent aEvent(PVMFInfoEvent, error, this, NULL);
    775     uint8* buf = aEvent.GetLocalBuffer();
    776     buf[0] = (uint8)PV_H324COMPONENT_H223;
    777     buf[1] = (uint8)component;
    778     buf[2] = (uint8)direction;
    779     if (component == PV_MUX_COMPONENT_LOGICAL_CHANNEL)
    780     {
    781         *((TPVChannelId*)(buf + 4)) = id;
    782     }
    783     //iInfoObserver->HandleNodeInformationalEvent(aEvent);
    784 }
    785 
    786 void TSC_324m::SkewDetected(TPVChannelId lcn1, TPVChannelId lcn2, uint32 skew)
    787 {
    788     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    789                     (0, "TSC_324m::SkewDetected - lcn1=%d, lcn2=%d, skew=%d",
    790                      lcn1, lcn2, skew));
    791     Tsc_IdcSkew(lcn1, lcn2, (uint16)skew);
    792 }
    793 
    794 void TSC_324m::LcnDataDetected(TPVChannelId lcn)
    795 {
    796     iTSCcomponent->LcnDataDetected(lcn);
    797 }
    798 
    799 void TSC_324m::ReceivedFormatSpecificInfo(TPVChannelId channel_id,
    800         uint8* fsi,
    801         uint32 fsi_len)
    802 {
    803     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    804                     (0, "TSC_324m::ReceivedFormatSpecificInfo lcn=%d, len=%d",
    805                      channel_id, fsi_len));
    806     iTSCcomponent->ReceivedFormatSpecificInfo(channel_id, fsi, fsi_len);
    807 }
    808 
    809 TPVStatusCode TSC_324m::Disconnect()
    810 {
    811     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    812                     (0, "TSC: Disconnect request."));
    813     //LogStats(OUTGOING);
    814     //LogStats(INCOMING);
    815 
    816     TPVStatusCode ret = EPVT_Success;
    817 
    818     iDisconnectInitiator |= EPVT_LOCAL;
    819 
    820     iTimer->Clear();
    821 
    822     StopSrp();
    823     iH223->Stop();
    824 
    825     MuxCloseComplete();
    826     while (iIncomingChannels.size())
    827     {
    828         H223ChannelParam* param = iIncomingChannels.back();
    829         iIncomingChannels.pop_back();
    830         delete param;
    831     }
    832 
    833     initVarsSession();
    834     return ret;
    835 }
    836 
    837 TPVStatusCode TSC_324m::Abort()
    838 {
    839 //  iMutex->Lock();
    840     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    841                     (0, "TSC: Abort."));
    842     //LogStats(OUTGOING);
    843     //LogStats(INCOMING);
    844     TPVStatusCode ret = EPVT_Success;
    845 
    846     iDisconnectInitiator |= EPVT_LOCAL;
    847 
    848     if (iSuppInfo)
    849     {
    850         OSCL_DEFAULT_FREE(iSuppInfo);
    851         iSuppInfo = NULL;
    852         iSuppInfoLen = 0;
    853         iTimer->Clear();
    854     }
    855 
    856     SessionClose_Comm();
    857 
    858     iSrp->SrpStop();
    859 
    860     /* All logical channels closed */
    861     iTerminalStatus = PhaseF_End;
    862 
    863     iH245->Reset();
    864     // set direct connection to MSD SE
    865     Msd = iH245->GetMSD();
    866     Msd->SetObserver(this);
    867 
    868     // set direct connection to CE SE
    869     Ce = iH245->GetCE();
    870     Ce->SetObserver(this);
    871 
    872     initVarsSession();
    873 
    874 //  iMutex->Unlock();
    875     return ret;
    876 }
    877 
    878 /* Handle control events depending on state */
    879 /*
    880         Phase0_Idle = 1 ,
    881         PhaseA          ,
    882         PhaseB          ,
    883         PhaseC          ,
    884         PhaseD_CSUP     ,  // Call Setup
    885         PhaseE_Comm     ,  // Ongoing Communication
    886         PhaseF_Clc      ,  // Closing all outgoing LCNs
    887         PhaseF_End      ,  // End of Session
    888         PhaseG_Dis
    889 */
    890 void TSC_324m::Handle(PS_ControlMsgHeader msg)
    891 {
    892     uint32            EventNo;                        /* EventNo         */
    893     uint32            Cnt;                            /* Counter         */
    894     DISPATCH_PTR func_ptr = NULL;
    895     bool handled = false;
    896 
    897 //  iMutex->Lock();
    898 
    899     /* Event Receive; a non blocking call */
    900     EventNo = Tsc_EventReceive(msg);
    901 
    902     for (Cnt = 0; iDispatchTable[Cnt].Module != NULL; Cnt++)
    903     {
    904         if (iDispatchTable[Cnt].Status == iTerminalStatus && iDispatchTable[Cnt].Event == EventNo)
    905         {
    906             func_ptr = iDispatchTable[Cnt].Module;
    907             handled = true;
    908             (this->*func_ptr)(msg);
    909             break;
    910         }
    911     }
    912     if (!handled)
    913     {
    914         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    915                         (0, "TSC_324m: Failed to handle control message - state(%d), event no(%d).",
    916                          iTerminalStatus, EventNo));
    917     }
    918 
    919     return;
    920 }
    921 
    922 TPVStatusCode TSC_324m::RequestFrameUpdate(PVMFPortInterface* port)
    923 {
    924     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    925                     (0, "TSC_324m::RequestFrameUpdate"));
    926 
    927     if (iTSCstatemanager.ReadState(TSC_CE_SEND) == NOT_STARTED)
    928     {
    929         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    930                         (0, "TSC_324m::RequestFrameUpdate ERROR  - TCS not yet requested, tcs state=NOT_STARTED"));
    931         return EPVT_ErrorInvalidState;
    932     }
    933 
    934     H223IncomingChannel *channel = OSCL_STATIC_CAST(H223IncomingChannel *, port);
    935     if (channel == NULL)
    936     {
    937         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    938                         (0, "TSC: RequestFrameUpdate - Null port"));
    939         return EPVT_Failed;
    940     }
    941     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    942                     (0, "TSC_324m::RequestFrameUpdate lcn=%d", channel->GetLogicalChannelNumber()));
    943     OlcParam* param = iTSCcomponent->FindOlcGivenChannel(INCOMING, channel->GetLogicalChannelNumber());
    944     if (param == NULL)
    945     {
    946         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    947                         (0, "TSC_324m: RequestFrameUpdate - Failed to lookup channel param"));
    948         return EPVT_Failed;
    949     }
    950     if (param->GetState() != OLC_ESTABLISHED)
    951     {
    952         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    953                         (0, "TSC_324m: RequestFrameUpdate - Channel not in established state.  Not sending request."));
    954         return EPVT_Failed;
    955     }
    956 
    957     CmdMisc(EVideoFastUpdatePicture, channel->GetLogicalChannelNumber());
    958     return EPVT_Success;
    959 }
    960 
    961 TPVStatusCode TSC_324m::RequestMaxMuxPduSize(unsigned aPduSize)
    962 {
    963     if ((iTerminalStatus != PhaseD_CSUP) && (iTerminalStatus != PhaseE_Comm))
    964     {
    965         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    966                         (0, "TSC_324m: ERROR - RequestMaxMuxPduSize - invalid state(%d)",
    967                          iTerminalStatus));
    968         return EPVT_ErrorInvalidState;
    969     }
    970     CmdMisc(EMaxH223MUXPDUsize, CHANNEL_ID_UNKNOWN&0xFFFF, aPduSize);
    971     return EPVT_Success;
    972 }
    973 
    974 OSCL_EXPORT_REF TPVStatusCode TSC_324m::SetTerminalType(uint8 aTType)
    975 {
    976     if (Msd)
    977     {
    978         Msd->SetTerminalType(aTType);
    979         return EPVT_Success;
    980     }
    981     else
    982     {
    983         return EPVT_Failed;
    984     }
    985 }
    986 
    987 OSCL_EXPORT_REF void TSC_324m::SetEndSessionTimeout(uint32 timeout)
    988 {
    989     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    990                     (0, "TSC_324m::SetEndSessionTimeout timeout(%d)", timeout));
    991     iEndSessionTimeout = timeout;
    992     if (iStopCmd != 0)
    993     {
    994         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
    995                         (0, "TSC_324m::SetEndSessionTimeout Already disconnectiing",
    996                          timeout));
    997     }
    998 }
    999 
   1000 OSCL_EXPORT_REF void TSC_324m::SetTimerCounter(TPVH324TimerCounter aTimerCounter,
   1001         uint8 aSeries, uint32 aSeriesOffset, uint32 aValue)
   1002 {
   1003     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1004                     (0, "TSC_324m::SetTimerCounter timer/counter(%d), series(%d), offset(%d), value(%d)",
   1005                      aTimerCounter, aSeries, aSeriesOffset, aValue));
   1006     if (aTimerCounter == EH324Timer)
   1007     {
   1008         switch (aSeries)
   1009         {
   1010             case 1:
   1011             {
   1012                 switch (aSeriesOffset)
   1013                 {
   1014                     case 1:
   1015                         iTimerValues.iT101 = aValue;
   1016                         break;
   1017                     case 3:
   1018                         iTimerValues.iT103 = aValue;
   1019                         break;
   1020                     case 4:
   1021                         iTimerValues.iT104 = aValue;
   1022                         break;
   1023                     case 5:
   1024                         iTimerValues.iT105 = aValue;
   1025                         break;
   1026                     case 6:
   1027                         iTimerValues.iT106 = aValue;
   1028                         break;
   1029                     case 7:
   1030                         iTimerValues.iT107 = aValue;
   1031                         break;
   1032                     case 8:
   1033                         iTimerValues.iT108 = aValue;
   1034                         break;
   1035                     case 9:
   1036                         iTimerValues.iT109 = aValue;
   1037                         break;
   1038                     default:
   1039                         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1040                                         (0, "TSC_324m::SetTimerCounter Error - Offset not supported for series"));
   1041                 }
   1042             }
   1043             break;
   1044             case 4:
   1045             {
   1046                 switch (aSeriesOffset)
   1047                 {
   1048                     case 1:
   1049                         iT401 = aValue;
   1050                         break;
   1051                     default:
   1052                         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1053                                         (0, "TSC_324m::SetTimerCounter Error - Offset not supported for series"));
   1054                 }
   1055             }
   1056             break;
   1057             default:
   1058                 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1059                                 (0, "TSC_324m::SetTimerCounter Error - Series not supported"));
   1060         }
   1061     }
   1062     else if (aTimerCounter == EH324Counter)
   1063     {
   1064         switch (aSeries)
   1065         {
   1066             case 1:
   1067             {
   1068                 switch (aSeriesOffset)
   1069                 {
   1070                     case 0:
   1071                         iN100 = aValue;
   1072                         iTSCstatemanager.SetN100(iN100);
   1073                         break;
   1074                     default:
   1075                         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1076                                         (0, "TSC_324m::SetTimerCounter Error - Offset not supported for series"));
   1077                 }
   1078             }
   1079             break;
   1080             case 4:
   1081             {
   1082                 switch (aSeriesOffset)
   1083                 {
   1084                     case 1:
   1085                         iN401 = aValue;
   1086                         break;
   1087                     default:
   1088                         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1089                                         (0, "TSC_324m::SetTimerCounter Error - Offset not supported for series"));
   1090                 }
   1091             }
   1092             break;
   1093             default:
   1094                 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1095                                 (0, "TSC_324m::SetTimerCounter Error - Series not supported"));
   1096         }
   1097     }
   1098 }
   1099 
   1100 OSCL_EXPORT_REF void TSC_324m::SetVideoResolutions(TPVDirection dir,
   1101         Oscl_Vector<PVMFVideoResolutionRange, OsclMemAllocator>& resolutions)
   1102 {
   1103     iTSCcapability.SetVideoResolutions(dir, resolutions);
   1104 }
   1105 
   1106 void TSC_324m::SetDispatchTable()
   1107 {
   1108     const uint16 sizeofDispatchTable = 56;
   1109     S_DispatchTable     aDispatchTable[sizeofDispatchTable] =
   1110     {
   1111         /* ----------------------------------------- */
   1112         /* ---------- CALL SETUP EVENTS ------------ */
   1113         /* ----------------------------------------- */
   1114         { OSCL_FUNCTION_PTR(TSC_324m::Status04Event22)   ,  PhaseD_CSUP  ,  22 }, //E_PtvId_Mt_Trf_Idc
   1115         { OSCL_FUNCTION_PTR(TSC_324m::Status04Event23)   ,  PhaseD_CSUP  ,  23 }, //E_PtvId_Mt_Trf_Cfm
   1116         { OSCL_FUNCTION_PTR(TSC_324m::Status04Event24)   ,  PhaseD_CSUP  ,  24 }, //E_PtvId_Mt_Rjt_Idc
   1117         { OSCL_FUNCTION_PTR(TSC_324m::ModeRequestIndication)   ,  PhaseD_CSUP  ,  28 }, //E_PtvId_Mr_Trf_Idc
   1118         { OSCL_FUNCTION_PTR(TSC_324m::EndSessionRecv)    ,  PhaseD_CSUP  ,  37 }, //E_PtvId_Cmd_Es_Cfm
   1119         { OSCL_FUNCTION_PTR(TSC_324m::VendorIdRecv)      ,  PhaseD_CSUP,    56},
   1120         { OSCL_FUNCTION_PTR(TSC_324m::UserInputIndicationRecv), PhaseD_CSUP, 57}, //E_PtvId_Idc_Ui_Cfm
   1121         { OSCL_FUNCTION_PTR(TSC_324m::LcEtbIdc)          ,  PhaseD_CSUP  ,   9 }, //E_PtvId_Lc_Etb_Idc
   1122         { OSCL_FUNCTION_PTR(TSC_324m::LcRlsIdc)          ,  PhaseD_CSUP  ,  11 }, //E_PtvId_Lc_Rls_Idc
   1123         { OSCL_FUNCTION_PTR(TSC_324m::BlcEtbIdc)          ,  PhaseD_CSUP  ,   14 }, //E_PtvId_Lc_Etb_Idc
   1124         { OSCL_FUNCTION_PTR(TSC_324m::BlcRlsIdc)          ,  PhaseD_CSUP  ,  16 }, //E_PtvId_Lc_Rls_Idc
   1125         { OSCL_FUNCTION_PTR(TSC_324m::FunctionNotSupportedIndicationReceived)   ,  PhaseD_CSUP  ,  49}, //E_PtvId_Idc_Fns_Cfm
   1126         { OSCL_FUNCTION_PTR(TSC_324m::FlowControlCommandReceived)   ,  PhaseD_CSUP  ,  53 }, //E_PtvId_Cmd_Fc
   1127         { OSCL_FUNCTION_PTR(TSC_324m::SendTerminalCapabilitySet)   ,  PhaseD_CSUP  ,  52 }, //E_PtvId_Cmd_Stcs_Cfm
   1128         { OSCL_FUNCTION_PTR(TSC_324m::MiscCmdRecv)       ,  PhaseD_CSUP  ,  54 }, //E_PtvId_Cmd_Mscl_Cfm
   1129         { OSCL_FUNCTION_PTR(TSC_324m::MiscIndicationRecv), PhaseD_CSUP, 58}, //E_PtvId_Idc_Mscl_Cfm
   1130         { OSCL_FUNCTION_PTR(TSC_324m::SkewIndicationRecv), PhaseD_CSUP, 59}, //E_PtvId_Idc_H223skw_Cfm
   1131         { OSCL_FUNCTION_PTR(TSC_324m::FlowControlIndicationReceived)   ,  PhaseD_CSUP  ,  60 }, //E_PtvId_Cmd_Fc
   1132 //      { InternalError_CSUP,  PhaseD_CSUP  ,  38 }, //H245_INTERNAL_ERROR
   1133         /* ----------------------------------------- */
   1134         /* --------- ONGOING COMM EVENTS ----------- */
   1135         /* ----------------------------------------- */
   1136         { OSCL_FUNCTION_PTR(TSC_324m::LcEtbIdc)          ,  PhaseE_Comm  ,   9 }, //E_PtvId_Lc_Etb_Idc
   1137         { OSCL_FUNCTION_PTR(TSC_324m::LcRlsIdc)          ,  PhaseE_Comm  ,  11 }, //E_PtvId_Lc_Rls_Idc
   1138         { OSCL_FUNCTION_PTR(TSC_324m::LcEtbCfm)          ,  PhaseE_Comm  ,  10 }, //E_PtvId_Lc_Etb_Cfm
   1139         { OSCL_FUNCTION_PTR(TSC_324m::LcRlsCfm)          ,  PhaseE_Comm  ,  12 }, //E_PtvId_Lc_Rls_Cfm
   1140         { OSCL_FUNCTION_PTR(TSC_324m::LcErrIdc)          ,  PhaseE_Comm  ,  13 }, //E_PtvId_Lc_Err_Idc
   1141         { OSCL_FUNCTION_PTR(TSC_324m::BlcEtbIdc)         ,  PhaseE_Comm  ,  14 }, //E_PtvId_Blc_Etb_Idc
   1142         { OSCL_FUNCTION_PTR(TSC_324m::BlcEtbCfm)         ,  PhaseE_Comm  ,  15 }, //E_PtvId_Blc_Etb_Cfm
   1143         { OSCL_FUNCTION_PTR(TSC_324m::BlcEtbCfm2)        ,  PhaseE_Comm  ,  50 }, //E_PtvId_Blc_Etb_Cfm2
   1144         { OSCL_FUNCTION_PTR(TSC_324m::BlcErrIdc)         ,  PhaseE_Comm  ,  18 }, //E_PtvId_Blc_Err_Idc
   1145         { OSCL_FUNCTION_PTR(TSC_324m::BlcRlsIdc)         ,  PhaseE_Comm  ,  16 }, //E_PtvId_Blc_Rls_Idc
   1146         { OSCL_FUNCTION_PTR(TSC_324m::BlcRlsCfm)         ,  PhaseE_Comm  ,  17 }, //E_PtvId_Blc_Rls_Cfm
   1147         { OSCL_FUNCTION_PTR(TSC_324m::Status08Event19)   ,  PhaseE_Comm  ,  19 }, //E_PtvId_Clc_Cls_Idc
   1148         { OSCL_FUNCTION_PTR(TSC_324m::Status08Event20)   ,  PhaseE_Comm  ,  20 }, //E_PtvId_Clc_Cls_Cfm
   1149         { OSCL_FUNCTION_PTR(TSC_324m::Status08Event21)   ,  PhaseE_Comm  ,  21 }, //E_PtvId_Clc_Rjt_Idc
   1150         { OSCL_FUNCTION_PTR(TSC_324m::Status04Event22)   ,  PhaseE_Comm  ,  22 }, //E_PtvId_Mt_Trf_Idc
   1151         { OSCL_FUNCTION_PTR(TSC_324m::Status04Event23)   ,  PhaseE_Comm  ,  23 }, //E_PtvId_Mt_Trf_Cfm
   1152         { OSCL_FUNCTION_PTR(TSC_324m::Status04Event24)   ,  PhaseE_Comm  ,  24 }, //E_PtvId_Mt_Rjt_Idc
   1153         { OSCL_FUNCTION_PTR(TSC_324m::Status08Event25)   ,  PhaseE_Comm  ,  25 }, //E_PtvId_Rme_Send_Idc
   1154         { OSCL_FUNCTION_PTR(TSC_324m::Status08Event26)   ,  PhaseE_Comm  ,  26 }, //E_PtvId_Rme_Send_Cfm
   1155         { OSCL_FUNCTION_PTR(TSC_324m::Status08Event27)   ,  PhaseE_Comm  ,  27 }, //E_PtvId_Rme_Rjt_Idc
   1156         { OSCL_FUNCTION_PTR(TSC_324m::ModeRequestIndication)   ,  PhaseE_Comm  ,  28 }, //E_PtvId_Mr_Trf_Idc
   1157         { OSCL_FUNCTION_PTR(TSC_324m::Status08Event29)   ,  PhaseE_Comm  ,  29 }, //E_PtvId_Mr_Trf_Cfm
   1158         { OSCL_FUNCTION_PTR(TSC_324m::Status08Event30)   ,  PhaseE_Comm  ,  30 }, //E_PtvId_Mr_Rjt_Idc
   1159         { OSCL_FUNCTION_PTR(TSC_324m::Status08Event31)   ,  PhaseE_Comm  ,  31 }, //E_PtvId_Rtd_Trf_Cfm
   1160         { OSCL_FUNCTION_PTR(TSC_324m::Status08Event32)   ,  PhaseE_Comm  ,  32 }, //E_PtvId_Rtd_Exp_Idc
   1161         { OSCL_FUNCTION_PTR(TSC_324m::FunctionNotSupportedIndicationReceived)   ,  PhaseE_Comm ,  49}, //E_PtvId_Idc_Fns_Cfm
   1162         { OSCL_FUNCTION_PTR(TSC_324m::SendTerminalCapabilitySet)   ,  PhaseE_Comm  ,  52 }, //E_PtvId_Cmd_Stcs_Cfm
   1163         { OSCL_FUNCTION_PTR(TSC_324m::FlowControlCommandReceived)   ,  PhaseE_Comm  ,  53 }, //E_PtvId_Cmd_Fc_Cfm
   1164         { OSCL_FUNCTION_PTR(TSC_324m::MiscCmdRecv)       ,  PhaseE_Comm  ,  54 }, //E_PtvId_Cmd_Mscl_Cfm
   1165         { OSCL_FUNCTION_PTR(TSC_324m::Status08Event55)   ,  PhaseE_Comm  ,  55 }, //E_PtvId_Cmd_Hmr_Cfm
   1166         { OSCL_FUNCTION_PTR(TSC_324m::EndSessionRecv)    ,  PhaseE_Comm  ,  37 }, //E_PtvId_Cmd_Es_Cfm
   1167         { OSCL_FUNCTION_PTR(TSC_324m::VendorIdRecv)      ,  PhaseE_Comm  ,  56},
   1168         { OSCL_FUNCTION_PTR(TSC_324m::UserInputIndicationRecv), PhaseE_Comm, 57}, //E_PtvId_Idc_Ui_Cfm
   1169         { OSCL_FUNCTION_PTR(TSC_324m::MiscIndicationRecv), PhaseE_Comm, 58}, //E_PtvId_Idc_Mscl_Cfm
   1170         { OSCL_FUNCTION_PTR(TSC_324m::SkewIndicationRecv), PhaseE_Comm, 59}, //E_PtvId_Idc_H223skw_Cfm
   1171         { OSCL_FUNCTION_PTR(TSC_324m::FlowControlIndicationReceived)   ,  PhaseE_Comm,  60 }, //E_PtvId_Cmd_Fc
   1172         /* ----------------------------------------- */
   1173         /* --------- CLOSE and END EVENTS ---------- */
   1174         /* ----------------------------------------- */
   1175         { OSCL_FUNCTION_PTR(TSC_324m::EndSessionRecv)    ,  PhaseF_End   ,  37 }, //E_PtvId_Cmd_Es_Cfm
   1176 
   1177         { NULL                  ,  0            ,   0 }
   1178     };
   1179 
   1180     for (int n = 0; n < sizeofDispatchTable; n++)
   1181     {
   1182         iDispatchTable[n] = aDispatchTable[n];
   1183     }
   1184 }
   1185 
   1186 OSCL_EXPORT_REF TPVStatusCode TSC_324m::SetVendorIdInfo(TPVH245Vendor* vendor,
   1187         const uint8* pn,
   1188         uint16 pn_len,
   1189         const uint8* vn,
   1190         uint16 vn_len)
   1191 {
   1192     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1193                     (0, "TSC_324m::SetVendorIdInfo vendor(%x), pn_len(%d), vn_len(%d)", vendor, pn_len, vn_len));
   1194     if (pn && pn_len && (pn[pn_len-1] == '\0'))
   1195     {
   1196         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1197                         (0, "TSC_324m::SetVendorIdInfo pn(%s)", pn));
   1198     }
   1199     if (vn && vn_len && (vn[vn_len-1] == '\0'))
   1200     {
   1201         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1202                         (0, "TSC_324m::SetVendorIdInfo vn(%s)", vn));
   1203     }
   1204 
   1205     if (iVendor)
   1206     {
   1207         OSCL_DELETE(iVendor);
   1208         iVendor = NULL;
   1209     }
   1210     if (iProductNumber)
   1211     {
   1212         OSCL_DEFAULT_FREE(iProductNumber);
   1213         iProductNumber = NULL;
   1214     }
   1215     if (iVersionNumber)
   1216     {
   1217         OSCL_DEFAULT_FREE(iVersionNumber);
   1218         iVersionNumber = NULL;
   1219     }
   1220     iProductNumberLen = pn_len;
   1221     iVersionNumberLen = vn_len;
   1222 
   1223     if (vendor)
   1224     {
   1225         iVendor = vendor->Copy();
   1226     }
   1227 
   1228     if (iProductNumberLen)
   1229     {
   1230         iProductNumber = (uint8*)OSCL_DEFAULT_MALLOC(iProductNumberLen);
   1231         oscl_memcpy(iProductNumber, pn, iProductNumberLen);
   1232     }
   1233 
   1234     if (iVersionNumberLen)
   1235     {
   1236         iVersionNumber = (uint8*)OSCL_DEFAULT_MALLOC(iVersionNumberLen);
   1237         oscl_memcpy(iVersionNumber, vn, iVersionNumberLen);
   1238     }
   1239     return EPVT_Success;
   1240 }
   1241 
   1242 OSCL_EXPORT_REF TSC* Allocate324mTSC(TPVLoopbackMode aLoopbackMode)
   1243 {
   1244     return OSCL_NEW(TSC_324m, (aLoopbackMode));
   1245 }
   1246 
   1247 OSCL_EXPORT_REF void Deallocate324mTSC(TSC* tsc)
   1248 {
   1249     TSC_324m* tsc_324m = (TSC_324m*)tsc;
   1250     OSCL_DELETE(tsc_324m);
   1251 }
   1252 
   1253 
   1254 void TSC_324m::TimeoutOccurred(int32 timerID, int32 timeoutInfo)
   1255 {
   1256     OSCL_UNUSED_ARG(timeoutInfo);
   1257     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1258                     (0, "TSC_324m::TimeoutOccurred"));
   1259 
   1260     if (timerID == PV_TSC_RTD_TIMER_ID)
   1261     {
   1262         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1263                         (0, "TSC_324m::TimeoutOccurred - Sending RTD"));
   1264         iTscSrpBuffer->EnableBuffering(false);
   1265         RtdTrfReq();
   1266     }
   1267     else if (timerID == PV_TSC_LEVEL_SETUP_TIMER_ID)
   1268     {
   1269         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1270                         (0, "TSC_324m::TimeoutOccurred Level setup timeout out, timeoutInfo=%d",
   1271                          timeoutInfo));
   1272         if (!timeoutInfo)
   1273         {
   1274             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1275                             (0, "TSC_324m::TimeoutOccurred Level Setup Failed."));
   1276             SignalCsupComplete(PVMFErrTimeout);
   1277         }
   1278         else
   1279         {
   1280             /* We timed out waiting for TCS. */
   1281             iTSCcomponent->Timeout();
   1282             /* Start timer to receive TCS */
   1283             iTimer->Request(PV_TSC_TCS_RECEIVE_TIMER_ID, PV_TSC_TCS_RECEIVE_TIMER_ID,
   1284                             DEFAULT_TCS_RECEIVE_TIMEOUT_SECONDS, this);
   1285             iH223->EnableStuffing(true);
   1286             iH223->SetInterleavingMultiplexFlags(0, NULL);
   1287             iH223->SetMuxLevel(TSC_H223_LEVEL_DEFAULT);
   1288             /* Start timer to receive TCS */
   1289             iTimer->Request(PV_TSC_LEVEL_SETUP_TIMER_ID, 0,
   1290                             DEFAULT_TCS_LEVEL_SETUP_TIMEOUT_SECONDS, this);
   1291         }
   1292     }
   1293     else if (timerID == PV_TSC_TCS_RECEIVE_TIMER_ID)
   1294     {
   1295         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1296                         (0, "TSC_324m::TimeoutOccurred Timed out on TCS receive.  Connect failed."));
   1297         SignalCsupComplete(PVMFErrTimeout);
   1298     }
   1299     else
   1300     {
   1301         iTSCcomponent->TimeoutOccurred(timerID, timeoutInfo);
   1302     }
   1303 }
   1304 
   1305 
   1306 void TSC_324m::ResetStats()
   1307 {
   1308     iH223->ResetStats();
   1309 }
   1310 void TSC_324m::LogStats(TPVDirection dir)
   1311 {
   1312     if (iH223)
   1313         iH223->LogStats(dir);
   1314 }
   1315 
   1316 // Node virtuals
   1317 // Node virtuals
   1318 // Sync requests that will NOT trigger callback events
   1319 
   1320 OSCL_EXPORT_REF  PVMFStatus TSC_324m::GetCapability(PVMFNodeCapability& aNodeCapability)
   1321 {
   1322     aNodeCapability.iCanSupportMultipleInputPorts = true;
   1323     aNodeCapability.iCanSupportMultipleOutputPorts = true;
   1324     aNodeCapability.iHasMaxNumberOfPorts = true;
   1325     aNodeCapability.iMaxNumberOfPorts = 5;
   1326     aNodeCapability.iInputFormatCapability.push_back(PVMF_MIME_H223);
   1327     aNodeCapability.iInputFormatCapability.push_back(PVMF_MIME_M4V);
   1328     aNodeCapability.iInputFormatCapability.push_back(PVMF_MIME_H2631998);
   1329     aNodeCapability.iInputFormatCapability.push_back(PVMF_MIME_H2632000);
   1330     aNodeCapability.iOutputFormatCapability.push_back(PVMF_MIME_H223);
   1331     aNodeCapability.iOutputFormatCapability.push_back(PVMF_MIME_M4V);
   1332     aNodeCapability.iOutputFormatCapability.push_back(PVMF_MIME_H2631998);
   1333     aNodeCapability.iOutputFormatCapability.push_back(PVMF_MIME_H2632000);
   1334     return PVMFSuccess;
   1335 }
   1336 
   1337 OSCL_EXPORT_REF  PVMFCommandId TSC_324m::Init(PVMFSessionId aSession, const OsclAny* aContext)
   1338 {
   1339     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1340                     (0, "TSC_324m::Init(%x)", aContext));
   1341 
   1342     if (iInterfaceState != EPVMFNodeIdle)
   1343     {
   1344         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
   1345                         (0, "TSC_324m::Init Invalid state(%d)", iInterfaceState));
   1346         OSCL_LEAVE(PVMFErrInvalidState);
   1347     }
   1348     // Add command to queue
   1349     Tsc324mNodeCommand cmd;
   1350     cmd.Construct(aSession, PVMF_GENERIC_NODE_INIT, aContext);
   1351     return QueueCommandL(cmd);
   1352 }
   1353 
   1354 // Async requests that will trigger callback events
   1355 /**
   1356 This should establish the comm server session.  Thread specific initialization happens here */
   1357 void TSC_324m::DoInit(Tsc324mNodeCommand& cmd)
   1358 {
   1359     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
   1360                     (0, "TSC_324m::DoInit(%x)", cmd.iId));
   1361 
   1362     PVMFStatus pvmfStatus = PVMFSuccess;
   1363     // Initialize TSC
   1364     int leave_status = 0;
   1365     OSCL_TRY(leave_status, InitTsc());
   1366     OSCL_FIRST_CATCH_ANY(leave_status, void());
   1367 
   1368     if (leave_status == 0)
   1369     {
   1370         iInterfaceState = EPVMFNodeInitialized;
   1371     }
   1372     else
   1373     {
   1374         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
   1375                         (0, "TSC_324m::Init - failed to initialize"));
   1376         pvmfStatus = PVMFFailure;
   1377         iInterfaceState = EPVMFNodeError;
   1378     }
   1379 
   1380     CommandComplete(iCmdQueue, cmd, pvmfStatus, NULL);
   1381 }
   1382 
   1383 PVMFCommandId TSC_324m::Prepare(PVMFSessionId aSession
   1384                                 , const OsclAny* aContext)
   1385 {
   1386     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1387                     (0, "TSC_324m::Prepare aSession=%x, aContext=%x",
   1388                      aSession, aContext));
   1389     if (iInterfaceState != EPVMFNodeInitialized)
   1390     {
   1391         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
   1392                         (0, "TSC_324m::Prepare Invalid state(%d)", iInterfaceState));
   1393         OSCL_LEAVE(PVMFErrInvalidState);
   1394     }
   1395     // Add command to queue
   1396     Tsc324mNodeCommand cmd;
   1397     cmd.Construct(aSession, PVMF_GENERIC_NODE_PREPARE, aContext);
   1398     return QueueCommandL(cmd);
   1399 }
   1400 
   1401 void TSC_324m::DoPrepare(Tsc324mNodeCommand& cmd)
   1402 {
   1403     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1404                     (0, "TSC_324m::DoPrepare"));
   1405     iInterfaceState = EPVMFNodePrepared;
   1406     CommandComplete(iCmdQueue, cmd, PVMFSuccess);
   1407 }
   1408 
   1409 OSCL_EXPORT_REF  PVMFCommandId TSC_324m::Start(PVMFSessionId aSession, const OsclAny* aContext)
   1410 {
   1411     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1412                     (0, "TSC_324m::Start aSession=%x, aContext=%x", aSession, aContext));
   1413 
   1414     iTSCcomponent->Start();
   1415 
   1416     if (iInterfaceState != EPVMFNodePrepared || iTerminalStatus != Phase0_Idle)
   1417     {
   1418         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
   1419                         (0, "TSC_324m::Start Init Invalid state iInterfaceState=%d, iTerminalStatus=%d",
   1420                          iInterfaceState, iTerminalStatus));
   1421         OSCL_LEAVE(PVMFErrInvalidState);
   1422     }
   1423 
   1424     // Add command to queue
   1425     Tsc324mNodeCommand cmd;
   1426     cmd.Construct(aSession, PVMF_GENERIC_NODE_START, aContext);
   1427     return QueueCommandL(cmd);
   1428 }
   1429 
   1430 void TSC_324m::DoStart(Tsc324mNodeCommand& cmd)
   1431 {
   1432     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1433                     (0, "TSC_324m::DoStart"));
   1434     TPVStatusCode stat = EPVT_Failed;
   1435     int leave_status = 0;
   1436     PVMFStatus pvmfStatus = PVMFFailure;
   1437 
   1438     OSCL_TRY(leave_status, stat = Connect());
   1439     OSCL_FIRST_CATCH_ANY(leave_status, Disconnect());
   1440     if (stat == EPVT_Success || stat == EPVT_Pending)
   1441     {
   1442         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1443                         (0, "TSC_324m::DoStart Connect complete"));
   1444         pvmfStatus = PVMFSuccess;
   1445         iInterfaceState = EPVMFNodeStarted;
   1446     }
   1447     else
   1448     {
   1449         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1450                         (0, "TSC_324m::DoStart Connect failed leave_status=%d",
   1451                          leave_status));
   1452         iInterfaceState = EPVMFNodePrepared;
   1453     }
   1454 
   1455     CommandComplete(iCmdQueue, cmd, pvmfStatus);
   1456     return;
   1457 
   1458 }
   1459 
   1460 /**
   1461  * Causes the node to stop servicing one or all disconnected ports.
   1462  * TBD:  Should we add an API or modify this to take an arbitrary subset of ports ?
   1463  * @exception port_connected leaves if any of the ports are not disconnected.
   1464  **/
   1465 OSCL_EXPORT_REF  PVMFCommandId TSC_324m::Stop(PVMFSessionId aSession,
   1466         const OsclAny* aContext)
   1467 {
   1468     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1469                     (0, "TSC_324m::Stop aSession=%x, aContext=%x",
   1470                      aSession, aContext));
   1471     switch (iInterfaceState)
   1472     {
   1473         case EPVMFNodeInitialized:
   1474         case EPVMFNodePrepared:
   1475         case EPVMFNodeStarted:
   1476         case EPVMFNodePaused:
   1477             // ok to call stop
   1478             break;
   1479         default:
   1480             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
   1481                             (0, "TSC_324m::Stop Invalid state(%d)", iInterfaceState));
   1482             OSCL_LEAVE(PVMFErrInvalidState);
   1483     }
   1484 
   1485     while (!iCmdQueue.empty())
   1486     {
   1487         CommandComplete(iCmdQueue, iCmdQueue.front(), PVMFErrCancelled);
   1488         iCmdQueue.Erase(&iCmdQueue.front());
   1489     }
   1490 
   1491     iPendingCmdQueue.clear();
   1492     // Add command to queue
   1493     Tsc324mNodeCommand cmd;
   1494     cmd.Construct(aSession, PVMF_GENERIC_NODE_STOP, aContext);
   1495     return QueueCommandL(cmd);
   1496 }
   1497 
   1498 
   1499 
   1500 void TSC_324m::DoStop(Tsc324mNodeCommand& cmd)
   1501 {
   1502     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1503                     (0, "TSC_324m::DoStop"));
   1504 
   1505     switch (iInterfaceState)
   1506     {
   1507         case EPVMFNodeInitialized:
   1508         case EPVMFNodePrepared:
   1509         case EPVMFNodeStarted:
   1510         case EPVMFNodePaused:
   1511             break;
   1512         default:
   1513             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1514                             (0, "TSC_324m::DoStop Ignoring stop due to invalid state(%d)",
   1515                              iInterfaceState));
   1516             CommandComplete(iCmdQueue, cmd, PVMFErrInvalidState);
   1517             return;
   1518     }
   1519 
   1520     if (iTSCcomponent)
   1521     {
   1522         iTSCcomponent->StartDisconnect(true);
   1523     }
   1524 
   1525     iTerminalStatus = PhaseF_Clc;
   1526     Disconnect();
   1527 
   1528     if (iNumRtdRequests)
   1529     {
   1530         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1531                         (0, "TSC_324m::DoStop iNumRtdRequests=%d, iRtdMin=%d, iRtdmax=%d, iRtdAve=%d",
   1532                          iNumRtdRequests, iRtdMin, iRtdMax, iRtdAve / iNumRtdRequests));
   1533     }
   1534     else
   1535     {
   1536         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1537                         (0, "TSC_324m::DoStop No RTD requests issued"));
   1538     }
   1539 
   1540     iInterfaceState = EPVMFNodePrepared;
   1541     CommandComplete(iCmdQueue, cmd, PVMFSuccess);
   1542 }
   1543 
   1544 /**
   1545  * Causes the node to pause servicing one or all connected and started ports.
   1546  * Ports are to be resumed using the Start command ?
   1547  * TBD:  Should we add an API or modify this to take an arbitrary subset of ports ?
   1548  * @exception port_disconnected leaves if any of the ports are not connected.
   1549  **/
   1550 OSCL_EXPORT_REF  PVMFCommandId TSC_324m::Pause(PVMFSessionId aSession,
   1551         const OsclAny* aContext)
   1552 {
   1553     OSCL_UNUSED_ARG(aSession);
   1554     OSCL_UNUSED_ARG(aContext);
   1555     OSCL_LEAVE(PVMFErrNotSupported);
   1556     return -1;
   1557 }
   1558 
   1559 /**
   1560  * Resets the node.  The node should relinquish all resources that is has acquired as part of the
   1561  * initialization process and should be ready to be deleted when this completes.
   1562  * @exception port_disconnected leaves if any of the ports are not connected.
   1563 
   1564  **/
   1565 OSCL_EXPORT_REF  PVMFCommandId TSC_324m::Reset(PVMFSessionId aSession,
   1566         const OsclAny* aContext)
   1567 {
   1568     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1569                     (0, "TSC_324m::Reset(%d)", iInterfaceState));
   1570 
   1571     switch (iInterfaceState)
   1572     {
   1573         case EPVMFNodeInitialized:
   1574         case EPVMFNodePrepared:
   1575         case EPVMFNodeError:
   1576             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1577                             (0, "TSC_324m::Reset Ok to reset"));
   1578             break;
   1579         default:
   1580             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1581                             (0, "TSC_324m::Reset Invalid state for Reset"));
   1582             OSCL_LEAVE(PVMFErrInvalidState);
   1583             break;
   1584     }
   1585 
   1586     while (!iCmdQueue.empty())
   1587     {
   1588         CommandComplete(iCmdQueue, iCmdQueue.front(), PVMFErrCancelled);
   1589         iCmdQueue.Erase(&iCmdQueue.front());
   1590     }
   1591     iPendingCmdQueue.clear();
   1592     // Add command to queue
   1593     Tsc324mNodeCommand cmd;
   1594     cmd.Construct(aSession, PVMF_GENERIC_NODE_RESET, aContext);
   1595     return QueueCommandL(cmd);
   1596 }
   1597 
   1598 void TSC_324m::DoReset(Tsc324mNodeCommand& cmd)
   1599 {
   1600     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1601                     (0, "TSC_324m::DoReset"));
   1602     iInterfaceState = EPVMFNodeIdle;
   1603     ResetTsc();
   1604     CommandComplete(iCmdQueue, cmd, PVMFSuccess);
   1605 }
   1606 
   1607 OSCL_EXPORT_REF PVMFCommandId TSC_324m::RequestPort(PVMFSessionId aSession
   1608         , int32 aPortTag
   1609         , const PvmfMimeString* aPortConfig
   1610         , const OsclAny* aContext)
   1611 {
   1612     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1613                     (0, "TSC_324m::RequestPort"));
   1614 
   1615     // Add command to queue
   1616     Tsc324mNodeCommand cmd;
   1617     cmd.Construct(aSession, PVMF_GENERIC_NODE_REQUESTPORT, aPortTag,
   1618                   aPortConfig, aContext);
   1619     return QueueCommandL(cmd);
   1620 }
   1621 
   1622 PVMFPortInterface* TSC_324m::FindOutgoingPort(TPVMediaType_t mediaType)
   1623 {
   1624     PVMFPortInterface* port = NULL;
   1625     OlcParam* param = iTSCcomponent->FindOlc(OUTGOING,
   1626                       mediaType, OLC_ESTABLISHED | OLC_PENDING);
   1627     if (param)
   1628     {
   1629         uint32 channelID = param->GetChannelId();
   1630         H223OutgoingChannelPtr outgoing_lcn;
   1631         PVMFStatus pvmfStatus = iH223->GetOutgoingChannel(channelID,
   1632                                 outgoing_lcn);
   1633         if (pvmfStatus == PVMFSuccess)
   1634         {
   1635             port = outgoing_lcn;
   1636             iRequestedOutgoingChannels[port] = outgoing_lcn;
   1637         }
   1638     }
   1639     return port;
   1640 }
   1641 
   1642 void TSC_324m::DoRequestPort(Tsc324mNodeCommand& cmd)
   1643 {
   1644     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1645                     (0, "TSC_324m::DoRequestPort"));
   1646     PVMFStatus pvmfStatus = PVMFSuccess;
   1647     int32 aPortTag = (int32)cmd.iParam1;
   1648 
   1649     PvmfMimeString* aPortConfig = (PvmfMimeString*)cmd.iParam2;
   1650     PVMFPortInterface* port = NULL;
   1651     if (aPortConfig)
   1652     {
   1653         PVMFFormatType formatType(aPortConfig->get_str());
   1654         if (formatType.isFile())
   1655         {
   1656 
   1657             // Multiplexed  PV_MULTIPLEXED
   1658             // x-pvmf/multiplexed: to identify the lowerlayer port
   1659             // Is the port already requested ?
   1660             if (iH223->GetLowerLayer()->IsConnected())
   1661             {
   1662                 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1663                                 (0, "TSC_324m::RequestPort - Port is in use"));
   1664                 pvmfStatus = PVMFErrBusy;
   1665             }
   1666             else
   1667             {
   1668                 port = iH223->GetLowerLayer();
   1669             }
   1670         }
   1671         else if (*aPortConfig == PVMF_AUDIO_OUTGOING_MIMETYPE)
   1672         {
   1673             // Audio x-pvmf/audio;dir=outgoing to identify the outgoing audio channel
   1674             port = FindOutgoingPort(PV_AUDIO);
   1675             if (port == NULL)
   1676             {
   1677                 pvmfStatus = PVMFFailure;
   1678                 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
   1679                                 (0, "TSC_324m::DoRequestPort Error - Failed to lookup outgoing channel %d",
   1680                                  aPortTag));
   1681             }
   1682         }
   1683         else if (*aPortConfig == PVMF_VIDEO_OUTGOING_MIMETYPE)
   1684         {
   1685             // Video x-pvmf/video;dir=outgoing to identify the outgoing video channel
   1686             port = FindOutgoingPort(PV_VIDEO);
   1687             if (port == NULL)
   1688             {
   1689                 pvmfStatus = PVMFFailure;
   1690                 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
   1691                                 (0, "TSC_324m::DoRequestPort Error - Failed to lookup outgoing channel %d",
   1692                                  aPortTag));
   1693             }
   1694         }
   1695 
   1696         else if (*aPortConfig == PVMF_INCOMING_MIMETYPE || (aPortTag < 0))
   1697         {
   1698             if (aPortTag < 0)
   1699             {
   1700                 aPortTag = -aPortTag;
   1701             }
   1702             // just use the channel id
   1703             //x-pvmf/dir=incoming
   1704             // Incoming
   1705             H223IncomingChannelPtr incoming_lcn;
   1706             pvmfStatus = iH223->GetIncomingChannel(aPortTag, incoming_lcn);
   1707             if (pvmfStatus == PVMFSuccess)
   1708             {
   1709                 port = incoming_lcn;
   1710                 iRequestedIncomingChannels[port] = incoming_lcn;
   1711             }
   1712             else
   1713             {
   1714                 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
   1715                                 (0, "TSC_324m::DoRequestPort Error - Failed to lookup incoming channel %d",
   1716                                  aPortTag));
   1717             }
   1718         }
   1719 
   1720         else //if (*aPortConfig == PVMF_OUTGOING_MIMETYPE || aPortTag >=0)
   1721         {
   1722             //x-pvmf/dir=outgoing
   1723             // Outgoing
   1724             H223OutgoingChannelPtr outgoing_lcn;
   1725             pvmfStatus = iH223->GetOutgoingChannel(aPortTag, outgoing_lcn);
   1726             if (pvmfStatus == PVMFSuccess)
   1727             {
   1728                 port = outgoing_lcn;
   1729                 iRequestedOutgoingChannels[port] = outgoing_lcn;
   1730             }
   1731             else
   1732             {
   1733                 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
   1734                                 (0, "TSC_324m::DoRequestPort Error - Failed to lookup outgoing channel %d",
   1735                                  aPortTag));
   1736             }
   1737         }
   1738 
   1739     }
   1740 
   1741     if (pvmfStatus != PVMFPending)
   1742     {
   1743         CommandComplete(iCmdQueue, cmd, pvmfStatus, port);
   1744         return;
   1745     }
   1746     // queue up the command in the pending queue
   1747     iPendingCmdQueue.StoreL(cmd);
   1748     iCmdQueue.Erase(&cmd);
   1749 }
   1750 
   1751 
   1752 OSCL_EXPORT_REF  PVMFCommandId TSC_324m::ReleasePort(PVMFSessionId aSession,
   1753         PVMFPortInterface& aPort,
   1754         const OsclAny* aContext)
   1755 {
   1756     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1757                     (0, "TSC_324m::ReleasePort"));
   1758     // Add command to queue
   1759     Tsc324mNodeCommand cmd;
   1760     cmd.Construct(aSession, PVMF_GENERIC_NODE_RELEASEPORT, aPort, aContext);
   1761     return QueueCommandL(cmd);
   1762 }
   1763 
   1764 void TSC_324m::DoReleasePort(Tsc324mNodeCommand& cmd)
   1765 {
   1766     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1767                     (0, "TSC_324m::DoReleasePort"));
   1768 
   1769     PVMFPortInterface* port = (PVMFPortInterface*)cmd.iParam1;
   1770     if (port->GetPortTag() == PV_MULTIPLEXED)
   1771     {
   1772         CommandComplete(iCmdQueue, cmd, PVMFSuccess, port);
   1773         return;
   1774     }
   1775 
   1776     H223LogicalChannel* lcn = OSCL_STATIC_CAST(H223LogicalChannel*, port);
   1777     if (lcn)
   1778     {
   1779         TPVDirection aDirection = port->GetPortTag() < 0 ? INCOMING : OUTGOING;
   1780         if (aDirection == INCOMING)
   1781         {
   1782             Oscl_Map<PVMFPortInterface*, H223IncomingChannelPtr, OsclMemAllocator>::iterator iter;
   1783             iter = iRequestedIncomingChannels.find(port);
   1784             if (iter != iRequestedIncomingChannels.end())
   1785             {
   1786                 iRequestedIncomingChannels[port]->Flush();
   1787                 iH223->CloseChannel(INCOMING,
   1788                                     iRequestedIncomingChannels[port]->GetLogicalChannelNumber());
   1789 
   1790 
   1791                 iRequestedIncomingChannels.erase(iter);
   1792             }
   1793             else
   1794             {
   1795                 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1796                                 (0, "TSC_324m::DoReleasePort - Incoming channel not requested"));
   1797 
   1798             }
   1799         }
   1800         else
   1801         {
   1802             Oscl_Map<PVMFPortInterface*, H223OutgoingChannelPtr, OsclMemAllocator>::iterator iter;
   1803             iter = iRequestedOutgoingChannels.find(port);
   1804             if (iter != iRequestedOutgoingChannels.end())
   1805             {
   1806                 iH223->FlushChannel(OUTGOING,
   1807                                     iRequestedOutgoingChannels[port]->GetLogicalChannelNumber());
   1808                 iH223->CloseChannel(OUTGOING,
   1809                                     iRequestedOutgoingChannels[port]->GetLogicalChannelNumber());
   1810                 iRequestedOutgoingChannels.erase(iter);
   1811             }
   1812         }
   1813     }
   1814 
   1815     CommandComplete(iCmdQueue, cmd, PVMFSuccess, port);
   1816     return;
   1817 }
   1818 
   1819 /**
   1820 * Returns a list of ports currently available in the node that meet the filter criteria
   1821 * We can add fancier iterators and filters as needed.  For now we return all the ports.
   1822 **/
   1823 OSCL_EXPORT_REF  PVMFPortIter* TSC_324m::GetPorts(const PVMFPortFilter* aFilter)
   1824 {
   1825     OSCL_UNUSED_ARG(aFilter);
   1826     return NULL;
   1827 }
   1828 
   1829 void TSC_324m::DoCancel()
   1830 {
   1831 }
   1832 
   1833 void TSC_324m::Run()
   1834 {
   1835     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1836                     (0, " TSC_324m::Run()"));
   1837     if (!iCmdQueue.empty())
   1838     {
   1839         ProcessCommand(iCmdQueue.front());
   1840     }
   1841 
   1842     if (!iCmdQueue.empty())
   1843     {
   1844         // Run again if there are more things to process
   1845         RunIfNotReady();
   1846     }
   1847 
   1848     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1849                     (0, " TSC_324m::Run() - done"));
   1850 }
   1851 
   1852 bool TSC_324m::ProcessCommand(Tsc324mNodeCommand& aCmd)
   1853 {
   1854     switch (aCmd.iCmd)
   1855     {
   1856         case PVMF_GENERIC_NODE_QUERYUUID:
   1857             DoQueryUuid(aCmd);
   1858             break;
   1859 
   1860         case PVMF_GENERIC_NODE_QUERYINTERFACE:
   1861             DoQueryInterface(aCmd);
   1862             break;
   1863 
   1864         case PVMF_GENERIC_NODE_REQUESTPORT:
   1865             DoRequestPort(aCmd);
   1866             break;
   1867 
   1868         case PVMF_GENERIC_NODE_RELEASEPORT:
   1869             DoReleasePort(aCmd);
   1870             break;
   1871 
   1872         case PVMF_GENERIC_NODE_INIT:
   1873             DoInit(aCmd);
   1874             break;
   1875 
   1876         case PVMF_GENERIC_NODE_PREPARE:
   1877             DoPrepare(aCmd);
   1878             break;
   1879 
   1880         case PVMF_GENERIC_NODE_START:
   1881             DoStart(aCmd);
   1882             break;
   1883 
   1884         case PVMF_GENERIC_NODE_STOP:
   1885             DoStop(aCmd);
   1886             break;
   1887 
   1888         case PVMF_GENERIC_NODE_FLUSH:
   1889             DoFlush(aCmd);
   1890             break;
   1891 
   1892         case PVMF_GENERIC_NODE_PAUSE:
   1893             DoPause(aCmd);
   1894             break;
   1895 
   1896         case PVMF_GENERIC_NODE_RESET:
   1897             DoReset(aCmd);
   1898             break;
   1899 
   1900         case PVMF_GENERIC_NODE_CANCELALLCOMMANDS:
   1901             DoCancelAllCommands(aCmd);
   1902             break;
   1903 
   1904         case PVMF_GENERIC_NODE_CANCELCOMMAND:
   1905             DoCancelCommand(aCmd);
   1906             break;
   1907 
   1908         default://unknown command type
   1909             if (iTSCcomponent->ProcessCommand(aCmd))
   1910             {
   1911                 CommandComplete(iCmdQueue, aCmd, PVMFSuccess);
   1912             }
   1913             else
   1914             {
   1915                 CommandComplete(iCmdQueue, aCmd, PVMFFailure);
   1916             }
   1917             break;
   1918     }
   1919 
   1920     return true;
   1921 }
   1922 
   1923 int32 TSC_324m::FindPendingPortCmd(TPVMFGenericNodeCommand aCmdType,
   1924                                    int32 aPortTag,
   1925                                    Tsc324mNodeCommand& cmd)
   1926 {
   1927     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1928                     (0, "TSC_324m::FindPendingRequestPortCmd aCmdType=%d, aPortTag=%d",
   1929                      aCmdType, aPortTag));
   1930 
   1931     int32 cmdIndex = -1;
   1932 
   1933     for (uint32 i = 0; i < iPendingCmdQueue.size(); i++)
   1934     {
   1935         if ((TPVMFGenericNodeCommand)iPendingCmdQueue[i].iCmd == aCmdType)
   1936         {
   1937             if (aPortTag == (int32)iPendingCmdQueue[i].iParam1)
   1938             {
   1939                 cmd = iPendingCmdQueue[i];
   1940                 cmdIndex = i;
   1941                 break;
   1942             }
   1943         }
   1944     }
   1945 
   1946     if (cmdIndex < 0)
   1947     {
   1948         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1949                         (0, "TSC_324m::FindPendingPortCmd Error - command not found"));
   1950         return 0;
   1951     }
   1952 
   1953     // Destroy command object
   1954     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1955                     (0, "TSC_324m::FindPendingPortCmd : Deleting cmd from iPendingQueue. cmdIndex=%d",
   1956                      cmdIndex));
   1957     iPendingCmdQueue.Erase(&iPendingCmdQueue[cmdIndex]);
   1958     return cmdIndex;
   1959 }
   1960 
   1961 OSCL_EXPORT_REF void TSC_324m::SetMultiplexLevel(TPVH223Level muxLevel)
   1962 {
   1963     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1964                     (0, "TSC_324m::SetMultiplexLevel  level(%d)\n", muxLevel));
   1965     iH223Level = muxLevel;
   1966 
   1967     if (iH223)
   1968     {
   1969         iH223->SetMultiplexLevel(muxLevel);
   1970     }
   1971 }
   1972 
   1973 OSCL_EXPORT_REF void TSC_324m::SetSduSize(TPVDirection direction,
   1974         uint16 size,
   1975         TPVAdaptationLayer al)
   1976 {
   1977     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1978                     (0, "TSC_324m::SetSduSize  direction(%d), size(%d), al(%d)\n",
   1979                      direction, size, al));
   1980     if (iH223)
   1981     {
   1982         iH223->SetSduSize(direction, size, EplForAdaptationLayer(al));
   1983     }
   1984 }
   1985 
   1986 OSCL_EXPORT_REF void TSC_324m::SetAl2Sn(int width)
   1987 {
   1988     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1989                     (0, "TSC_324m::SetAl2Sn on/off(%d)\n", width));
   1990     iTSCcomponent->SetAl2Sn(width);
   1991 }
   1992 
   1993 OSCL_EXPORT_REF void TSC_324m::SetAl3ControlFieldOctets(unsigned cfo)
   1994 {
   1995     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1996                     (0, "TSC_324m::SetAl3ControlFieldOctets cfo(%d)\n", cfo));
   1997     iTSCcomponent->SetAl3ControlFieldOctets(cfo);
   1998 }
   1999 
   2000 OSCL_EXPORT_REF void TSC_324m::SetMaxOutgoingPduSize(uint16 size)
   2001 {
   2002     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2003                     (0, "TSC_324m::SetMaxOutgoingPduSize size(%d)\n", size));
   2004     if (iH223)
   2005     {
   2006         iH223->SetMaxOutgoingPduSize(size);
   2007     }
   2008 }
   2009 
   2010 OSCL_EXPORT_REF void TSC_324m::SetMaxMuxPduSize(uint16 size)
   2011 {
   2012     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2013                     (0, "TSC_324m::SetMaxMuxPduSize size(%d)\n", size));
   2014     iRequestMaxMuxPduSize = size;
   2015 }
   2016 
   2017 OSCL_EXPORT_REF void TSC_324m::SetMaxCcsrlSduSize(int size)
   2018 {
   2019     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2020                     (0, "TSC_324m::SetMaxCcsrlSduSize size(%d)\n", size));
   2021     if (iSrp)
   2022     {
   2023         iSrp->SetCCSRLSduSize(size);
   2024     }
   2025     else
   2026     {
   2027         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2028                         (0, "TSC_324m::SetMaxCcsrlSduSize - Invalid state: SRP == NULL"));
   2029     }
   2030 }
   2031 
   2032 OSCL_EXPORT_REF void TSC_324m::SetOutgoingMuxPduType(TPVH223MuxPduType outgoingPduType)
   2033 {
   2034     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2035                     (0, "TSC_324m::SetOutgoingMuxPduType type(%d)\n",
   2036                      outgoingPduType));
   2037     iOutgoingPduType = outgoingPduType;
   2038 }
   2039 
   2040 OSCL_EXPORT_REF void TSC_324m::SetOutgoingChannelConfig(
   2041     Oscl_Vector<H324ChannelParameters, PVMFTscAlloc>& out_channel_config)
   2042 {
   2043     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2044                     (0, "TSC_324m::SetOutgoingChannelConfig size(%d)\n",
   2045                      out_channel_config.size()));
   2046     if (iInterfaceState != EPVMFNodeInitialized)
   2047     {
   2048         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2049                         (0, "TSC_324m::SetOutgoingChannelConfig Error: Invalid state."));
   2050         OSCL_LEAVE(PVMFErrInvalidState);
   2051     }
   2052     iTSCcomponent->SetOutgoingChannelConfig(out_channel_config);
   2053 }
   2054 
   2055 OSCL_EXPORT_REF void TSC_324m::SetIncomingChannelConfig(
   2056     Oscl_Vector<H324ChannelParameters, PVMFTscAlloc>& in_channel_config)
   2057 {
   2058     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2059                     (0, "TSC_324m::SetIncomingChannelConfig size(%d)\n",
   2060                      in_channel_config.size()));
   2061     iTSCcomponent->SetIncomingChannelConfig(in_channel_config);
   2062 }
   2063 
   2064 OSCL_EXPORT_REF void TSC_324m::SetAlConfig(PV2WayMediaType media_type,
   2065         TPVAdaptationLayer layer,
   2066         bool allow)
   2067 {
   2068     iTSCcomponent->SetAlConfig(media_type, layer, allow);
   2069 }
   2070 
   2071 PVMFCommandId TSC_324m::QueryUUID(PVMFSessionId aSession,
   2072                                   const PvmfMimeString& aMimeType,
   2073                                   Oscl_Vector<PVUuid, OsclMemAllocator>& aUuids,
   2074                                   bool aExactUuidsOnly,
   2075                                   const OsclAny* aContext)
   2076 {
   2077     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2078                     (0, "TSC_324m::QueryUUID"));
   2079     // create message to be completed later - depending on what it is...
   2080     Tsc324mNodeCommand cmd;
   2081     cmd.Construct(aSession, PVMF_GENERIC_NODE_QUERYUUID, aMimeType,
   2082                   aUuids, aExactUuidsOnly, aContext);
   2083     iComponentRegistry.QueryRegistry(cmd);
   2084     //return QueueCommandL(cmd);
   2085     return 0;
   2086 }
   2087 
   2088 PVMFCommandId TSC_324m::QueryInterface(PVMFSessionId aSession,
   2089                                        const PVUuid& aUuid,
   2090                                        PVInterface*& aInterfacePtr,
   2091                                        const OsclAny* aContext)
   2092 {
   2093     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2094                     (0, "TSC_324m::QueryInterface()"));
   2095 
   2096     if (aUuid == PVH324MConfigUuid)
   2097     {
   2098         aInterfacePtr = OSCL_NEW(H324MConfig, (this, true));
   2099     }
   2100     else if (aUuid == PVUidProxiedInterface)
   2101     {
   2102         H324MProxiedInterface* proxied_interface_ptr = NULL;
   2103         proxied_interface_ptr = OSCL_NEW(H324MProxiedInterface, ());
   2104         proxied_interface_ptr->SetH324M(this);
   2105         aInterfacePtr = proxied_interface_ptr;
   2106     }
   2107     else
   2108     {
   2109         TSC_component* backup = iTSCcomponent;
   2110 
   2111         // send onto TSCComponentRegistry::Create to let it finish
   2112         iTSCcomponent = iComponentRegistry.Create(aSession, aUuid,
   2113                         aInterfacePtr, aContext);
   2114         if (iTSCcomponent)
   2115         {
   2116             InitComponent();
   2117             if (backup)
   2118             {
   2119                 OSCL_DELETE(backup);
   2120             }
   2121         }
   2122     }
   2123 
   2124     // Add command to queue
   2125     /*Tsc324mNodeCommand cmd;
   2126     cmd.Construct(aSession, PVMF_GENERIC_NODE_QUERYINTERFACE, aUuid, aInterfacePtr, aContext) ;
   2127     return QueueCommandL(cmd);
   2128     */
   2129     return 0;
   2130 }
   2131 
   2132 void TSC_324m::DoQueryInterface(Tsc324mNodeCommand& cmd)
   2133 {
   2134     OSCL_UNUSED_ARG(cmd);
   2135     //CommandComplete(iCmdQueue, cmd, PVMFSuccess);
   2136 }
   2137 
   2138 void TSC_324m::DoQueryUuid(Tsc324mNodeCommand& cmd)
   2139 {
   2140     OSCL_UNUSED_ARG(cmd);
   2141     //CommandComplete(iCmdQueue, cmd, PVMFSuccess);
   2142 }
   2143 
   2144 PVMFCommandId TSC_324m::CancelAllCommands(PVMFSessionId aSession,
   2145         const OsclAny* aContext)
   2146 {
   2147     OSCL_UNUSED_ARG(aSession);
   2148     OSCL_UNUSED_ARG(aContext);
   2149     OSCL_LEAVE(PVMFErrNotSupported);
   2150     return -1;
   2151 }
   2152 
   2153 
   2154 OSCL_EXPORT_REF PVMFCommandId TSC_324m::CancelCommand(PVMFSessionId aSession,
   2155         PVMFCommandId aCommandId,
   2156         const OsclAny* aContext)
   2157 {
   2158     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2159                     (0, "TSC_324m::CancelCommand id(%d)", aCommandId));
   2160     // Add command to queue
   2161     Tsc324mNodeCommand cmd;
   2162     cmd.Construct(aSession, PVMF_GENERIC_NODE_CANCELCOMMAND, aCommandId, aContext);
   2163     return QueueCommandL(cmd);
   2164 }
   2165 
   2166 void TSC_324m::DoCancelCommand(Tsc324mNodeCommand& cmd)
   2167 {
   2168     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2169                     (0, "TSC_324m::DoCancelCommand cmd(%x)", &cmd));
   2170     PVMFStatus status = PVMFSuccess;
   2171     int cmdIndex = FindPendingCmd((PVMFCommandId)cmd.iParam1);
   2172 
   2173     if (cmdIndex < 0)
   2174     {
   2175         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2176                         (0, "TSC_324m::DoCancelCommand Failed to lookup command(%d)",
   2177                          (PVMFCommandId)cmd.iParam1));
   2178         Tsc324mNodeCommand* found_cmd = iCmdQueue.FindById((PVMFCommandId)cmd.iParam1);
   2179         if (found_cmd)
   2180         {
   2181             iCmdQueue.Erase(found_cmd);
   2182         }
   2183         else
   2184             status = PVMFErrArgument;
   2185     }
   2186     else
   2187     {
   2188         // Destroy command object
   2189         Tsc324mNodeCommand to_be_deleted_cmd = iPendingCmdQueue[cmdIndex];
   2190         iPendingCmdQueue.Erase(&iPendingCmdQueue[cmdIndex]);
   2191     }
   2192     CommandComplete(iCmdQueue, cmd, status);
   2193 }
   2194 
   2195 int TSC_324m::FindPendingCmd(PVMFCommandId aCommandId)
   2196 {
   2197     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2198                     (0, "TSC_324m::FindPendingCmd id(%d)", aCommandId));
   2199     int32 cmdIndex = -1;
   2200     for (uint32 i = 0; i < iPendingCmdQueue.size(); i++)
   2201     {
   2202         if (iPendingCmdQueue[i].iId == aCommandId)
   2203         {
   2204             PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2205                             (0, "TSC_324m::FindPendingCmd - command found in iPendingCmdQueue"));
   2206             cmdIndex = i;
   2207             break;
   2208         }
   2209     }
   2210     return cmdIndex;
   2211 }
   2212 
   2213 const uint8* TSC_324m::GetFormatSpecificInfo(PVMFPortInterface* port,
   2214         uint32* len)
   2215 {
   2216     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2217                     (0, "TSC_324m::GetFormatSpecificInfo port(%x)", port));
   2218     return ((H223LogicalChannel*)port)->GetFormatSpecificInfo(len);
   2219 }
   2220 
   2221 LogicalChannelInfo* TSC_324m::GetLogicalChannelInfo(PVMFPortInterface& port)
   2222 {
   2223     return iTSCcomponent->GetLogicalChannelInfo(port);
   2224 }
   2225 
   2226 bool TSC_324m::IsEstablishedLogicalChannel(TPVDirection aDir,
   2227         TPVChannelId aChannelId)
   2228 {
   2229     return iTSCcomponent->IsEstablishedLogicalChannel(aDir, aChannelId);
   2230 }
   2231 
   2232 void TSC_324m::SetSkewReference(PVMFPortInterface* aPort,
   2233                                 PVMFPortInterface* aReferencePort)
   2234 {
   2235     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2236                     (0, "TSC_324m::SetSkewReference"));
   2237     H223OutgoingChannel* lcn2 = OSCL_STATIC_CAST(H223OutgoingChannel*,
   2238                                 aPort);
   2239     H223OutgoingChannel* lcn1 = OSCL_STATIC_CAST(H223OutgoingChannel*,
   2240                                 aReferencePort);
   2241     lcn2->SetSkewReference(lcn1);
   2242 }
   2243 
   2244 void TSC_324m::SendVideoTemporalSpatialTradeoffCommand(TPVChannelId aLogicalChannel,
   2245         uint8 aTradeoff)
   2246 {
   2247     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2248                     (0, "TSC_324m::SendVideoTemporalSpatialTradeoffCommand aLogicalChannel=%d, aTradeoff=%d", aLogicalChannel, aTradeoff));
   2249     if (iTerminalStatus != PhaseE_Comm)
   2250     {
   2251         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2252                         (0, "TSC_324m::SendVideoTemporalSpatialTradeoffCommand Ignoring due to invalid state."));
   2253         return;
   2254     }
   2255     CmdMisc(EVideoTemporalSpatialTradeOff, aLogicalChannel, aTradeoff);
   2256 }
   2257 
   2258 void TSC_324m::SendVideoTemporalSpatialTradeoffIndication(TPVChannelId aLogicalChannel,
   2259         uint8 aTradeoff)
   2260 {
   2261     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2262                     (0, "TSC_324m::SendVideoTemporalSpatialTradeoffIndication aLogicalChannel=%d, aTradeoff=%d", aLogicalChannel, aTradeoff));
   2263     if (iTerminalStatus != PhaseE_Comm)
   2264     {
   2265         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2266                         (0, "TSC_324m::SendVideoTemporalSpatialTradeoffIndication Ignoring due to invalid state."));
   2267         return;
   2268     }
   2269     IndicationMisc(EVideoTemporalSpatialTradeOffIdc, aLogicalChannel,
   2270                    aTradeoff);
   2271 }
   2272 
   2273 void TSC_324m::SetDatapathLatency(TPVDirection aDir, PVMFPortInterface* aPort,
   2274                                   uint32 aLatency)
   2275 {
   2276     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2277                     (0, "TSC_324m::SetDatapathLatency aDir=%d, aPort=%x, aLatency=%d", aDir, aPort, aLatency));
   2278     OSCL_UNUSED_ARG(aDir);
   2279     H223LogicalChannel* lcn = OSCL_STATIC_CAST(H223LogicalChannel* , aPort);
   2280     if (lcn == NULL)
   2281     {
   2282         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
   2283                         (0, "TSC_324m::SetDatapathLatency WARNING lcn==NULL"));
   2284         return;
   2285     }
   2286 
   2287     lcn->SetDatapathLatency(aLatency);
   2288 }
   2289 
   2290 void TSC_324m::SendSkewIndication(TPVChannelId aLogicalChannel1,
   2291                                   TPVChannelId aLogicalChannel2,
   2292                                   uint16 aSkew)
   2293 {
   2294     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2295                     (0, "TSC_324m::SendSkewIndication aLogicalChannel1=%d, aLogicalChannel2=%d, aSkew=%d",
   2296                      aLogicalChannel1, aLogicalChannel2, aSkew));
   2297     if (iTerminalStatus != PhaseE_Comm)
   2298     {
   2299         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2300                         (0, "TSC_324m::SendSkewIndication Ignoring due to invalid state."));
   2301         return;
   2302     }
   2303     Tsc_IdcSkew(aLogicalChannel1, aLogicalChannel2, aSkew);
   2304 }
   2305 
   2306 OSCL_EXPORT_REF void TSC_324m::SetMultiplexingDelayMs(uint16 aDelay)
   2307 {
   2308     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2309                     (0, "TSC_324m::SetMultiplexingDelayMs,aDelay=%d", aDelay));
   2310     iMultiplexingDelayMs = aDelay;
   2311     if (iH223)
   2312         iH223->SetMultiplexingDelayMs((uint16)iMultiplexingDelayMs);
   2313 }
   2314 
   2315 void TSC_324m::ConfigureSrp(TPVH223Level aLevel)
   2316 {
   2317     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2318                     (0, "TSC_324m::ConfigureSrp aLevel=%d", aLevel));
   2319     iTscSrpBuffer->Stop();
   2320 
   2321     iSrp->SrpStop();
   2322     iSrp->SrpReset();
   2323     iSrp->SrpInitL();
   2324     iSrp->SetSRPTimeoutValue(iT401);
   2325     iSrp->SetNumSRPRetries(iN401);
   2326 
   2327     /* We will enable NSRP for level 0 if the remote terminal signals capability */
   2328     if (aLevel == H223_LEVEL0)
   2329     {
   2330         iSrp->SetCCSRLSduSize(0);
   2331         iSrp->UseNSRP(false);
   2332     }
   2333     else
   2334     {
   2335         iSrp->UseNSRP(true);
   2336     }
   2337 
   2338     if (!iEnableWnsrp || aLevel == H223_LEVEL0)
   2339     {
   2340         iSrp->DisableWNSRPSupport();
   2341     }
   2342 
   2343     H223IncomingChannelPtr incoming_control_channel;
   2344     PVMFStatus aStatus = iH223->GetIncomingChannel((TPVChannelId)0,
   2345                          incoming_control_channel);
   2346     if (aStatus == PVMFSuccess)
   2347     {
   2348         incoming_control_channel->Disconnect();
   2349     }
   2350     else
   2351     {
   2352         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
   2353                         (0, "TSC_324m::ConfigureSrp Error - Failed to lookup incoming logical channel %d", 0));
   2354         return;
   2355     }
   2356 
   2357     H223OutgoingChannelPtr outgoing_control_channel;
   2358     aStatus = iH223->GetOutgoingChannel((TPVChannelId)0,
   2359                                         outgoing_control_channel);
   2360     if (aStatus == PVMFSuccess)
   2361     {
   2362         outgoing_control_channel->Disconnect();
   2363     }
   2364     else
   2365     {
   2366         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
   2367                         (0, "TSC_324m::ConfigureSrp Error - Failed to lookup outgoing logical channel %d", 0));
   2368         return;
   2369     }
   2370 
   2371     PVMFPortInterface *port;
   2372 
   2373     port = iSrp->RequestULPort(SRP_INPUT_PORT_TAG);
   2374     iTscSrpBuffer->GetLLPort(TSCSRPBUFFER_OUTPUT_PORT_TAG)->Connect(port);
   2375 
   2376     port = iSrp->RequestULPort(SRP_OUTPUT_PORT_TAG);
   2377     port->Connect(iTscSrpBuffer->GetLLPort(TSCSRPBUFFER_INPUT_PORT_TAG));
   2378 
   2379     iTscSrpBuffer->GetUpperLayer()->Bind(iH245);
   2380 
   2381     iOutgoingSrpPort = iSrp->RequestLLPort(SRP_INPUT_PORT_TAG);
   2382     iIncomingSrpPort = iSrp->RequestLLPort(SRP_OUTPUT_PORT_TAG);
   2383     iOutgoingSrpPort->Connect(incoming_control_channel);
   2384 //  incoming_control_channel->Connect(iOutgoingSrpPort);
   2385     iIncomingSrpPort->Connect(outgoing_control_channel);
   2386 //  outgoing_control_channel->Connect(iIncomingSrpPort);
   2387 
   2388     iTscSrpBuffer->Start();
   2389     iSrp->SrpStart();
   2390 }
   2391 
   2392 void TSC_324m::StopSrp()
   2393 {
   2394     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2395                     (0, "TSC_324m::StopSrp "));
   2396     iSrp->SrpStop();
   2397     iTscSrpBuffer->Stop();
   2398 
   2399     H223IncomingChannelPtr incoming_control_channel;
   2400     PVMFStatus aStatus = iH223->GetIncomingChannel((TPVChannelId)0,
   2401                          incoming_control_channel);
   2402     if (aStatus == PVMFSuccess)
   2403     {
   2404         incoming_control_channel->Disconnect();
   2405     }
   2406     else
   2407     {
   2408         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
   2409                         (0, "TSC_324m::ConfigureSrp Error - Failed to lookup incoming logical channel %d", 0));
   2410     }
   2411 
   2412     H223OutgoingChannelPtr outgoing_control_channel;
   2413     aStatus = iH223->GetOutgoingChannel((TPVChannelId)0,
   2414                                         outgoing_control_channel);
   2415     if (aStatus == PVMFSuccess)
   2416     {
   2417         outgoing_control_channel->Disconnect();
   2418     }
   2419     else
   2420     {
   2421         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING,
   2422                         (0, "TSC_324m::ConfigureSrp Error - Failed to lookup outgoing logical channel %d", 0));
   2423     }
   2424 
   2425     PVMFPortInterface *port = NULL;
   2426 
   2427     port = iSrp->RequestULPort(SRP_INPUT_PORT_TAG);
   2428     if (port)
   2429         port->Disconnect();
   2430 
   2431     port = iTscSrpBuffer->GetLLPort(TSCSRPBUFFER_OUTPUT_PORT_TAG);
   2432     if (port)
   2433         port->Disconnect();
   2434 
   2435     port = iSrp->RequestULPort(SRP_OUTPUT_PORT_TAG);
   2436     if (port)
   2437         port->Disconnect();
   2438 
   2439     port = iTscSrpBuffer->GetLLPort(TSCSRPBUFFER_INPUT_PORT_TAG);
   2440     if (port)
   2441         port->Disconnect();
   2442 
   2443     iTscSrpBuffer->GetUpperLayer()->UnBind();
   2444 
   2445     if (iOutgoingSrpPort)
   2446         iOutgoingSrpPort->Disconnect();
   2447     if (iIncomingSrpPort)
   2448         iIncomingSrpPort->Disconnect();
   2449 }
   2450 
   2451 
   2452 OSCL_EXPORT_REF void TSC_324m::GetChannelFormatAndCapabilities(TPVDirection dir,
   2453         Oscl_Vector<FormatCapabilityInfo, OsclMemAllocator>& formats)
   2454 {
   2455     iTSCcomponent->GetChannelFormatAndCapabilities(dir, formats);
   2456 }
   2457 
   2458 OSCL_EXPORT_REF void TSC_324m::SetLogicalChannelBufferingMs(uint32 aInBufferingMs,
   2459         uint32 aOutBufferingMs)
   2460 {
   2461     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2462                     (0, "TSC_324m::SetLogicalChannelBufferingMs aInBufferingMs=%d, aOutBufferingMs=%d",
   2463                      aInBufferingMs, aOutBufferingMs));
   2464     iInLogicalChannelBufferingMs = aInBufferingMs;
   2465     iOutLogicalChannelBufferingMs = aOutBufferingMs;
   2466 }
   2467 
   2468 void TSC_324m::UseWNSRP(bool aUse)
   2469 {
   2470     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2471                     (0, "TSC_324m::UseWNSRP %d", aUse));
   2472     SetWnsrp(aUse);
   2473 
   2474     PS_MultiplexEntryDescriptor desc = iH223->GetIncomingMuxDescriptor(TSC_WNSRP_MUX_ENTRY_NUMBER);
   2475     if (desc &&
   2476             desc->size_of_elementList &&
   2477             desc->elementList->muxType.index == 0 &&
   2478             desc->elementList->muxType.logicalChannelNumber == 0)
   2479     {
   2480         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2481                         (0, "TSC_324m::UseWNSRP Deleting incoming descriptor for WNSRP"));
   2482         iH223->RemoveIncomingMuxDescriptor(TSC_WNSRP_MUX_ENTRY_NUMBER);
   2483     }
   2484 }
   2485 
   2486 
   2487 void TSC_324m::SetTSC_324mObserver(TSC_324mObserver* aObserver)
   2488 {
   2489     if (aObserver == NULL)
   2490         return;
   2491     iTSC_324mObserver = aObserver;
   2492 }
   2493 
   2494 PVMFCommandId TSC_324m::QueueCommandL(Tsc324mNodeCommand& aCmd)
   2495 {
   2496     PVMFCommandId id;
   2497 
   2498     id = iCmdQueue.AddL(aCmd);
   2499 
   2500     //wakeup the AO
   2501     RunIfNotReady();
   2502 
   2503     return id;
   2504 }
   2505 
   2506 void TSC_324m::CommandComplete(Tsc324mNodeCmdQ& aCmdQ, Tsc324mNodeCommand& aCmd,
   2507                                PVMFStatus aStatus, OsclAny* aEventData)
   2508 {
   2509     PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   2510                     (0, "TSC_324m:CommandComplete Id %d Cmd %d Status %d Context %d Data %d",
   2511                      aCmd.iId, aCmd.iCmd, aStatus, aCmd.iContext, aEventData));
   2512 
   2513     //create response
   2514     PVMFCmdResp resp(aCmd.iId, aCmd.iContext, aStatus, aEventData);
   2515     PVMFSessionId session = aCmd.iSession;
   2516 
   2517     //Erase the command from the queue.
   2518     aCmdQ.Erase(&aCmd);
   2519 
   2520     //Report completion to the session observer.
   2521     ReportCmdCompleteEvent(session, resp);
   2522 }
   2523 
   2524 int32 TSC_324m::GetPortTagForLcn(TPVDirection aDir, TPVChannelId aId,
   2525                                  PVCodecType_t aCodecType)
   2526 {
   2527     if (aDir == INCOMING)
   2528         return -aId;
   2529     return GetMediaType(aCodecType);
   2530 }
   2531 
   2532 PVMFStatus TSC_324m::ThreadLogon()
   2533 {
   2534     AddToScheduler();
   2535 
   2536     SetState(EPVMFNodeIdle);
   2537     return PVMFSuccess;
   2538 }
   2539 
   2540 PVMFStatus TSC_324m::ThreadLogoff()
   2541 {
   2542     SetState(EPVMFNodeCreated);
   2543     RemoveFromScheduler();
   2544     return PVMFSuccess;
   2545 }
   2546 
   2547 void TSC_324m::HandlePortActivity(const PVMFPortActivity& aActivity)
   2548 {
   2549     OSCL_UNUSED_ARG(aActivity);
   2550 }
   2551 
   2552 PVMFCommandId TSC_324m::Flush(PVMFSessionId aSession,
   2553                               const OsclAny* aContext)
   2554 {
   2555     OSCL_UNUSED_ARG(aSession);
   2556     OSCL_UNUSED_ARG(aContext);
   2557 
   2558     OSCL_LEAVE(PVMFErrNotSupported);
   2559     return 0;
   2560 }
   2561 
   2562 void TSC_324m::SetMioLatency(int32 aLatency, bool aAudio)
   2563 {
   2564     iH223->SetMioLatency(aLatency, aAudio);
   2565 }
   2566 
   2567 #ifdef MEM_TRACK
   2568 void TSC_324m::MemStats()
   2569 {
   2570 #if !(OSCL_BYPASS_MEMMGT)
   2571 
   2572     OsclAuditCB auditCB;
   2573     OsclMemInit(auditCB);
   2574     if (auditCB.pAudit)
   2575     {
   2576         MM_Stats_t* stats = auditCB.pAudit->MM_GetStats("");
   2577         if (stats)
   2578         {
   2579             printf("\n###################Memory Stats Start#################\n");
   2580             printf("  numBytes %d\n", stats->numBytes);
   2581             printf("  peakNumBytes %d\n", stats->peakNumBytes);
   2582             printf("  numAllocs %d\n", stats->numAllocs);
   2583             printf("  peakNumAllocs %d\n", stats->peakNumAllocs);
   2584             printf("  numAllocFails %d\n", stats->numAllocFails);
   2585             printf("  totalNumAllocs %d\n", stats->totalNumAllocs);
   2586             printf("  totalNumBytes %d\n", stats->totalNumBytes);
   2587             printf("\n###################Memory Stats End###################\n");
   2588         }
   2589 
   2590     }
   2591 #endif
   2592 }
   2593 #endif
   2594 
   2595