/* ------------------------------------------------------------------
 * Copyright (C) 2008 PacketVideo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 * -------------------------------------------------------------------
 */
#ifndef OSCL_SNPRINTF_H_INCLUDED
#include "oscl_snprintf.h"
#endif
#ifndef OSCL_EXCLUSIVE_PTR_H_INCLUDED
#include "oscl_exclusive_ptr.h"
#endif
#ifndef PVLOGGER_H_INCLUDED
#include "pvlogger.h"
#endif
#ifndef OSCL_MIME_STRING_UTILS_H
#include "pv_mime_string_utils.h"
#endif
#ifndef PVMF_SM_NODE_FACTORY_H_INCLUDED
#include "pvmf_sm_node_factory.h"
#endif
#ifndef PVMF_SM_TUNABLES_H_INCLUDED
#include "pvmf_sm_tunables.h"
#endif
#ifndef PVMF_STREAMING_MANAGER_NODE_H_INCLUDED
#include "pvmf_streaming_manager_node.h"
#endif
#ifndef PVMF_STREAMING_MANAGER_INTERNAL_H_INCLUDED
#include "pvmf_streaming_manager_internal.h"
#endif
#ifndef PVMF_SM_CAPCONFIG_H_INCLUDED
#include "pvmf_sm_capconfig.h"
#endif
#ifndef PVMF_SOCKET_NODE_H_INCLUDED
#include "pvmf_socket_node.h"
#endif
#ifndef PVMF_RTSP_ENGINE_NODE_FACTORY_H_INCLUDED
#include "pvrtsp_client_engine_factory.h"
#endif
#ifndef PVMF_JITTER_BUFFER_NODE_H_INCLUDED
#include "pvmf_jitter_buffer_node.h"
#endif
#ifndef PVMF_MEDIALAYER_NODE_H_INCLUDED
#include "pvmf_medialayer_node.h"
#endif
#ifndef PVRTSP_ENGINE_NODE_EXTENSION_INTERFACE_H_INCLUDED
#include "pvrtspenginenodeextensioninterface.h"
#endif
#ifndef PVMF_MEDIA_PRESENTATION_INFO_H_INCLUDED
#include "pvmf_media_presentation_info.h"
#endif
#ifndef SDP_PARSER_H
#include "sdp_parser.h"
#endif
#ifndef PVMF_BASIC_ERRORINFOMESSAGE_H_INCLUDED
#include "pvmf_basic_errorinfomessage.h"
#endif
#ifndef PVMF_ERRORINFOMESSAGE_EXTENSION_H_INCLUDED
#include "pvmf_errorinfomessage_extension.h"
#endif
#ifndef OSCL_STRING_UTILS_H_INCLUDED
#include "oscl_string_utils.h"
#endif
#ifndef PVMI_KVP_UTIL_H_INCLUDED
#include "pvmi_kvp_util.h"
#endif
#ifndef OSCL_DLL_H_INCLUDED
#include "oscl_dll.h"
#endif
#ifndef PVMF_PROTOCOLENGINE_FACTORY_H_INCLUDED
#include "pvmf_protocol_engine_factory.h"
#endif
#ifndef PVMF_PROTOCOLENGINE_DEFS_H_INCLUDED
#include "pvmf_protocol_engine_defs.h"
#endif
#ifndef PVMFPROTOCOLENGINENODE_EXTENSION_H_INCLUDED
#include "pvmf_protocol_engine_node_extension.h"
#endif
#ifndef PVMF_STREAMING_ASF_INTERFACES_INCLUDED
#include "pvmf_streaming_asf_interfaces.h"
#endif
#ifndef PVMI_DRM_KVP_H_INCLUDED
#include "pvmi_drm_kvp.h"
#endif

#ifndef OSCL_UTF8CONV_H
#include "oscl_utf8conv.h"
#endif
#ifndef PVMF_SM_CONFIG_H_INCLUDED
#include "pvmf_sm_config.h"
#endif

// Define entry point for this DLL
OSCL_DLL_ENTRY_POINT_DEFAULT()


// Number of metadata keys supported in this node.
#define PVMFSTREAMINGMGRNODE_NUM_METADATAKEYS 16
// Constant character strings for metadata keys
static const char PVMFSTREAMINGMGRNODE_AUTHOR_KEY[] = "author";
static const char PVMFSTREAMINGMGRNODE_ARTIST_KEY[] = "artist";
static const char PVMFSTREAMINGMGRNODE_TITLE_KEY[] = "title";
static const char PVMFSTREAMINGMGRNODE_DESCRIPTION_KEY[] = "description";
static const char PVMFSTREAMINGMGRNODE_RATING_KEY[] = "rating";
static const char PVMFSTREAMINGMGRNODE_COPYRIGHT_KEY[] = "copyright";
static const char PVMFSTREAMINGMGRNODE_GENRE_KEY[] = "genre";
static const char PVMFSTREAMINGMGRNODE_LYRICS_KEY[] = "lyrics";
static const char PVMFSTREAMINGMGRNODE_CLASSIFICATION_KEY[] = "classification";
static const char PVMFSTREAMINGMGRNODE_KEYWORDS_KEY[] = "keywords";
static const char PVMFSTREAMINGMGRNODE_LOCATION_KEY[] = "location";
static const char PVMFSTREAMINGMGRNODE_DURATION_KEY[] = "duration";
static const char PVMFSTREAMINGMGRNODE_NUMTRACKS_KEY[] = "num-tracks";
static const char PVMFSTREAMINGMGRNODE_RANDOM_ACCESS_DENIED_KEY[] = "random-access-denied";
static const char PVMFSTREAMINGMGRNODE_NUM_GRAPHICS_KEY[] = "graphic/num-frames;format=APIC";
static const char PVMFSTREAMINGMGRNODE_GRAPHICS_KEY[] = "graphic;format=APIC";
static const char PVMFSTREAMINGMGRNODE_TRACKINFO_TYPE_KEY[] = "track-info/type";
static const char PVMFSTREAMINGMGRNODE_TRACKINFO_DURATION_KEY[] = "track-info/duration";
static const char PVMFSTREAMINGMGRNODE_TRACKINFO_BITRATE_KEY[] = "track-info/bit-rate";
static const char PVMFSTREAMINGMGRNODE_TRACKINFO_MAX_BITRATE_KEY[] = "track-info/max-bitrate";
static const char PVMFSTREAMINGMGRNODE_TRACKINFO_SELECTED_KEY[] = "track-info/selected";
static const char PVMFSTREAMINGMGRNODE_TRACKINFO_WIDTH_KEY[] = "track-info/video/width";
static const char PVMFSTREAMINGMGRNODE_TRACKINFO_HEIGHT_KEY[] = "track-info/video/height";
static const char PVMFSTREAMINGMGRNODE_TRACKINFO_SAMPLERATE_KEY[] = "track-info/sample-rate";
static const char PVMFSTREAMINGMGRNODE_TRACKINFO_NUMCHANNELS_KEY[] = "track-info/audio/channels";
static const char PVMFSTREAMINGMGRNODE_TRACKINFO_AUDIO_BITS_PER_SAMPLE_KEY[] = "track-info/audio/bits-per-sample";
static const char PVMFSTREAMINGMGRNODE_TRACKINFO_TRACKID_KEY[] = "track-info/track-id";

static const char PVMFSTREAMINGMGRNODE_SEMICOLON[] = ";";
static const char PVMFSTREAMINGMGRNODE_TIMESCALE[] = "timescale=";
static const char PVMFSTREAMINGMGRNODE_INDEX[] = "index=";
static const char PVMFSTREAMINGMGRNODE_CLIP_TYPE_KEY[] = "clip-type";
static const char PVMFSTREAMINGMGRNODE_TRACKINFO_FRAME_RATE_KEY[] = "track-info/frame-rate";
static const char PVMFSTREAMINGMGRNODE_TRACKINFO_CODEC_NAME_KEY[] = "track-info/codec-name";
static const char PVMFSTREAMINGMGRNODE_TRACKINFO_CODEC_DESCRIPTION_KEY[] = "track-info/codec-description";
static const char PVMFSTREAMINGMGRNODE_TRACKINFO_CODEC_DATA_KEY[] = "track-info/codec-specific-info";

static const char PVMFSTREAMINGMGRNODE_MAXSIZE[] = "maxsize=";
static const char PVMFSTREAMINGMGRNODE_REQSIZE[] = "reqsize=";
static const char PVMFSTREAMINGMGRNODE_TRUNCATE_FLAG[] = "truncate=";

///////////////////////////////////////////////////////////////////////////////
//
// Capability and config interface related constants and definitions
//   - based on pv_player_engine.h
//
///////////////////////////////////////////////////////////////////////////////

static const StreamingManagerKeyStringData StreamingManagerConfig_BaseKeys[] =
{
    {"delay", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32},
    {"jitterBufferNumResize", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32},
    {"jitterBufferResizeSize", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32},
    {"user-agent", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_WCHARPTR},
    {"keep-alive-interval", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32},
    {"keep-alive-during-play", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_BOOL},
    {"switch-streams", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_CHARPTR},
    {"speed", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32},
    {"http-version", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_CHARPTR},
    {"num-redirect-attempts", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32},
    {"protocol-extension-header", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_CHARPTR},
    {"http-timeout", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32},
    {"http-streaming-logging-timeout", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32},
    {"x-str-header", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_BOOL},
    {"max-streaming-asf-header-size", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32},
    {"max-tcp-recv-buffer-size", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32},
    {"rebuffering-threshold", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32},
    {"accel-bitrate", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32},
    {"accel-duration", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_UINT32},
    {"disable-firewall-packets", PVMI_KVPTYPE_VALUE, PVMI_KVPVALTYPE_BOOL}
};

static const uint StreamingManagerConfig_NumBaseKeys =
    (sizeof(StreamingManagerConfig_BaseKeys) /
     sizeof(StreamingManagerKeyStringData));

enum BaseKeys_IndexMapType
{
    BASEKEY_DELAY = 0,
    BASEKEY_JITTERBUFFER_NUMRESIZE,
    BASEKEY_JITTERBUFFER_RESIZESIZE,
    BASEKEY_SESSION_CONTROLLER_USER_AGENT,
    BASEKEY_SESSION_CONTROLLER_KEEP_ALIVE_INTERVAL,
    BASEKEY_SESSION_CONTROLLER_KEEP_ALIVE_DURING_PLAY,
    BASEKEY_STREAMING_MGR_SWITCH_STREAMS,
    BASEKEY_STREAMING_SPEED,
    BASEKEY_HTTP_VERSION,
    BASEKEY_NUM_REDIRECT_ATTEMPTS,
    BASEKEY_PROTOCOL_EXTENSION_HEADER,
    BASEKEY_SESSION_CONTROLLER_HTTP_TIMEOUT,
    BASEKEY_SESSION_CONTROLLER_HTTP_STREAMING_LOGGING_TIMEOUT,
    BASEKEY_SESSION_CONTROLLER_XSTR_HTTP_HEADER,
    BASEKEY_MAX_STREAMING_ASF_HEADER_SIZE,
    BASEKEY_MAX_TCP_RECV_BUFFER_SIZE,
    BASEKEY_REBUFFERING_THRESHOLD,
    BASEKEY_ACCEL_BITRATE,
    BASEKEY_ACCEL_DURATION,
    BASEKEY_DISABLE_FIREWALL_PACKETS
};

///////////////////////////////////////////////////////////////////////////////

void
PVMFStreamingManagerNodeCommand::Copy(const PVMFGenericNodeCommand<OsclMemAllocator>& aCmd)
{
    PVMFGenericNodeCommand<OsclMemAllocator>::Copy(aCmd);
    switch (aCmd.iCmd)
    {
        case PVMF_STREAMING_MANAGER_NODE_GETNODEMETADATAKEYS:
            if (aCmd.iParam4)
            {
                /* copy the allocated string */
                OSCL_HeapString<OsclMemAllocator>* aStr =
                    (OSCL_HeapString<OsclMemAllocator>*)aCmd.iParam4;
                Oscl_TAlloc<OSCL_HeapString<OsclMemAllocator>, OsclMemAllocator> str;
                iParam4 = str.ALLOC_AND_CONSTRUCT(*aStr);
            }
            break;
        default:
            break;
    }
}

/* need to overlaod the base Destroy routine to cleanup metadata key */
void PVMFStreamingManagerNodeCommand::Destroy()
{
    PVMFGenericNodeCommand<OsclMemAllocator>::Destroy();
    switch (iCmd)
    {
        case PVMF_STREAMING_MANAGER_NODE_GETNODEMETADATAKEYS:
            if (iParam4)
            {
                /* cleanup the allocated string */
                Oscl_TAlloc<OSCL_HeapString<OsclMemAllocator>, OsclMemAllocator> str;
                str.destruct_and_dealloc(iParam4);
            }
            break;
        default:
            break;
    }
}

/**
//////////////////////////////////////////////////
// Node Constructor & Destructor
//////////////////////////////////////////////////
*/

OSCL_EXPORT_REF PVMFStreamingManagerNode::PVMFStreamingManagerNode(int32 aPriority)
        : OsclActiveObject(aPriority, "StreamingManagerNode")
{
    iLogger = NULL;
    iCmdSeqLogger = NULL;
    iReposLogger = NULL;

    iLogger = PVLogger::GetLoggerObject("StreamingManagerNode");

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::PVMFStreamingManagerNode - In"));

    iExtensionInterface = NULL;
    iExtensionInterfacePlaceholder = NULL;
    iQueryUUIDComplete = false;
    iQueryInterfaceComplete = false;
    iTotalNumRequestPortsComplete = 0;
    iNumRequestPortsPending = 0;
    iTotalNumInitPhaseRequestPortsComplete = 0;
    iTotalNumInitPhaseRequestPortsPending = 0;
    oGraphConstructComplete = false;
    oGraphConnectComplete = false;
    iSessionStartTime = 0;
    iSessionStopTime = 0;
    iSessionStopTimeAvailable = true;
    iSessionSeekAvailable = true;
    oRepositioning = false;
    oPlayListRepositioning = false;
    iRepositionRequestedStartNPTInMS = 0;
    iActualRepositionStartNPTInMS = 0;
    iActualMediaDataTS = 0;
    iActualRepositionStartNPTInMSPtr = NULL;
    iActualMediaDataTSPtr = NULL;
    iPVMFDataSourcePositionParamsPtr = NULL;
    iJumpToIFrame = false;
    iJitterBufferDurationInMilliSeconds = DEFAULT_JITTER_BUFFER_DURATION_IN_MS;
    iAutoPausePending = false;
    iAutoResumePending = 0;
    iAutoPaused = false;
    iStreamThinningInProgress = false;
    iPlaylistPlayInProgress = false;
    iSwitchStreamIFrameVideo = false;
    iErrorDuringProcess = SM_NO_ERROR;
    iErrorResponseInf = NULL;
    iCmdErrStatus = PVMFFailure;
    iEventData = NULL;

    ibRdtTransport = false;
    ibCloaking = false;

    ipRealChallengeGen = NULL;
    ipRdtParser = NULL;

    iStreamID = 0;

    iSourceContextDataValid    = false;
    iUseCPMPluginRegistry      = false;
    iPreviewMode               = false;
    iDRMResetPending		   = false;
    iCPMInitPending            = false;
    maxPacketSize			   = 0;
    iPVMFStreamingManagerNodeMetadataValueCount = 0;
    iCPMMetaDataExtensionInterface = NULL;
    iCPMLicenseInterface           = NULL;
    iCPMGetMetaDataKeysCmdId       = 0;
    iCPMGetMetaDataValuesCmdId     = 0;
    iCPMGetLicenseInterfaceCmdId   = 0;
    iCPMGetLicenseCmdId			   = 0;
    iCPMCancelGetLicenseCmdId	   = 0;
    iCPM                       = NULL;
    iCPMSessionID              = 0xFFFFFFFF;
    iCPMContentType            = PVMF_CPM_CONTENT_FORMAT_UNKNOWN;
    iCPMContentAccessFactory   = NULL;
    iDecryptionInterface       = NULL;
    iCPMInitCmdId              = 0;
    iCPMOpenSessionCmdId       = 0;
    iCPMRegisterContentCmdId   = 0;
    iCPMRequestUsageId         = 0;
    iCPMUsageCompleteCmdId     = 0;
    iCPMCloseSessionCmdId      = 0;
    iCPMResetCmdId             = 0;
    iRequestedUsage.key        = NULL;
    iApprovedUsage.key         = NULL;
    iAuthorizationDataKvp.key  = NULL;
    CleanupCPMdata();

    int32 err;
    OSCL_TRY(err,
             /*
              * Create the input command queue.  Use a reserve to avoid lots of
              * dynamic memory allocation.
              */
             iInputCommands.Construct(PVMF_STREAMING_MANAGER_NODE_COMMAND_ID_START,
                                      PVMF_STREAMING_MANAGER_VECTOR_RESERVE);

             /*
              * Create the "current command" queue.  It will only contain one
              * command at a time, so use a reserve of 1.
              */
             iCurrentCommand.Construct(0, 1);

             /*
              * Create the "cancel command" queue.  It will only contain one
              * command at a time, so use a reserve of 1.
              */
             iCancelCommand.Construct(0, 1);

             /*
              * Set the node capability data.
              * This node can support an unlimited number of ports.
              */
             iCapability.iCanSupportMultipleInputPorts = false;
             iCapability.iCanSupportMultipleOutputPorts = true;
             iCapability.iHasMaxNumberOfPorts = false;
             iCapability.iMaxNumberOfPorts = 0;//no maximum

             PVMF_STREAMING_MANAGER_NEW(NULL,
                                        PVMFSMSessionSourceInfo,
                                        (),
                                        iSessionSourceInfo);

             /*
              * Create Socket Node
              */
             OsclExclusivePtr<PVMFNodeInterface> socketNodeAutoPtr;
             PVMFNodeInterface* iSocketNode;
             PVMF_STREAMING_MANAGER_NEW(NULL,
                                        PVMFSocketNode,
                                        (OsclActiveObject::EPriorityNominal),
                                        iSocketNode);
             socketNodeAutoPtr.set(iSocketNode);

             PVMFSMNodeContainer sSocketNodeContainer;

             PVMFNodeSessionInfo socketNodeSession(this,
                                                   this,
                                                   OSCL_REINTERPRET_CAST(OsclAny*,
                                                                         iSocketNode),
                                                   this,
                                                   OSCL_REINTERPRET_CAST(OsclAny*,
                                                                         iSocketNode));

             sSocketNodeContainer.iNode = iSocketNode;
             sSocketNodeContainer.iSessionId =
                 iSocketNode->Connect(socketNodeSession);
             sSocketNodeContainer.iNodeTag =
                 PVMF_STREAMING_MANAGER_SOCKET_NODE;
             sSocketNodeContainer.commandStartOffset =
                 PVMF_STREAMING_MANAGER_SOCKET_NODE_COMMAND_START;
             /* Push back the known UUID in case there are no queries */
             PVUuid uuid(PVMF_SOCKET_NODE_EXTENSION_INTERFACE_UUID);
             sSocketNodeContainer.iExtensionUuids.push_back(uuid);
             iNodeContainerVec.push_back(sSocketNodeContainer);

             /*
              * Create Session Controller Node
              */
             OsclExclusivePtr<PVMFNodeInterface> sessionControllerAutoPtr;
             PVMFNodeInterface* iSessionControllerNode = PVMFRrtspEngineNodeFactory::CreatePVMFRtspEngineNode(OsclActiveObject::EPriorityNominal);
             sessionControllerAutoPtr.set(iSessionControllerNode);

             PVMFSMNodeContainer sSessionControllerNodeContainer;

             PVMFNodeSessionInfo sessionControllerSession(this,
                     this,
                     OSCL_REINTERPRET_CAST(OsclAny*,
                                           iSessionControllerNode),
                     this,
                     OSCL_REINTERPRET_CAST(OsclAny*,
                                           iSessionControllerNode));

             sSessionControllerNodeContainer.iNode = iSessionControllerNode;
             sSessionControllerNodeContainer.iSessionId =
                 iSessionControllerNode->Connect(sessionControllerSession);
             sSessionControllerNodeContainer.iNodeTag =
                 PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE;
             sSessionControllerNodeContainer.commandStartOffset =
                 PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_COMMAND_START;
             /* Push back the known UUID in case there are no queries */
             sSessionControllerNodeContainer.iExtensionUuids.push_back(KPVRTSPEngineNodeExtensionUuid);
             iNodeContainerVec.push_back(sSessionControllerNodeContainer);

             /*
              * Create jitter buffer node
              */
             OsclExclusivePtr<PVMFNodeInterface> jitterBufferNodeAutoPtr;
             PVMFNodeInterface* iJitterBufferNode;
             PVMF_STREAMING_MANAGER_NEW(NULL,
                                        PVMFJitterBufferNode,
                                        (OsclActiveObject::EPriorityNominal),
                                        iJitterBufferNode);
             jitterBufferNodeAutoPtr.set(iJitterBufferNode);

             PVMFSMNodeContainer sJitterBufferNodeContainer;

             PVMFNodeSessionInfo jitterBufferSession(this,
                                                     this,
                                                     OSCL_REINTERPRET_CAST(OsclAny*,
                                                                           iJitterBufferNode),
                                                     this,
                                                     OSCL_REINTERPRET_CAST(OsclAny*,
                                                                           iJitterBufferNode));

             sJitterBufferNodeContainer.iNode = iJitterBufferNode;
             sJitterBufferNodeContainer.iSessionId =
                 iJitterBufferNode->Connect(jitterBufferSession);
             sJitterBufferNodeContainer.iNodeTag =
                 PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE;
             sJitterBufferNodeContainer.commandStartOffset =
                 PVMF_STREAMING_MANAGER_JITTER_BUFFER_CONTROLLER_COMMAND_START;
             /* Push back the known UUID in case there are no queries */
             sJitterBufferNodeContainer.iExtensionUuids.push_back(PVMF_JITTERBUFFERNODE_EXTENSIONINTERFACE_UUID);
             iNodeContainerVec.push_back(sJitterBufferNodeContainer);

             /*
              * Create media layer node
              */
             OsclExclusivePtr<PVMFNodeInterface> mediaLayerNodeAutoPtr;
             PVMFNodeInterface* iMediaLayerNode;
             PVMF_STREAMING_MANAGER_NEW(NULL,
                                        PVMFMediaLayerNode,
                                        (OsclActiveObject::EPriorityNominal),
                                        iMediaLayerNode);
             mediaLayerNodeAutoPtr.set(iMediaLayerNode);

             PVMFSMNodeContainer sMediaLayerNodeContainer;

             PVMFNodeSessionInfo mediaLayerSession(this,
                                                   this,
                                                   OSCL_REINTERPRET_CAST(OsclAny*,
                                                                         iMediaLayerNode),
                                                   this,
                                                   OSCL_REINTERPRET_CAST(OsclAny*,
                                                                         iMediaLayerNode));

             sMediaLayerNodeContainer.iNode = iMediaLayerNode;
             sMediaLayerNodeContainer.iSessionId =
                 iMediaLayerNode->Connect(mediaLayerSession);
             sMediaLayerNodeContainer.iNodeTag =
                 PVMF_STREAMING_MANAGER_MEDIA_LAYER_NODE;
             sMediaLayerNodeContainer.commandStartOffset =
                 PVMF_STREAMING_MANAGER_MEDIA_LAYER_COMMAND_START;
             /* Push back the known UUID in case there are no queries */
             sMediaLayerNodeContainer.iExtensionUuids.push_back(PVMF_MEDIALAYERNODE_EXTENSIONINTERFACE_UUID);
             iNodeContainerVec.push_back(sMediaLayerNodeContainer);

             for (int32 i = 0; i < PVMF_STREAMING_MANAGER_INTERNAL_CMDQ_SIZE; i++)
{
    iInternalCmdPool[i].cmd = PVMF_STREAMING_MANAGER_INTERNAL_COMMAND_NONE;
        iInternalCmdPool[i].oFree = true;
    }

    sessionControllerAutoPtr.release();
    socketNodeAutoPtr.release();
    jitterBufferNodeAutoPtr.release();
    mediaLayerNodeAutoPtr.release();

    // Allocate memory for metadata key list
    iAvailableMetadataKeys.reserve(PVMFSTREAMINGMGRNODE_NUM_METADATAKEYS);
    iAvailableMetadataKeys.clear();
            );
    if (err != OsclErrNone)
    {
        CleanUp();
        OSCL_LEAVE(err);
    }

    if (err != OsclErrNone)
    {
        CleanUp();
        OSCL_LEAVE(err);
    }

    if (err != OsclErrNone)
    {
        CleanUp();
        OSCL_LEAVE(err);
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::PVMFStreamingManagerNode - Out"));
}

void PVMFStreamingManagerNode::CleanUp()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CleanUp - In"));

    /*
     * if a leave happened, cleanup and re-throw the error
     */
    iInputCommands.clear();
    iCurrentCommand.clear();

    PVMF_STREAMING_MANAGER_DELETE(NULL,
                                  PVMFSMSessionSourceInfo,
                                  iSessionSourceInfo);
    /*
     * Clean up all children nodes
     */
    for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
    {
        if (iNodeContainerVec[i].iNodeTag == PVMF_STREAMING_MANAGER_SOCKET_NODE)
        {
            PVMF_STREAMING_MANAGER_DELETE(NULL,
                                          PVMFSocketNode,
                                          ((PVMFSocketNode*)(iNodeContainerVec[i].iNode)));
        }
        else if (iNodeContainerVec[i].iNodeTag == PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE)
        {
            PVMFRrtspEngineNodeFactory::DeletePVMFRtspEngineNode(iNodeContainerVec[i].iNode);
            iNodeContainerVec[i].iNode = NULL;
        }
        else if (iNodeContainerVec[i].iNodeTag == PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE)
        {
            PVMF_STREAMING_MANAGER_DELETE(NULL,
                                          PVMFJitterBufferNode,
                                          ((PVMFJitterBufferNode*)(iNodeContainerVec[i].iNode)));
        }
        else if (iNodeContainerVec[i].iNodeTag == PVMF_STREAMING_MANAGER_MEDIA_LAYER_NODE)
        {
            PVMF_STREAMING_MANAGER_DELETE(NULL,
                                          PVMFMediaLayerNode,
                                          ((PVMFMediaLayerNode*)(iNodeContainerVec[i].iNode)));
        }
        else if (iNodeContainerVec[i].iNodeTag == PVMF_STREAMING_MANAGER_RTPPACKETSOURCE_NODE)
        {
            PVMF_STREAMING_MANAGER_DELETE(NULL,
                                          PVMFMediaLayerNode,
                                          ((PVMFMediaLayerNode*)(iNodeContainerVec[i].iNode)));
        }

    }
    iNodeContainerVec.clear();
    iCapability.iInputFormatCapability.clear();
    iCapability.iOutputFormatCapability.clear();
    OSCL_CLEANUP_BASE_CLASS(PVMFNodeInterface);
    OSCL_CLEANUP_BASE_CLASS(OsclActiveObject);

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CleanUp - Out"));
    return;
}

OSCL_EXPORT_REF PVMFStreamingManagerNode::~PVMFStreamingManagerNode()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::~PVMFStreamingManagerNode - In"));

    Cancel();

    /* Reset the metadata key list */
    /* Clean up CPM related variables */
    CleanupCPMdata();
    /*Cleanup CPM instance*/
    if (iCPM != NULL)
    {
        iCPM->ThreadLogoff();
        PVMFCPMFactory::DestroyContentPolicyManager(iCPM);
        iCPM = NULL;
    }

    /* thread logoff */
    if (IsAdded())
        RemoveFromScheduler();

    /* Cleanup any old key */
    if (iRequestedUsage.key)
    {
        OSCL_ARRAY_DELETE(iRequestedUsage.key);
        iRequestedUsage.key = NULL;
    }

    if (iApprovedUsage.key)
    {
        OSCL_ARRAY_DELETE(iApprovedUsage.key);
        iApprovedUsage.key = NULL;
    }

    if (iAuthorizationDataKvp.key)
    {
        OSCL_ARRAY_DELETE(iAuthorizationDataKvp.key);
        iAuthorizationDataKvp.key = NULL;
    }

    /* Cleanup allocated interfaces */
    if (iExtensionInterface)
    {
        /*
         * clear the interface container
         * the interface can't function without the node.
         */
        iExtensionInterface->iContainer = NULL;
        iExtensionInterface->removeRef();
    }

    /*
     * Cleanup commands
     * The command queues are self-deleting, but we want to
     * notify the observer of unprocessed commands.
     */
    while (iCurrentCommand.size() > 0)
    {
        CommandComplete(iCurrentCommand, iCurrentCommand.front(), PVMFFailure);
    }
    while (iInputCommands.size() > 0)
    {
        CommandComplete(iInputCommands, iInputCommands.front(), PVMFFailure);
    }

    PVMF_STREAMING_MANAGER_DELETE(NULL,
                                  PVMFSMSessionSourceInfo,
                                  iSessionSourceInfo);

    /*
     * Clean up all children nodes & interfaces
     */
    uint32 i, j;
    for (i = 0; i < iNodeContainerVec.size(); i++)
    {
        for (j = 0; j < iNodeContainerVec[i].iExtensions.size(); j++)
        {
            PVInterface* extIntf = iNodeContainerVec[i].iExtensions[j];
            extIntf->removeRef();
        }

        if (iNodeContainerVec[i].iNodeTag == PVMF_STREAMING_MANAGER_SOCKET_NODE)
        {
            PVMF_STREAMING_MANAGER_DELETE(NULL,
                                          PVMFSocketNode,
                                          ((PVMFSocketNode*)(iNodeContainerVec[i].iNode)));
        }
        else if (iNodeContainerVec[i].iNodeTag == PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE)
        {
            PVMFRrtspEngineNodeFactory::DeletePVMFRtspEngineNode(iNodeContainerVec[i].iNode);
            iNodeContainerVec[i].iNode = NULL;
        }
        else if (iNodeContainerVec[i].iNodeTag == PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE)
        {
            PVMF_STREAMING_MANAGER_DELETE(NULL,
                                          PVMFJitterBufferNode,
                                          ((PVMFJitterBufferNode*)(iNodeContainerVec[i].iNode)));
        }
        else if (iNodeContainerVec[i].iNodeTag == PVMF_STREAMING_MANAGER_MEDIA_LAYER_NODE)
        {
            PVMF_STREAMING_MANAGER_DELETE(NULL,
                                          PVMFMediaLayerNode,
                                          ((PVMFMediaLayerNode*)(iNodeContainerVec[i].iNode)));
        }

    }
    iNodeContainerVec.clear();

    // destroy the payload parser registry
    destroyPayloadParserRegistry();


    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::~PVMFStreamingManagerNode - Out"));
}

void PVMFStreamingManagerNode::CleanupCPMdata()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CleanupCPMdata() Called"));

    /* Clean up CPM related variables */
    iSourceContextDataValid = false;
    iUseCPMPluginRegistry   = false;
    if (iCPMContentAccessFactory != NULL)
    {
        if (iDecryptionInterface != NULL)
        {
            iDecryptionInterface->Reset();
            /* Remove the decrpytion interface */
            PVUuid uuid = PVMFCPMPluginDecryptionInterfaceUuid;
            iCPMContentAccessFactory->DestroyPVMFCPMPluginAccessInterface(uuid, iDecryptionInterface);
            iDecryptionInterface = NULL;
        }
        iCPMContentAccessFactory->removeRef();
        iCPMContentAccessFactory = NULL;
    }
    iCPMContentType = PVMF_CPM_CONTENT_FORMAT_UNKNOWN;
    iPreviewMode = false;
    iCPMInitPending = false;
    iCPMMetadataKeys.clear();
}

/* Called during a Reset */
void PVMFStreamingManagerNode::ResetNodeParams()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::ResetNodeParams - In"));

    iTotalNumRequestPortsComplete = 0;
    iNumRequestPortsPending = 0;
    iTotalNumInitPhaseRequestPortsComplete = 0;
    iTotalNumInitPhaseRequestPortsPending = 0;
    oGraphConstructComplete = false;
    oGraphConnectComplete = false;
    iAutoPausePending = false;
    iAutoResumePending = 0;
    iAutoPaused = false;
    iStreamThinningInProgress = false;
    iPlaylistPlayInProgress = false;
    iSwitchStreamIFrameVideo = false;

    iMetaDataInfo.Reset();
    iTrackInfoVec.clear();

    PVMFSMNodeContainerVector::iterator it;
    for (it = iNodeContainerVec.begin(); it != iNodeContainerVec.end(); it++)
    {
        it->Reset();
    }

    /* Delete current session info and recreate a new one */
    PVMF_STREAMING_MANAGER_DELETE(NULL,
                                  PVMFSMSessionSourceInfo,
                                  iSessionSourceInfo);
    iSessionSourceInfo = NULL;

    PVMF_STREAMING_MANAGER_NEW(NULL,
                               PVMFSMSessionSourceInfo,
                               (),
                               iSessionSourceInfo);

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::ResetNodeParams - Out"));
}

/**
 * Do thread-specific node creation and go to "Idle" state.
 */
OSCL_EXPORT_REF PVMFStatus PVMFStreamingManagerNode::ThreadLogon()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::ThreadLogon - In"));

    PVMFStatus status = PVMFSuccess;
    switch (iInterfaceState)
    {
        case EPVMFNodeCreated:
        {
            if (!IsAdded())
                AddToScheduler();

            iCmdSeqLogger = PVLogger::GetLoggerObject("pvplayercmdseq.streamingmanager");
            iReposLogger = PVLogger::GetLoggerObject("pvplayerrepos.sourcenode.streamingmanager");

            /*
             * Call thread logon for all the children nodes
             */
            for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
            {
                if (iNodeContainerVec[i].iNode->ThreadLogon() != PVMFSuccess)
                {
                    PVMF_SM_LOGERROR((0, "StreamingManagerNode - Child Node:ThreadLogon Failed, Node Tag %d", iNodeContainerVec[i].iNodeTag));
                    status = PVMFFailure;
                }
            }
            if (status == PVMFSuccess)
            {
                PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::ThreadLogon() - State - EPVMFNodeIdle"));
                SetState(EPVMFNodeIdle);
            }
        }
        break;
        default:
            status = PVMFErrInvalidState;
            break;
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::ThreadLogon - Out"));
    return (status);
}

/**
 * Do thread-specific node cleanup and go to "Created" state.
 */
OSCL_EXPORT_REF PVMFStatus PVMFStreamingManagerNode::ThreadLogoff()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::ThreadLogoff - In"));

    PVMFStatus status = PVMFSuccess;
    switch (iInterfaceState)
    {
        case EPVMFNodeIdle:
        {
            /* Reset the metadata key list */
            /* Clean up CPM related variables */
            CleanupCPMdata();

            if (IsAdded())
                RemoveFromScheduler();
            iLogger = NULL;
            iCmdSeqLogger = NULL;
            iReposLogger = NULL;

            /*
             * Call thread logon for all the children nodes
             */
            for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
            {
                PVMFNodeInterface* node = iNodeContainerVec[i].iNode;
                if (node->GetState() != EPVMFNodeCreated)
                {
                    if (node->ThreadLogoff() != PVMFSuccess)
                    {
                        PVMF_SM_LOGERROR((0, "StreamingManagerNode - Child Node:ThreadLogoff Failed, Node Tag %d", iNodeContainerVec[i].iNodeTag));
                        status = PVMFFailure;
                    }
                }
            }
            if (status == PVMFSuccess)
            {
                SetState(EPVMFNodeCreated);
                PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::ThreadLogoff() - State - EPVMFNodeIdle"));
            }
            else
            {
                SetState(EPVMFNodeError);
                PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::ThreadLogoff() - State - EPVMFNodeError"));
            }
        }
        break;

        case EPVMFNodeCreated:
            status = PVMFSuccess;
            break;

        default:
            status = PVMFErrInvalidState;
            break;
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::ThreadLogoff - Out"));
    return (status);
}

/**
 * retrieve node capabilities.
 */
OSCL_EXPORT_REF PVMFStatus PVMFStreamingManagerNode::GetCapability(PVMFNodeCapability& aNodeCapability)
{
    PVMF_SM_LOGINFO((0, "StreamingManagerNode:GetCapability"));
    aNodeCapability = iCapability;
    return PVMFSuccess;
}

/**
 * retrive a port iterator.
 */
OSCL_EXPORT_REF PVMFPortIter* PVMFStreamingManagerNode::GetPorts(const PVMFPortFilter* aFilter)
{
    PVMF_SM_LOGINFO((0, "StreamingManagerNode:GetPorts"));
    OSCL_UNUSED_ARG(aFilter);//port filter is not implemented.
    return NULL;
}

/**
 * Queue an asynchronous QueryUUID command
 * QueryUUID for the streaming manager node is not complete until QueryUUIDs
 * are complete for all the children node (viz. session controller, jitter buffer
 * controller etc)
 */
OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::QueryUUID(PVMFSessionId s, const PvmfMimeString& aMimeType,
        Oscl_Vector<PVUuid, OsclMemAllocator>& aUuids,
        bool aExactUuidsOnly,
        const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::QueryUUID - In"));
    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommandBase::Construct(s, PVMF_STREAMING_MANAGER_NODE_QUERYUUID, aMimeType, aUuids, aExactUuidsOnly, aContext);
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::QueryUUID - Out"));
    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::QueryUUID() - Cmd Recvd"));
    return QueueCommandL(cmd);
}

/**
 * Called by the command handler AO to do the Query UUID
 */
void PVMFStreamingManagerNode::DoQueryUuid(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoQueryUuid - In"));
    if (iQueryUUIDComplete == false)
    {
        /*
         * QueryUUID for streaming manager cannot be completed unless
         * QueryUUID for all the children nodes are complete
         */

        PVMFSMCommandContext* internalCmd = NULL;
        OsclAny *cmdContextData  = NULL;
        /*
         * QueryUUID from socket node
         */
        OSCL_StackString<50> socketNodeExtMimeType(PVMF_SOCKET_NODE_EXTENSION_INTERFACE_MIMETYPE);

        internalCmd = RequestNewInternalCmd();
        if (internalCmd == NULL)
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:DoQueryUuid:RequestNewInternalCmd - Failed"));
            CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
            return;
        }
        internalCmd->cmd = PVMF_STREAMING_MANAGER_SOCKET_NODE_QUERY_UUID;
        internalCmd->parentCmd = aCmd.iCmd;
        cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

        PVMFSMNodeContainer* iSocketNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_SOCKET_NODE);
        if (iSocketNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
        PVMFNodeInterface* iSocketNode = iSocketNodeContainer->iNode;

        iSocketNode->QueryUUID(iSocketNodeContainer->iSessionId,
                               socketNodeExtMimeType,
                               iSocketNodeContainer->iExtensionUuids,
                               true,
                               cmdContextData);
        iSocketNodeContainer->iNodeCmdState = PVMFSM_NODE_CMD_PENDING;

        /*
         * QueryUUID from rtsp session controller
         */
        OSCL_StackString<50> sessionControllerExtMimeType(PVMF_RTSPENGINENODE_CUSTOM1_MIMETYPE);

        internalCmd = RequestNewInternalCmd();
        if (internalCmd == NULL)
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:DoQueryUuid:RequestNewInternalCmd - Failed"));
            CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
            return;
        }
        internalCmd->cmd = PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_QUERY_UUID;
        internalCmd->parentCmd = aCmd.iCmd;
        cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

        PVMFSMNodeContainer* iSessionControllerNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);
        if (iSessionControllerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
        PVMFNodeInterface* iSessionControllerNode = iSessionControllerNodeContainer->iNode;

        iSessionControllerNode->QueryUUID(iSessionControllerNodeContainer->iSessionId,
                                          sessionControllerExtMimeType,
                                          iSessionControllerNodeContainer->iExtensionUuids,
                                          true,
                                          cmdContextData);
        iSessionControllerNodeContainer->iNodeCmdState = PVMFSM_NODE_CMD_PENDING;

        /*
         * QueryUUID from jitter buffer node
         */
        OSCL_StackString<50> jitterBufferExtMimeType(PVMF_JITTERBUFFER_CUSTOMINTERFACE_MIMETYPE);

        internalCmd = RequestNewInternalCmd();
        if (internalCmd == NULL)
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:DoQueryUuid:RequestNewInternalCmd - Failed"));
            CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
            return;
        }
        internalCmd->cmd = PVMF_STREAMING_MANAGER_JITTER_BUFFER_QUERY_UUID;
        internalCmd->parentCmd = aCmd.iCmd;
        cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

        PVMFSMNodeContainer* iJitterBufferNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
        if (iJitterBufferNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
        PVMFNodeInterface* iJitterBufferNode = iJitterBufferNodeContainer->iNode;

        iJitterBufferNode->QueryUUID(iJitterBufferNodeContainer->iSessionId,
                                     jitterBufferExtMimeType,
                                     iJitterBufferNodeContainer->iExtensionUuids,
                                     true,
                                     cmdContextData);
        iJitterBufferNodeContainer->iNodeCmdState = PVMFSM_NODE_CMD_PENDING;

        /*
         * QueryUUID from media layer node
         */
        OSCL_StackString<50> mediaLayerExtMimeType(PVMF_MEDIALAYER_CUSTOMINTERFACE_MIMETYPE);

        internalCmd = RequestNewInternalCmd();
        if (internalCmd == NULL)
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:DoQueryUuid:RequestNewInternalCmd - Failed"));
            CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
            return;
        }
        internalCmd->cmd = PVMF_STREAMING_MANAGER_MEDIA_LAYER_QUERY_UUID;
        internalCmd->parentCmd = aCmd.iCmd;
        cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

        PVMFSMNodeContainer* iMediaLayerNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_MEDIA_LAYER_NODE);
        if (iMediaLayerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
        PVMFNodeInterface* iMediaLayerNode = iMediaLayerNodeContainer->iNode;

        iMediaLayerNode->QueryUUID(iMediaLayerNodeContainer->iSessionId,
                                   mediaLayerExtMimeType,
                                   iMediaLayerNodeContainer->iExtensionUuids,
                                   true,
                                   cmdContextData);
        iMediaLayerNodeContainer->iNodeCmdState = PVMFSM_NODE_CMD_PENDING;
        /*
         * QueryUUID from HTTP PE node
         */
        OSCL_StackString<50> httpNodeExtMimeType(PVMF_PROTOCOL_ENGINE_MSHTTP_STREAMING_EXTENSION_MIMETYPE);

        internalCmd = RequestNewInternalCmd();
        if (internalCmd == NULL)
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:DoQueryUuid:RequestNewInternalCmd - Failed"));
            CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
            return;
        }
        internalCmd->cmd = PVMF_STREAMING_MANAGER_HTTP_SESSION_CONTROLLER_QUERY_UUID;
        internalCmd->parentCmd = aCmd.iCmd;
        cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

        PVMFSMNodeContainer* iHTTPNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_HTTP_SESSION_CONTROLLER_NODE);
        if (iHTTPNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
        PVMFNodeInterface* iHTTPNode = iHTTPNodeContainer->iNode;

        iHTTPNode->QueryUUID(iHTTPNodeContainer->iSessionId,
                             httpNodeExtMimeType,
                             iHTTPNodeContainer->iExtensionUuids,
                             true,
                             cmdContextData);
        iHTTPNodeContainer->iNodeCmdState = PVMFSM_NODE_CMD_PENDING;

        /*
         * This node supports Query UUID from any state
         * Query UUID is asynchronous. move the command from
         * the input command queue to the current command, where
         * it will remain until the Query UUID completes.
         */
        MoveCmdToCurrentQueue(aCmd);
    }
    else if (iQueryUUIDComplete == true)
    {
        /*
         * We have already queried the child nodes for UUID
         */
        MoveCmdToCurrentQueue(aCmd);
        CompleteQueryUuid();
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoQueryUuid - Out"));
    return;
}

bool
PVMFStreamingManagerNode::CheckChildrenNodesQueryUuid()
{
    for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
    {
        if (iNodeContainerVec[i].iNodeCmdState != PVMFSM_NODE_CMD_COMPLETE)
        {
            return false;
        }
    }
    ResetNodeContainerCmdState();
    return true;
}

void PVMFStreamingManagerNode::CompleteQueryUuid()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteQueryUuid - In"));
    if (CheckChildrenNodesQueryUuid() || iQueryUUIDComplete == true)
    {
        PVMFStreamingManagerNodeCommand aCmd = iCurrentCommand.front();

        OSCL_String* mimetype;
        Oscl_Vector<PVUuid, OsclMemAllocator> *uuidvec;
        bool exactmatch;
        aCmd.PVMFStreamingManagerNodeCommandBase::Parse(mimetype, uuidvec, exactmatch);

        /*
         * Try to match the input mimetype against any of
         * the custom interfaces for this node
         * Match against extension interface...
         * also match against base mimetypes for extension interface,
         * unless exactmatch is set.
         */
        if (*mimetype == PVMF_STREAMINGMANAGER_CUSTOMINTERFACE_MIMETYPE)
        {
            PVUuid uuid(PVMF_STREAMINGMANAGERNODE_EXTENSIONINTERFACE_UUID);
            uuidvec->push_back(uuid);
        }
        else if (*mimetype == PVMF_DATA_SOURCE_INIT_INTERFACE_MIMETYPE)
        {
            PVUuid uuid(PVMF_DATA_SOURCE_INIT_INTERFACE_UUID);
            uuidvec->push_back(uuid);
        }
        else if (*mimetype == PVMF_TRACK_SELECTION_INTERFACE_MIMETYPE)
        {
            PVUuid uuid(PVMF_TRACK_SELECTION_INTERFACE_UUID);
            uuidvec->push_back(uuid);
        }
        else if (*mimetype == PVMF_DATA_SOURCE_PLAYBACK_CONTROL_INTERFACE_MIMETYPE)
        {
            PVUuid uuid(PvmfDataSourcePlaybackControlUuid);
            uuidvec->push_back(uuid);
        }
        else if (*mimetype == PVMF_META_DATA_EXTENSION_INTERFACE_MIMETYPE)
        {
            PVUuid uuid(KPVMFMetadataExtensionUuid);
            uuidvec->push_back(uuid);
        }

        PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::QueryUUID() - CmdComplete - PVMFSuccess"));
        iQueryUUIDComplete = true;

        CommandComplete(aCmd, PVMFSuccess);
        /* Erase the command from the current queue */
        iCurrentCommand.Erase(&iCurrentCommand.front());
        PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode::QueryUuid Complete"));
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteQueryUuid - Out"));
}

/**
 * Queue an asynchronous node command QueryInterface
 */
OSCL_EXPORT_REF PVMFCommandId
PVMFStreamingManagerNode::QueryInterface(PVMFSessionId s,
        const PVUuid& aUuid,
        PVInterface*& aInterfacePtr,
        const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::QueryInterface - In"));
    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommandBase::Construct(s, PVMF_STREAMING_MANAGER_NODE_QUERYINTERFACE, aUuid, aInterfacePtr, aContext);
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::QueryInterface - Out"));
    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::QueryInterface() - Cmd Recvd"));
    return QueueCommandL(cmd);
}

/**
 * Called by the command handler AO to do the Query Interface.
 */
void PVMFStreamingManagerNode::DoQueryInterface(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoQueryInterface - In"));
    if (iQueryInterfaceComplete == false)
    {
        /*
         * QueryInterface for streaming manager cannot be completed unless
         * QueryInterface for all the children nodes are complete
         */
        for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
        {
            PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
            if (internalCmd != NULL)
            {
                internalCmd->cmd =
                    iNodeContainerVec[i].commandStartOffset +
                    PVMF_STREAMING_MANAGER_NODE_INTERNAL_QUERY_INTERFACE_CMD_OFFSET;
                internalCmd->parentCmd = aCmd.iCmd;

                OsclAny *cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

                PVMFNodeInterface* iNode = iNodeContainerVec[i].iNode;

                iNode->QueryInterface(iNodeContainerVec[i].iSessionId,
                                      iNodeContainerVec[i].iExtensionUuids.front(),
                                      iExtensionInterfacePlaceholder,
                                      cmdContextData);
                iNodeContainerVec[i].iNodeCmdState = PVMFSM_NODE_CMD_PENDING;
            }
            else
            {
                PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoQueryInterface:RequestNewInternalCmd - Failed"));
                CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
                return;
            }
        }
        /*
         * This node supports QueryInterface from any state
         * QueryInterface is asynchronous. move the command from
         * the input command queue to the current command, where
         * it will remain until the QueryInterface completes.
         */
        MoveCmdToCurrentQueue(aCmd);
    }
    else if (iQueryInterfaceComplete == true)
    {
        /*
         * We have already queried the child nodes for interface
         */
        MoveCmdToCurrentQueue(aCmd);
        CompleteQueryInterface();
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoQueryInterface - Out"));
    return;
}

bool
PVMFStreamingManagerNode::CheckChildrenNodesQueryInterface()
{
    for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
    {
        if (iNodeContainerVec[i].iNodeCmdState != PVMFSM_NODE_CMD_COMPLETE)
        {
            return false;
        }
    }
    ResetNodeContainerCmdState();
    return true;
}

void PVMFStreamingManagerNode::CompleteQueryInterface()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteQueryInterface - In"));
    if (CheckChildrenNodesQueryInterface() || iQueryInterfaceComplete == true)
    {
        PVMFStreamingManagerNodeCommand aCmd = iCurrentCommand.front();

        PVUuid* uuid;
        PVInterface** ptr;
        aCmd.PVMFStreamingManagerNodeCommandBase::Parse(uuid, ptr);

        if ((*uuid == PVUuid(PVMF_STREAMINGMANAGERNODE_EXTENSIONINTERFACE_UUID)) ||
                (*uuid == PVUuid(PVMF_DATA_SOURCE_INIT_INTERFACE_UUID)) ||
                (*uuid == PVUuid(PVMF_TRACK_SELECTION_INTERFACE_UUID)) ||
                (*uuid == PVUuid(PvmfDataSourcePlaybackControlUuid)) ||
                (*uuid == PVUuid(KPVMFMetadataExtensionUuid)) ||
                (*uuid == PVUuid(PVMI_CAPABILITY_AND_CONFIG_PVUUID)) ||
                (*uuid == PVUuid(PVMFCPMPluginLicenseInterfaceUuid)))
        {
            if (!iExtensionInterface)
            {
                PVMFStreamingManagerNodeAllocator alloc;
                int32 err;
                OsclAny*ptr = NULL;
                OSCL_TRY(err,
                         ptr = alloc.ALLOCATE(sizeof(PVMFStreamingManagerExtensionInterfaceImpl));
                        );
                if (err != OsclErrNone || !ptr)
                {
                    PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode CompleteQueryInterface Failed"));
                    CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
                    return;
                }
                iExtensionInterface =
                    new(ptr) PVMFStreamingManagerExtensionInterfaceImpl(this,
                            aCmd.iSession);
            }

            iQueryInterfaceComplete = true;
            iExtensionInterface->queryInterface(*uuid, *ptr);
            iExtensionInterface->addRef();
            PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::QueryInterface() - CmdComplete - PVMFSuccess"));
            CommandComplete(aCmd, PVMFSuccess);
            /* Erase the command from the current queue */
            iCurrentCommand.Erase(&iCurrentCommand.front());

            PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode CompleteQueryInterface Success"));
        }
        else
        {
            PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::QueryInterface() - CmdFailed - PVMFErrNotSupported"));
            //not supported
            *ptr = NULL;
            CommandComplete(aCmd, PVMFErrNotSupported);
            /* Erase the command from the current queue */
            iCurrentCommand.Erase(&iCurrentCommand.front());
        }
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteQueryInterface - Out"));
}

/**
 * Queue an asynchronous node command - RequestPort
 */
OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::RequestPort(PVMFSessionId s,
        int32 aPortTag,
        const PvmfMimeString* aPortConfig,
        const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::RequestPort - In"));
    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommandBase::Construct(s,
            PVMF_STREAMING_MANAGER_NODE_REQUESTPORT,
            aPortTag,
            aPortConfig,
            aContext);
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::RequestPort - Out"));
    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::RequestPort() - Cmd Recvd"));
    return QueueCommandL(cmd);
}

/**
 * Called by the command handler AO to do the port request
 */
void PVMFStreamingManagerNode::DoRequestPort(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoRequestPort - In"));
    /*
     * This node supports port request only after the graph
     * has been fully constructed
     */
    if (oGraphConstructComplete)
    {
        /*
         * retrieve port tag
         */
        OSCL_String* mimetype;
        int32 tag;
        aCmd.PVMFStreamingManagerNodeCommandBase::Parse(tag, mimetype);
        /*
         * Do not Allocate a new port. Streaming manager treats the output
         * port from the media layer as its own output port. Find the media
         * layer output port corresponding to the input mimetype and hand the
         * same out
         */
        PVMFSMTrackInfo* trackInfo = FindTrackInfo(tag);

        PVUuid eventuuid = PVMFStreamingManagerNodeEventTypeUUID;
        int32 errcode = PVMFStreamingManagerNodeErrorInvalidRequestPortTag;

        if (trackInfo == NULL)
        {
            PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::DoRequestPort: FindTrackInfo failed"));
            CommandComplete(iInputCommands, aCmd, PVMFErrArgument, NULL, &eventuuid, &errcode);
            return;
        }
        if (trackInfo->iMediaLayerOutputPort == NULL)
        {
            PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::DoRequestPort: iMediaLayerOutputPort NULL"));
            CommandComplete(iInputCommands, aCmd, PVMFFailure, NULL, &eventuuid, &errcode);
            return;
        }
        PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::RequestPort() - CmdComplete - PVMFSuccess"));
        /*
         * Return the port pointer to the caller.
         */
        CommandComplete(iInputCommands,
                        aCmd,
                        PVMFSuccess,
                        (OsclAny*)(trackInfo->iMediaLayerOutputPort));

        PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode::DoRequestPort Success"));
    }
    else
    {
        PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::RequestPort() - CmdFailed - PVMFErrInvalidState"));
        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::DoRequestPort Failed - InvalidState"));
        CommandComplete(iInputCommands, aCmd, PVMFErrInvalidState);
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoRequestPort - Out"));
}

/**
 * Queue an asynchronous node command
 */
OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::ReleasePort(PVMFSessionId s, PVMFPortInterface& aPort, const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::ReleasePort - In"));
    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommandBase::Construct(s, PVMF_STREAMING_MANAGER_NODE_RELEASEPORT, aPort, aContext);
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::ReleasePort - Out"));
    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::ReleasePort() - Cmd Recvd"));
    return QueueCommandL(cmd);
}

/**
 * Called by the command handler AO to do the port release
 */
void PVMFStreamingManagerNode::DoReleasePort(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoReleasePort - In"));
    /*
     * Since the streaming manager does not have ports of its own,
     * a release port command typically translates to disconnecting
     * the underlying media layer port.
     */
    PVMFPortInterface* port;
    aCmd.PVMFStreamingManagerNodeCommandBase::Parse((PVMFPortInterface*&)port);

    /*
     * Find TrackInfo that corresponds to the Media Layer Output port
     * on which the current relase is being called.
     */
    PVMFSMTrackInfoVector::iterator it;
    PVMFSMTrackInfo* trackInfo = NULL;

    for (it = iTrackInfoVec.begin();
            it != iTrackInfoVec.end();
            it++)
    {
        if (it->iMediaLayerOutputPort == port)
        {
            trackInfo = it;
            break;
        }
    }

    PVUuid eventuuid = PVMFStreamingManagerNodeEventTypeUUID;
    if (trackInfo == NULL)
    {
        PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::ReleasePort() - CmdFailed - PVMFErrArgument"));
        /* invalid port */
        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::DoReleasePort Failed - Invalid Port"));
        int32 errcode = PVMFStreamingManagerNodeErrorInvalidPort;
        CommandComplete(iInputCommands, aCmd, PVMFErrArgument, NULL, &eventuuid, &errcode);
        return;
    }
    PVMFStatus status = it->iMediaLayerOutputPort->Disconnect();

    if (status != PVMFSuccess)
    {
        PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode::DoReleasePort Success"));
        CommandComplete(iInputCommands, aCmd, PVMFSuccess);
    }
    else
    {
        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::DoReleasePort Failed"));
        CommandComplete(iInputCommands, aCmd, PVMFErrPortProcessing);
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoReleasePort - Out"));
}

/**
 * Queue an asynchronous node command - Init
 */
OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::Init(PVMFSessionId s, const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Init - In"));
    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommandBase::Construct(s, PVMF_STREAMING_MANAGER_NODE_INIT, aContext);
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Init - Out"));
    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::Init() - Cmd Recvd"));
    return QueueCommandL(cmd);
}

/**
 * Call by DoInit as a prep step
 */
PVMFStatus PVMFStreamingManagerNode::DoPreInit(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoPreInit - In"));
    PVMFStatus status = PVMFSuccess;

    if (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE)
    {
    }
    else if (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE)
    {
        status = ProcessSDP();
        if (status == PVMFSuccess)
        {
            PVMFSMNodeContainer* iSessionControllerNodeContainer =
                getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);

            if (iSessionControllerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);

            PVRTSPEngineNodeExtensionInterface* rtspExtIntf =
                (PVRTSPEngineNodeExtensionInterface*)
                (iSessionControllerNodeContainer->iExtensions[0]);

            /*
             * This vector is intentionally left uninitialized.
             * Streaming manager does not have any track selection info
             * at this stage. "SetSDPInfo" would be called again before
             * prepare complete to set up all the selected tracks. This
             * call is needed here to indicate to Session Controller node
             * that it is NOT a RTSP URL based session
             */
            Oscl_Vector<StreamInfo, OsclMemAllocator> aSelectedStream;

            status = rtspExtIntf->SetSDPInfo(iSessionSourceInfo->_sdpInfo,
                                             aSelectedStream);
            if (status != PVMFSuccess)
            {
                PVMF_SM_LOGERROR((0, "StreamingManagerNode:DoPreInit - SetSDPInfo Failed"));
            }
        }
        else
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:DoPreInit - ProcessSDP Failed"));
        }
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoPreInit - Out"));
    return status;
}

void PVMFStreamingManagerNode::CompletePreInit()
{
    OSCL_ASSERT(iSessionSourceInfo->_sessionType ==
                PVMF_DATA_SOURCE_MS_HTTP_STREAMING_URL);

    Asf_CompletePreInit();
}

/**
 * Called by the command handler AO to do the node Init
 */
void PVMFStreamingManagerNode::DoInit(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoInit - In"));
    switch (iInterfaceState)
    {
        case EPVMFNodeIdle:
        {
            /*
             * At first Init, PVMFErrLicneseRequest is replied from Janus.
             * Then iCPMInitPending is set into true.
             * If second Init is called, just to check license authentication is required.
             */
            if (iCPMInitPending == true)
            {
                MoveCmdToCurrentQueue(aCmd);
                {
                    CommandComplete(iCurrentCommand,
                                    iCurrentCommand.front(),
                                    PVMFFailure,
                                    NULL, NULL, NULL);
                    return;
                }
            }
            else
            {
                /* An asynchronous method that prepare's the node for init */
                PVMFStatus status = DoPreInit(aCmd);

                DeleteUnusedSessionControllerNode();

                if (status == PVMFSuccess)
                {
                    /*
                     * Init for streaming manager cannot be completed unless Init
                     * for all the children nodes are complete
                     */
                    PVMFSMNodeContainerVector::iterator it;
                    for (it = iNodeContainerVec.begin(); it != iNodeContainerVec.end(); it++)
                    {
                        {
                            PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
                            if (internalCmd != NULL)
                            {
                                internalCmd->cmd =
                                    it->commandStartOffset +
                                    PVMF_STREAMING_MANAGER_NODE_INTERNAL_INIT_CMD_OFFSET;
                                internalCmd->parentCmd = aCmd.iCmd;

                                OsclAny *cmdContextData =
                                    OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

                                PVMFNodeInterface* iNode = it->iNode;

                                iNode->Init(it->iSessionId, cmdContextData);
                                it->iNodeCmdState = PVMFSM_NODE_CMD_PENDING;
                            }
                            else
                            {
                                PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoInit:RequestNewInternalCmd - Failed"));
                                CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
                                return;
                            }
                        }
                    }
                    MoveCmdToCurrentQueue(aCmd);
                }
                else if (status == PVMFPending)
                {
                    MoveCmdToCurrentQueue(aCmd);
                }
                else
                {
                    PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoInit: DoPreInit() - Failed"));
                    PVUuid eventuuid = PVMFStreamingManagerNodeEventTypeUUID;
                    int32 errcode = PVMFStreamingManagerNodeErrorParseSDPFailed;
                    CommandComplete(iInputCommands, aCmd, PVMFFailure, NULL, &eventuuid, &errcode);
                    return;
                }
            }
        }
        break;

        default:
        {
            PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::DoInit Failed - Invalid State"));
            CommandComplete(iInputCommands, aCmd, PVMFErrInvalidState);
        }
        break;
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoInit - Out"));
}

bool
PVMFStreamingManagerNode::CheckChildrenNodesInit()
{
    {
        for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
        {
            if (iNodeContainerVec[i].iNodeCmdState != PVMFSM_NODE_CMD_COMPLETE)
            {
                return false;
            }
        }
    }
    ResetNodeContainerCmdState();
    return true;
}

void PVMFStreamingManagerNode::CompleteInit()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteInit - In"));
    if (CheckChildrenNodesInit() && iErrorDuringProcess == SM_NO_ERROR)
    {
        if (!iCurrentCommand.empty() && iCancelCommand.empty())
        {
            PVMFStreamingManagerNodeCommand aCmd = iCurrentCommand.front();
            if (aCmd.iCmd == PVMF_STREAMING_MANAGER_NODE_INIT)
            {
                // create and pass the payload parser registry on to the media layer node
                PopulatePayloadParserRegistry();

                PVMFStatus status = PVMFSuccess;

                if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL))
                {
                    status = ProcessSDP();
                }
                if (status == PVMFSuccess)
                {
                    status = InitMetaData();
                    if (status == PVMFSuccess)
                    {
                    }
                    else
                    {
                        PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteInit - InitMetaData fail"));
                    }

                    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::Init() - CmdComplete - PVMFSuccess"));
                    //Init is completed at unprotected clip
                    SetState(EPVMFNodeInitialized);
                    PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode::CompleteInit Success"));
                    CommandComplete(aCmd, PVMFSuccess);
                }
                else
                {
                    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::Init() - Cmd Failed - PVMFStreamingManagerNodeErrorParseSDPFailed"));
                    PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::CompleteInit Failure"));
                    PVUuid eventuuid = PVMFStreamingManagerNodeEventTypeUUID;
                    int32 errcode = PVMFStreamingManagerNodeErrorParseSDPFailed;
                    CommandComplete(aCmd, status, NULL, &eventuuid, &errcode);
                }
                /* Erase the command from the current queue */
                iCurrentCommand.Erase(&iCurrentCommand.front());
            }
        }
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteInit - Out"));
    return;
}

/**
 * Queue an asynchronous node command - Prepare
 */
OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::Prepare(PVMFSessionId s,
        const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Prepare - In"));
    /* Queue an internal command for Graph construct */
    PVMFStreamingManagerNodeCommand cmdGC;
    cmdGC.PVMFStreamingManagerNodeCommandBase::Construct(s,
            PVMF_STREAMING_MANAGER_NODE_CONSTRUCT_SESSION,
            NULL);

    QueueCommandL(cmdGC);

    PVMFStreamingManagerNodeCommand cmdPrep;
    cmdPrep.PVMFStreamingManagerNodeCommandBase::Construct(s,
            PVMF_STREAMING_MANAGER_NODE_PREPARE,
            aContext);

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Prepare - Out"));
    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::Prepare() - Cmd Recvd"));
    return QueueCommandL(cmdPrep);
}

/**
 * Called by the command handler AO to do the node Prepare
 */
void PVMFStreamingManagerNode::DoPrepare(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoPrepare - In"));
    switch (iInterfaceState)
    {
        case EPVMFNodeInitialized:
        {
            if (oGraphConstructComplete)
            {
                /*
                 * Connect the graph here. This is needed since we would send firewall packets
                 * as part of Prepare.
                 */
                if (GraphConnect() == false)
                {
                    PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoPrepare - GraphConnect Failed"));
                    SetState(EPVMFNodeError);
                    PVUuid eventuuid = PVMFStreamingManagerNodeEventTypeUUID;
                    int32 errcode = PVMFStreamingManagerNodeGraphConnectFailed;
                    CommandComplete(aCmd, PVMFFailure, NULL, &eventuuid, &errcode);
                    return;
                }
                {
                    /*
                     * Prepare for streaming manager cannot be completed unless Prepare
                     * for all the children nodes are complete
                     */
                    for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
                    {
                        PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
                        if (internalCmd != NULL)
                        {
                            internalCmd->cmd =
                                iNodeContainerVec[i].commandStartOffset +
                                PVMF_STREAMING_MANAGER_NODE_INTERNAL_PREPARE_CMD_OFFSET;
                            internalCmd->parentCmd = aCmd.iCmd;

                            OsclAny *cmdContextData =
                                OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

                            PVMFNodeInterface* iNode = iNodeContainerVec[i].iNode;

                            iNode->Prepare(iNodeContainerVec[i].iSessionId, cmdContextData);
                            iNodeContainerVec[i].iNodeCmdState = PVMFSM_NODE_CMD_PENDING;
                        }
                        else
                        {
                            PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoPrepare:RequestNewInternalCmd - Failed"));
                            CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
                            return;
                        }
                    }
                }
                MoveCmdToCurrentQueue(aCmd);
            }
            else
            {
                /* Graph construction not complete, so cant prep */
                PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoPrepare Failed - Incomplete Graph"));
                CommandComplete(iInputCommands, aCmd, PVMFErrInvalidState);
            }
        }
        break;

        default:
            PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoPrepare Failed - Invalid State"));
            CommandComplete(iInputCommands, aCmd, PVMFErrInvalidState);
            break;
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoPrepare - Out"));
}

bool
PVMFStreamingManagerNode::CheckChildrenNodesPrepare()
{
    {
        for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
        {
            if (iNodeContainerVec[i].iNodeCmdState != PVMFSM_NODE_CMD_COMPLETE)
            {
                return false;
            }
        }
    }
    ResetNodeContainerCmdState();
    return true;
}

void PVMFStreamingManagerNode::CompletePrepare()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompletePrepare - In"));
    if ((CheckChildrenNodesPrepare()) && (oGraphConstructComplete) && iErrorDuringProcess == SM_NO_ERROR)
    {
        if (!iCurrentCommand.empty() && iCancelCommand.empty())
        {
            PVMFStreamingManagerNodeCommand aCmd = iCurrentCommand.front();
            if (aCmd.iCmd == PVMF_STREAMING_MANAGER_NODE_PREPARE)
            {
                SetState(EPVMFNodePrepared);
                PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::Prepare() - CmdComplete - PVMFSuccess"));
                CommandComplete(aCmd, PVMFSuccess);
                /* Erase the command from the current queue */
                iCurrentCommand.Erase(&iCurrentCommand.front());
            }
        }
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompletePrepare - Out"));
    return;
}

/**
 * Queue an asynchronous node command
 */
OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::Start(PVMFSessionId s, const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Start - In"));
    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommandBase::Construct(s, PVMF_STREAMING_MANAGER_NODE_START, aContext);
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Start - Out"));
    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::Start() - Cmd Recvd"));
    return QueueCommandL(cmd);
}

/**
 * Called by the command handler AO to do the node Start
 */
void PVMFStreamingManagerNode::DoStart(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoStart - In"));
    switch (iInterfaceState)
    {
        case EPVMFNodePrepared:
        {
            /*
             * Connect the graph if not already connected. Usually the graph is
             * disconnected as part of Stop. In case we are doing a start after
             * stop, we would need to connect the graph again.
             */
            if (GraphConnect() == false)
            {
                PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:CompleteStart - GraphConnect Failed"));
                SetState(EPVMFNodeError);
                PVUuid eventuuid = PVMFStreamingManagerNodeEventTypeUUID;
                int32 errcode = PVMFStreamingManagerNodeGraphConnectFailed;
                CommandComplete(aCmd, PVMFFailure, NULL, &eventuuid, &errcode);
                return;
            }
            /*
             * Start for streaming manager cannot be completed unless
             * Start for all the children nodes are complete
             */
            {
                if (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE)
                {
                    uint32 duration = 2000;
                    PVMFSMNodeContainer* iJitterBufferNodeContainer =
                        getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
                    PVMFJitterBufferExtensionInterface* jbExtIntf =
                        (PVMFJitterBufferExtensionInterface*)
                        (iJitterBufferNodeContainer->iExtensions[0]);

                    /* Set jitter buffer duration */
                    jbExtIntf->setJitterBufferDurationInMilliSeconds(duration);
                }
                /*
                 * Start for streaming manager cannot be completed unless
                 * Start for all the children nodes are complete
                 */
                for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
                {
                    PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
                    if (internalCmd != NULL)
                    {
                        internalCmd->cmd =
                            iNodeContainerVec[i].commandStartOffset +
                            PVMF_STREAMING_MANAGER_NODE_INTERNAL_START_CMD_OFFSET;
                        internalCmd->parentCmd = aCmd.iCmd;

                        OsclAny *cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

                        PVMFNodeInterface* iNode = iNodeContainerVec[i].iNode;

                        iNode->Start(iNodeContainerVec[i].iSessionId, cmdContextData);
                        iNodeContainerVec[i].iNodeCmdState = PVMFSM_NODE_CMD_PENDING;
                    }
                    else
                    {
                        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoStart:RequestNewInternalCmd - Failed"));
                        CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
                        return;
                    }
                }
            }
            MoveCmdToCurrentQueue(aCmd);
        }
        break;

        /*
         * GraphConnect() not needed if starting from a paused state
         */
        case EPVMFNodePaused:
        {
            /*
             * Start for streaming manager cannot be completed unless
             * Start for all the children nodes are complete
             */
            {
                for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
                {
                    if (iNodeContainerVec[i].iAutoPaused == false)
                    {
                        PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
                        if (internalCmd != NULL)
                        {
                            internalCmd->cmd =
                                iNodeContainerVec[i].commandStartOffset +
                                PVMF_STREAMING_MANAGER_NODE_INTERNAL_START_CMD_OFFSET;
                            internalCmd->parentCmd = aCmd.iCmd;

                            OsclAny *cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

                            PVMFNodeInterface* iNode = iNodeContainerVec[i].iNode;

                            iNode->Start(iNodeContainerVec[i].iSessionId, cmdContextData);
                            iNodeContainerVec[i].iNodeCmdState = PVMFSM_NODE_CMD_PENDING;
                        }
                        else
                        {
                            PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoStart:RequestNewInternalCmd - Failed"));
                            CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
                            return;
                        }
                    }
                }
            }
            MoveCmdToCurrentQueue(aCmd);
        }
        break;

        case EPVMFNodeStarted:
            //Ignore start if already started
            CommandComplete(iInputCommands, aCmd, PVMFSuccess);
            break;

        default:
            CommandComplete(iInputCommands, aCmd, PVMFErrInvalidState);
            break;
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoStart - Out"));
}

bool
PVMFStreamingManagerNode::CheckChildrenNodesStart()
{
    {
        for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
        {
            PVMFSMNodeCmdState tmp = iNodeContainerVec[i].iNodeCmdState;
            uint32 tag = iNodeContainerVec[i].iNodeTag;
            if (iNodeContainerVec[i].iNodeCmdState == PVMFSM_NODE_CMD_PENDING)
            {
                return false;
            }
        }
    }
    ResetNodeContainerCmdState();
    return true;
}

void PVMFStreamingManagerNode::CompleteStart()
{
    int32 localMode = 0;
    if (iPVMFDataSourcePositionParamsPtr != NULL)
    {
        localMode = iPVMFDataSourcePositionParamsPtr->iMode;
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteStart - In"));
    if (CheckChildrenNodesStart() && iErrorDuringProcess == SM_NO_ERROR)
    {
        if (!iCurrentCommand.empty() && iCancelCommand.empty())
        {
            PVMFStreamingManagerNodeCommand aCmd = iCurrentCommand.front();
            if ((aCmd.iCmd == PVMF_STREAMING_MANAGER_NODE_START) ||
                    (aCmd.iCmd == PVMF_STREAMING_MANAGER_NODE_SET_DATASOURCE_POSITION))
            {
                if (oRepositioning)
                {
                    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::SetDataSourcePosition() - CmdComplete - PMVFSuccess"));
                    oRepositioning = false;
                    oPlayListRepositioning = false;

                    if ((localMode == 0) || (localMode == -1))
                    {
                        GetAcutalMediaTSAfterSeek();
                    }

                    iPVMFDataSourcePositionParamsPtr = NULL;
                }
                if ((iAutoResumePending == 2) && (iAutoPaused == true))
                {
                    iAutoResumePending = 1;
                    /* internal command - session id does not matter */
                    PVMFSessionId s = 0;
                    PVMFStreamingManagerNodeCommand cmdAutoResume;
                    cmdAutoResume.PVMFStreamingManagerNodeCommandBase::Construct(s,
                            PVMF_STREAMING_MANAGER_NODE_AUTO_RESUME,
                            NULL);
                    QueueCommandL(cmdAutoResume);
                    PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode:CompleteStart: - AutoResume Queued"));
                }
                if ((localMode == 0) || (localMode == -1))
                {
                    SetState(EPVMFNodeStarted);
                    if (IsAdded())
                    {
                        /* wakeup the AO */
                        RunIfNotReady();
                    }
                    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::Start() - CmdComplete - PMVFSuccess"));
                }
                CommandComplete(aCmd, PVMFSuccess);
                /* Erase the command from the current queue */
                iCurrentCommand.Erase(&iCurrentCommand.front());
            }
        }
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteStart - Out"));
    return;
}

/**
 * Called by the command handler AO to do the Auto Resume
 */
void PVMFStreamingManagerNode::DoAutoResume(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoAutoResume - In"));

    if (iSessionStopTimeAvailable == false)
    {
        /* Implies an open ended session - no pause or reposition */
        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoAutoResume in live  - PVMFErrNotSupported"));
        InternalCommandComplete(iInputCommands, aCmd, PVMFErrNotSupported);
        return;
    }

    bool oCmdSent = false;
    switch (iInterfaceState)
    {
        case EPVMFNodeStarted:
        {
            for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
            {
                /* We only pause session controller and socket nodes in auto-pause */
                int32 nodeTag = iNodeContainerVec[i].iNodeTag;
                PVMFNodeInterface* iNode = iNodeContainerVec[i].iNode;

                if ((nodeTag == PVMF_STREAMING_MANAGER_HTTP_SESSION_CONTROLLER_NODE) ||
                        (nodeTag == PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE))
                {
                    if (iNode->GetState() != EPVMFNodeStarted)
                    {
                        PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
                        if (internalCmd != NULL)
                        {
                            internalCmd->cmd =
                                iNodeContainerVec[i].commandStartOffset +
                                PVMF_STREAMING_MANAGER_NODE_INTERNAL_START_CMD_OFFSET;
                            internalCmd->parentCmd = aCmd.iCmd;

                            OsclAny *cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);
                            iNode->Start(iNodeContainerVec[i].iSessionId, cmdContextData);
                            iNodeContainerVec[i].iNodeCmdState = PVMFSM_NODE_CMD_PENDING;
                            oCmdSent = true;
                        }
                        else
                        {
                            PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoAutoResume:RequestNewInternalCmd - Failed"));
                            InternalCommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
                            return;
                        }
                    }
                }
            }
            if (oCmdSent)
            {
                MoveCmdToCurrentQueue(aCmd);
                PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode:DoAutoResume: - Start Sent"));
            }
            else
            {
                iAutoResumePending = 0;
                InternalCommandComplete(iInputCommands, aCmd, PVMFSuccess);
                PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode:DoAutoResume: - Done"));
            }
        }
        break;

        case EPVMFNodePaused:
        {
            for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
            {
                int32 nodeTag = iNodeContainerVec[i].iNodeTag;
                if (nodeTag == PVMF_STREAMING_MANAGER_HTTP_SESSION_CONTROLLER_NODE)
                {
                    iNodeContainerVec[i].iAutoPaused = false;
                }
            }
            iAutoResumePending = 0;
            InternalCommandComplete(iInputCommands, aCmd, PVMFSuccess);
            PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode:DoAutoResume in EPVMFNodePaused: - Done"));
        }
        break;
        default:
        {
            iAutoResumePending = 0;
            InternalCommandComplete(iInputCommands, aCmd, PVMFErrInvalidState);
        }
        break;
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoAutoResume - Out"));
    return;
}

bool
PVMFStreamingManagerNode::CheckChildrenNodesAutoResume()
{
    PVMFSMNodeContainerVector::iterator it;
    for (it = iNodeContainerVec.begin(); it != iNodeContainerVec.end(); it++)
    {
        int32 nodeTag = it->iNodeTag;
        if ((nodeTag == PVMF_STREAMING_MANAGER_HTTP_SESSION_CONTROLLER_NODE) ||
                (nodeTag == PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE))
        {
            if (it->iNodeCmdState != PVMFSM_NODE_CMD_COMPLETE
                    && it->iNodeCmdState != PVMFSM_NODE_CMD_NO_PENDING)
            {
                return false;
            }
            else
            {
                it->iAutoPaused = false;
            }
        }
    }
    ResetNodeContainerCmdState();
    return true;
}

void PVMFStreamingManagerNode::CompleteAutoResume()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteAutoResume - In"));
    if (CheckChildrenNodesAutoResume() && iErrorDuringProcess == SM_NO_ERROR)
    {
        iAutoResumePending = 0;
        iAutoPaused = false;
        /* Notify jitter buffer so that it may pause its estimated server clock */
        PVMFSMNodeContainer* iJitterBufferNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
        if (iJitterBufferNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
        PVMFJitterBufferExtensionInterface* jbExtIntf =
            (PVMFJitterBufferExtensionInterface*)
            (iJitterBufferNodeContainer->iExtensions[0]);
        if (jbExtIntf == NULL) OSCL_LEAVE(OsclErrBadHandle);
        jbExtIntf->NotifyAutoResumeComplete();

        PVMFStreamingManagerNodeCommand aCmd = iCurrentCommand.front();
        InternalCommandComplete(aCmd, PVMFSuccess);
        /* Erase the command from the current queue */
        iCurrentCommand.Erase(&iCurrentCommand.front());
        PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode:DoAutoResume: - Done"));
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteAutoResume - Out"));
    return;
}


/**
 * Queue an asynchronous node command
 */
OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::Stop(PVMFSessionId s, const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Stop - In"));
    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommandBase::Construct(s, PVMF_STREAMING_MANAGER_NODE_STOP, aContext);
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Stop - Out"));
    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::Stop() - Cmd Recvd"));
    return QueueCommandL(cmd);
}

/**
 * Called by the command handler AO to do the node Stop
 */
void PVMFStreamingManagerNode::DoStop(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoStop - In"));
    switch (iInterfaceState)
    {
        case EPVMFNodeStarted:
        case EPVMFNodePaused:
        {
            {
                /*
                 * Stop for streaming manager cannot be completed unless
                 * Stop for all the children nodes are complete
                 */
                for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
                {
                    PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
                    if (internalCmd != NULL)
                    {
                        internalCmd->cmd =
                            iNodeContainerVec[i].commandStartOffset +
                            PVMF_STREAMING_MANAGER_NODE_INTERNAL_STOP_CMD_OFFSET;
                        internalCmd->parentCmd = aCmd.iCmd;

                        OsclAny *cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

                        PVMFNodeInterface* iNode = iNodeContainerVec[i].iNode;

                        iNode->Stop(iNodeContainerVec[i].iSessionId, cmdContextData);
                        iNodeContainerVec[i].iNodeCmdState = PVMFSM_NODE_CMD_PENDING;
                    }
                    else
                    {
                        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoStop:RequestNewInternalCmd - Failed"));
                        CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
                        return;
                    }
                }
            }
            MoveCmdToCurrentQueue(aCmd);
        }
        break;

        default:
            PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::DoStop Failure - Invalid State"));
            CommandComplete(iInputCommands, aCmd, PVMFErrInvalidState);
            break;
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoStop - Out"));
}

bool
PVMFStreamingManagerNode::CheckChildrenNodesStop()
{
    {
        for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
        {
            if (iNodeContainerVec[i].iNodeCmdState != PVMFSM_NODE_CMD_COMPLETE)
            {
                return false;
            }
        }
    }
    ResetNodeContainerCmdState();
    return true;
}

void PVMFStreamingManagerNode::CompleteStop()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteStop - In"));
    if (CheckChildrenNodesStop() && iErrorDuringProcess == SM_NO_ERROR)
    {
        if (!iCurrentCommand.empty() && iCancelCommand.empty())
        {
            PVMFStreamingManagerNodeCommand aCmd = iCurrentCommand.front();
            if (aCmd.iCmd == PVMF_STREAMING_MANAGER_NODE_STOP)
            {
                /* transition to Prepared state */
                ResetStopCompleteParams();
                SetState(EPVMFNodePrepared);
                PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::Stop() - CmdComplete - PVMFSuccess"));
                CommandComplete(aCmd, PVMFSuccess);
                /* Erase the command from the current queue */
                iCurrentCommand.Erase(&iCurrentCommand.front());
            }
        }
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteStop - Out"));
    return;
}

void PVMFStreamingManagerNode::ResetStopCompleteParams()
{
    iStreamThinningInProgress = false;
    iPlaylistPlayInProgress = false;
    iSwitchStreamIFrameVideo = false;
    iRepositionRequestedStartNPTInMS = 0;
}

/**
 * Queue an asynchronous node command
 */
OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::Flush(PVMFSessionId s, const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Flush - In"));
    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommandBase::Construct(s, PVMF_STREAMING_MANAGER_NODE_FLUSH, aContext);
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Flush - Out"));
    return QueueCommandL(cmd);
}
/**
 * Called by the command handler AO to do the node Flush
 */
void PVMFStreamingManagerNode::DoFlush(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoFlush - In"));
    switch (iInterfaceState)
    {
        case EPVMFNodeStarted:
        case EPVMFNodePaused:
        {
            /*
             * Flush for streaming manager cannot be completed unless
             * Flush for all the children nodes are complete
             */
            for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
            {
                PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
                if (internalCmd != NULL)
                {
                    internalCmd->cmd =
                        iNodeContainerVec[i].commandStartOffset +
                        PVMF_STREAMING_MANAGER_NODE_INTERNAL_FLUSH_CMD_OFFSET;
                    internalCmd->parentCmd = aCmd.iCmd;

                    OsclAny *cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

                    PVMFNodeInterface* iNode = iNodeContainerVec[i].iNode;

                    iNode->Flush(iNodeContainerVec[i].iSessionId, cmdContextData);
                    iNodeContainerVec[i].iNodeCmdState = PVMFSM_NODE_CMD_PENDING;
                }
                else
                {
                    PVMF_SM_LOGERROR((0, "StreamingManagerNode:DoFlush:RequestNewInternalCmd - Failed"));
                    CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
                    return;
                }
            }
            MoveCmdToCurrentQueue(aCmd);
            /*
             * Notify all ports to suspend their input - TBD
             */
            /*
             * If the node is not running we need to wakeup the
             * AO to further complete the flush, which means all
             * port activity needs to be completed.
             */
            if (IsAdded())
            {
                RunIfNotReady();
            }
        }
        break;

        default:
            CommandComplete(iInputCommands, aCmd, PVMFErrInvalidState);
            break;
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoFlush - Out"));
}

bool
PVMFStreamingManagerNode::CheckChildrenNodesFlush()
{
    for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
    {
        if (iNodeContainerVec[i].iNodeCmdState != PVMFSM_NODE_CMD_COMPLETE)
        {
            return false;
        }
    }
    ResetNodeContainerCmdState();
    return true;
}

void PVMFStreamingManagerNode::CompleteFlush()
{
    /*
     * If the node is not running we need to wakeup the
     * AO to further complete the flush, which means all
     * port activity needs to be completed.
     */
    if (iInterfaceState != EPVMFNodeStarted)
    {
        if (IsAdded())
        {
            RunIfNotReady();
        }
    }
    return;
}

/**
 * Queue an asynchronous node command
 */
OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::Pause(PVMFSessionId s, const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Pause - In"));
    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommandBase::Construct(s, PVMF_STREAMING_MANAGER_NODE_PAUSE, aContext);
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Pause - Out"));
    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::Pause() - Cmd Recvd"));
    return QueueCommandL(cmd);
}

/**
 * Called by the command handler AO to do the node Pause
 */
void PVMFStreamingManagerNode::DoPause(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoPause - In"));
    switch (iInterfaceState)
    {
        case EPVMFNodeStarted:
        {
            {
                for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
                {
                    /*
                     * Pause only if not already paused - could happen that
                     * some of the nodes could be paused due to flow control
                     */
                    if ((iNodeContainerVec[i].iNode->GetState()) != EPVMFNodePaused)
                    {
                        PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
                        if (internalCmd != NULL)
                        {
                            internalCmd->cmd =
                                iNodeContainerVec[i].commandStartOffset +
                                PVMF_STREAMING_MANAGER_NODE_INTERNAL_PAUSE_CMD_OFFSET;
                            internalCmd->parentCmd = aCmd.iCmd;

                            OsclAny *cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

                            PVMFNodeInterface* iNode = iNodeContainerVec[i].iNode;

                            iNode->Pause(iNodeContainerVec[i].iSessionId, cmdContextData);
                            iNodeContainerVec[i].iNodeCmdState = PVMFSM_NODE_CMD_PENDING;
                        }
                        else
                        {
                            PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoPause:RequestNewInternalCmd - Failed"));
                            CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
                            return;
                        }
                    }
                }
            }
            MoveCmdToCurrentQueue(aCmd);
        }
        break;
        default:
            CommandComplete(iInputCommands, aCmd, PVMFErrInvalidState);
            break;
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoPause - Out"));
    return;
}

bool
PVMFStreamingManagerNode::CheckChildrenNodesPause()
{
    {
        for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
        {
            if (iNodeContainerVec[i].iNodeCmdState != PVMFSM_NODE_CMD_COMPLETE
                    && iNodeContainerVec[i].iNodeCmdState != PVMFSM_NODE_CMD_NO_PENDING)
            {
                return false;
            }
        }
    }
    ResetNodeContainerCmdState();
    return true;
}

void PVMFStreamingManagerNode::CompletePause()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompletePause - In"));
    if (CheckChildrenNodesPause() && iErrorDuringProcess == SM_NO_ERROR)
    {
        SetState(EPVMFNodePaused);
        if (oRepositioning)
        {
            if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
                    (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE))
            {
                /*
                 * Pause request generated by a reposition command
                 * complete. Issue a start.
                 */
                if (iPVMFDataSourcePositionParamsPtr == NULL)
                {
                    DoRepositioningStart3GPPStreaming();
                }
            }
        }
        else
        {
            if (!iCurrentCommand.empty() && iCancelCommand.empty())
            {
                PVMFStreamingManagerNodeCommand aCmd = iCurrentCommand.front();
                PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::Pause() - CmdComplete - PVMFSuccess"));
                CommandComplete(aCmd, PVMFSuccess);
                /* Erase the command from the current queue */
                iCurrentCommand.Erase(&iCurrentCommand.front());
            }
        }

    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompletePause - Out"));
    return;
}

/**
 * Called by the command handler AO to do the Auto Pause
 */
void PVMFStreamingManagerNode::DoAutoPause(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoAutoPause - In"));

    if (iSessionStopTimeAvailable == false)
    {
        /* Implies an open ended session - no pause or reposition */
        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoAutoPause in live  - PVMFErrNotSupported"));
        InternalCommandComplete(iInputCommands, aCmd, PVMFErrNotSupported);
        return;
    }
    bool oCmdSent = false;
    switch (iInterfaceState)
    {
        case EPVMFNodeStarted:
        {
            for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
            {
                /* We only pause session controller and socket nodes in auto-pause */
                int32 nodeTag = iNodeContainerVec[i].iNodeTag;
                PVMFNodeInterface* iNode = iNodeContainerVec[i].iNode;

                if ((nodeTag == PVMF_STREAMING_MANAGER_HTTP_SESSION_CONTROLLER_NODE) ||
                        (nodeTag == PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE))
                {
                    if (iNode->GetState() != EPVMFNodePaused)
                    {
                        PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
                        if (internalCmd != NULL)
                        {
                            internalCmd->cmd =
                                iNodeContainerVec[i].commandStartOffset +
                                PVMF_STREAMING_MANAGER_NODE_INTERNAL_PAUSE_CMD_OFFSET;
                            internalCmd->parentCmd = aCmd.iCmd;

                            OsclAny *cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);
                            iNode->Pause(iNodeContainerVec[i].iSessionId, cmdContextData);
                            iNodeContainerVec[i].iNodeCmdState = PVMFSM_NODE_CMD_PENDING;
                            oCmdSent = true;
                        }
                        else
                        {
                            PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoAutoPause:RequestNewInternalCmd - Failed"));
                            InternalCommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
                            return;
                        }
                    }
                }
            }
            if (oCmdSent == true)
            {
                MoveCmdToCurrentQueue(aCmd);
                PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode:DoAutoPause: - Pause Sent"));
            }
            else
            {
                iAutoPausePending = false;
                InternalCommandComplete(iInputCommands, aCmd, PVMFSuccess);
                PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode:DoAutoPause: - Done"));
            }
        }
        break;
        case EPVMFNodePaused:
        {
            /*
             * If state is EPVMFNodePaused when Highwatermark event is reported, we ignore this event.
             * But if Highwatermark event is reported while pause cmd is pending,
             * we call DoAutoPause and JB node expect SM node go to autopause. So we set iAutoPaused to true.
             */
            for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
            {
                int32 nodeTag = iNodeContainerVec[i].iNodeTag;
                if (nodeTag == PVMF_STREAMING_MANAGER_HTTP_SESSION_CONTROLLER_NODE)
                {
                    iNodeContainerVec[i].iAutoPaused = true;
                }
            }
            iAutoPausePending = false;
            iAutoPaused = true;

            InternalCommandComplete(iInputCommands, aCmd, PVMFSuccess);
            PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode:DoAutoPause in EPVMFNodePaused: - Done"));
        }
        break;
        default:
        {
            iAutoPausePending = false;
            InternalCommandComplete(iInputCommands, aCmd, PVMFErrInvalidState);
        }
        break;
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoAutoPause - Out"));
    return;
}

bool
PVMFStreamingManagerNode::CheckChildrenNodesAutoPause()
{
    PVMFSMNodeContainerVector::iterator it;
    for (it = iNodeContainerVec.begin(); it !=  iNodeContainerVec.end(); it++)
    {
        int32 nodeTag = it->iNodeTag;
        if ((nodeTag == PVMF_STREAMING_MANAGER_HTTP_SESSION_CONTROLLER_NODE) ||
                (nodeTag == PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE))
        {
            if (it->iNodeCmdState != PVMFSM_NODE_CMD_COMPLETE
                    && it->iNodeCmdState != PVMFSM_NODE_CMD_NO_PENDING)
            {
                return false;
            }
            else
            {
                it->iAutoPaused = true;
            }
        }
    }
    ResetNodeContainerCmdState();
    return true;
}

void PVMFStreamingManagerNode::CompleteAutoPause()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteAutoPause - In"));
    if (CheckChildrenNodesAutoPause() && iErrorDuringProcess == SM_NO_ERROR)
    {
        iAutoPausePending = false;
        iAutoPaused = true;
        /* Notify jitter buffer so that it may pause its estimated server clock */
        PVMFSMNodeContainer* iJitterBufferNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
        if (iJitterBufferNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
        PVMFJitterBufferExtensionInterface* jbExtIntf =
            (PVMFJitterBufferExtensionInterface*)
            (iJitterBufferNodeContainer->iExtensions[0]);
        if (jbExtIntf == NULL) OSCL_LEAVE(OsclErrBadHandle);
        jbExtIntf->NotifyAutoPauseComplete();

        PVMFStreamingManagerNodeCommand aCmd = iCurrentCommand.front();
        InternalCommandComplete(aCmd, PVMFSuccess);
        /* Erase the command from the current queue */
        iCurrentCommand.Erase(&iCurrentCommand.front());
        PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode:DoAutoPause: - Done"));
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteAutoPause - Out"));
    return;
}


/**
 * Queue an asynchronous node command
 */
OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::Reset(PVMFSessionId s, const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Reset - In"));
    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommandBase::Construct(s, PVMF_STREAMING_MANAGER_NODE_RESET, aContext);
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Reset - Out"));
    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::Reset() - Cmd Recvd"));
    return QueueCommandL(cmd);
}

/**
 * Called by the command handler AO to do the node Reset.
 */
void PVMFStreamingManagerNode::DoReset(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoReset - In"));
    /* this node allows a reset from any idle or error state */
    switch (iInterfaceState)
    {
        case EPVMFNodeCreated:
        case EPVMFNodeIdle:
        case EPVMFNodeInitialized:
        case EPVMFNodePrepared:
        case EPVMFNodeStarted:
        case EPVMFNodePaused:
        case EPVMFNodeError:
        {
            /*
             * Reset for streaming manager cannot be completed unless
             * Reset for all the children nodes are complete
             */
            for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
            {
                PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
                if (internalCmd != NULL)
                {
                    internalCmd->cmd =
                        iNodeContainerVec[i].commandStartOffset +
                        PVMF_STREAMING_MANAGER_NODE_INTERNAL_RESET_CMD_OFFSET;
                    internalCmd->parentCmd = aCmd.iCmd;

                    OsclAny *cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

                    PVMFNodeInterface* iNode = iNodeContainerVec[i].iNode;

                    iNode->Reset(iNodeContainerVec[i].iSessionId, cmdContextData);
                    iNodeContainerVec[i].iNodeCmdState = PVMFSM_NODE_CMD_PENDING;
                }
                else
                {
                    PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoReset:RequestNewInternalCmd - Failed"));
                    CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
                    return;
                }
            }
            MoveCmdToCurrentQueue(aCmd);
        }
        break;

        default:
            PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::DoReset Failure - Invalid State"));
            CommandComplete(iInputCommands, aCmd, PVMFErrInvalidState);
            break;
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoReset - Out"));
}

bool
PVMFStreamingManagerNode::CheckChildrenNodesReset()
{
    for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
    {
        if (iNodeContainerVec[i].iNodeCmdState != PVMFSM_NODE_CMD_COMPLETE)
        {
            return false;
        }
    }
    return true;
}

void PVMFStreamingManagerNode::CompleteReset()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteReset - In"));
    if (CheckChildrenNodesReset() && iDRMResetPending == false)
    {
        ResetNodeContainerCmdState();
        if (!iCurrentCommand.empty() && iCancelCommand.empty())
        {
            /* Indicates that the init for Children Nodes was successfull */
            /* At protected clip, Reset CPM also was successfull */
            PVMFStreamingManagerNodeCommand aCmd = iCurrentCommand.front();
            if (aCmd.iCmd == PVMF_STREAMING_MANAGER_NODE_RESET)
            {

                /* Reset Params */
                ResetNodeParams();

                /* Reset the metadata key list */
                /* Clean up CPM related variables */
                CleanupCPMdata();

                /* logoff & go back to Created state */
                SetState(EPVMFNodeIdle);
                PVMFStatus status = ThreadLogoff();

                if (iErrorDuringProcess == SM_NO_ERROR)
                {
                    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::Reset() - CmdComplete - Status=%d", status));
                    CommandComplete(aCmd, status);
                }
                else
                {
                    PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::CompleteReset -- CPM Reset error"));
                    CommandComplete(aCmd, PVMFFailure, iErrorResponseInf);

                    if (iErrorResponseInf != NULL)
                    {
                        iErrorResponseInf->removeRef();
                        iErrorResponseInf = NULL;
                    }
                    iErrorDuringProcess = SM_NO_ERROR;
                }

                /* Erase the command from the current queue */
                iCurrentCommand.Erase(&iCurrentCommand.front());
                // destroy the payload parser registry
                destroyPayloadParserRegistry();
            }
        }
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteReset - Out"));
    return;
}

/**
 * Queue an asynchronous node command
 */
OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::CancelAllCommands(PVMFSessionId s, const OsclAny* aContext)
{
    PVMF_SM_LOGINFO((0, "StreamingManagerNode:CancelAllCommands"));
    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommandBase::Construct(s, PVMF_STREAMING_MANAGER_NODE_CANCELALLCOMMANDS, aContext);
    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::CancelAllCommands() - Cmd Recvd"));
    return QueueCommandL(cmd);
}

/**
 * Queue an asynchronous node command
 */
OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::CancelCommand(PVMFSessionId s, PVMFCommandId aCmdId, const OsclAny* aContext)
{
    PVMF_SM_LOGINFO((0, "StreamingManagerNode:CancelCommand"));
    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommandBase::Construct(s, PVMF_STREAMING_MANAGER_NODE_CANCELCOMMAND, aCmdId, aContext);
    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::CancelCommand() - Cmd Recvd"));
    return QueueCommandL(cmd);
}

/**
 * This routine is called by various command APIs to queue an
 * asynchronous command for processing by the command handler AO.
 * This function may leave if the command can't be queued due to
 * memory allocation failure.
 */
PVMFCommandId PVMFStreamingManagerNode::QueueCommandL(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMFCommandId id;

    id = iInputCommands.AddL(aCmd);

    if (IsAdded())
    {
        //wakeup the AO
        RunIfNotReady();
    }
    return id;
}
/**
 * Called by the command handler AO to process a command from
 * the input queue.
 * Return true if a command was processed, false if the command
 * processor is busy and can't process another command now.
 */
bool PVMFStreamingManagerNode::ProcessCommand(PVMFStreamingManagerNodeCommand& aCmd)
{
    /*
     * normally this node will not start processing one command
     * until the prior one is finished.  However, a hi priority
     * command such as Cancel must be able to interrupt a command
     * in progress.
     */
    if ((iCurrentCommand.size() > 0 && !aCmd.hipri()
            && aCmd.iCmd != PVMF_STREAMING_MANAGER_NODE_CANCEL_GET_LICENSE)
            || iCancelCommand.size() > 0)
        return false;

    switch (aCmd.iCmd)
    {
        case PVMF_STREAMING_MANAGER_NODE_QUERYUUID:
            DoQueryUuid(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_QUERYINTERFACE:
            DoQueryInterface(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_REQUESTPORT:
            DoRequestPort(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_RELEASEPORT:
            DoReleasePort(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_INIT:
            DoInit(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_PREPARE:
            DoPrepare(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_START:
            DoStart(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_STOP:
            DoStop(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_FLUSH:
            DoFlush(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_PAUSE:
            DoPause(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_RESET:
            DoReset(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_CANCELALLCOMMANDS:
            DoCancelAllCommands(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_CANCELCOMMAND:
            DoCancelCommand(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_CONSTRUCT_SESSION:
        {
            if (!GraphConstruct())
            {
                InternalCommandComplete(iInputCommands,
                                        aCmd,
                                        PVMFFailure);
            }
            else
            {
                /*
                 * Move it to current command queue where it would
                 * stay until "GraphConstruct" is complete
                 */
                MoveCmdToCurrentQueue(aCmd);
            }
        }
        break;

        case PVMF_STREAMING_MANAGER_NODE_SET_DATASOURCE_POSITION:
        {
            {
                DoSetDataSourcePosition(aCmd);
            }
        }
        break;

        case PVMF_STREAMING_MANAGER_NODE_QUERY_DATASOURCE_POSITION:
            DoQueryDataSourcePosition(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_GETNODEMETADATAKEYS:
        {
            PVMFStatus status = DoGetMetadataKeys(aCmd);
            if (status != PVMFPending)
            {
                CommandComplete(iInputCommands, aCmd, status);
            }
            else
            {
                MoveCmdToCurrentQueue(aCmd);
            }
        }
        break;

        case PVMF_STREAMING_MANAGER_NODE_GETNODEMETADATAVALUES:
        {
            PVMFStatus status = DoGetMetadataValues(aCmd);
            if (status != PVMFPending)
            {
                CommandComplete(iInputCommands, aCmd, status);
            }
            else
            {
                MoveCmdToCurrentQueue(aCmd);
            }
        }
        break;
        case PVMF_STREAMING_MANAGER_NODE_CAPCONFIG_SETPARAMS:
        {
            PvmiMIOSession session;
            PvmiKvp* aParameters;
            int num_elements;
            PvmiKvp** ppRet_kvp;
            aCmd.Parse(session, aParameters, num_elements, ppRet_kvp);
            setParametersSync(NULL, aParameters, num_elements, *ppRet_kvp);
            ciObserver->SignalEvent(aCmd.iId);
        }

        case PVMF_STREAMING_MANAGER_NODE_AUTO_PAUSE:
            DoAutoPause(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_AUTO_RESUME:
            DoAutoResume(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_GET_LICENSE_W:
        {
            PVMFStatus status = DoGetLicense(aCmd, true);
            if (status == PVMFPending)
            {
                MoveCmdToCurrentQueue(aCmd);
            }
            else
            {
                CommandComplete(iInputCommands, aCmd, status);
            }
        }
        break;

        case PVMF_STREAMING_MANAGER_NODE_GET_LICENSE:
        {
            PVMFStatus status = DoGetLicense(aCmd);
            if (status == PVMFPending)
            {
                MoveCmdToCurrentQueue(aCmd);
            }
            else
            {
                CommandComplete(iInputCommands, aCmd, status);
            }
        }
        break;

        case PVMF_STREAMING_MANAGER_NODE_CANCEL_GET_LICENSE:
            DoCancelGetLicense(aCmd);
            break;

        default:
            /* unknown command type */
            CommandComplete(iInputCommands, aCmd, PVMFErrNotSupported);
            break;
    }

    return true;
}

/**
 * The various command handlers call this when a command is complete.
 */
void PVMFStreamingManagerNode::CommandComplete(PVMFStreamingManagerNodeCmdQ& aCmdQ,
        PVMFStreamingManagerNodeCommand& aCmd,
        PVMFStatus aStatus,
        OsclAny* aEventData,
        PVUuid* aEventUUID,
        int32* aEventCode,
        PVInterface* aExtMsg)
{
    PVMF_SM_LOGSTACKTRACE((0, "StreamingManagerNode:CommandComplete Id %d Cmd %d Status %d Context %d Data %d"
                           , aCmd.iId, aCmd.iCmd, aStatus, aCmd.iContext, aEventData));

    PVInterface* extif = NULL;
    PVMFBasicErrorInfoMessage* errormsg = NULL;
    if (aExtMsg)
    {
        extif = aExtMsg;
    }
    else if (aEventUUID && aEventCode)
    {
        errormsg = OSCL_NEW(PVMFBasicErrorInfoMessage, (*aEventCode, *aEventUUID, NULL));
        extif = OSCL_STATIC_CAST(PVInterface*, errormsg);
    }

    /* create response */
    PVMFCmdResp resp(aCmd.iId, aCmd.iContext, aStatus, extif, aEventData);
    PVMFSessionId session = aCmd.iSession;

    /* Erase the command from the queue */
    aCmdQ.Erase(&aCmd);

    /* Report completion to the session observer */
    ReportCmdCompleteEvent(session, resp);

    if (errormsg)
    {
        errormsg->removeRef();
    }
    /* Reschedule AO if input command queue is not empty */
    if (!iInputCommands.empty())
    {
        if (IsAdded())
        {
            RunIfNotReady();
        }
    }
    /*
     * Transition to error state in case of select errors only, viz.
     * PVMFFailure, PVMFErrNoMemory, PVMFErrNoResources
     * Any other error implies that the node is probably in a recoverable
     * state
     */
    if (IsFatalErrorEvent(aStatus))
    {
        SetState(EPVMFNodeError);
    }
}

void PVMFStreamingManagerNode::CommandComplete(PVMFStreamingManagerNodeCmdQ& aCmdQ,
        PVMFStreamingManagerNodeCommand& aCmd,
        PVMFStatus aStatus,
        OsclAny* aEventData,
        PVUuid* aEventUUID,
        int32* aEventCode)
{
    PVMF_SM_LOGSTACKTRACE((0, "StreamingManagerNode:CommandComplete Id %d Cmd %d Status %d Context %d Data %d"
                           , aCmd.iId, aCmd.iCmd, aStatus, aCmd.iContext, aEventData));

    PVInterface* extif = NULL;
    PVMFBasicErrorInfoMessage* errormsg = NULL;
    if (aEventUUID && aEventCode)
    {
        errormsg = OSCL_NEW(PVMFBasicErrorInfoMessage, (*aEventCode, *aEventUUID, NULL));
        extif = OSCL_STATIC_CAST(PVInterface*, errormsg);
    }

    /* create response */
    PVMFCmdResp resp(aCmd.iId, aCmd.iContext, aStatus, extif, aEventData);
    PVMFSessionId session = aCmd.iSession;

    /* Erase the command from the queue */
    aCmdQ.Erase(&aCmd);

    /* Report completion to the session observer */
    ReportCmdCompleteEvent(session, resp);

    if (errormsg)
    {
        errormsg->removeRef();
    }
    /* Reschedule AO if input command queue is not empty */
    if (!iInputCommands.empty() && IsAdded())
    {
        if (IsAdded())
        {
            RunIfNotReady();
        }
    }
    /*
     * Transition to error state in case of select errors only, viz.
     * PVMFFailure, PVMFErrNoMemory, PVMFErrNoResources
     * Any other error implies that the node is probably in a recoverable
     * state
     */
    if (IsFatalErrorEvent(aStatus))
    {
        SetState(EPVMFNodeError);
    }
}

void PVMFStreamingManagerNode::CommandComplete(PVMFStreamingManagerNodeCommand& aCmd,
        PVMFStatus aStatus,
        OsclAny* aEventData,
        PVUuid* aEventUUID,
        int32* aEventCode)
{
    PVMF_SM_LOGSTACKTRACE((0, "StreamingManagerNode:CommandComplete Id %d Cmd %d Status %d Context %d Data %d"
                           , aCmd.iId, aCmd.iCmd, aStatus, aCmd.iContext, aEventData));

    PVInterface* extif = NULL;
    PVMFBasicErrorInfoMessage* errormsg = NULL;
    if (aEventUUID && aEventCode)
    {
        errormsg = OSCL_NEW(PVMFBasicErrorInfoMessage, (*aEventCode, *aEventUUID, NULL));
        extif = OSCL_STATIC_CAST(PVInterface*, errormsg);
    }

    /* create response */
    PVMFCmdResp resp(aCmd.iId, aCmd.iContext, aStatus, extif, aEventData);
    PVMFSessionId session = aCmd.iSession;

    /* Report completion to the session observer */
    ReportCmdCompleteEvent(session, resp);

    if (errormsg)
    {
        errormsg->removeRef();
    }
    /* Reschedule AO if input command queue is not empty */
    if (!iInputCommands.empty())
    {
        if (IsAdded())
        {
            RunIfNotReady();
        }
    }
    /*
     * Transition to error state in case of select errors only, viz.
     * PVMFFailure, PVMFErrNoMemory, PVMFErrNoResources
     * Any other status implies that the node is probably in a recoverable
     * state
     */
    if (IsFatalErrorEvent(aStatus))
    {
        SetState(EPVMFNodeError);
    }
}

/**
 * The various command handlers call this when a command is complete.
 */
void PVMFStreamingManagerNode::CommandComplete(PVMFStreamingManagerNodeCmdQ& aCmdQ,
        PVMFStreamingManagerNodeCommand& aCmd,
        PVMFStatus aStatus,
        PVInterface* aErrorExtIntf)
{
    PVMF_SM_LOGSTACKTRACE((0, "StreamingManagerNode:CommandComplete Id %d Cmd %d Status %d Context %d"
                           , aCmd.iId, aCmd.iCmd, aStatus, aCmd.iContext));

    /* create response */
    PVMFCmdResp resp(aCmd.iId, aCmd.iContext, aStatus, aErrorExtIntf, NULL);
    PVMFSessionId session = aCmd.iSession;

    /* Erase the command from the queue */
    aCmdQ.Erase(&aCmd);

    /* Report completion to the session observer */
    ReportCmdCompleteEvent(session, resp);

    /* Reschedule AO if input command queue is not empty */
    if (!iInputCommands.empty())
    {
        if (IsAdded())
        {
            RunIfNotReady();
        }
    }
    /*
     * Transition to error state in case of select errors only, viz.
     * PVMFFailure, PVMFErrNoMemory, PVMFErrNoResources
     * Any other error implies that the node is probably in a recoverable
     * state
     */
    if (IsFatalErrorEvent(aStatus))
    {
        SetState(EPVMFNodeError);
    }
}

void PVMFStreamingManagerNode::CommandComplete(PVMFStreamingManagerNodeCommand& aCmd,
        PVMFStatus aStatus,
        PVInterface* aErrorExtIntf,
        OsclAny* aData)
{
    PVMF_SM_LOGSTACKTRACE((0, "StreamingManagerNode:CommandComplete Id %d Cmd %d Status %d Context %d"
                           , aCmd.iId, aCmd.iCmd, aStatus, aCmd.iContext));

    /* create response */
    PVMFCmdResp resp(aCmd.iId, aCmd.iContext, aStatus, aErrorExtIntf, aData);
    PVMFSessionId session = aCmd.iSession;

    /* Report completion to the session observer */
    ReportCmdCompleteEvent(session, resp);

    /* Reschedule AO if input command queue is not empty */
    if (!iInputCommands.empty())
    {
        if (IsAdded())
        {
            RunIfNotReady();
        }
    }
    /*
     * Transition to error state in case of select errors only, viz.
     * PVMFFailure, PVMFErrNoMemory, PVMFErrNoResources
     * Any other status implies that the node is probably in a recoverable
     * state
     */
    if (IsFatalErrorEvent(aStatus))
    {
        SetState(EPVMFNodeError);
    }
}

/**
 * The various command handlers call this when an internal command is complete.
 * Does not report events to the observer
 */
void
PVMFStreamingManagerNode::InternalCommandComplete(PVMFStreamingManagerNodeCmdQ& aCmdQ,
        PVMFStreamingManagerNodeCommand& aCmd,
        PVMFStatus aStatus,
        OsclAny* aEventData)
{
    PVMF_SM_LOGSTACKTRACE((0, "StreamingManagerNode:CommandComplete Id %d Cmd %d Status %d Context %d Data %d"
                           , aCmd.iId, aCmd.iCmd, aStatus, aCmd.iContext, aEventData));

    /* Erase the command from the queue */
    aCmdQ.Erase(&aCmd);

    /* Reschedule AO if input command queue is not empty */
    if (!iInputCommands.empty())
    {
        if (IsAdded())
        {
            RunIfNotReady();
        }
    }

    /*
     * Transition to error state in case of select errors only, viz.
     * PVMFFailure, PVMFErrNoMemory, PVMFErrNoResources
     * Any other status implies that the node is probably in a recoverable
     * state
     */
    if (IsFatalErrorEvent(aStatus))
    {
        SetState(EPVMFNodeError);
    }
}

void
PVMFStreamingManagerNode::InternalCommandComplete(PVMFStreamingManagerNodeCommand& aCmd,
        PVMFStatus aStatus,
        OsclAny* aEventData)
{
    PVMF_SM_LOGSTACKTRACE((0, "StreamingManagerNode:CommandComplete Id %d Cmd %d Status %d Context %d Data %d"
                           , aCmd.iId, aCmd.iCmd, aStatus, aCmd.iContext, aEventData));

    /* Reschedule AO if input command queue is not empty */
    if (!iInputCommands.empty())
    {
        if (IsAdded())
        {
            RunIfNotReady();
        }
    }
    /*
     * Transition to error state in case of select errors only, viz.
     * PVMFFailure, PVMFErrNoMemory, PVMFErrNoResources
     * Any other status implies that the node is probably in a recoverable
     * state
     */
    if (IsFatalErrorEvent(aStatus))
    {
        SetState(EPVMFNodeError);
    }
}

/**
//A routine to tell if a flush operation is in progress.
*/
bool PVMFStreamingManagerNode::FlushPending()
{
    if ((iCurrentCommand.size() > 0) &&
            (iCurrentCommand.front().iCmd == PVMF_STREAMING_MANAGER_NODE_FLUSH) &&
            (CheckChildrenNodesFlush() == false))
    {
        return true;
    }
    return false;
}

/**
//Called by the command handler AO to do the Cancel All
*/
void PVMFStreamingManagerNode::DoCancelAllCommands(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVMFStreamingManagerNode::DoCancelAllCommands In"));
    //first cancel the current command if any
    if (iCurrentCommand.size() > 0)
    {
        PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVMFStreamingManagerNode::DoCancelAllCommands iCurrentCommand.size()>0"));
        /*
         * As of now we only allow cancelling the start command. Also only jitter buffer start
         * needs to be cancelled. Rest of the nodes dont do anything in start.
         */
        {
            ResetNodeContainerCmdState();
            for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
            {
                PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
                if (internalCmd != NULL)
                {
                    internalCmd->cmd =
                        iNodeContainerVec[i].commandStartOffset +
                        PVMF_STREAMING_MANAGER_NODE_INTERNAL_CANCEL_ALL_OFFSET;
                    internalCmd->parentCmd = PVMF_STREAMING_MANAGER_NODE_CANCELALLCOMMANDS;

                    OsclAny *cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

                    PVMFNodeInterface* iNode = iNodeContainerVec[i].iNode;

                    iNode->CancelAllCommands(iNodeContainerVec[i].iSessionId, cmdContextData);
                    iNodeContainerVec[i].iNodeCmdState = PVMFSM_NODE_CMD_CANCEL_PENDING;
                }
                else
                {
                    PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoCancelAllCommands:RequestNewInternalCmd - Failed"));
                    CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
                    return;
                }
            }
            /* Wait for jitter buffer cancel all to complete */
            /* If current command is not start then just wait for current command to complete */
        }
        MoveCmdToCancelQueue(aCmd);
    }
    else
    {
        //no current command - just cancel all queued commands, if any
        {
            //start at element 1 since this cancel command is element 0.
            while (iInputCommands.size() > 1)
            {
                if (IsInternalCmd(iInputCommands.front().iCmd) == false)
                {
                    CommandComplete(iInputCommands.front(), PVMFErrCancelled);
                }
                /* Erase the command from the input queue */
                iInputCommands.Erase(&iInputCommands.front());
            }
        }

        //finally, report cancel complete.
        CommandComplete(iInputCommands, aCmd, PVMFSuccess);
    }
    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVMFStreamingManagerNode::DoCancelAllCommands Out"));
}

bool PVMFStreamingManagerNode::CheckChildrenNodesCancelAll()
{
    for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
    {
        if (iNodeContainerVec[i].iNodeCmdState != PVMFSM_NODE_CMD_CANCEL_COMPLETE)
        {
            return false;
        }
    }
    ResetNodeContainerCmdState();
    return true;
}

void PVMFStreamingManagerNode::CompleteCancelAll()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteCancelAll - In"));
    if (CheckChildrenNodesCancelAll())
    {
        if (iCancelCommand.front().iContext)
        {
            /*
             * CancelAllCommands is issued by upper layer
             */
            PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::CancelCommand() - CmdComplete - PVMFErrCancelled"));
            if (!iCurrentCommand.empty())
            {
                //not need to send commandcmp during GraphConstruct
                if (IsInternalCmd(iCurrentCommand.front().iCmd) == false)
                {
                    CommandComplete(iCurrentCommand.front(), PVMFErrCancelled);
                }
                /* Erase the command from the current queue */
                iCurrentCommand.Erase(&iCurrentCommand.front());
            }

            /*
             * cancel all queued commands, if any
             */
            while (iInputCommands.size() > 0)
            {
                if (IsInternalCmd(iInputCommands.front().iCmd) == false)
                    CommandComplete(iInputCommands, iInputCommands.front(), PVMFErrCancelled);
            }
            /* finally send command complete for the cancel all command */
            if (iErrorDuringProcess == SM_NO_ERROR)
            {
                PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteCancelAll - CancelAllCommands complete"));
                CommandComplete(iCancelCommand,
                                iCancelCommand.front(),
                                PVMFSuccess);
            }
            else
            {
                PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::CompleteCancelAll - CancelAllCommands complete error"));
                CommandComplete(iCancelCommand, iCancelCommand.front(), PVMFFailure, iErrorResponseInf);

                if (iErrorResponseInf != NULL)
                {
                    iErrorResponseInf->removeRef();
                    iErrorResponseInf = NULL;
                }
                iErrorDuringProcess = SM_NO_ERROR;
            }
        }
        else
        {
            /*
             * CancelAllCommands is issued due to error
             */
            if (iCurrentCommand.front().iCmd == PVMF_STREAMING_MANAGER_NODE_RESET)
            {
                PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::CompleteCancelAll Shound not issue CancelAllCommands durint Reset"));
                OSCL_ASSERT(false);
            }
            PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::CompleteCancelAll() due to error - CmdComplete"));
            /* Erase the command from the cancel queue */
            iCancelCommand.Erase(&iCancelCommand.front());
            if (!iCurrentCommand.empty())
            {
                /*
                 * not need to send commandcmp for internal purpose
                 */
                if (IsInternalCmd(iCurrentCommand.front().iCmd) == false)
                {
                    CommandComplete(iCurrentCommand.front(), iCmdErrStatus, iErrorResponseInf, iEventData);
                }
                if (iErrorResponseInf != NULL)
                {
                    iErrorResponseInf->removeRef();
                    iErrorResponseInf = NULL;
                }
                iCmdErrStatus = PVMFFailure;
                iEventData = NULL;

                /* Erase the command from the current queue */
                iCurrentCommand.Erase(&iCurrentCommand.front());
            }

            /*
             * cancel all queued commands, if any
             */
            if (iErrorDuringProcess == SM_NODE_COMMAND_COMPLETION)
            {
                while (iInputCommands.size() > 0)
                {
                    if (IsInternalCmd(iInputCommands.front().iCmd) == false)
                    {
                        CommandComplete(iInputCommands.front(), PVMFErrCancelled);
                    }
                    /* Erase the command from the input queue */
                    iInputCommands.Erase(&iInputCommands.front());
                }
            }
            iErrorDuringProcess = SM_NO_ERROR;
        }
    }
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CompleteCancelAll - Out"));
    return;
}

/**
//Called by the command handler AO to do the Cancel single command
*/
void PVMFStreamingManagerNode::DoCancelCommand(PVMFStreamingManagerNodeCommand& aCmd)
{
    //extract the command ID from the parameters.
    PVMFCommandId id;
    aCmd.PVMFStreamingManagerNodeCommandBase::Parse(id);

    //first check "current" command if any
    {
        PVMFStreamingManagerNodeCommand* cmd = iCurrentCommand.FindById(id);
        if (cmd)
        {
            //cancel the queued command
            CommandComplete(iCurrentCommand, *cmd, PVMFErrCancelled);
            //report cancel success
            CommandComplete(iInputCommands, aCmd, PVMFSuccess);
            return;
        }
    }
    //next check input queue.
    {
        //start at element 1 since this cancel command is element 0.
        PVMFStreamingManagerNodeCommand* cmd = iInputCommands.FindById(id, 1);
        if (cmd)
        {
            //cancel the queued command
            CommandComplete(iInputCommands, *cmd, PVMFErrCancelled);
            //report cancel success
            CommandComplete(iInputCommands, aCmd, PVMFSuccess);
            return;
        }
    }
    //if we get here the command isn't queued so the cancel fails.
    CommandComplete(iInputCommands, aCmd, PVMFFailure);
}

/////////////////////////////////////////////////////
// Event reporting routines.
/////////////////////////////////////////////////////
void PVMFStreamingManagerNode::SetState(TPVMFNodeInterfaceState s)
{
    PVMF_SM_LOGINFO((0, "StreamingManagerNode:SetState %d", s));
    PVMFNodeInterface::SetState(s);
}

void PVMFStreamingManagerNode::ReportErrorEvent(PVMFEventType aEventType,
        OsclAny* aEventData,
        PVUuid* aEventUUID,
        int32* aEventCode)
{
    PVMF_SM_LOGSTACKTRACE((0, "StreamingManagerNode:NodeErrorEvent Type %d Data %d"
                           , aEventType, aEventData));

    if (aEventUUID && aEventCode)
    {
        PVMFBasicErrorInfoMessage* eventmsg =
            OSCL_NEW(PVMFBasicErrorInfoMessage, (*aEventCode, *aEventUUID, NULL));
        PVMFAsyncEvent asyncevent(PVMFErrorEvent,
                                  aEventType,
                                  NULL,
                                  OSCL_STATIC_CAST(PVInterface*, eventmsg),
                                  aEventData,
                                  NULL,
                                  0);
        PVMFNodeInterface::ReportErrorEvent(asyncevent);
        eventmsg->removeRef();
    }
    else
    {
        PVMFNodeInterface::ReportErrorEvent(aEventType, aEventData);
    }
}

void PVMFStreamingManagerNode::ReportInfoEvent(PVMFEventType aEventType,
        OsclAny* aEventData,
        PVUuid* aEventUUID,
        int32* aEventCode)

{
    PVMF_SM_LOGSTACKTRACE((0, "StreamingManagerNode:NodeInfoEvent Type %d Data %d"
                           , aEventType, aEventData));

    if (aEventUUID && aEventCode)
    {
        PVMFBasicErrorInfoMessage* eventmsg =
            OSCL_NEW(PVMFBasicErrorInfoMessage, (*aEventCode, *aEventUUID, NULL));
        PVMFAsyncEvent asyncevent(PVMFInfoEvent,
                                  aEventType,
                                  NULL,
                                  OSCL_STATIC_CAST(PVInterface*, eventmsg),
                                  aEventData,
                                  NULL,
                                  0);
        PVMFNodeInterface::ReportInfoEvent(asyncevent);
        eventmsg->removeRef();
    }
    else
    {
        PVMFNodeInterface::ReportInfoEvent(aEventType, aEventData);
    }
}

void
PVMFStreamingManagerNode::HandlePortActivity(const PVMFPortActivity& aActivity)
{
    OSCL_UNUSED_ARG(aActivity);
    PVMF_SM_LOGSTACKTRACE((0, "StreamingManagerNode:HandlePortActivity - Not Implemented"));
}

/**
 * Active object implementation
 * The AO will either process one command or service one connected
 * port per call.  It will re-schedule itself and run continuously
 * until it runs out of things to do.
 */
void PVMFStreamingManagerNode::Run()
{
    /* Process commands */
    if (!iInputCommands.empty())
    {
        if (ProcessCommand(iInputCommands.front()))
        {
            /*
             * re-schedule if more commands to do
             * and node isn't reset.
             */
            if (!iInputCommands.empty() && iInterfaceState != EPVMFNodeCreated)
            {
                if (IsAdded())
                {
                    RunIfNotReady();
                }
            }
            return;
        }
    }

    /*
     * If we get here we did not process any commands.
     * Check for completion of a flush command...
     */
    if (FlushPending())
    {
        /*
         * Flush is complete.  Go to initialized state.
         */
        SetState(EPVMFNodeInitialized);
        CommandComplete(iCurrentCommand, iCurrentCommand.front(), PVMFSuccess);
        if (IsAdded())
        {
            RunIfNotReady();
        }
    }
}

void PVMFStreamingManagerNode::DoCancel()
{
    /* the base class cancel operation is sufficient */
    OsclActiveObject::DoCancel();
}

void
PVMFStreamingManagerNode::NodeCommandCompleted(const PVMFCmdResp& aResponse)
{
    PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode::NodeCommandCompleted"));

    bool oResponseOverRide = false;

    PVMFSMCommandContext *cmdContextData =
        OSCL_REINTERPRET_CAST(PVMFSMCommandContext*, aResponse.GetContext());

    PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode:NodeCommandCompleted: %d", cmdContextData->cmd));

    if ((cmdContextData->cmd >=
            PVMF_STREAMING_MANAGER_SOCKET_NODE_COMMAND_START) &&
            (cmdContextData->cmd <
             PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_COMMAND_START))

    {
        HandleSocketNodeCommandCompleted(aResponse);
    }
    else if ((cmdContextData->cmd >=
              PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_COMMAND_START) &&
             (cmdContextData->cmd <
              PVMF_STREAMING_MANAGER_JITTER_BUFFER_CONTROLLER_COMMAND_START))

    {
        HandleRTSPSessionControllerCommandCompleted(aResponse, oResponseOverRide);
    }
    else if ((cmdContextData->cmd >=
              PVMF_STREAMING_MANAGER_JITTER_BUFFER_CONTROLLER_COMMAND_START) &&
             (cmdContextData->cmd <
              PVMF_STREAMING_MANAGER_MEDIA_LAYER_COMMAND_START))

    {
        HandleJitterBufferCommandCompleted(aResponse);
    }
    else if ((cmdContextData->cmd >=
              PVMF_STREAMING_MANAGER_MEDIA_LAYER_COMMAND_START) &&
             (cmdContextData->cmd <
              PVMF_STREAMING_MANAGER_HTTP_SESSION_CONTROLLER_COMMAND_START))

    {
        HandleMediaLayerCommandCompleted(aResponse);
    }
    else if (cmdContextData->cmd >=
             PVMF_STREAMING_MANAGER_RTPPACKETSOURCE_NODE_COMMAND_START)
    {
    }

    if ((aResponse.GetCmdStatus() != PVMFSuccess) &&
            (aResponse.GetCmdStatus() != PVMFErrCancelled) &&
            (oResponseOverRide == false))
    {
        if (iCancelCommand.size() > 0)
        {
            if (cmdContextData->parentCmd == PVMF_STREAMING_MANAGER_NODE_CANCELALLCOMMANDS)
            {
                /*
                 * During CancelAllComands, error happen from child node.
                 * Then we save this err and after all current cmd is canceled in child node, we send this err code.
                 * If CancelAllCommands is issued by internal error handling, iErrorDuringProcess should be true.
                 */
                if (iErrorDuringProcess == SM_NO_ERROR)
                {
                    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode:NodeCommandCompleted: - Reset Error during CancelAll"));
                    if (iErrorResponseInf != NULL)
                    {
                        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::NodeCommandCompleted - iErrorResponseInf is not NULL"));
                        OSCL_ASSERT(false);
                    }
                    /*
                     * Only first error msg from cancelall completion in child node is stored.
                     */
                    if (aResponse.GetEventExtensionInterface())
                    {
                        iErrorResponseInf = aResponse.GetEventExtensionInterface();
                        iErrorResponseInf->addRef();
                    }
                    iErrorDuringProcess = SM_NODE_COMMAND_COMPLETION;
                }
                CompleteCancelAll();
            }
            /*
             * If Error is recieved for Current Cmd during cancelling, we just ignore.
             */
        }
        else if (iCurrentCommand.size() > 0)
        {
            /*
             * If error is recieved while current cmd is ongoing, we save this error code and issue CancelAllCommands.
             * After all current cmd is canceled in child node,
             * we send this error code if current cmd is not internal use.
             */
            if (iErrorDuringProcess == SM_NO_ERROR)
            {
                if (iErrorResponseInf != NULL)
                {
                    PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::NodeCommandCompleted - iErrorResponseInf is not NULL"));
                    OSCL_ASSERT(false);
                }
                if (aResponse.GetEventExtensionInterface())
                {
                    iErrorResponseInf = aResponse.GetEventExtensionInterface();
                    iErrorResponseInf->addRef();
                }
                iCmdErrStatus = aResponse.GetCmdStatus();
                iEventData = aResponse.GetEventData();
                iErrorDuringProcess = SM_NODE_COMMAND_COMPLETION;

                /*
                 * We don't interupt any Reset cmd for child node.
                 * After all Reset cmd is completed in child node, we send this error.
                 */
                if (cmdContextData->parentCmd != PVMF_STREAMING_MANAGER_NODE_RESET)
                {
                    PVMFSessionId s = 0;
                    PVMFStreamingManagerNodeCommand cmdCancelPendingCmd;
                    cmdCancelPendingCmd.PVMFStreamingManagerNodeCommandBase::Construct(s,
                            PVMF_STREAMING_MANAGER_NODE_CANCELALLCOMMANDS,
                            NULL);
                    QueueCommandL(cmdCancelPendingCmd);
                    PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode:NodeCommandCompleted: - CancelAllCommands Queued"));

                    ResetNodeContainerCmdState();
                }
            }
            else
            {
                PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode:NodeCommandCompleted: - CancelAllCommands already Queued"));
            }
        }
    }
    return;
}

void
PVMFStreamingManagerNode::HandleSocketNodeCommandCompleted(const PVMFCmdResp& aResponse)
{
    PVMFSMNodeContainer* iSocketNodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_SOCKET_NODE);
    if (iSocketNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);

    PVMFSMCommandContext *cmdContextData =
        OSCL_REINTERPRET_CAST(PVMFSMCommandContext*, aResponse.GetContext());

    if (iSocketNodeContainer->iNodeCmdState == PVMFSM_NODE_CMD_PENDING)
    {
        iSocketNodeContainer->iNodeCmdState = PVMFSM_NODE_CMD_COMPLETE;
    }
    else if (iSocketNodeContainer->iNodeCmdState == PVMFSM_NODE_CMD_CANCEL_PENDING)
    {
        if (cmdContextData->parentCmd == PVMF_STREAMING_MANAGER_NODE_CANCELALLCOMMANDS)
            iSocketNodeContainer->iNodeCmdState = PVMFSM_NODE_CMD_CANCEL_COMPLETE;
    }

    if (aResponse.GetCmdStatus() != PVMFSuccess)
    {
        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::HandleSocketNodeCommandCompleted - Command failed - context=0x%x, status=0x%x", aResponse.GetContext(), aResponse.GetCmdStatus()));
        if (IsBusy())
        {
            Cancel();
            RunIfNotReady();
        }
        return;
    }
    cmdContextData->oFree = true;

    switch (cmdContextData->cmd)
    {
        case PVMF_STREAMING_MANAGER_SOCKET_NODE_QUERY_UUID:
            CompleteQueryUuid();
            break;

        case PVMF_STREAMING_MANAGER_SOCKET_NODE_QUERY_INTERFACE:
        {
            if (iExtensionInterfacePlaceholder == NULL) OSCL_LEAVE(OsclErrBadHandle);
            iSocketNodeContainer->iExtensions.push_back(iExtensionInterfacePlaceholder);
            CompleteQueryInterface();
        }
        break;

        case PVMF_STREAMING_MANAGER_SOCKET_NODE_INIT:
        {
            {
                CompleteInit();
            }
        }
        break;

        case PVMF_STREAMING_MANAGER_SOCKET_NODE_PREPARE:
        {
            {
                CompletePrepare();
            }
        }
        break;

        case PVMF_STREAMING_MANAGER_SOCKET_NODE_START:
        {
            {
                {
                    CompleteStart();
                }
            }
        }
        break;

        case PVMF_STREAMING_MANAGER_SOCKET_NODE_STOP:
        {
            CompleteStop();
        }
        break;

        case PVMF_STREAMING_MANAGER_SOCKET_NODE_FLUSH:
            CompleteFlush();
            break;

        case PVMF_STREAMING_MANAGER_SOCKET_NODE_PAUSE:
        {
            {
                CompletePause();
            }
        }
        break;

        case PVMF_STREAMING_MANAGER_SOCKET_NODE_RESET:
            CompleteReset();
            break;

        case PVMF_STREAMING_MANAGER_SOCKET_NODE_REQUEST_PORT:
        {
            PVMFPortInterface* port =
                (PVMFPortInterface*)aResponse.GetEventData();
            {
                /*
                 * Save the port in TrackInfo
                 */
                PVMFSMTrackInfo* trackInfo =
                    FindTrackInfo(cmdContextData->portContext.trackID);

                if (cmdContextData->portContext.portTag ==
                        PVMF_SOCKET_NODE_PORT_TYPE_SOURCE)
                {
                    trackInfo->iNetworkNodePort = port;
                    iSocketNodeContainer->iOutputPorts.push_back(port);
                }
                else if (cmdContextData->portContext.portTag ==
                         PVMF_SOCKET_NODE_PORT_TYPE_SINK)
                {
                    trackInfo->iNetworkNodeRTCPPort = port;
                    iSocketNodeContainer->iInputPorts.push_back(port);
                }
                CompleteGraphConstruct();
            }
        }
        break;
        case PVMF_STREAMING_MANAGER_SOCKET_NODE_CANCEL_ALL_COMMANDS:
        {
            CompleteCancelAll();
        }
        break;

        default:
            break;
    }
    return;
}

void
PVMFStreamingManagerNode::HandleRTSPSessionControllerCommandCompleted(const PVMFCmdResp& aResponse,
        bool& aResponseOverRide)
{
    aResponseOverRide = false;

    PVMFSMNodeContainer* iSessionControllerNodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);
    if (iSessionControllerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);

    PVMFSMCommandContext *cmdContextData =
        OSCL_REINTERPRET_CAST(PVMFSMCommandContext*, aResponse.GetContext());

    if (iSessionControllerNodeContainer->iNodeCmdState == PVMFSM_NODE_CMD_PENDING)
    {
        iSessionControllerNodeContainer->iNodeCmdState = PVMFSM_NODE_CMD_COMPLETE;
    }
    else if (iSessionControllerNodeContainer->iNodeCmdState == PVMFSM_NODE_CMD_CANCEL_PENDING)
    {
        if (cmdContextData->parentCmd == PVMF_STREAMING_MANAGER_NODE_CANCELALLCOMMANDS)
            iSessionControllerNodeContainer->iNodeCmdState = PVMFSM_NODE_CMD_CANCEL_COMPLETE;
    }

    cmdContextData->oFree = true;

    if (aResponse.GetCmdStatus() != PVMFSuccess)
    {
        if (cmdContextData->cmd == PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_PAUSE)
        {
            /*
             * Check if it is a pause failure - suppress pause failures if they
             * happen after a session is complete
             */
            PVMFSMNodeContainer* iJitterBufferNodeContainer =
                getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
            if (iJitterBufferNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
            PVMFJitterBufferExtensionInterface* jbExtIntf =
                (PVMFJitterBufferExtensionInterface*)
                (iJitterBufferNodeContainer->iExtensions[0]);
            bool oSessionExpired = false;
            jbExtIntf->HasSessionDurationExpired(oSessionExpired);
            if (oSessionExpired == true)
            {
                aResponseOverRide = true;
            }
        }
        /* if a failure has been overridden just fall thru */
        if (aResponseOverRide == false)
        {
            PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::HandleRTSPSessionControllerCommandCompleted - Command failed - context=0x%x, status=0x%x", aResponse.GetContext(), aResponse.GetCmdStatus()));
            if (IsBusy())
            {
                Cancel();
                RunIfNotReady();
            }
            return;
        }
    }

    switch (cmdContextData->cmd)
    {
        case PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_QUERY_UUID:
            CompleteQueryUuid();
            break;

        case PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_QUERY_INTERFACE:
        {
            if (iExtensionInterfacePlaceholder == NULL) OSCL_LEAVE(OsclErrBadHandle);
            iSessionControllerNodeContainer->iExtensions.push_back(iExtensionInterfacePlaceholder);
            CompleteQueryInterface();
        }
        break;

        case PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_INIT:
            CompleteInit();
            break;

        case PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_PREPARE:
        {
            if (iSessionSourceInfo->iRTSPTunnelling == false)
            {
                /* Complete set up of feedback channels */
                CompleteFeedBackPortsSetup();
            }
            /*
             * Send start complete params to child nodes
             * viz. SSRC etc
             */
            SendSessionControlPrepareCompleteParams();
            CompletePrepare();
        }
        break;

        case PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_START:
        {
            {
                /*
                 * Send start complete params to child nodes
                 * viz. actual play range, rtp info params etc
                 */
                SendSessionControlStartCompleteParams();
                CompleteStart();
            }
        }
        break;

        case PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_STOP:
        {
            CompleteStop();
        }
        break;

        case PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_FLUSH:
            CompleteFlush();
            break;

        case PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_PAUSE:
        {
            {
                CompletePause();
            }
        }
        break;

        case PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_RESET:
            CompleteReset();
            break;

        case PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_REQUEST_PORT:
        {
            /*
             * Save the port in TrackInfo
             */
            PVMFSMTrackInfo* trackInfo =
                FindTrackInfo(cmdContextData->portContext.trackID);

            PVMFPortInterface* port =
                (PVMFPortInterface*)aResponse.GetEventData();

            if (cmdContextData->portContext.portTag ==
                    PVMF_RTSP_NODE_PORT_TYPE_OUTPUT)
            {
                trackInfo->iSessionControllerOutputPort = port;
                iSessionControllerNodeContainer->iOutputPorts.push_back(port);

            }
            else if (cmdContextData->portContext.portTag ==
                     PVMF_RTSP_NODE_PORT_TYPE_INPUT)
            {
                iSessionControllerNodeContainer->iInputPorts.push_back(port);
            }
            else if (cmdContextData->portContext.portTag ==
                     PVMF_RTSP_NODE_PORT_TYPE_INPUT_OUTPUT)
            {
                trackInfo->iSessionControllerFeedbackPort = port;
                iSessionControllerNodeContainer->iFeedBackPorts.push_back(port);
            }
            CompleteGraphConstruct();
        }
        break;

        case PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_CANCEL_ALL_COMMANDS:
        {
            CompleteCancelAll();
        }
        break;

        default:
            break;
    }
    return;
}

void
PVMFStreamingManagerNode::HandleJitterBufferCommandCompleted(const PVMFCmdResp& aResponse)
{
    PVMFSMNodeContainer* iJitterBufferNodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
    if (iJitterBufferNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);

    PVMFSMCommandContext *cmdContextData =
        OSCL_REINTERPRET_CAST(PVMFSMCommandContext*, aResponse.GetContext());

    if (iJitterBufferNodeContainer->iNodeCmdState == PVMFSM_NODE_CMD_PENDING)
    {
        iJitterBufferNodeContainer->iNodeCmdState = PVMFSM_NODE_CMD_COMPLETE;
    }
    else if (iJitterBufferNodeContainer->iNodeCmdState == PVMFSM_NODE_CMD_CANCEL_PENDING)
    {
        if (cmdContextData->parentCmd == PVMF_STREAMING_MANAGER_NODE_CANCELALLCOMMANDS)
            iJitterBufferNodeContainer->iNodeCmdState = PVMFSM_NODE_CMD_CANCEL_COMPLETE;
    }

    if (aResponse.GetCmdStatus() != PVMFSuccess)
    {
        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::HandleJitterBufferCommandCompleted - Command failed - context=0x%x, status=0x%x", aResponse.GetContext(), aResponse.GetCmdStatus()));
        if (IsBusy())
        {
            Cancel();
            RunIfNotReady();
        }
        return;
    }

    cmdContextData->oFree = true;

    switch (cmdContextData->cmd)
    {
        case PVMF_STREAMING_MANAGER_JITTER_BUFFER_QUERY_UUID:
            CompleteQueryUuid();
            break;

        case PVMF_STREAMING_MANAGER_JITTER_BUFFER_QUERY_INTERFACE:
        {
            if (iExtensionInterfacePlaceholder == NULL) OSCL_LEAVE(OsclErrBadHandle);
            iJitterBufferNodeContainer->iExtensions.push_back(iExtensionInterfacePlaceholder);
            CompleteQueryInterface();
        }
        break;

        case PVMF_STREAMING_MANAGER_JITTER_BUFFER_INIT:
        {
            PVMFJitterBufferExtensionInterface* jbExtIntf =
                (PVMFJitterBufferExtensionInterface*)
                (iJitterBufferNodeContainer->iExtensions[0]);
            if (jbExtIntf == NULL) OSCL_LEAVE(OsclErrBadHandle);
            if (IsRTPPacketSourcePresent())
            {
                jbExtIntf->SetBroadCastSession();
            }
            bool disableFireWallPackets = true;
            if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
                    (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE))
            {
                if (iSessionSourceInfo->iRTSPTunnelling == false)
                {
                    //do not disable fw pkts run time
                    //apps can still disable it compile time or using KVP
                    //for UDP sessions ofcourse
                    disableFireWallPackets = false;
                }
            }
            if (disableFireWallPackets == true)
            {
                jbExtIntf->DisableFireWallPackets();
            }
            CompleteInit();
        }
        break;

        case PVMF_STREAMING_MANAGER_JITTER_BUFFER_PREPARE:
            CompletePrepare();
            break;

        case PVMF_STREAMING_MANAGER_JITTER_BUFFER_START:
        {
            /* If start has been cancelled wait for cancel success */
            if (aResponse.GetCmdStatus() != PVMFErrCancelled)
            {
                CompleteStart();
            }
        }
        break;

        case PVMF_STREAMING_MANAGER_JITTER_BUFFER_STOP:
        {
            CompleteStop();
        }
        break;

        case PVMF_STREAMING_MANAGER_JITTER_BUFFER_FLUSH:
            CompleteFlush();
            break;

        case PVMF_STREAMING_MANAGER_JITTER_BUFFER_PAUSE:
            CompletePause();
            break;

        case PVMF_STREAMING_MANAGER_JITTER_BUFFER_RESET:
            CompleteReset();
            break;

        case PVMF_STREAMING_MANAGER_JITTER_BUFFER_REQUEST_PORT:
        {
            PVMFJitterBufferExtensionInterface* jbExtIntf =
                (PVMFJitterBufferExtensionInterface*)
                (iJitterBufferNodeContainer->iExtensions[0]);

            if (jbExtIntf == NULL) OSCL_LEAVE(OsclErrBadHandle);

            /*
             * Save the port in TrackInfo
             */
            PVMFSMTrackInfo* trackInfo =
                FindTrackInfo(cmdContextData->portContext.trackID);

            PVMFPortInterface* port =
                (PVMFPortInterface*)aResponse.GetEventData();

            uint32 bitrate = 0;

            if (cmdContextData->portContext.portTag ==
                    PVMF_JITTER_BUFFER_PORT_TYPE_INPUT)
            {
                bitrate = trackInfo->bitRate;
                trackInfo->iJitterBufferInputPort = port;
                iJitterBufferNodeContainer->iInputPorts.push_back(port);
            }
            else if (cmdContextData->portContext.portTag ==
                     PVMF_JITTER_BUFFER_PORT_TYPE_OUTPUT)
            {
                trackInfo->iJitterBufferOutputPort = port;
                iJitterBufferNodeContainer->iOutputPorts.push_back(port);
            }
            else if (cmdContextData->portContext.portTag ==
                     PVMF_JITTER_BUFFER_PORT_TYPE_FEEDBACK)
            {
                trackInfo->iJitterBufferRTCPPort = port;
                iJitterBufferNodeContainer->iFeedBackPorts.push_back(port);

                //if RTP packet source is present, it implies a DVBH session
                //and we disable RTCP RRs for DVB sessions
                if (IsRTPPacketSourcePresent())
                {
                    //The packet source does not process RTCP reader reports.
                    //So, disable them by setting the RR bandwidth to zero.
                    //The RS bandwidth is set to the RFC default of 800 bps but
                    //actual bandwidth is allocated by the fraction RS/(RR+RS), so
                    //the number used for RS in this case is arbitrary because
                    //sender reports will get 100% of the RTCP bandwidth as RS/RS = 100%.
                    jbExtIntf->setPortRTCPParams(port,
                                                 iTrackInfoVec.size(),
                                                 0,
                                                 800);
                }
                else
                {
                    if (trackInfo->iRTCPBwSpecified)
                    {
                        jbExtIntf->setPortRTCPParams(port, iTrackInfoVec.size(), trackInfo->iRR, trackInfo->iRS);
                    }
                }
            }
            jbExtIntf->setPortParams(port,
                                     trackInfo->trackTimeScale,
                                     bitrate,
                                     trackInfo->iTrackConfig,
                                     trackInfo->iRateAdaptation,
                                     trackInfo->iRateAdaptationFeedBackFrequency);
            CompleteGraphConstruct();
        }
        break;

        case PVMF_STREAMING_MANAGER_JITTER_BUFFER_CANCEL_ALL_COMMANDS:
        {
            CompleteCancelAll();
        }
        break;

        default:
            break;
    }
    return;
}

void
PVMFStreamingManagerNode::HandleMediaLayerCommandCompleted(const PVMFCmdResp& aResponse)
{
    PVMFSMNodeContainer* iMediaLayerNodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_MEDIA_LAYER_NODE);
    if (iMediaLayerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);

    PVMFSMCommandContext *cmdContextData =
        OSCL_REINTERPRET_CAST(PVMFSMCommandContext*, aResponse.GetContext());

    if (iMediaLayerNodeContainer->iNodeCmdState == PVMFSM_NODE_CMD_PENDING)
    {
        iMediaLayerNodeContainer->iNodeCmdState = PVMFSM_NODE_CMD_COMPLETE;
    }
    else if (iMediaLayerNodeContainer->iNodeCmdState == PVMFSM_NODE_CMD_CANCEL_PENDING)
    {
        if (cmdContextData->parentCmd == PVMF_STREAMING_MANAGER_NODE_CANCELALLCOMMANDS)
            iMediaLayerNodeContainer->iNodeCmdState = PVMFSM_NODE_CMD_CANCEL_COMPLETE;
    }

    if (aResponse.GetCmdStatus() != PVMFSuccess)
    {
        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::HandleMediaLayerCommandCompleted - Command failed - context=0x%x, status=0x%x", aResponse.GetContext(), aResponse.GetCmdStatus()));
        if (IsBusy())
        {
            Cancel();
            RunIfNotReady();
        }
        return;
    }

    cmdContextData->oFree = true;

    switch (cmdContextData->cmd)
    {
        case PVMF_STREAMING_MANAGER_MEDIA_LAYER_QUERY_UUID:
            CompleteQueryUuid();
            break;

        case PVMF_STREAMING_MANAGER_MEDIA_LAYER_QUERY_INTERFACE:
        {
            if (iExtensionInterfacePlaceholder == NULL) OSCL_LEAVE(OsclErrBadHandle);
            iMediaLayerNodeContainer->iExtensions.push_back(iExtensionInterfacePlaceholder);
            CompleteQueryInterface();
        }
        break;

        case PVMF_STREAMING_MANAGER_MEDIA_LAYER_INIT:
            CompleteInit();
            break;

        case PVMF_STREAMING_MANAGER_MEDIA_LAYER_PREPARE:
            CompletePrepare();
            break;

        case PVMF_STREAMING_MANAGER_MEDIA_LAYER_START:
        {
            CompleteStart();
        }
        break;

        case PVMF_STREAMING_MANAGER_MEDIA_LAYER_STOP:
        {
            CompleteStop();
        }
        break;

        case PVMF_STREAMING_MANAGER_MEDIA_LAYER_FLUSH:
            CompleteFlush();
            break;

        case PVMF_STREAMING_MANAGER_MEDIA_LAYER_PAUSE:
            CompletePause();
            break;

        case PVMF_STREAMING_MANAGER_MEDIA_LAYER_RESET:
            CompleteReset();
            break;

        case PVMF_STREAMING_MANAGER_MEDIA_LAYER_REQUEST_PORT:
        {
            PVMFMediaLayerNodeExtensionInterface* mlExtIntf =
                (PVMFMediaLayerNodeExtensionInterface*)
                (iMediaLayerNodeContainer->iExtensions[0]);

            if (mlExtIntf == NULL) OSCL_LEAVE(OsclErrBadHandle);

            /*
             * Save the port in TrackInfo
             */
            PVMFSMTrackInfo* trackInfo =
                FindTrackInfo(cmdContextData->portContext.trackID);

            PVMFPortInterface* port =
                (PVMFPortInterface*)aResponse.GetEventData();

            if (cmdContextData->portContext.portTag ==
                    PVMF_MEDIALAYER_PORT_TYPE_INPUT)
            {
                trackInfo->iMediaLayerInputPort = port;
                iMediaLayerNodeContainer->iInputPorts.push_back(port);
            }
            else if (cmdContextData->portContext.portTag ==
                     PVMF_MEDIALAYER_PORT_TYPE_OUTPUT)
            {
                trackInfo->iMediaLayerOutputPort = port;
                iMediaLayerNodeContainer->iOutputPorts.push_back(port);
            }
            mediaInfo* mInfo = NULL;
            if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
                    (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE) ||
                    (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE))
            {
                SDPInfo* sdpInfo = iSessionSourceInfo->_sdpInfo.GetRep();
                if (sdpInfo == NULL) OSCL_LEAVE(OsclErrBadHandle);
                mInfo = sdpInfo->getMediaInfoBasedOnID(trackInfo->trackID);
            }
            mlExtIntf->setPortMediaParams(port, trackInfo->iTrackConfig, mInfo);
            CompleteGraphConstruct();
        }
        break;

        case PVMF_STREAMING_MANAGER_MEDIA_LAYER_CANCEL_ALL_COMMANDS:
        {
            CompleteCancelAll();
        }
        break;

        default:
            break;
    }
    return;
}

bool PVMFStreamingManagerNode::IsFatalErrorEvent(const PVMFEventType& event)
{
    bool retval = false;
    switch (event)
    {
        case PVMFErrCorrupt:
        case PVMFErrOverflow:
        case PVMFErrResource:
        case PVMFErrProcessing:
        case PVMFErrUnderflow:
        case PVMFErrNoResources:
        case PVMFErrResourceConfiguration:
        case PVMFErrTimeout:
        case PVMFErrNoMemory:
        case PVMFFailure:
            retval = true;
            break;
        default:
            retval = false;
    }
    return retval;
}

void
PVMFStreamingManagerNode::HandleNodeErrorEvent(const PVMFAsyncEvent& aEvent)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::HandleNodeErrorEvent - In iCancelCommand.empty() [%d] current command id[%d] event type [%d]", iCancelCommand.empty(), iCurrentCommand.front().iCmd, aEvent.GetEventType()));

    //Check if fatal error occurred, then we may need to enque the cancelallcommand due to error
    if (IsFatalErrorEvent(aEvent.GetEventType())
            && !iCurrentCommand.empty()
            && iCancelCommand.empty())
    {
        if ((IsInternalCmd(iCurrentCommand.front().iCmd) == true))
        {
            /*
             * cancel all queued commands, if any
             */
            while (iInputCommands.size() > 0)
            {
                if (IsInternalCmd(iInputCommands.front().iCmd) == false)
                {
                    CommandComplete(iInputCommands.front(), PVMFErrCancelled);
                }
                /* Erase the command from the input queue */
                iInputCommands.Erase(&iInputCommands.front());
            }

            /*
             * After the completion of the cancel due to error, we will complete the current command in which failure occurred.
             */
            iErrorDuringProcess = SM_ERROR_EVENT;
            PVMFSessionId s = 0;
            PVMFStreamingManagerNodeCommand cmdCancelPendingCmd;
            cmdCancelPendingCmd.PVMFStreamingManagerNodeCommandBase::Construct(s,
                    PVMF_STREAMING_MANAGER_NODE_CANCELALLCOMMANDS,
                    NULL);
            QueueCommandL(cmdCancelPendingCmd);
            PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode:HandleNodeErrorEvent: - CancelAllCommands Queued"));
        }
    }
    //just pass the error event up
    PVMFAsyncEvent event = OSCL_CONST_CAST(PVMFAsyncEvent, aEvent);
    PVMFNodeInterface::ReportErrorEvent(event);

    return;
}

void
PVMFStreamingManagerNode::HandleNodeInformationalEvent(const PVMFAsyncEvent& aEvent)
{
    PVMFAsyncEvent event = OSCL_CONST_CAST(PVMFAsyncEvent, aEvent);
    PVMFEventType infoEvent = aEvent.GetEventType();
    if (infoEvent == PVMFInfoEndOfData)
    {
        /* Notify jitter buffer */
        PVMFSMNodeContainer* iJitterBufferNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
        if (iJitterBufferNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
        PVMFJitterBufferExtensionInterface* jbExtIntf =
            (PVMFJitterBufferExtensionInterface*)
            (iJitterBufferNodeContainer->iExtensions[0]);
        jbExtIntf->NotifyOutOfBandEOS();
    }
    else
    {
        /* Just pass the info event up */
        PVMFNodeInterface::ReportInfoEvent(event);
    }
}

PVMFSMCommandContext* PVMFStreamingManagerNode::RequestNewInternalCmd()
{
    int32 i = 0;
    /* Search for the next free node command in the pool */
    while (i < PVMF_STREAMING_MANAGER_INTERNAL_CMDQ_SIZE)
    {
        if (iInternalCmdPool[i].oFree)
        {
            iInternalCmdPool[i].oFree = false;
            return &(iInternalCmdPool[i]);
        }
        ++i;
    }
    /* Free one not found so return NULL */
    return NULL;
}

void
PVMFStreamingManagerNode::MoveCmdToCurrentQueue(PVMFStreamingManagerNodeCommand& aCmd)
{
    int32 err;
    OSCL_TRY(err, iCurrentCommand.StoreL(aCmd););
    if (err != OsclErrNone)
    {
        CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
        return;
    }
    iInputCommands.Erase(&aCmd);
    return;
}

void
PVMFStreamingManagerNode::MoveCmdToCancelQueue(PVMFStreamingManagerNodeCommand& aCmd)
{
    /*
     * note: the StoreL cannot fail since the queue is never more than 1 deep
     * and we reserved space.
     */
    iCancelCommand.StoreL(aCmd);
    iInputCommands.Erase(&aCmd);
    return;
}

PVMFSMNodeContainer*
PVMFStreamingManagerNode::getNodeContainer(int32 tag)
{
    for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
    {
        if (iNodeContainerVec[i].iNodeTag == tag)
        {
            return (&(iNodeContainerVec[i]));
        }
    }
    return NULL;
}

bool PVMFStreamingManagerNode::PopulateTrackInfoVec()
{
    if (iSelectedMediaPresetationInfo.getNumTracks() == 0)
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:PopulateTrackInfoVec - Selected Track List Empty"));
        return false;
    }

    if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE))
    {
        /*
         * Get selected tracks
         */
        SDPInfo* sdpInfo = iSessionSourceInfo->_sdpInfo;

        int32 numTracks = sdpInfo->getNumMediaObjects();

        if (numTracks > 0)
        {
            for (int32 i = 0; i < numTracks; i++)
            {
                /*
                 * Get the vector of mediaInfo as there can
                 * alternates for each track
                 */
                Oscl_Vector<mediaInfo*, SDPParserAlloc> mediaInfoVec =
                    sdpInfo->getMediaInfo(i);

                uint32 minfoVecLen = mediaInfoVec.size();
                for (uint32 j = 0; j < minfoVecLen; j++)
                {
                    mediaInfo* mInfo = mediaInfoVec[j];

                    if (mInfo == NULL)
                    {
                        return false;
                    }

                    if (mInfo->getSelect())
                    {
                        PVMFSMTrackInfo trackInfo;

                        {
                            trackInfo.iTransportType += _STRLIT_CHAR("RTP");
                        }

                        trackInfo.trackID = mInfo->getMediaInfoID();

                        Oscl_Vector<PayloadSpecificInfoTypeBase*, SDPParserAlloc> payloadVector;
                        payloadVector = mInfo->getPayloadSpecificInfoVector();

                        if (payloadVector.size() == 0)
                        {
                            return false;
                        }
                        /*
                         * There can be multiple payloads per media segment.
                         * We only support one for now, so
                         * use just the first payload
                         */
                        PayloadSpecificInfoTypeBase* payloadInfo = payloadVector[0];
                        trackInfo.trackTimeScale = payloadInfo->sampleRate;

                        // set config for later
                        int32 configSize = payloadInfo->configSize;
                        OsclAny* config = payloadInfo->configHeader.GetRep();

                        const char* mimeType = mInfo->getMIMEType();
                        OSCL_StackString<32> h263(_STRLIT_CHAR("H263"));
                        {
                            trackInfo.iMimeType += mimeType;
                        }

                        trackInfo.portTag = mInfo->getMediaInfoID();
                        trackInfo.bitRate = mInfo->getBitrate();
                        if (mInfo->getReportFrequency() > 0)
                        {
                            trackInfo.iRateAdaptation = true;
                            trackInfo.iRateAdaptationFeedBackFrequency =
                                mInfo->getReportFrequency();
                        }

                        if ((mInfo->getRTCPReceiverBitRate() >= 0) &&
                                (mInfo->getRTCPSenderBitRate() >= 0))
                        {
                            trackInfo.iRR = mInfo->getRTCPReceiverBitRate();
                            trackInfo.iRS = mInfo->getRTCPSenderBitRate();
                            trackInfo.iRTCPBwSpecified = true;
                        }

                        if ((configSize > 0) && (config != NULL))
                        {
                            OsclMemAllocDestructDealloc<uint8> my_alloc;
                            OsclRefCounter* my_refcnt;
                            uint aligned_refcnt_size =
                                oscl_mem_aligned_size(sizeof(OsclRefCounterSA< OsclMemAllocDestructDealloc<uint8> >));

                            uint8* my_ptr = NULL;
                            int32 errcode = 0;
                            OSCL_TRY(errcode, my_ptr = (uint8*) my_alloc.ALLOCATE(aligned_refcnt_size + configSize));

                            my_refcnt = OSCL_PLACEMENT_NEW(my_ptr, OsclRefCounterSA< OsclMemAllocDestructDealloc<uint8> >(my_ptr));
                            my_ptr += aligned_refcnt_size;

                            OsclMemoryFragment memfrag;
                            memfrag.len = (uint32)configSize;
                            memfrag.ptr = my_ptr;

                            oscl_memcpy((void*)(memfrag.ptr), (const void*)config, memfrag.len);

                            OsclRefCounterMemFrag tmpRefcntMemFrag(memfrag, my_refcnt, memfrag.len);
                            trackInfo.iTrackConfig = tmpRefcntMemFrag;
                        }
                        iTrackInfoVec.push_back(trackInfo);
                    }
                }
            }
        }
        else
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:PopulateTrackInfoVec - Selected Track List Empty"));
            return false;
        }
    }
    return true;
}

PVMFSMTrackInfo*
PVMFStreamingManagerNode::FindTrackInfo(uint32 trackID)
{
    PVMFSMTrackInfoVector::iterator it;

    for (it = iTrackInfoVec.begin();
            it != iTrackInfoVec.end();
            it++)
    {
        if (it->trackID == trackID)
        {
            return (it);
        }
    }
    return NULL;
}

PVMFSMTrackInfo*
PVMFStreamingManagerNode::FindTrackInfo(PvmfMimeString* trackMimeType)
{
    PVMFSMTrackInfoVector::iterator it;

    for (it = iTrackInfoVec.begin();
            it != iTrackInfoVec.end();
            it++)
    {
        if (!(oscl_CIstrcmp(it->iMimeType.get_cstr(),
                            trackMimeType->get_cstr())))
        {
            return (it);
        }
    }
    return NULL;
}

bool PVMFStreamingManagerNode::ReserveSockets()
{
    uint32 sockid = 0;
    char portConfigBuf[64];
    oscl_memset((OsclAny*)portConfigBuf, 0, 64);
    oscl_snprintf(portConfigBuf, 64, "%d", sockid);
    OSCL_StackString<128> portConfig("UDP");
    portConfig += _STRLIT_CHAR("/remote_address=0.0.0.0");
    portConfig += _STRLIT_CHAR(";client_port=");
    portConfig += portConfigBuf;

    PVMFSMNodeContainer* iSocketNodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_SOCKET_NODE);
    if (iSocketNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
    PVMFSocketNode* socketNode =
        (PVMFSocketNode*)(iSocketNodeContainer->iNode);
    PVMFSMTrackInfoVector::iterator it;
    uint32 startPortNum = 0;
    {
        TimeValue current_time;
        current_time.set_to_current_time();
        uint32 my_seed = current_time.get_sec();

        OsclRand random_num;
        random_num.Seed(my_seed);
        int32 first = random_num.Rand();
        uint32 myport = (first & 0x1FFF) + 0x2000;	//start from 8192
        startPortNum = (myport >> 1) << 1;	//start from even
    }

    for (it = iTrackInfoVec.begin();
            it != iTrackInfoVec.end();
            it++)
    {
        OSCL_StackString<128> portConfigWithMime;
        portConfigWithMime += portConfig;
        portConfigWithMime += _STRLIT_CHAR(";mime=");
        portConfigWithMime += it->iMimeType;

        PVMFStatus status = socketNode->AllocateConsecutivePorts(&portConfigWithMime,
                            it->iRTPSocketID,
                            it->iRTCPSocketID, startPortNum);
        if (status != PVMFSuccess)
        {
            return false;
        }
    }
    return true;
}

bool PVMFStreamingManagerNode::RequestNetworkNodePorts(int32 portTag,
        uint32& numPortsRequested)
{
    numPortsRequested = 0;

    PVMFSMNodeContainer* nodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_SOCKET_NODE);

    if (nodeContainer == NULL)
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:RequestNetworkNodePorts - getNodeContainer Failed"));
        return false;
    }

    for (uint32 i = 0; i < iTrackInfoVec.size(); i++)
    {
        PVMFSMTrackInfo trackInfo = iTrackInfoVec[i];

        PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
        if (internalCmd != NULL)
        {
            internalCmd->cmd =
                nodeContainer->commandStartOffset +
                PVMF_STREAMING_MANAGER_NODE_INTERNAL_REQUEST_PORT_OFFSET;
            internalCmd->parentCmd = PVMF_STREAMING_MANAGER_NODE_CONSTRUCT_SESSION;
            internalCmd->portContext.trackID = trackInfo.trackID;
            internalCmd->portContext.portTag = portTag;

            OsclAny *cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

            PVMFNodeInterface* iNode = nodeContainer->iNode;

            uint32 sockid = 0;
            bool oRTCP = false;

            if (portTag == PVMF_SOCKET_NODE_PORT_TYPE_SOURCE)
            {
                sockid = trackInfo.iRTPSocketID;
            }
            else if (portTag == PVMF_SOCKET_NODE_PORT_TYPE_SINK)
            {
                sockid = trackInfo.iRTCPSocketID;
                oRTCP = true;
            }

            char portConfigBuf[64];
            oscl_memset((OsclAny*)portConfigBuf, 0, 64);
            oscl_snprintf(portConfigBuf, 64, "%d", sockid);
            OSCL_StackString<128> portConfig("UDP");
            portConfig += _STRLIT_CHAR("/remote_address=0.0.0.0");
            portConfig += _STRLIT_CHAR(";client_port=");
            portConfig += portConfigBuf;
            portConfig += _STRLIT_CHAR(";mime=");
            portConfig += trackInfo.iMimeType.get_cstr();
            if (oRTCP == true)
            {
                portConfig += _STRLIT_CHAR("/rtp");
            }
            else
            {
                portConfig += _STRLIT_CHAR("/rtcp");
            }

            iNode->RequestPort(nodeContainer->iSessionId,
                               internalCmd->portContext.portTag,
                               &portConfig,
                               cmdContextData);
            numPortsRequested++;
        }
        else
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:RequestNetworkNodePorts - RequestNewInternalCmd Failed"));
            return false;
        }
    }
    return true;
}

bool PVMFStreamingManagerNode::RequestRTSPNodePorts(int32 portTag,
        uint32& numPortsRequested)
{
    numPortsRequested = 0;

    PVMFSMNodeContainer* nodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);

    if (nodeContainer == NULL)
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:RequestNetworkNodePorts - getNodeContainer Failed"));
        return false;
    }

    for (uint32 i = 0; i < iTrackInfoVec.size(); i++)
    {
        PVMFSMTrackInfo trackInfo = iTrackInfoVec[i];

        PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
        if (internalCmd != NULL)
        {
            internalCmd->cmd =
                nodeContainer->commandStartOffset +
                PVMF_STREAMING_MANAGER_NODE_INTERNAL_REQUEST_PORT_OFFSET;
            internalCmd->parentCmd = PVMF_STREAMING_MANAGER_NODE_CONSTRUCT_SESSION;
            internalCmd->portContext.trackID = trackInfo.trackID;
            internalCmd->portContext.portTag = portTag;

            OsclAny *cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

            PVMFNodeInterface* iNode = nodeContainer->iNode;

            char portConfigBuf[64];
            oscl_memset((OsclAny*)portConfigBuf, 0, 64);
            oscl_snprintf(portConfigBuf, 64, "sdpTrackIndex=%d", trackInfo.trackID);
            OSCL_StackString<128> portConfig;
            portConfig += portConfigBuf;

            if (portTag == PVMF_RTSP_NODE_PORT_TYPE_OUTPUT)
            {
                portConfig += _STRLIT_CHAR("/media");
            }
            if (portTag == PVMF_RTSP_NODE_PORT_TYPE_INPUT_OUTPUT)
            {
                portConfig += _STRLIT_CHAR("/feedback");
            }

            iNode->RequestPort(nodeContainer->iSessionId,
                               internalCmd->portContext.portTag,
                               &portConfig,
                               cmdContextData);
            numPortsRequested++;
        }
        else
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:RequestNetworkNodePorts - RequestNewInternalCmd Failed"));
            return false;
        }
    }
    return true;
}

bool
PVMFStreamingManagerNode::RequestJitterBufferPorts(int32 portType,
        uint32 &numPortsRequested)
{
    PVMFSMNodeContainer* nodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);

    if (nodeContainer == NULL)
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:RequestJitterBufferPorts - getNodeContainer Failed"));
        return false;
    }

    numPortsRequested = 0;
    /*
     * Request port - all jitter buffer input ports
     * are even numbered and output and rtcp ports are odd numbered
     */
    int32 portTagStart = portType;

    if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE))
    {
        for (uint32 i = 0; i < iTrackInfoVec.size(); i++)
        {
            PVMFSMTrackInfo trackInfo = iTrackInfoVec[i];

            PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
            if (internalCmd != NULL)
            {
                internalCmd->cmd =
                    nodeContainer->commandStartOffset +
                    PVMF_STREAMING_MANAGER_NODE_INTERNAL_REQUEST_PORT_OFFSET;
                internalCmd->parentCmd = PVMF_STREAMING_MANAGER_NODE_CONSTRUCT_SESSION;
                internalCmd->portContext.trackID = trackInfo.trackID;
                internalCmd->portContext.portTag = portType;

                OsclAny *cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

                PVMFNodeInterface* iNode = nodeContainer->iNode;

                OSCL_StackString<32> portConfig = trackInfo.iTransportType;
                portConfig += _STRLIT_CHAR("/");
                portConfig += trackInfo.iMimeType;
                iNode->RequestPort(nodeContainer->iSessionId,
                                   portTagStart,
                                   &(portConfig),
                                   cmdContextData);
                numPortsRequested++;
            }
            else
            {
                PVMF_SM_LOGERROR((0, "StreamingManagerNode:RequestJitterBufferPorts - RequestNewInternalCmd Failed"));
                return false;
            }
            portTagStart += 3;
        }
        return true;
    }
    // error
    return false;
}

bool
PVMFStreamingManagerNode::RequestMediaLayerPorts(int32 portType,
        uint32& numPortsRequested)
{
    PVMFSMNodeContainer* nodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_MEDIA_LAYER_NODE);

    if (nodeContainer == NULL)
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:RequestMediaLayerPorts - getNodeContainer Failed"));
        return false;
    }

    numPortsRequested = 0;
    /*
     * Request port - all media layer input ports
     * are even numbered and output are odd numbered
     */
    int32 portTagStart = portType;

    if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE))
    {
        for (uint32 i = 0; i < iTrackInfoVec.size(); i++)
        {
            PVMFSMTrackInfo trackInfo = iTrackInfoVec[i];

            PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
            if (internalCmd != NULL)
            {
                internalCmd->cmd =
                    nodeContainer->commandStartOffset +
                    PVMF_STREAMING_MANAGER_NODE_INTERNAL_REQUEST_PORT_OFFSET;
                internalCmd->parentCmd = PVMF_STREAMING_MANAGER_NODE_CONSTRUCT_SESSION;
                internalCmd->portContext.trackID = trackInfo.trackID;
                internalCmd->portContext.portTag = portType;

                OsclAny *cmdContextData =
                    OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

                PVMFNodeInterface* iNode = nodeContainer->iNode;

                iNode->RequestPort(nodeContainer->iSessionId,
                                   portTagStart,
                                   &(trackInfo.iMimeType),
                                   cmdContextData);
                numPortsRequested++;
            }
            else
            {
                PVMF_SM_LOGERROR((0, "StreamingManagerNode:RequestMediaLayerPorts - RequestNewInternalCmd Failed"));
                return false;
            }
            portTagStart += 2;
        }

        return true;
    }
    //error
    return false;
}

bool PVMFStreamingManagerNode::ConstructGraphFor3GPPUDPStreaming()
{
    uint32 numPortsRequested = 0;

    /*
     * Reserve UDP socket pairs
     */
    if (!ReserveSockets())
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:ConstructGraphFor3GPPUDPStreaming - ReserveSockets() Failed"));
        return false;
    }

    /*
     * Request data UDP ports
     */
    if (!RequestNetworkNodePorts(PVMF_SOCKET_NODE_PORT_TYPE_SOURCE,
                                 numPortsRequested))
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:ConstructGraphFor3GPPUDPStreaming - RequestNetworkNodePorts(PVMF_SOCKET_NODE_PORT_TYPE_SOURCE) Failed"));
        return false;
    }
    iNumRequestPortsPending += numPortsRequested;

    /*
     * Request feedback (RTCP) UDP ports
     */
    if (!RequestNetworkNodePorts(PVMF_SOCKET_NODE_PORT_TYPE_SINK,
                                 numPortsRequested))
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:ConstructGraphFor3GPPUDPStreaming - RequestNetworkNodePorts(PVMF_SOCKET_NODE_PORT_TYPE_SINK) Failed"));
        return false;
    }
    iNumRequestPortsPending += numPortsRequested;

    if (!RequestJitterBufferPorts(PVMF_JITTER_BUFFER_PORT_TYPE_INPUT,
                                  numPortsRequested))
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:ConstructGraphFor3GPPUDPStreaming - RequestJitterBufferPorts(PVMF_JITTER_BUFFER_PORT_TYPE_INPUT) Failed"));
        return false;
    }
    iNumRequestPortsPending += numPortsRequested;

    if (!RequestJitterBufferPorts(PVMF_JITTER_BUFFER_PORT_TYPE_OUTPUT,
                                  numPortsRequested))
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:ConstructGraphFor3GPPUDPStreaming - RequestJitterBufferPorts(PVMF_JITTER_BUFFER_PORT_TYPE_OUTPUT) Failed"));
        return false;
    }
    iNumRequestPortsPending += numPortsRequested;

    if (!RequestJitterBufferPorts(PVMF_JITTER_BUFFER_PORT_TYPE_FEEDBACK,
                                  numPortsRequested))
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:ConstructGraphFor3GPPUDPStreaming - RequestJitterBufferPorts(PVMF_JITTER_BUFFER_PORT_TYPE_FEEDBACK) Failed"));
        return false;
    }
    iNumRequestPortsPending += numPortsRequested;

    if (!RequestMediaLayerPorts(PVMF_MEDIALAYER_PORT_TYPE_INPUT,
                                numPortsRequested))
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:ConstructGraphFor3GPPUDPStreaming - RequestMediaLayerPorts(PVMF_MEDIALAYER_PORT_TYPE_INPUT) Failed"));
        return false;
    }
    iNumRequestPortsPending += numPortsRequested;

    if (!RequestMediaLayerPorts(PVMF_MEDIALAYER_PORT_TYPE_OUTPUT,
                                numPortsRequested))
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:ConstructGraphFor3GPPUDPStreaming - RequestMediaLayerPorts(PVMF_MEDIALAYER_PORT_TYPE_OUTPUT) Failed"));
        return false;
    }
    iNumRequestPortsPending += numPortsRequested;

    return true;
}

bool PVMFStreamingManagerNode::ConstructGraphFor3GPPTCPStreaming()
{
    uint32 numPortsRequested = 0;

    /*
     * Request media ports
     */
    if (!RequestRTSPNodePorts(PVMF_RTSP_NODE_PORT_TYPE_OUTPUT,
                              numPortsRequested))
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:ConstructGraphFor3GPPTCPStreaming - RequestRTSPNodePorts(PVMF_RTSP_NODE_PORT_TYPE_OUTPUT) Failed"));
        return false;
    }
    iNumRequestPortsPending += numPortsRequested;

    /*
     * Request feedback (RTCP) ports
     */
    if (!RequestRTSPNodePorts(PVMF_RTSP_NODE_PORT_TYPE_INPUT_OUTPUT,
                              numPortsRequested))
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:ConstructGraphFor3GPPTCPStreaming - RequestRTSPNodePorts(PVMF_RTSP_NODE_PORT_TYPE_INPUT_OUTPUT) Failed"));
        return false;
    }
    iNumRequestPortsPending += numPortsRequested;

    if (!RequestJitterBufferPorts(PVMF_JITTER_BUFFER_PORT_TYPE_INPUT,
                                  numPortsRequested))
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:ConstructGraphFor3GPPTCPStreaming - RequestJitterBufferPorts(PVMF_JITTER_BUFFER_PORT_TYPE_INPUT) Failed"));
        return false;
    }
    iNumRequestPortsPending += numPortsRequested;

    if (!RequestJitterBufferPorts(PVMF_JITTER_BUFFER_PORT_TYPE_OUTPUT,
                                  numPortsRequested))
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:ConstructGraphFor3GPPTCPStreaming - RequestJitterBufferPorts(PVMF_JITTER_BUFFER_PORT_TYPE_OUTPUT) Failed"));
        return false;
    }
    iNumRequestPortsPending += numPortsRequested;

    if (!RequestJitterBufferPorts(PVMF_JITTER_BUFFER_PORT_TYPE_FEEDBACK,
                                  numPortsRequested))
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:ConstructGraphFor3GPPTCPStreaming - RequestJitterBufferPorts(PVMF_JITTER_BUFFER_PORT_TYPE_FEEDBACK) Failed"));
        return false;
    }
    iNumRequestPortsPending += numPortsRequested;

    if (!RequestMediaLayerPorts(PVMF_MEDIALAYER_PORT_TYPE_INPUT,
                                numPortsRequested))
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:ConstructGraphFor3GPPTCPStreaming - RequestMediaLayerPorts(PVMF_MEDIALAYER_PORT_TYPE_INPUT) Failed"));
        return false;
    }
    iNumRequestPortsPending += numPortsRequested;

    if (!RequestMediaLayerPorts(PVMF_MEDIALAYER_PORT_TYPE_OUTPUT,
                                numPortsRequested))
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:ConstructGraphFor3GPPTCPStreaming - RequestMediaLayerPorts(PVMF_MEDIALAYER_PORT_TYPE_OUTPUT) Failed"));
        return false;
    }
    iNumRequestPortsPending += numPortsRequested;

    return true;
}


bool
PVMFStreamingManagerNode::GraphConstruct()
{
    /*
     * Session source info must have been set
     */
    if (iSessionSourceInfo->_sessionType == PVMF_FORMAT_UNKNOWN)
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:GraphConstruct - Invalid Session Type"));
        return false;
    }

    if (!PopulateTrackInfoVec())
    {
        return false;
    }

    if (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE)
    {
    }
    else if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
             (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE))
    {
        if (iSessionSourceInfo->iRTSPTunnelling == true)
        {
            return (ConstructGraphFor3GPPTCPStreaming());
        }
        else
        {
            return (ConstructGraphFor3GPPUDPStreaming());
        }
    }
    //error
    return false;
}

/*
 * Called by the call back routine whenever a "RequestPort" call
 * completes successfully.
 */
void PVMFStreamingManagerNode::CompleteGraphConstruct()
{
    iTotalNumRequestPortsComplete++;
    /*
     * Once all port requests are complete, connect the graph
     */
    if (iTotalNumRequestPortsComplete == iNumRequestPortsPending)
    {
        PVMFStreamingManagerNodeCommand aCmd = iCurrentCommand.front();
        if (!SendSessionSourceInfoToSessionController())
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:CompleteGraphConstruct - SendSessionSourceInfoToSessionController Failed"));
            InternalCommandComplete(aCmd, PVMFFailure);
            iCurrentCommand.Erase(&iCurrentCommand.front());
        }
        else
        {
            oGraphConstructComplete = true;
            InternalCommandComplete(aCmd, PVMFSuccess);
            /* Erase the command from the current queue */
            iCurrentCommand.Erase(&iCurrentCommand.front());
        }
    }
}

PVMFStatus
PVMFStreamingManagerNode::ConnectPortPairs(PVMFPortInterface* aPort1,
        PVMFPortInterface* aPort2)
{
    PVMFStatus status;

    status = aPort1->Connect(aPort2);

    if (status != PVMFSuccess)
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:ConnectPortPairs - Connect Failed"));
        return status;
    }

    return status;
}

bool PVMFStreamingManagerNode::GraphConnectFor3GPPUDPStreaming()
{
    if (oGraphConnectComplete == false)
    {
        /*
         * Go over the track list and connect:
         * network_node_port -> jitter_buffer_node_input_port;
         * jitter_buffer_node_output_port -> media_layer_input_port
         */
        PVMFStatus status;
        for (uint32 i = 0; i < iTrackInfoVec.size(); i++)
        {
            PVMFSMTrackInfo trackInfo = iTrackInfoVec[i];

            if ((trackInfo.iNetworkNodePort == NULL) ||
                    (trackInfo.iNetworkNodeRTCPPort == NULL) ||
                    (trackInfo.iJitterBufferInputPort == NULL) ||
                    (trackInfo.iJitterBufferOutputPort == NULL) ||
                    (trackInfo.iJitterBufferRTCPPort == NULL) ||
                    (trackInfo.iMediaLayerInputPort == NULL) ||
                    (trackInfo.iMediaLayerOutputPort == NULL))
            {
                PVMF_SM_LOGERROR((0, "StreamingManagerNode:GraphConnectFor3GPPUDPStreaming - Invalid Ports"));
                return false;
            }

            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnect - Track MimeType %s", trackInfo.iMimeType.get_cstr()));

            /* connect network_node_port <-> jitter_buffer_node_input_port */
            status = ConnectPortPairs(trackInfo.iJitterBufferInputPort,
                                      trackInfo.iNetworkNodePort);

            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectFor3GPPUDPStreaming - Connected Network - JB Input"));
            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectFor3GPPUDPStreaming - NetworkPort=0x%x - JBInputPort=0x%x", trackInfo.iNetworkNodePort, trackInfo.iJitterBufferInputPort));

            if (status != PVMFSuccess)
            {
                return false;
            }

            /*
             * connect jitter_buffer_node_output_port <->
             * media_layer_input_port
             */
            status = ConnectPortPairs(trackInfo.iJitterBufferOutputPort,
                                      trackInfo.iMediaLayerInputPort);

            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectFor3GPPUDPStreaming - JB Output - ML Input"));
            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectFor3GPPUDPStreaming - JB Output=0x%x - ML Input=0x%x", trackInfo.iJitterBufferOutputPort, trackInfo.iMediaLayerInputPort));

            if (status != PVMFSuccess)
            {
                return false;
            }

            /*
             * connect network_rtcp_port <-> jitter_buffer_rtcp_port
             */
            status = ConnectPortPairs(trackInfo.iJitterBufferRTCPPort,
                                      trackInfo.iNetworkNodeRTCPPort);

            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectFor3GPPUDPStreaming - NetworkRTCPPort - JBRTCPPort"));
            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectFor3GPPUDPStreaming - NetworkRTCPPort=0x%x - JBRTCPPort=0x%x", trackInfo.iNetworkNodeRTCPPort, trackInfo.iJitterBufferRTCPPort));

            if (status != PVMFSuccess)
            {
                return false;
            }
        }
        oGraphConnectComplete = true;
    }
    return true;
}

bool PVMFStreamingManagerNode::GraphConnectForRTPPacketSource()
{
    if (oGraphConnectComplete == false)
    {
        /*
         * Go over the track list and connect:
         * network_node_port -> jitter_buffer_node_input_port;
         * jitter_buffer_node_output_port -> media_layer_input_port
         */
        PVMFStatus status;
        for (uint32 i = 0; i < iTrackInfoVec.size(); i++)
        {
            PVMFSMTrackInfo trackInfo = iTrackInfoVec[i];

            if ((trackInfo.iNetworkNodePort == NULL) ||
                    (trackInfo.iJitterBufferInputPort == NULL) ||
                    (trackInfo.iJitterBufferOutputPort == NULL) ||
                    (trackInfo.iMediaLayerInputPort == NULL) ||
                    (trackInfo.iMediaLayerOutputPort == NULL))
            {
                PVMF_SM_LOGERROR((0, "StreamingManagerNode:GraphConnectForRTPPacketSource - Invalid Ports"));
                return false;
            }

            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnect - Track MimeType %s", trackInfo.iMimeType.get_cstr()));

            /* connect network_node_port <-> jitter_buffer_node_input_port */
            status = ConnectPortPairs(trackInfo.iJitterBufferInputPort,
                                      trackInfo.iNetworkNodePort);

            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectForRTPPacketSource - Connected Network - JB Input"));
            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectForRTPPacketSource - NetworkPort=0x%x - JBInputPort=0x%x", trackInfo.iNetworkNodePort, trackInfo.iJitterBufferInputPort));

            if (status != PVMFSuccess)
            {
                return false;
            }

            /*
             * connect jitter_buffer_node_output_port <->
             * media_layer_input_port
             */
            status = ConnectPortPairs(trackInfo.iJitterBufferOutputPort,
                                      trackInfo.iMediaLayerInputPort);

            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectForRTPPacketSource - JB Output - ML Input"));
            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectForRTPPacketSource - JB Output=0x%x - ML Input=0x%x", trackInfo.iJitterBufferOutputPort, trackInfo.iMediaLayerInputPort));

            if (status != PVMFSuccess)
            {
                return false;
            }

            /*
             * connect network_rtcp_port <-> jitter_buffer_rtcp_port
             */
            status = ConnectPortPairs(trackInfo.iJitterBufferRTCPPort,
                                      trackInfo.iNetworkNodeRTCPPort);

            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectFor3GPPUDPStreaming - NetworkRTCPPort - JBRTCPPort"));
            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectFor3GPPUDPStreaming - NetworkRTCPPort=0x%x - JBRTCPPort=0x%x", trackInfo.iNetworkNodeRTCPPort, trackInfo.iJitterBufferRTCPPort));

            if (status != PVMFSuccess)
            {
                return false;
            }

        }
        oGraphConnectComplete = true;
    }
    return true;
}


bool PVMFStreamingManagerNode::GraphConnectFor3GPPTCPStreaming()
{
    if (oGraphConnectComplete == false)
    {
        /*
         * Go over the track list and connect:
         * network_node_port -> jitter_buffer_node_input_port;
         * jitter_buffer_node_output_port -> media_layer_input_port
         */
        PVMFStatus status;
        for (uint32 i = 0; i < iTrackInfoVec.size(); i++)
        {
            PVMFSMTrackInfo trackInfo = iTrackInfoVec[i];

            if ((trackInfo.iSessionControllerOutputPort == NULL) ||
                    (trackInfo.iSessionControllerFeedbackPort == NULL) ||
                    (trackInfo.iJitterBufferInputPort == NULL) ||
                    (trackInfo.iJitterBufferOutputPort == NULL) ||
                    (trackInfo.iJitterBufferRTCPPort == NULL) ||
                    (trackInfo.iMediaLayerInputPort == NULL) ||
                    (trackInfo.iMediaLayerOutputPort == NULL))
            {
                PVMF_SM_LOGERROR((0, "StreamingManagerNode:GraphConnectFor3GPPTCPStreaming - Invalid Ports"));
                return false;
            }

            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectFor3GPPTCPStreaming - Track MimeType %s", trackInfo.iMimeType.get_cstr()));

            /* connect sessioncontroller_node_output_port <-> jitter_buffer_node_input_port */
            status = ConnectPortPairs(trackInfo.iJitterBufferInputPort,
                                      trackInfo.iSessionControllerOutputPort);

            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectFor3GPPTCPStreaming - Connected SessionController Output - JB Input"));
            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectFor3GPPTCPStreaming - SessionControllerPort=0x%x - JBInputPort=0x%x", trackInfo.iSessionControllerOutputPort, trackInfo.iJitterBufferInputPort));

            if (status != PVMFSuccess)
            {
                return false;
            }

            /*
             * connect jitter_buffer_node_output_port <->
             * media_layer_input_port
             */
            status = ConnectPortPairs(trackInfo.iJitterBufferOutputPort,
                                      trackInfo.iMediaLayerInputPort);

            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectFor3GPPTCPStreaming - JB Output - ML Input"));
            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectFor3GPPTCPStreaming - JB Output=0x%x - ML Input=0x%x", trackInfo.iJitterBufferOutputPort, trackInfo.iMediaLayerInputPort));

            if (status != PVMFSuccess)
            {
                return false;
            }

            /*
             * connect sessioncontroller_node_feedback_port <-> jitter_buffer_rtcp_port
             */
            status = ConnectPortPairs(trackInfo.iJitterBufferRTCPPort,
                                      trackInfo.iSessionControllerFeedbackPort);

            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectFor3GPPTCPStreaming - SessionControllerFeedbackPort - JBRTCPPort"));
            PVMF_SM_LOGINFO((0, "PVMFSM:GraphConnectFor3GPPTCPStreaming - SessionControllerFeedbackPort=0x%x - JBRTCPPort=0x%x", trackInfo.iSessionControllerFeedbackPort, trackInfo.iJitterBufferRTCPPort));

            if (status != PVMFSuccess)
            {
                return false;
            }
        }
        oGraphConnectComplete = true;
    }
    return true;
}


/*
 * Called by command handler AO once all request ports are complete
 */
bool PVMFStreamingManagerNode::GraphConnect()
{
    if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE))
    {
        if (iSessionSourceInfo->iRTSPTunnelling == true)
        {
            return (GraphConnectFor3GPPTCPStreaming());
        }
        else
        {
            return (GraphConnectFor3GPPUDPStreaming());
        }
    }
    else if (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE)
    {
        return (GraphConnectForRTPPacketSource());
    }

    //error
    return false;
}


/*
 * Called when all port requests are complete, in order to send the
 * UDP port information to RTSP
 */
bool
PVMFStreamingManagerNode::SendSessionSourceInfoToSessionController()
{
    if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE))
    {
        PVMFSMNodeContainer* iSocketNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_SOCKET_NODE);
        if (iSocketNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);

        PVMFSocketNode* socketNode =
            (PVMFSocketNode*)(iSocketNodeContainer->iNode);

        PVMFSMNodeContainer* iSessionControllerNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);

        if (iSessionControllerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);

        PVRTSPEngineNodeExtensionInterface* rtspExtIntf =
            (PVRTSPEngineNodeExtensionInterface*)
            (iSessionControllerNodeContainer->iExtensions[0]);

        Oscl_Vector<StreamInfo, OsclMemAllocator> aSelectedStream;

        for (uint32 i = 0; i < iTrackInfoVec.size(); i++)
        {
            PVMFSMTrackInfo trackInfo = iTrackInfoVec[i];

            OsclNetworkAddress localAdd;
            OsclNetworkAddress remoteAdd;
            StreamInfo sInfo;

            sInfo.iSDPStreamId = trackInfo.trackID;

            if (iSessionSourceInfo->iRTSPTunnelling == false)
            {
                if (trackInfo.iNetworkNodePort == NULL)
                {
                    PVMF_SM_LOGERROR((0, "StreamingManagerNode:SendSessionSourceInfoToSessionController - Invalid Port"));
                    return false;
                }

                socketNode->GetPortConfig(*trackInfo.iNetworkNodePort,
                                          localAdd,
                                          remoteAdd);

                sInfo.iCliRTPPort = localAdd.port;

                socketNode->GetPortConfig(*trackInfo.iNetworkNodeRTCPPort,
                                          localAdd,
                                          remoteAdd);

                sInfo.iCliRTCPPort = localAdd.port;
            }

            /* Set Rate Adaptation parameters */
            sInfo.b3gppAdaptationIsSet = false;
            if (trackInfo.iRateAdaptation)
            {
                sInfo.b3gppAdaptationIsSet = true;
                /* Compute buffer size based on bitrate and jitter duration*/
                uint32 sizeInBytes = MIN_RTP_SOCKET_MEM_POOL_SIZE_IN_BYTES;
                if (((int32)iJitterBufferDurationInMilliSeconds > 0) &&
                        ((int32)trackInfo.bitRate > 0))
                {
                    uint32 byteRate = trackInfo.bitRate / 8;
                    uint32 overhead = (byteRate * PVMF_JITTER_BUFFER_NODE_MEM_POOL_OVERHEAD) / 100;
                    uint32 durationInSec = iJitterBufferDurationInMilliSeconds / 1000;
                    sizeInBytes = ((byteRate + overhead) * durationInSec);
                    if (sizeInBytes < MIN_RTP_SOCKET_MEM_POOL_SIZE_IN_BYTES)
                    {
                        sizeInBytes = MIN_RTP_SOCKET_MEM_POOL_SIZE_IN_BYTES;
                    }
                    sizeInBytes += 2 * MAX_SOCKET_BUFFER_SIZE;
                }
                sInfo.iBufSize = sizeInBytes;
                sInfo.iTargetTime = iJitterBufferDurationInMilliSeconds;
            }
            aSelectedStream.push_back(sInfo);
        }

        if (rtspExtIntf->SetSDPInfo(iSessionSourceInfo->_sdpInfo,
                                    aSelectedStream) != PVMFSuccess)
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:SendSessionSourceInfoToSessionController - SetSDPInfo Failed"));
            return false;
        }

        /* Set play range from SDP */
        sessionDescription* sessionInfo = iSessionSourceInfo->_sdpInfo->getSessionInfo();
        RtspRangeType *rtspRange = OSCL_CONST_CAST(RtspRangeType*, (sessionInfo->getRange()));
        rtspRange->convertToMilliSec((int32&)iSessionStartTime, (int32&)iSessionStopTime);

        if (rtspRange->end_is_set == false)
        {
            iSessionStopTime = -1;
            iSessionStopTimeAvailable = false;
        }

        if ((rtspRange->format != RtspRangeType::INVALID_RANGE) &&
                (rtspRange->start_is_set != false))
        {
            if (rtspExtIntf->SetRequestPlayRange(*rtspRange) != PVMFSuccess)
            {
                PVMF_SM_LOGERROR((0, "StreamingManagerNode:SendRequestPlayRangeToSessionController - SetRequestPlayRange Failed"));
                return false;
            }
        }
    }
    return true;
}

bool
PVMFStreamingManagerNode::SendSessionControlPrepareCompleteParams()
{
    if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE))
    {
        PVMFSMNodeContainer* iSessionControllerNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);
        if (iSessionControllerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
        PVRTSPEngineNodeExtensionInterface* rtspExtIntf =
            (PVRTSPEngineNodeExtensionInterface*)
            (iSessionControllerNodeContainer->iExtensions[0]);

        PVMFSMNodeContainer* iJitterBufferNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
        if (iJitterBufferNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
        PVMFJitterBufferExtensionInterface* jbExtIntf =
            (PVMFJitterBufferExtensionInterface*)
            (iJitterBufferNodeContainer->iExtensions[0]);

        Oscl_Vector<StreamInfo, OsclMemAllocator> aSelectedStream;

        if (rtspExtIntf->GetStreamInfo(aSelectedStream) != PVMFSuccess)
        {
            OSCL_LEAVE(OsclErrGeneral);
        }

        for (uint32 i = 0; i < aSelectedStream.size(); i++)
        {
            StreamInfo streamInfo = aSelectedStream[i];

            PVMFSMTrackInfo* trackInfo = FindTrackInfo(streamInfo.iSDPStreamId);

            if (trackInfo == NULL)
            {
                PVMF_SM_LOGERROR((0, "StreamingManagerNode:SendSessionControlPrepareCompleteParams - FindTrackInfo Failed"));
                return false;
            }

            if (trackInfo->iJitterBufferInputPort == NULL)
            {
                PVMF_SM_LOGERROR((0, "StreamingManagerNode:SendSessionControlPrepareCompleteParams - Invalid Port"));
                return false;
            }

            if (streamInfo.ssrcIsSet)
            {
                jbExtIntf->setPortSSRC(trackInfo->iJitterBufferInputPort,
                                       streamInfo.iSSRC);
            }
        }

        /* Set server info */
        PVRTSPEngineNodeServerInfo rtspServerInfo;
        PVMFJitterBufferFireWallPacketInfo fireWallPktInfo;

        rtspExtIntf->GetServerInfo(rtspServerInfo);

        if (rtspServerInfo.iIsPVServer)
        {
            fireWallPktInfo.iFormat = PVMF_JB_FW_PKT_FORMAT_PV;
        }
        fireWallPktInfo.iServerRoundTripDelayInMS = rtspServerInfo.iRoundTripDelayInMS;
        fireWallPktInfo.iNumAttempts = PVMF_JITTER_BUFFER_NODE_DEFAULT_FIREWALL_PKT_ATTEMPTS;

        jbExtIntf->setServerInfo(fireWallPktInfo);
    }
    if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_REAL_HTTP_CLOAKING_URL))
    {
        PVMFSMNodeContainer* iSessionControllerNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);
        if (iSessionControllerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
        PVRTSPEngineNodeExtensionInterface* rtspExtIntf =
            (PVRTSPEngineNodeExtensionInterface*)
            (iSessionControllerNodeContainer->iExtensions[0]);

        PVMFSMNodeContainer* iJitterBufferNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
        if (iJitterBufferNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
        PVMFJitterBufferExtensionInterface* jbExtIntf =
            (PVMFJitterBufferExtensionInterface*)
            (iJitterBufferNodeContainer->iExtensions[0]);

    }
    return true;
}

bool
PVMFStreamingManagerNode::SendSessionControlStartCompleteParams()
{
    PVMFSMNodeContainer* iJitterBufferNodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
    if (iJitterBufferNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
    PVMFJitterBufferExtensionInterface* jbExtIntf =
        (PVMFJitterBufferExtensionInterface*)
        (iJitterBufferNodeContainer->iExtensions[0]);

    PVMFSMNodeContainer* iMediaLayerNodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_MEDIA_LAYER_NODE);
    if (iMediaLayerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
    PVMFMediaLayerNodeExtensionInterface* mlExtIntf =
        (PVMFMediaLayerNodeExtensionInterface*)
        (iMediaLayerNodeContainer->iExtensions[0]);

    bool end_is_set = true;
    int32 startTime = 0;
    int32 stopTime  = 0;

    if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE))
    {
        PVMFSMNodeContainer* iSessionControllerNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);
        if (iSessionControllerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
        PVRTSPEngineNodeExtensionInterface* rtspExtIntf =
            (PVRTSPEngineNodeExtensionInterface*)
            (iSessionControllerNodeContainer->iExtensions[0]);

        /* Get Actual Play Range */
        RtspRangeType rangeType;
        if (rtspExtIntf->GetActualPlayRange(rangeType) != PVMFSuccess)
        {
            return false;
        }

        rangeType.convertToMilliSec(startTime, stopTime);

        /* Use from SDP if not set */
        end_is_set = rangeType.end_is_set;
        if (end_is_set == false)
        {
            stopTime = iSessionStopTime;
        }

        if (oRepositioning)
        {
            iActualRepositionStartNPTInMS = startTime;
            if (iActualRepositionStartNPTInMSPtr != NULL)
            {
                *iActualRepositionStartNPTInMSPtr = startTime;
            }
            if (iPVMFDataSourcePositionParamsPtr != NULL)
            {
                iPVMFDataSourcePositionParamsPtr->iActualNPT = startTime;
            }
        }

        Oscl_Vector<StreamInfo, OsclMemAllocator> aSelectedStream;

        if (rtspExtIntf->GetStreamInfo(aSelectedStream) != PVMFSuccess)
        {
            OSCL_LEAVE(OsclErrGeneral);
        }

        for (uint32 i = 0; i < aSelectedStream.size(); i++)
        {
            StreamInfo streamInfo = aSelectedStream[i];

            PVMFSMTrackInfo* trackInfo = FindTrackInfo(streamInfo.iSDPStreamId);

            if (trackInfo == NULL)
            {
                PVMF_SM_LOGERROR((0, "StreamingManagerNode:SendStartCompleteSessionControlParams - FindTrackInfo Failed"));
                return false;
            }

            if (trackInfo->iJitterBufferInputPort == NULL)
            {
                PVMF_SM_LOGERROR((0, "StreamingManagerNode:SendStartCompleteSessionControlParams - Invalid Port"));
                return false;
            }

            if (streamInfo.seqIsSet != true)
            {
                streamInfo.seqIsSet = false;
                streamInfo.seq = 0;
            }
            if (streamInfo.rtptimeIsSet != true)
            {
                streamInfo.rtptimeIsSet = false;
                streamInfo.rtptime = 0;
            }
            jbExtIntf->setPortRTPParams(trackInfo->iJitterBufferInputPort,
                                        streamInfo.seqIsSet,
                                        streamInfo.seq,
                                        streamInfo.rtptimeIsSet,
                                        streamInfo.rtptime,
                                        startTime,
                                        oRepositioning);

        }
    }
    /* Send actual stop time to Jitter Buffer */
    if (jbExtIntf->setPlayRange(startTime,
                                stopTime,
                                oRepositioning,
                                end_is_set) != true)
    {
        return false;
    }

    if (mlExtIntf->setPlayRange(startTime, stopTime) != true)
    {
        return false;
    }
    return true;
}

bool
PVMFStreamingManagerNode::SendPacketSourceStartCompleteParams()
{
    PVMFSMNodeContainer* iJitterBufferNodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
    if (iJitterBufferNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
    PVMFJitterBufferExtensionInterface* jbExtIntf =
        (PVMFJitterBufferExtensionInterface*)
        (iJitterBufferNodeContainer->iExtensions[0]);

    PVMFSMNodeContainer* iMediaLayerNodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_MEDIA_LAYER_NODE);
    if (iMediaLayerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
    PVMFMediaLayerNodeExtensionInterface* mlExtIntf =
        (PVMFMediaLayerNodeExtensionInterface*)
        (iMediaLayerNodeContainer->iExtensions[0]);

    bool end_is_set = true;
    int32 startTime = 0;
    int32 stopTime  = 0;

    /* Get Actual Play Range */
    RtspRangeType rangeType;
    rangeType.convertToMilliSec(startTime, stopTime);

    /* Use from SDP if not set */
    end_is_set = false;
    stopTime = -1;

    PVMFSMTrackInfoVector::iterator it;

    for (it = iTrackInfoVec.begin();
            it != iTrackInfoVec.end();
            it++)
    {
        StreamInfo streamInfo;

        streamInfo.seqIsSet = false;
        streamInfo.seq = 0;

        streamInfo.rtptimeIsSet = false;
        streamInfo.rtptime = 0;
        jbExtIntf->setPortRTPParams(it->iJitterBufferInputPort,
                                    streamInfo.seqIsSet,
                                    streamInfo.seq,
                                    streamInfo.rtptimeIsSet,
                                    streamInfo.rtptime,
                                    startTime,
                                    oRepositioning);

    }

    /* Send actual stop time to Jitter Buffer */
    if (jbExtIntf->setPlayRange(startTime, stopTime, false, end_is_set) != true)
    {
        return false;
    }

    if (mlExtIntf->setPlayRange(startTime, stopTime) != true)
    {
        return false;
    }
    return true;
}


bool
PVMFStreamingManagerNode::CompleteFeedBackPortsSetup()
{
    PVMFSMNodeContainer* iSocketNodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_SOCKET_NODE);
    if (iSocketNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);

    PVMFSocketNode* socketNode =
        (PVMFSocketNode*)(iSocketNodeContainer->iNode);

    PVMFSMNodeContainer* iSessionControllerNodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);

    if (iSessionControllerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);

    PVRTSPEngineNodeExtensionInterface* rtspExtIntf =
        (PVRTSPEngineNodeExtensionInterface*)
        (iSessionControllerNodeContainer->iExtensions[0]);

    Oscl_Vector<StreamInfo, OsclMemAllocator> aSelectedStream;

    if (rtspExtIntf->GetStreamInfo(aSelectedStream) != PVMFSuccess)
    {
        OSCL_LEAVE(OsclErrGeneral);
    }

    for (uint32 i = 0; i < aSelectedStream.size(); i++)
    {
        StreamInfo streamInfo = aSelectedStream[i];

        PVMFSMTrackInfo* trackInfo = FindTrackInfo(streamInfo.iSDPStreamId);

        if (trackInfo == NULL)
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:CompleteFeedBackPortsSetup - FindTrackInfo Failed"));
            return false;
        }

        if (trackInfo->iNetworkNodeRTCPPort == NULL)
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:CompleteFeedBackPortsSetup - Invalid RTCP Port"));
            return false;
        }

        OsclNetworkAddress localAddRTCP;
        OsclNetworkAddress remoteAddRTCP;

        localAddRTCP.port = streamInfo.iCliRTCPPort;
        remoteAddRTCP.port = streamInfo.iSerRTCPPort;
        remoteAddRTCP.ipAddr = streamInfo.iSerIpAddr;

        socketNode->SetPortConfig(*(trackInfo->iNetworkNodeRTCPPort),
                                  localAddRTCP,
                                  remoteAddRTCP);

        if (trackInfo->iNetworkNodePort == NULL)
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:CompleteFeedBackPortsSetup - Invalid RTP Port"));
            return false;
        }

        OsclNetworkAddress localAddRTP;
        OsclNetworkAddress remoteAddRTP;

        localAddRTP.port = streamInfo.iCliRTPPort;
        remoteAddRTP.port = streamInfo.iSerRTPPort;
        remoteAddRTP.ipAddr = streamInfo.iSerIpAddr;

        socketNode->SetPortConfig(*(trackInfo->iNetworkNodePort),
                                  localAddRTP,
                                  remoteAddRTP);

    }

    return true;
}

PVMFStatus
PVMFStreamingManagerNode::DeleteUnusedSessionControllerNode()
{
    if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE))
    {
        /* Delete HTTP PE Node */
        PVMFSMNodeContainerVector::iterator it;
        for (it = iNodeContainerVec.begin(); it != iNodeContainerVec.end(); it++)
        {
            if (it->iNodeTag == PVMF_STREAMING_MANAGER_HTTP_SESSION_CONTROLLER_NODE)
            {
                for (uint32 j = 0; j < it->iExtensions.size(); j++)
                {
                    PVInterface* extIntf = it->iExtensions[j];
                    extIntf->removeRef();
                }
                PVMFProtocolEngineNodeFactory::DeletePVMFProtocolEngineNode(it->iNode);
                it->iNode = NULL;
                iNodeContainerVec.erase(it);
                break;
            }
        }
    }
    DeleteUnusedNodes();

    return PVMFSuccess;
}

PVMFStatus
PVMFStreamingManagerNode::DeleteUnusedNodes()
{
    if (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE)
    {
        PVMFSMNodeContainerVector::iterator it;
        for (it = iNodeContainerVec.begin(); it != iNodeContainerVec.end(); it++)
        {
            /* Delete Unused Socket Node */
            if (it->iNodeTag == PVMF_STREAMING_MANAGER_SOCKET_NODE)
            {
                for (uint32 j = 0; j < it->iExtensions.size(); j++)
                {
                    PVInterface* extIntf = it->iExtensions[j];
                    extIntf->removeRef();
                }
                PVMF_STREAMING_MANAGER_DELETE(NULL,
                                              PVMFSocketNode,
                                              ((PVMFSocketNode*)(it->iNode)));
                it->iNode = NULL;
                iNodeContainerVec.erase(it);
                break;
            }
        }
        for (it = iNodeContainerVec.begin(); it != iNodeContainerVec.end(); it++)
        {
            /* Delete Unused RTSP Session Controller Node */
            if (it->iNodeTag == PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE)
            {
                for (uint32 j = 0; j < it->iExtensions.size(); j++)
                {
                    PVInterface* extIntf = it->iExtensions[j];
                    extIntf->removeRef();
                }
                PVMFRrtspEngineNodeFactory::DeletePVMFRtspEngineNode(it->iNode);
                it->iNode = NULL;
                iNodeContainerVec.erase(it);
                break;
            }
        }
        for (it = iNodeContainerVec.begin(); it != iNodeContainerVec.end(); it++)
        {
            /* Delete Unused HTTP Session Controller Node */
            if (it->iNodeTag == PVMF_STREAMING_MANAGER_HTTP_SESSION_CONTROLLER_NODE)
            {
                for (uint32 j = 0; j < it->iExtensions.size(); j++)
                {
                    PVInterface* extIntf = it->iExtensions[j];
                    extIntf->removeRef();
                }
                PVMFProtocolEngineNodeFactory::DeletePVMFProtocolEngineNode(it->iNode);
                it->iNode = NULL;
                iNodeContainerVec.erase(it);
                break;
            }
        }
    }
    else
    {
    }
    return PVMFSuccess;
}

PVMFStatus
PVMFStreamingManagerNode::setSessionSourceInfo(OSCL_wString& aSourceURL,
        PVMFFormatType aSourceFormatType,
        OsclAny* aSourceData)
{

    if (((aSourceFormatType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (aSourceFormatType == PVMF_DATA_SOURCE_SDP_FILE)) && (aSourceData != NULL))
    {
        PVInterface* pvInterface = OSCL_STATIC_CAST(PVInterface*, aSourceData);

        PVInterface* sourceDataContext = NULL;
        PVUuid sourceContextUuid(PVMF_SOURCE_CONTEXT_DATA_UUID);
        if (pvInterface->queryInterface(sourceContextUuid, sourceDataContext))
        {
            if (sourceDataContext)
            {
                PVInterface* streamingDataContext = NULL;
                PVUuid streamingContextUuid(PVMF_SOURCE_CONTEXT_DATA_STREAMING_UUID);

                if (sourceDataContext->queryInterface(streamingContextUuid, streamingDataContext))
                {
                    if (streamingDataContext)
                    {
                        PVMFSourceContextDataStreaming* sContext =
                            OSCL_STATIC_CAST(PVMFSourceContextDataStreaming*, streamingDataContext);
                        if (sContext->iProxyName.get_size() > 0)
                        {
                            PVMFSMNodeContainer* iSessionControllerNodeContainer = NULL;
                            iSessionControllerNodeContainer = getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);
                            if (iSessionControllerNodeContainer)
                            {
                                PVRTSPEngineNodeExtensionInterface* rtspExtIntf =
                                    (PVRTSPEngineNodeExtensionInterface*)(iSessionControllerNodeContainer->iExtensions[0]);
                                if (rtspExtIntf)
                                {//the proxyname doesn't need to be unicode
                                    OsclMemAllocator alloc;
                                    char *buf = (char*)alloc.allocate(sContext->iProxyName.get_size() + 1);
                                    if (!buf)
                                        return PVMFErrNoMemory;
                                    uint32 size = oscl_UnicodeToUTF8(sContext->iProxyName.get_cstr(), sContext->iProxyName.get_size(), buf, sContext->iProxyName.get_size() + 1);
                                    if (size == 0)
                                    {
                                        alloc.deallocate(buf);
                                        return PVMFErrNoMemory;
                                    }

                                    OSCL_FastString myProxyName(buf, size);

                                    rtspExtIntf->SetRtspProxy(myProxyName, sContext->iProxyPort);
                                    alloc.deallocate(buf);
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    if ((aSourceFormatType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (aSourceFormatType == PVMF_DATA_SOURCE_REAL_HTTP_CLOAKING_URL))
    {
        PVMFSMNodeContainer* iSessionControllerNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);
        if (iSessionControllerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
        PVRTSPEngineNodeExtensionInterface* rtspExtIntf =
            (PVRTSPEngineNodeExtensionInterface*)
            (iSessionControllerNodeContainer->iExtensions[0]);

        OSCL_wStackString<8> rtspScheme(_STRLIT_WCHAR("rtsp"));
        OSCL_wStackString<8> rtsptScheme(_STRLIT_WCHAR("rtspt"));
        OSCL_wStackString<8> schemeDelimiter(_STRLIT_WCHAR("://"));
        oscl_wchar* actualURL = NULL;
        if (oscl_strncmp(rtsptScheme.get_cstr(), aSourceURL.get_cstr(), 5) == 0)
        {
            iSessionSourceInfo->iRTSPTunnelling = true;
            actualURL = oscl_strstr(aSourceURL.get_cstr(), schemeDelimiter.get_cstr());
            if (actualURL == NULL)
            {
                return PVMFErrArgument;
            }
            //skip over ://
            actualURL += schemeDelimiter.get_size();
            iSessionSourceInfo->_sessionType = aSourceFormatType;
            iSessionSourceInfo->_sessionURL  += rtspScheme.get_str();
            iSessionSourceInfo->_sessionURL  += schemeDelimiter.get_str();
            iSessionSourceInfo->_sessionURL  += actualURL;
        }
        else
        {
            iSessionSourceInfo->_sessionType = aSourceFormatType;
            iSessionSourceInfo->_sessionURL  = aSourceURL;
        }

        if (iSessionSourceInfo->iRTSPTunnelling == true)
        {
            rtspExtIntf->SetStreamingType(PVRTSP_3GPP_TCP);
        }
        else
        {
            /* default to UDP */
            rtspExtIntf->SetStreamingType(PVRTSP_3GPP_UDP);
        }

        return (rtspExtIntf->SetSessionURL(iSessionSourceInfo->_sessionURL));
    }
    else if (aSourceFormatType == PVMF_DATA_SOURCE_SDP_FILE)
    {
        PVMFSMNodeContainer* iSessionControllerNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);
        if (iSessionControllerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
        PVRTSPEngineNodeExtensionInterface* rtspExtIntf =
            (PVRTSPEngineNodeExtensionInterface*)
            (iSessionControllerNodeContainer->iExtensions[0]);

        iSessionSourceInfo->_sessionType = aSourceFormatType;
        iSessionSourceInfo->_sessionURL  = aSourceURL;

        rtspExtIntf->SetStreamingType(PVRTSP_3GPP_UDP);

        return PVMFSuccess;
    }
    else if (aSourceFormatType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE)
    {
        iSessionSourceInfo->_sessionType = aSourceFormatType;
        iSessionSourceInfo->_sessionURL  = aSourceURL;
        return PVMFSuccess;
    }
    return PVMFErrNotSupported;
}

PVMFStatus PVMFStreamingManagerNode::ProcessSDP()
{
    PVMFStatus status;
    OsclRefCounterMemFrag iSDPText;

    if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_REAL_HTTP_CLOAKING_URL))
    {
        PVMFSMNodeContainer* iSessionControllerNodeContainer =
            getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);

        if (iSessionControllerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);

        PVRTSPEngineNodeExtensionInterface* rtspExtIntf =
            (PVRTSPEngineNodeExtensionInterface*)
            (iSessionControllerNodeContainer->iExtensions[0]);

        status = rtspExtIntf->GetSDP(iSDPText);

        if (status != PVMFSuccess)
        {
            return status;
        }
    }
    else if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE) ||
             (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE))
    {
        /* Parse SDP file contents into a buffer */
        Oscl_FileServer fileServ;
        Oscl_File osclFile;
        fileServ.Connect();

        if (osclFile.Open(iSessionSourceInfo->_sessionURL.get_cstr(),
                          Oscl_File::MODE_READ,
                          fileServ) != 0)
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:ProcessSDP - Unable to open SDP file"));
            return PVMFFailure;
        }

        /* Get File Size */
        osclFile.Seek(0, Oscl_File::SEEKEND);
        int32 fileSize = osclFile.Tell();
        osclFile.Seek(0, Oscl_File::SEEKSET);

        if (fileSize <= 0)
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:ProcessSDP - Corrupt SDP file"));
            return PVMFFailure;
        }

        OsclMemAllocDestructDealloc<uint8> my_alloc;
        OsclRefCounter* my_refcnt;
        uint aligned_refcnt_size =
            oscl_mem_aligned_size(sizeof(OsclRefCounterSA< OsclMemAllocDestructDealloc<uint8> >));
        uint8* my_ptr = NULL;
        int32 errcode = 0;
        /*
         * To acct for null char, as SDP buffer is treated akin to a string by the
         * SDP parser lib.
         */
        uint allocsize = oscl_mem_aligned_size(aligned_refcnt_size + fileSize + 2);
        OSCL_TRY(errcode, my_ptr = (uint8*) my_alloc.ALLOCATE(allocsize));

        if (errcode != OsclErrNone)
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:ProcessSDP - Unable to process SDP file"));
            return PVMFFailure;
        }

        my_refcnt = OSCL_PLACEMENT_NEW(my_ptr, OsclRefCounterSA< OsclMemAllocDestructDealloc<uint8> >(my_ptr));
        my_ptr += aligned_refcnt_size;

        OsclMemoryFragment memfrag;
        memfrag.len = fileSize;
        memfrag.ptr = my_ptr;

        OsclRefCounterMemFrag tmpRefcntMemFrag(memfrag, my_refcnt, memfrag.len);
        iSDPText = tmpRefcntMemFrag;

        osclFile.Read(memfrag.ptr, 1, fileSize);

        osclFile.Close();
        fileServ.Close();

    }

    PVMFSMSharedPtrAlloc<SDPInfo> sdpAlloc;
    SDPInfo* sdpInfo = sdpAlloc.allocate();

    SDP_Parser *sdpParser;

    PVMF_STREAMING_MANAGER_NEW(NULL, SDP_Parser, (), sdpParser);

    int32 sdpRetVal =
        sdpParser->parseSDP((const char*)(iSDPText.getMemFragPtr()),
                            iSDPText.getMemFragSize(),
                            sdpInfo);

    // save the SDP file name - the packet source node will need this
    sdpInfo->setSDPFilename(iSessionSourceInfo->_sessionURL);

    PVMF_STREAMING_MANAGER_DELETE(NULL, SDP_Parser, sdpParser);

    OsclRefCounterSA< PVMFSMSharedPtrAlloc<SDPInfo> > *refcnt =
        new OsclRefCounterSA< PVMFSMSharedPtrAlloc<SDPInfo> >(sdpInfo);

    OsclSharedPtr<SDPInfo> sharedSDPInfo(sdpInfo, refcnt);

    if (sdpRetVal != SDP_SUCCESS)
    {
        return PVMFFailure;
    }

    iSessionSourceInfo->_sdpInfo = sharedSDPInfo;

    return PVMFSuccess;
}

PVMFStatus PVMFStreamingManagerNode::RecognizeAndProcessHeader()
{
    OSCL_ASSERT(iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_MS_HTTP_STREAMING_URL);

    return Asf_RecognizeAndProcessHeader();
}

PVMFStatus
PVMFStreamingManagerNode::GetMediaPresentationInfo(PVMFMediaPresentationInfo& aInfo)
{
    if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE))
    {
        SDPInfo* sdpInfo = iSessionSourceInfo->_sdpInfo.GetRep();

        /* Get SDP Session Info */
        sessionDescription* sessionInfo = sdpInfo->getSessionInfo();

        RtspRangeType *sessionRange = OSCL_CONST_CAST(RtspRangeType*, (sessionInfo->getRange()));

        int32 sessionStartTime = 0, sessionStopTime = 0;

        sessionRange->convertToMilliSec(sessionStartTime, sessionStopTime);

        int32 duration_msec = (sessionStopTime - sessionStartTime);

        uint64 duration64;
        Oscl_Int64_Utils::set_uint64(duration64, 0, (uint32)duration_msec);

        if (sessionRange->end_is_set == true)
        {
            aInfo.setDurationValue(duration64);
            aInfo.setDurationTimeScale(1000);
        }
        else
        {
            aInfo.SetDurationAvailable(false);
        }

        aInfo.setSeekableFlag((!(sessionInfo->getRandomAccessDenied())));

        int32 numTracks = sdpInfo->getNumMediaObjects();

        SDPAltGroupType sdpAltGroupType = sessionInfo->getSDPAltGroupType();

        PVMF_TRACK_INFO_TRACK_ALTERNATE_TYPE iAltType = PVMF_TRACK_ALTERNATE_TYPE_UNDEFINED;

        if (sdpAltGroupType == SDP_ALT_GROUP_LANGUAGE)
        {
            iAltType = PVMF_TRACK_ALTERNATE_TYPE_LANGUAGE;
        }
        else if (sdpAltGroupType == SDP_ALT_GROUP_BANDWIDTH)
        {
            iAltType = PVMF_TRACK_ALTERNATE_TYPE_BANDWIDTH;
        }

        for (int32 i = 0; i < numTracks; i++)
        {
            /*
             * Get the vector of mediaInfo as there can
             * alternates for each track
             */
            Oscl_Vector<mediaInfo*, SDPParserAlloc> mediaInfoVec =
                sdpInfo->getMediaInfo(i);

            uint32 minfoVecLen = mediaInfoVec.size();

            for (uint32 j = 0; j < minfoVecLen; j++)
            {
                mediaInfo* mInfo = mediaInfoVec[j];

                if (mInfo == NULL)
                {
                    return PVMFFailure;
                }

                RtspRangeType *mediaRange = mInfo->getRtspRange();

                int32 mediaStartTime = 0, mediaStopTime = 0;

                mediaRange->convertToMilliSec(mediaStartTime, mediaStopTime);
                int32 mediaDuration_ms = mediaStopTime - mediaStartTime;
                uint64 mediaDuration64;
                Oscl_Int64_Utils::set_uint64(mediaDuration64, 0, (uint32)mediaDuration_ms);

                PVMFTrackInfo trackInfo;

                Oscl_Vector<PayloadSpecificInfoTypeBase*, SDPParserAlloc> payloadVector;
                payloadVector = mInfo->getPayloadSpecificInfoVector();

                if (payloadVector.size() == 0)
                {
                    return false;
                }
                /*
                 * There can be multiple payloads per media segment.
                 * We only support one for now, so
                 * use just the first payload
                 */
                PayloadSpecificInfoTypeBase* payloadInfo = payloadVector[0];

                // set config for later
                int32 configSize = payloadInfo->configSize;
                OsclAny* config = payloadInfo->configHeader.GetRep();

                OSCL_StackString<256> mimeString;
                const char* mimeType = mInfo->getMIMEType();
                {
                    mimeString += mimeType;
                }
                trackInfo.setTrackMimeType(mimeString);

                uint32 trackID = mInfo->getMediaInfoID();

                trackInfo.setTrackID(trackID);
                trackInfo.setPortTag(trackID);

                trackInfo.setTrackBitRate(mInfo->getBitrate());

                if (mediaRange->end_is_set == true)
                {
                    trackInfo.setTrackDurationValue(mediaDuration64);
                }
                else
                {
                    trackInfo.SetDurationAvailable(false);
                }

                if ((configSize > 0) && (config != NULL))
                {
                    OsclMemAllocDestructDealloc<uint8> my_alloc;
                    OsclRefCounter* my_refcnt;
                    uint aligned_refcnt_size =
                        oscl_mem_aligned_size(sizeof(OsclRefCounterSA< OsclMemAllocDestructDealloc<uint8> >));

                    uint8* my_ptr = NULL;
                    int32 errcode = 0;
                    OSCL_TRY(errcode, my_ptr = (uint8*) my_alloc.ALLOCATE(aligned_refcnt_size + configSize));

                    my_refcnt = OSCL_PLACEMENT_NEW(my_ptr, OsclRefCounterSA< OsclMemAllocDestructDealloc<uint8> >(my_ptr));
                    my_ptr += aligned_refcnt_size;

                    OsclMemoryFragment memfrag;
                    memfrag.len = (uint32)configSize;
                    memfrag.ptr = my_ptr;

                    oscl_memcpy((void*)(memfrag.ptr), (const void*)config, memfrag.len);

                    OsclRefCounterMemFrag tmpRefcntMemFrag(memfrag, my_refcnt, memfrag.len);
                    trackInfo.setTrackConfigInfo(tmpRefcntMemFrag);
                }

                int32 dependsOnTrackID = mInfo->getDependsOnTrackID();

                if (dependsOnTrackID != -1)
                {
                    trackInfo.setDependsOn();
                    mediaInfo* baseMediaInfo = sdpInfo->getMediaInfoBasedOnDependsOnID(dependsOnTrackID);
                    if (baseMediaInfo == NULL)
                    {
                        return PVMFFailure;
                    }
                    trackInfo.addDependsOnTrackID(baseMediaInfo->getMediaInfoID());
                }

                if (iAltType != PVMF_TRACK_ALTERNATE_TYPE_UNDEFINED)
                {
                    /* Expose alternate track ids */
                    trackInfo.setTrackAlternates(iAltType);
                    for (uint32 k = 0; k < minfoVecLen; k++)
                    {
                        mediaInfo* mInfo = mediaInfoVec[k];
                        if (mInfo == NULL)
                        {
                            return PVMFFailure;
                        }
                        uint32 altID = mInfo->getMediaInfoID();
                        if (altID != trackID)
                        {
                            trackInfo.addAlternateTrackID((int32)altID);
                        }
                    }
                }
                aInfo.addTrackInfo(trackInfo);
            }
        }
        iCompleteMediaPresetationInfo = aInfo;
        return PVMFSuccess;
    }
    return PVMFErrNotSupported;
}

PVMFStatus
PVMFStreamingManagerNode::SelectTracks(PVMFMediaPresentationInfo& aInfo,
                                       PVMFSessionId s)
{
    if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE))
    {
        SDPInfo* sdpInfo = iSessionSourceInfo->_sdpInfo.GetRep();
        if (sdpInfo == NULL)
        {
            PVMF_SM_LOGERROR((0, "StreamingManagerNode:SelectTracks - SDP Not Available"));
            return PVMFErrArgument;
        }

        int32 numTracks = aInfo.getNumTracks();

        for (int32 i = 0; i < numTracks; i++)
        {
            PVMFTrackInfo* trackInfo = aInfo.getTrackInfo(i);

            uint32 trackID = trackInfo->getTrackID();

            mediaInfo* mInfo =
                sdpInfo->getMediaInfoBasedOnID(trackID);

            if (mInfo == NULL)
            {
                PVMF_SM_LOGERROR((0, "StreamingManagerNode:SelectTracks - Invalid SDP TrackID"));
                return PVMFErrArgument;
            }

            mInfo->setSelect();

            /* Set selected field in meta info */
            Oscl_Vector<PVMFSMTrackMetaDataInfo, PVMFStreamingManagerNodeAllocator>::iterator it;
            for (it = iMetaDataInfo.iTrackMetaDataInfoVec.begin(); it != iMetaDataInfo.iTrackMetaDataInfoVec.end(); it++)
            {
                if (it->iTrackID == trackID)
                {
                    it->iTrackSelected = true;
                }
            }
        }
        iSelectedMediaPresetationInfo = aInfo;
        return PVMFSuccess;
    }
    return PVMFErrNotSupported;
}

PVMFCommandId
PVMFStreamingManagerNode::SetDataSourcePosition(PVMFSessionId aSessionId,
        PVMFTimestamp aTargetNPT,
        PVMFTimestamp& aActualNPT,
        PVMFTimestamp& aActualMediaDataTS,
        bool aJumpToIFrame,
        uint32 aStreamID,
        OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::SetDataSourcePosition - In"));

    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommand::Construct(aSessionId,
            PVMF_STREAMING_MANAGER_NODE_SET_DATASOURCE_POSITION,
            aTargetNPT,
            &aActualNPT,
            &aActualMediaDataTS,
            aJumpToIFrame,
            aStreamID,
            aContext);

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::SetDataSourcePosition - Out"));
    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::SetDataSourcePosition() - Cmd Recvd"));
    return QueueCommandL(cmd);
}

PVMFCommandId
PVMFStreamingManagerNode::SetDataSourcePosition(PVMFSessionId aSessionId,
        PVMFDataSourcePositionParams& aPVMFDataSourcePositionParams,
        OsclAny* aContext)
{
    PVMFStreamingManagerNodeCommand cmd;
    return QueueCommandL(cmd);
}


void PVMFStreamingManagerNode::DoSetDataSourcePosition(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoSetDataSourcePosition - In"));

    iActualRepositionStartNPTInMSPtr = NULL;
    iActualMediaDataTSPtr = NULL;
    iPVMFDataSourcePositionParamsPtr = NULL;
    iJumpToIFrame = false;
    uint32 streamID = 0;

    aCmd.PVMFStreamingManagerNodeCommand::Parse(iRepositionRequestedStartNPTInMS,
            iActualRepositionStartNPTInMSPtr,
            iActualMediaDataTSPtr,
            iJumpToIFrame,
            streamID);

    PVMF_SM_LOG_COMMAND_REPOS((0, "PVMFStreamingManagerNode::DoSetDataSourcePosition - TargetNPT = %d", iRepositionRequestedStartNPTInMS));

    PVMFSMNodeContainer* iJitterBufferNodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
    if (iJitterBufferNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
    PVMFJitterBufferExtensionInterface* jbExtIntf =
        (PVMFJitterBufferExtensionInterface*)
        (iJitterBufferNodeContainer->iExtensions[0]);
    bool retVal = false;

    // duplicate bos has been received
    // dont perform reposition at source node
    if (iStreamID == streamID)	retVal = true; // data is already present in the graph

    iStreamID = streamID;
    jbExtIntf->SendBOSMessage(iStreamID);


    *iActualRepositionStartNPTInMSPtr = 0;
    *iActualMediaDataTSPtr = 0;


    if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE))
    {
        if (iInterfaceState == EPVMFNodePrepared)
        {
            /*
             * SetDataSource from a prepared state could mean two things:
             *	- In Play-Stop-Play usecase engine does a SetDataSourcePosition
             *    to get the start media TS to set its playback clock
             *  - Engine is trying to do a play with a non-zero start offset
             */
            if (iRepositionRequestedStartNPTInMS < iSessionStopTime && iRepositionRequestedStartNPTInMS != iSessionStartTime)
            {

                /* Set Requested Play Range */
                PVMFSMNodeContainer* iSessionControllerNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);
                if (iSessionControllerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
                PVRTSPEngineNodeExtensionInterface* rtspExtIntf =
                    (PVRTSPEngineNodeExtensionInterface*)
                    (iSessionControllerNodeContainer->iExtensions[0]);

                RtspRangeType rtspRange;
                rtspRange.format = RtspRangeType::NPT_RANGE;
                rtspRange.start_is_set = true;
                rtspRange.npt_start.npt_format = NptTimeFormat::NPT_SEC;
                rtspRange.npt_start.npt_sec.sec = iRepositionRequestedStartNPTInMS / 1000;
                rtspRange.npt_start.npt_sec.milli_sec =
                    (iRepositionRequestedStartNPTInMS - ((iRepositionRequestedStartNPTInMS / 1000) * 1000));
                rtspRange.end_is_set = true;
                rtspRange.npt_end.npt_format = NptTimeFormat::NPT_SEC;
                rtspRange.npt_end.npt_sec.sec = iSessionStopTime / 1000;
                rtspRange.npt_end.npt_sec.milli_sec =
                    (iSessionStopTime - ((iSessionStopTime / 1000) * 1000));

                if (rtspExtIntf->SetRequestPlayRange(rtspRange) != PVMFSuccess)
                {
                    PVMF_SM_LOGERROR((0, "StreamingManagerNode:DoSetDataSourcePosition - SetRequestPlayRange Failed"));
                    PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::SetDataSourcePosition() - Cmd Failed - PVMFFailure"));
                    CommandComplete(iInputCommands, aCmd, PVMFFailure);
                    return;
                }

                // we need to use part of the logic of repositioning to start
                // streaming from a non-zero offset. Enabled only for 3gpp streaming
                if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
                        (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE))
                {
                    oRepositioning = true;
                    /* Start the nodes */
                    if (!DoRepositioningStart3GPPStreaming())
                    {
                        CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
                        return;
                    }

                    MoveCmdToCurrentQueue(aCmd);
                    return;
                }
            }

            GetAcutalMediaTSAfterSeek();
            PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::SetDataSourcePosition() - CmdComplete"));
            CommandComplete(iInputCommands, aCmd, PVMFSuccess);
        }
        else if ((iInterfaceState == EPVMFNodeStarted) || (iInterfaceState == EPVMFNodePaused))
        {
            bool oRandAccessDenied = true;

            sessionDescription* sessionInfo =
                iSessionSourceInfo->_sdpInfo->getSessionInfo();
            oRandAccessDenied = sessionInfo->getRandomAccessDenied();


            if ((oRandAccessDenied == true) ||
                    (iSessionStopTimeAvailable == false) ||
                    (((int32)iRepositionRequestedStartNPTInMS < (int32)iSessionStartTime) ||
                     ((int32)iRepositionRequestedStartNPTInMS >= (int32)iSessionStopTime)))
            {
                /*
                 * Implies an open ended session or invalid request time
                 * - no pause or reposition
                 */
                CommandComplete(iInputCommands, aCmd, PVMFErrNotSupported);
                return;
            }

            oRepositioning = true;

            /* Put the jitter buffer into a state of transition */
            PVMFSMNodeContainer* iJitterBufferNodeContainer =
                getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
            if (iJitterBufferNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
            PVMFJitterBufferExtensionInterface* jbExtIntf =
                (PVMFJitterBufferExtensionInterface*)
                (iJitterBufferNodeContainer->iExtensions[0]);
            jbExtIntf->PrepareForRepositioning();

            /* If node is running, pause first */
            if (iInterfaceState == EPVMFNodeStarted)
            {
                if (!DoRepositioningPause3GPPStreaming())
                {
                    CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
                }
            }
            /* If already paused do not pause */
            else if (iInterfaceState == EPVMFNodePaused)
            {
                /* Start the nodes */
                if (!DoRepositioningStart3GPPStreaming())
                {
                    CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
                }
            }
            MoveCmdToCurrentQueue(aCmd);
        }
        else
        {
            CommandComplete(iInputCommands, aCmd, PVMFErrInvalidState);
            return;
        }
    }
    else
    {
        PVMF_SM_LOG_COMMAND_SEQ((0, "PVMFStreamingManagerNode::SetDataSourcePosition() - Cmd Failed - PVMFErrArgument"));
        CommandComplete(iInputCommands, aCmd, PVMFErrArgument);
        return;
    }
    return;
}

bool PVMFStreamingManagerNode::DoRepositioningPause3GPPStreaming()
{
    for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
    {
        int32 nodeTag = iNodeContainerVec[i].iNodeTag;

        if ((nodeTag == PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE) ||
                (nodeTag == PVMF_STREAMING_MANAGER_MEDIA_LAYER_NODE) ||
                (nodeTag == PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE) ||
                (nodeTag == PVMF_STREAMING_MANAGER_SOCKET_NODE))
        {
            PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
            if (internalCmd != NULL)
            {
                internalCmd->cmd =
                    iNodeContainerVec[i].commandStartOffset +
                    PVMF_STREAMING_MANAGER_NODE_INTERNAL_PAUSE_CMD_OFFSET;
                internalCmd->parentCmd = PVMF_STREAMING_MANAGER_NODE_SET_DATASOURCE_POSITION;

                OsclAny *cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

                PVMFNodeInterface* iNode = iNodeContainerVec[i].iNode;

                iNode->Pause(iNodeContainerVec[i].iSessionId, cmdContextData);
                iNodeContainerVec[i].iNodeCmdState = PVMFSM_NODE_CMD_PENDING;
            }
            else
            {
                PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoRepositioningPause:RequestNewInternalCmd - Failed"));
                return false;
            }
        }
    }
    return true;
}

bool PVMFStreamingManagerNode::DoRepositioningPauseMSHTTPStreaming()
{
    /* Pause session controller */
    for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
    {
        int32 nodeTag = iNodeContainerVec[i].iNodeTag;
        if ((nodeTag == PVMF_STREAMING_MANAGER_MEDIA_LAYER_NODE) ||
                (nodeTag == PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE))
        {
            PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
            if (internalCmd != NULL)
            {
                internalCmd->cmd =
                    iNodeContainerVec[i].commandStartOffset +
                    PVMF_STREAMING_MANAGER_NODE_INTERNAL_PAUSE_CMD_OFFSET;
                internalCmd->parentCmd = PVMF_STREAMING_MANAGER_NODE_SET_DATASOURCE_POSITION;

                OsclAny *cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

                PVMFNodeInterface* iNode = iNodeContainerVec[i].iNode;

                iNode->Pause(iNodeContainerVec[i].iSessionId, cmdContextData);
                iNodeContainerVec[i].iNodeCmdState = PVMFSM_NODE_CMD_PENDING;
            }
            else
            {
                PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoRepositioningPause:RequestNewInternalCmd - Failed"));
                return false;
            }
        }
    }
    return true;
}


bool PVMFStreamingManagerNode::DoRepositioningStart3GPPStreaming()
{
    /* Set Requested Play Range */
    PVMFSMNodeContainer* iSessionControllerNodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);

    if (iSessionControllerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);

    PVRTSPEngineNodeExtensionInterface* rtspExtIntf =
        (PVRTSPEngineNodeExtensionInterface*)
        (iSessionControllerNodeContainer->iExtensions[0]);

    RtspRangeType rtspRange;
    rtspRange.format = RtspRangeType::NPT_RANGE;
    rtspRange.start_is_set = true;
    rtspRange.npt_start.npt_format = NptTimeFormat::NPT_SEC;
    rtspRange.npt_start.npt_sec.sec = iRepositionRequestedStartNPTInMS / 1000;
    rtspRange.npt_start.npt_sec.milli_sec =
        (iRepositionRequestedStartNPTInMS - ((iRepositionRequestedStartNPTInMS / 1000) * 1000));
    rtspRange.end_is_set = true;
    rtspRange.npt_end.npt_format = NptTimeFormat::NPT_SEC;
    rtspRange.npt_end.npt_sec.sec = iSessionStopTime / 1000;
    rtspRange.npt_end.npt_sec.milli_sec =
        (iSessionStopTime - ((iSessionStopTime / 1000) * 1000));

    if (rtspExtIntf->SetRequestPlayRange(rtspRange) != PVMFSuccess)
    {
        PVMF_SM_LOGERROR((0, "StreamingManagerNode:DoRepositioningStart - SetRequestPlayRange Failed"));
        return false;
    }
    for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
    {
        PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
        if (internalCmd != NULL)
        {
            internalCmd->cmd =
                iNodeContainerVec[i].commandStartOffset +
                PVMF_STREAMING_MANAGER_NODE_INTERNAL_START_CMD_OFFSET;
            internalCmd->parentCmd = PVMF_STREAMING_MANAGER_NODE_SET_DATASOURCE_POSITION;

            OsclAny *cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

            PVMFNodeInterface* iNode = iNodeContainerVec[i].iNode;

            iNode->Start(iNodeContainerVec[i].iSessionId, cmdContextData);
            iNodeContainerVec[i].iNodeCmdState = PVMFSM_NODE_CMD_PENDING;
        }
        else
        {
            PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoRepositioningStart:RequestNewInternalCmd - Failed"));
            return false;
        }
    }
    return true;
}


bool PVMFStreamingManagerNode::DoRepositioningStartMSHTTPStreaming()
{
    PVMFSMNodeContainer* iMediaLayerNodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_MEDIA_LAYER_NODE);
    if (iMediaLayerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
    PVMFMediaLayerNodeExtensionInterface* mlExtIntf =
        (PVMFMediaLayerNodeExtensionInterface*)
        (iMediaLayerNodeContainer->iExtensions[0]);
    if (mlExtIntf == NULL) OSCL_LEAVE(OsclErrBadHandle);

    PVMFPortInterface* mlInPort = iMediaLayerNodeContainer->iInputPorts[0];
    mlExtIntf->setInPortReposFlag(mlInPort);

    //Check Track Config. If error is detected, MediaLayer send EOS.
    PVMFSMTrackInfoVector::iterator it;
    for (it = iTrackInfoVec.begin(); it != iTrackInfoVec.end(); it++)
    {
        if (it->iTrackDisable == true)
            mlExtIntf->setTrackDisable(it->iMediaLayerOutputPort);
    }

    for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
    {
        int32 nodeTag = iNodeContainerVec[i].iNodeTag;

        if ((nodeTag == PVMF_STREAMING_MANAGER_MEDIA_LAYER_NODE) ||
                (nodeTag == PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE) ||
                (iInterfaceState == EPVMFNodePrepared && nodeTag != PVMF_STREAMING_MANAGER_SOCKET_NODE))
        {
            PVMFSMCommandContext* internalCmd = RequestNewInternalCmd();
            if (internalCmd != NULL)
            {
                internalCmd->cmd =
                    iNodeContainerVec[i].commandStartOffset +
                    PVMF_STREAMING_MANAGER_NODE_INTERNAL_START_CMD_OFFSET;
                internalCmd->parentCmd = PVMF_STREAMING_MANAGER_NODE_SET_DATASOURCE_POSITION;

                OsclAny *cmdContextData = OSCL_REINTERPRET_CAST(OsclAny*, internalCmd);

                PVMFNodeInterface* iNode = iNodeContainerVec[i].iNode;

                iNode->Start(iNodeContainerVec[i].iSessionId, cmdContextData);
                iNodeContainerVec[i].iNodeCmdState = PVMFSM_NODE_CMD_PENDING;
            }
            else
            {
                PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode:DoRepositioningStartMSHTTPStreaming:RequestNewInternalCmd - Failed"));
                return false;
            }
        }
    }
    return true;
}

void PVMFStreamingManagerNode::GetAcutalMediaTSAfterSeek()
{
    PVMFSMNodeContainer* iJitterBufferNodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
    if (iJitterBufferNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
    PVMFJitterBufferExtensionInterface* jbExtIntf =
        (PVMFJitterBufferExtensionInterface*)
        (iJitterBufferNodeContainer->iExtensions[0]);

    PVMFSMNodeContainer* iMediaLayerNodeContainer =
        getNodeContainer(PVMF_STREAMING_MANAGER_MEDIA_LAYER_NODE);
    if (iMediaLayerNodeContainer == NULL) OSCL_LEAVE(OsclErrBadHandle);
    PVMFMediaLayerNodeExtensionInterface* mlExtIntf =
        (PVMFMediaLayerNodeExtensionInterface*)
        (iMediaLayerNodeContainer->iExtensions[0]);
    if (mlExtIntf == NULL) OSCL_LEAVE(OsclErrBadHandle);
    PVMFPortInterface* mlInPort = iMediaLayerNodeContainer->iInputPorts[0];

    if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE))
    {
        iActualMediaDataTS = jbExtIntf->getActualMediaDataTSAfterSeek();
        if (iActualMediaDataTSPtr != NULL)
        {
            *iActualMediaDataTSPtr = iActualMediaDataTS;
            PVMF_SM_LOG_COMMAND_REPOS((0, "PVMFStreamingManagerNode::GetAcutalMediaTSAfterSeek - TargetNPT = %d, ActualNPT=%d, ActualMediaDataTS=%d",
                                       iRepositionRequestedStartNPTInMS, *iActualRepositionStartNPTInMSPtr, *iActualMediaDataTSPtr));
        }
        if (iPVMFDataSourcePositionParamsPtr != NULL)
        {
            iPVMFDataSourcePositionParamsPtr->iActualMediaDataTS = iActualMediaDataTS;
            PVMF_SM_LOG_COMMAND_REPOS((0, "PVMFStreamingManagerNode::GetAcutalMediaTSAfterSeek - ActualMediaDataTS=%d",
                                       iPVMFDataSourcePositionParamsPtr->iActualMediaDataTS));
        }
    }
}

PVMFCommandId
PVMFStreamingManagerNode::QueryDataSourcePosition(PVMFSessionId aSessionId,
        PVMFTimestamp aTargetNPT,
        PVMFTimestamp& aActualNPT,
        bool aSeekToSyncPoint,
        OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::QueryDataSourcePosition - In"));
    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommand::Construct(aSessionId,
            PVMF_STREAMING_MANAGER_NODE_QUERY_DATASOURCE_POSITION,
            aTargetNPT,
            &aActualNPT,
            aSeekToSyncPoint,
            aContext);

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::QueryDataSourcePosition - Out"));
    return QueueCommandL(cmd);
}

PVMFCommandId
PVMFStreamingManagerNode::QueryDataSourcePosition(PVMFSessionId aSessionId,
        PVMFTimestamp aTargetNPT,
        PVMFTimestamp& aSeekPointBeforeTargetNPT,
        PVMFTimestamp& aSeekPointAfterTargetNPT,
        OsclAny* aContext,
        bool aSeekToSyncPoint)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::QueryDataSourcePosition - In"));
    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommand::Construct(aSessionId,
            PVMF_STREAMING_MANAGER_NODE_QUERY_DATASOURCE_POSITION,
            aTargetNPT,
            &aSeekPointBeforeTargetNPT,
            &aSeekPointAfterTargetNPT,
            aContext,
            aSeekToSyncPoint);

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::QueryDataSourcePosition - Out"));
    return QueueCommandL(cmd);
}

void PVMFStreamingManagerNode::DoQueryDataSourcePosition(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoQueryDataSourcePosition - In"));

    PVMFTimestamp repositionrequestedstartnptinms = 0;
    PVMFTimestamp* actualrepositionstartnptinmsptr = NULL;
    bool seektosyncpoint = false;

    aCmd.PVMFStreamingManagerNodeCommand::Parse(repositionrequestedstartnptinms,
            actualrepositionstartnptinmsptr,
            seektosyncpoint);

    if (actualrepositionstartnptinmsptr == NULL)
    {
        CommandComplete(iInputCommands, aCmd, PVMFErrArgument);
        return;
    }
    *actualrepositionstartnptinmsptr = 0;

    // This query is not supported for streaming sessions
    CommandComplete(iInputCommands, aCmd, PVMFErrNotSupported);
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoQueryDataSourcePosition - Out"));
    return;
}

PVMFCommandId
PVMFStreamingManagerNode::SetDataSourceRate(PVMFSessionId aSessionId,
        int32 aRate,
        OsclTimebase* aTimebase,
        OsclAny* aContext)
{
    OSCL_UNUSED_ARG(aSessionId);
    OSCL_UNUSED_ARG(aRate);
    OSCL_UNUSED_ARG(aTimebase);
    OSCL_UNUSED_ARG(aContext);

    OSCL_LEAVE(OsclErrNotSupported);
    return 0;
}

void PVMFStreamingManagerNode::DoSetDataSourceRate(PVMFStreamingManagerNodeCommand& aCmd)
{
    CommandComplete(iInputCommands, aCmd, PVMFErrNotSupported);
}

uint32
PVMFStreamingManagerNode::GetNumMetadataKeys(char* aQueryKeyString)
{
    uint32 num_entries = 0;

    if (aQueryKeyString == NULL)
    {
        // No query key so just return all the available keys
        num_entries = iAvailableMetadataKeys.size();
    }
    else
    {
        // Determine the number of metadata keys based on the query key string provided
        uint32 i;
        for (i = 0; i < iAvailableMetadataKeys.size(); i++)
        {
            // Check if the key matches the query key
            if (pv_mime_strcmp(iAvailableMetadataKeys[i].get_cstr(), aQueryKeyString) >= 0)
            {
                num_entries++;
            }
        }
        for (i = 0; i < iCPMMetadataKeys.size(); i++)
        {
            /* Check if the key matches the query key */
            if (pv_mime_strcmp(iCPMMetadataKeys[i].get_cstr(),
                               aQueryKeyString) >= 0)
            {
                num_entries++;
            }
        }
    }
    return num_entries;
}

uint32
PVMFStreamingManagerNode::GetNumMetadataValues(PVMFMetadataList& aKeyList)
{
    uint32 numkeys = aKeyList.size();

    if (numkeys == 0)
    {
        return 0;
    }

    SDPInfo* sdpInfo = NULL;
    if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE))
    {
        sdpInfo = iSessionSourceInfo->_sdpInfo.GetRep();
        if (sdpInfo == NULL)
        {
            return 0;
        }
    }
    // Get Num Tracks
    uint32 numtracks = iMetaDataInfo.iNumTracks;

    uint32 numvalentries = 0;
    for (uint32 lcv = 0; lcv < numkeys; lcv++)
    {
        if (oscl_strcmp(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_AUTHOR_KEY) == 0 &&
                iMetaDataInfo.iAuthorPresent)
        {
            // Author
            // Increment the counter for the number of values found so far
            ++numvalentries;
        }
        else if (oscl_strcmp(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_ARTIST_KEY) == 0 &&
                 iMetaDataInfo.iPerformerPresent)
        {
            // Artist/performer
            // Increment the counter for the number of values found so far
            ++numvalentries;
        }
        else if (oscl_strcmp(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TITLE_KEY) == 0 &&
                 iMetaDataInfo.iTitlePresent)
        {
            // Title
            // Increment the counter for the number of values found so far
            ++numvalentries;
        }
        else if (oscl_strcmp(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_DESCRIPTION_KEY) == 0 &&
                 iMetaDataInfo.iDescriptionPresent)
        {
            // Description
            // Increment the counter for the number of values found so far
            ++numvalentries;
        }
        else if (oscl_strcmp(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_RATING_KEY) == 0 &&
                 iMetaDataInfo.iRatingPresent)
        {
            // Rating
            // Increment the counter for the number of values found so far
            ++numvalentries;
        }
        else if (oscl_strcmp(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_COPYRIGHT_KEY) == 0 &&
                 iMetaDataInfo.iCopyRightPresent)
        {
            // Copyright
            // Increment the counter for the number of values found so far
            ++numvalentries;
        }
        else if (oscl_strcmp(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_GENRE_KEY) == 0 &&
                 iMetaDataInfo.iGenrePresent)
        {
            // Genre
            // Increment the counter for the number of values found so far
            ++numvalentries;
        }
        else if (oscl_strcmp(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_LYRICS_KEY) == 0 &&
                 iMetaDataInfo.iLyricsPresent)
        {
            // Lyrics
            // Increment the counter for the number of values found so far
            ++numvalentries;
        }
        else if (oscl_strcmp(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_NUM_GRAPHICS_KEY) == 0 &&
                 iMetaDataInfo.iWMPicturePresent)
        {
            // Num Picture
            // Increment the counter for the number of values found so far
            ++numvalentries;
        }
        else if (oscl_strcmp(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_GRAPHICS_KEY) == 0 &&
                 iMetaDataInfo.iWMPicturePresent)
        {
            // Picture
            // Increment the counter for the number of values found so far
            ++numvalentries;
        }
        else if (oscl_strcmp(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_CLASSIFICATION_KEY) == 0 &&
                 iMetaDataInfo.iClassificationPresent)
        {
            // Classification
            // Increment the counter for the number of values found so far
            ++numvalentries;
        }
        else if (oscl_strcmp(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_KEYWORDS_KEY) == 0 &&
                 iMetaDataInfo.iKeyWordsPresent)
        {
            // Keywords
            // Increment the counter for the number of values found so far
            ++numvalentries;
        }
        else if (oscl_strcmp(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_LOCATION_KEY) == 0 &&
                 iMetaDataInfo.iLocationPresent)
        {
            // Location
            // Increment the counter for the number of values found so far
            ++numvalentries;
        }
        else if (oscl_strcmp(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_DURATION_KEY) == 0)
        {
            // Session Duration
            // Increment the counter for the number of values found so far
            ++numvalentries;
        }
        else if (oscl_strcmp(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_NUMTRACKS_KEY) == 0 &&
                 numtracks > 0)
        {
            // Number of tracks
            // Increment the counter for the number of values found so far
            ++numvalentries;
        }
        else if (oscl_strcmp(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_RANDOM_ACCESS_DENIED_KEY) == 0)
        {
            // Increment the counter for the number of values found so far
            ++numvalentries;
        }
        else if (oscl_strcmp(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_CLIP_TYPE_KEY) == 0)
        {
            // Increment the counter for the number of values found so far
            ++numvalentries;
        }
        else if (oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_TYPE_KEY) != NULL)
        {
            // Track type
            // Determine the index requested. Default to all tracks
            uint32 startindex = 0;
            uint32 endindex = numtracks - 1;
            // Check if the index parameter is present
            char* indexstr = oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                // Retrieve the index values
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            // Validate the indices
            if (startindex > endindex || startindex >= (uint32)numtracks || endindex >= (uint32)numtracks)
            {
                continue;
            }
            // Increment the counter for the number of values found so far
            numvalentries += (endindex + 1 - startindex);
        }
        else if (oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_DURATION_KEY) != NULL)
        {
            // Track duration
            // Determine the index requested. Default to all tracks
            uint32 startindex = 0;
            uint32 endindex = numtracks - 1;
            // Check if the index parameter is present
            char* indexstr = oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                // Retrieve the index values
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            // Validate the indices
            if (startindex > endindex || startindex >= (uint32)numtracks || endindex >= (uint32)numtracks)
            {
                continue;
            }

            // Increment the counter for the number of values found so far
            numvalentries += (endindex + 1 - startindex);
        }
        else if (oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_BITRATE_KEY) != NULL)
        {
            // Track bitrate
            // Determine the index requested. Default to all tracks
            uint32 startindex = 0;
            uint32 endindex = numtracks - 1;
            // Check if the index parameter is present
            char* indexstr = oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                // Retrieve the index values
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            // Validate the indices
            if (startindex > endindex || startindex >= (uint32)numtracks || endindex >= (uint32)numtracks)
            {
                continue;
            }
            // Increment the counter for the number of values found so far
            numvalentries += (endindex + 1 - startindex);
        }
        else if (oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_MAX_BITRATE_KEY) != NULL)
        {
            // Track bitrate
            // Determine the index requested. Default to all tracks
            uint32 startindex = 0;
            uint32 endindex = numtracks - 1;
            // Check if the index parameter is present
            char* indexstr = oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                // Retrieve the index values
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            // Validate the indices
            if (startindex > endindex || startindex >= (uint32)numtracks || endindex >= (uint32)numtracks)
            {
                continue;
            }
            // Increment the counter for the number of values found so far
            numvalentries += (endindex + 1 - startindex);
        }
        else if (oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_SELECTED_KEY) != NULL)
        {
            // Track selected
            // Determine the index requested. Default to all tracks
            uint32 startindex = 0;
            uint32 endindex = numtracks - 1;
            // Check if the index parameter is present
            char* indexstr = oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                // Retrieve the index values
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            // Validate the indices
            if (startindex > endindex || startindex >= (uint32)numtracks || endindex >= (uint32)numtracks)
            {
                continue;
            }
            // Increment the counter for the number of values found so far
            numvalentries += (endindex + 1 - startindex);
        }
        else if ((oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_CODEC_NAME_KEY) != NULL))
        {
            /*
             * Codec Name
             * Determine the index requested.
             */
            uint32 startindex = 0;
            uint32 endindex   = 0;
            /* Check if the index parameter is present */
            char* indexstr = oscl_strstr(aKeyList[lcv].get_cstr(),
                                         PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                /* Retrieve the index values */
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            /* Validate the indices */
            if ((startindex > endindex) ||
                    (startindex >= (uint32)numtracks) ||
                    (endindex >= (uint32)numtracks))
            {
                continue;
            }

            numvalentries += (endindex + 1 - startindex);
        }
        else if ((oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_CODEC_DESCRIPTION_KEY) != NULL))
        {
            /*
             * Codec Description
             * Determine the index requested.
             */
            uint32 startindex = 0;
            uint32 endindex   = 0;
            /* Check if the index parameter is present */
            char* indexstr = oscl_strstr(aKeyList[lcv].get_cstr(),
                                         PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                /* Retrieve the index values */
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            /* Validate the indices */
            if ((startindex > endindex) ||
                    (startindex >= (uint32)numtracks) ||
                    (endindex >= (uint32)numtracks))
            {
                continue;
            }
            numvalentries += (endindex + 1 - startindex);
        }
        else if ((oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_CODEC_DATA_KEY) != NULL))
        {
            /*
             * Codec Description
             * Determine the index requested.
             */
            uint32 startindex = 0;
            uint32 endindex   = 0;
            /* Check if the index parameter is present */
            char* indexstr = oscl_strstr(aKeyList[lcv].get_cstr(),
                                         PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                /* Retrieve the index values */
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            /* Validate the indices */
            if ((startindex > endindex) ||
                    (startindex >= (uint32)numtracks) ||
                    (endindex >= (uint32)numtracks))
            {
                continue;
            }
            numvalentries += (endindex + 1 - startindex);
        }
        else if ((oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_WIDTH_KEY) != NULL))
        {
            /*
             * Codec Description
             * Determine the index requested.
             */
            uint32 startindex = 0;
            uint32 endindex   = 0;
            /* Check if the index parameter is present */
            char* indexstr = oscl_strstr(aKeyList[lcv].get_cstr(),
                                         PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                /* Retrieve the index values */
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            /* Validate the indices */
            if ((startindex > endindex) ||
                    (startindex >= (uint32)numtracks) ||
                    (endindex >= (uint32)numtracks))
            {
                continue;
            }
            numvalentries += (endindex + 1 - startindex);
        }
        else if ((oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_HEIGHT_KEY) != NULL))
        {
            /*
             * Codec Description
             * Determine the index requested.
             */
            uint32 startindex = 0;
            uint32 endindex   = 0;
            /* Check if the index parameter is present */
            char* indexstr = oscl_strstr(aKeyList[lcv].get_cstr(),
                                         PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                /* Retrieve the index values */
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            /* Validate the indices */
            if ((startindex > endindex) ||
                    (startindex >= (uint32)numtracks) ||
                    (endindex >= (uint32)numtracks))
            {
                continue;
            }
            numvalentries += (endindex + 1 - startindex);
        }
        else if ((oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_FRAME_RATE_KEY) != NULL))
        {
            /*
             * Codec Description
             * Determine the index requested.
             */
            uint32 startindex = 0;
            uint32 endindex   = 0;
            /* Check if the index parameter is present */
            char* indexstr = oscl_strstr(aKeyList[lcv].get_cstr(),
                                         PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                /* Retrieve the index values */
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            /* Validate the indices */
            if ((startindex > endindex) ||
                    (startindex >= (uint32)numtracks) ||
                    (endindex >= (uint32)numtracks))
            {
                continue;
            }
            numvalentries += (endindex + 1 - startindex);
        }
        else if ((oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_SAMPLERATE_KEY) != NULL))
        {
            /*
             * Codec Description
             * Determine the index requested.
             */
            uint32 startindex = 0;
            uint32 endindex   = 0;
            /* Check if the index parameter is present */
            char* indexstr = oscl_strstr(aKeyList[lcv].get_cstr(),
                                         PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                /* Retrieve the index values */
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            /* Validate the indices */
            if ((startindex > endindex) ||
                    (startindex >= (uint32)numtracks) ||
                    (endindex >= (uint32)numtracks))
            {
                continue;
            }
            numvalentries += (endindex + 1 - startindex);
        }
        else if ((oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_NUMCHANNELS_KEY) != NULL))
        {
            /*
             * Codec Description
             * Determine the index requested.
             */
            uint32 startindex = 0;
            uint32 endindex   = 0;
            /* Check if the index parameter is present */
            char* indexstr = oscl_strstr(aKeyList[lcv].get_cstr(),
                                         PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                /* Retrieve the index values */
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            /* Validate the indices */
            if ((startindex > endindex) ||
                    (startindex >= (uint32)numtracks) ||
                    (endindex >= (uint32)numtracks))
            {
                continue;
            }
            numvalentries += (endindex + 1 - startindex);
        }
        else if ((oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_AUDIO_BITS_PER_SAMPLE_KEY) != NULL))
        {
            /*
             * Codec Description
             * Determine the index requested.
             */
            uint32 startindex = 0;
            uint32 endindex   = 0;
            /* Check if the index parameter is present */
            char* indexstr = oscl_strstr(aKeyList[lcv].get_cstr(),
                                         PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                /* Retrieve the index values */
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            /* Validate the indices */
            if ((startindex > endindex) ||
                    (startindex >= (uint32)numtracks) ||
                    (endindex >= (uint32)numtracks))
            {
                continue;
            }
            numvalentries += (endindex + 1 - startindex);
        }
        else if ((oscl_strstr(aKeyList[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_TRACKID_KEY) != NULL))
        {
            /*
             * Codec Description
             * Determine the index requested.
             */
            uint32 startindex = 0;
            uint32 endindex   = 0;
            /* Check if the index parameter is present */
            char* indexstr = oscl_strstr(aKeyList[lcv].get_cstr(),
                                         PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                /* Retrieve the index values */
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            /* Validate the indices */
            if ((startindex > endindex) ||
                    (startindex >= (uint32)numtracks) ||
                    (endindex >= (uint32)numtracks))
            {
                continue;
            }
            numvalentries += (endindex + 1 - startindex);
        }
        else
        {
            /* Check the extended meta data list */
            for (uint32 i = 0; i < iMetaDataInfo.iExtendedMetaDataNameVec.size(); i++)
            {
                OSCL_HeapString<PVMFStreamingManagerNodeAllocator> extMetaDataName =
                    iMetaDataInfo.iExtendedMetaDataNameVec[i];
                if (oscl_strcmp(aKeyList[lcv].get_cstr(), extMetaDataName.get_cstr()) == 0)
                {
                    /*
                     * Increment the counter for the number of values found so far
                     */
                    ++numvalentries;
                }
            }
        }
    }
    return numvalentries; // Number of elements
}

PVMFStatus PVMFStreamingManagerNode::InitMetaData()
{
    // Init Metadata
    {
        // Clear out the existing key list
        iAvailableMetadataKeys.clear();
        iCPMMetadataKeys.clear();

        int32 leavecode = 0;

        if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
                (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_REAL_HTTP_CLOAKING_URL) ||
                (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE) ||
                (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE))
        {
            // Get the SDP info
            SDPInfo* sdpInfo = iSessionSourceInfo->_sdpInfo.GetRep();
            if (sdpInfo == NULL)
            {
                return PVMFErrInvalidState;
            }

            // Get Asset Info
            sessionDescription* sessionInfo = sdpInfo->getSessionInfo();
            if (sessionInfo != NULL)
            {
                iMetaDataInfo.iRandomAccessDenied = sessionInfo->getRandomAccessDenied();

                AssetInfoType assetInfo = sessionInfo->getAssetInfo();

                iMetaDataInfo.iTitlePresent = assetInfo.oTitlePresent;
                iMetaDataInfo.iDescriptionPresent = assetInfo.oDescriptionPresent;
                iMetaDataInfo.iCopyRightPresent = assetInfo.oCopyRightPresent;
                iMetaDataInfo.iPerformerPresent = assetInfo.oPerformerPresent;
                iMetaDataInfo.iAuthorPresent = assetInfo.oAuthorPresent;
                iMetaDataInfo.iGenrePresent = assetInfo.oGenrePresent;
                iMetaDataInfo.iRatingPresent = assetInfo.oRatingPresent;
                iMetaDataInfo.iClassificationPresent = assetInfo.oClassificationPresent;
                iMetaDataInfo.iKeyWordsPresent = assetInfo.oKeyWordsPresent;
                iMetaDataInfo.iLocationPresent = assetInfo.oLocationPresent;

                if (iMetaDataInfo.iTitlePresent)
                {
                    iMetaDataInfo.iTitle = assetInfo.Box[AssetInfoType::TITLE];
                }
                if (iMetaDataInfo.iDescriptionPresent)
                {
                    iMetaDataInfo.iDescription = assetInfo.Box[AssetInfoType::DESCRIPTION];
                }
                if (iMetaDataInfo.iCopyRightPresent)
                {
                    iMetaDataInfo.iCopyright = assetInfo.Box[AssetInfoType::COPYRIGHT];
                }
                if (iMetaDataInfo.iPerformerPresent)
                {
                    iMetaDataInfo.iPerformer = assetInfo.Box[AssetInfoType::PERFORMER];
                }
                if (iMetaDataInfo.iAuthorPresent)
                {
                    iMetaDataInfo.iAuthor = assetInfo.Box[AssetInfoType::AUTHOR];
                }
                if (iMetaDataInfo.iRatingPresent)
                {
                    iMetaDataInfo.iRating = assetInfo.Box[AssetInfoType::RATING];
                }
                if (iMetaDataInfo.iClassificationPresent)
                {
                    iMetaDataInfo.iClassification = assetInfo.Box[AssetInfoType::CLASSIFICATION];
                }
                if (iMetaDataInfo.iKeyWordsPresent)
                {
                    iMetaDataInfo.iKeyWords = assetInfo.Box[AssetInfoType::KEYWORDS];
                }
                if (iMetaDataInfo.iLocationPresent)
                {
                    iMetaDataInfo.iLocation = assetInfo.Box[AssetInfoType::LOCATION];
                }

                RtspRangeType *sessionRange = OSCL_CONST_CAST(RtspRangeType*, (sessionInfo->getRange()));
                if (sessionRange->end_is_set == true)
                {
                    iMetaDataInfo.iSessionDurationAvailable = true;

                    int32 sessionStartTime = 0, sessionStopTime = 0;
                    sessionRange->convertToMilliSec(sessionStartTime, sessionStopTime);
                    uint32 duration = 0;
                    if (sessionStopTime > sessionStartTime && sessionStartTime >= 0)
                    {
                        duration = (uint32)(sessionStopTime - sessionStartTime);
                    }
                    Oscl_Int64_Utils::set_uint64(iMetaDataInfo.iSessionDuration, 0, duration);
                    iMetaDataInfo.iSessionDurationTimeScale = 1000;
                }

            }
            iMetaDataInfo.iNumTracks = sdpInfo->getNumMediaObjects();

            for (uint32 i = 0; i < iMetaDataInfo.iNumTracks; i++)
            {
                Oscl_Vector<mediaInfo*, SDPParserAlloc> mediaInfoVec = sdpInfo->getMediaInfo(i);
                for (uint32 j = 0; j < mediaInfoVec.size(); ++j)
                {
                    mediaInfo* mInfo = mediaInfoVec[j];
                    if (mInfo != NULL)
                    {
                        PVMFSMTrackMetaDataInfo trackMetaDataInfo;

                        trackMetaDataInfo.iTrackID = mInfo->getMediaInfoID();
                        const char* mimeType = mInfo->getMIMEType();
                        OSCL_StackString<32> h263(_STRLIT_CHAR("H263"));
                        {
                            trackMetaDataInfo.iMimeType += mimeType;
                        }

                        Oscl_Vector<PayloadSpecificInfoTypeBase*, SDPParserAlloc> payloadVector;
                        payloadVector = mInfo->getPayloadSpecificInfoVector();
                        if (payloadVector.size() != 0)
                        {
                            /*
                             * There can be multiple payloads per media segment.
                             * We only support one for now, so
                             * use just the first payload
                             */
                            PayloadSpecificInfoTypeBase* payloadInfo = payloadVector[0];
                            if (oscl_strstr(mimeType, h263.get_cstr()) != NULL)
                            {
                                H263PayloadSpecificInfoType* h263PayloadInfo =
                                    OSCL_STATIC_CAST(H263PayloadSpecificInfoType*, payloadInfo);
                                trackMetaDataInfo.iTrackWidth = h263PayloadInfo->getFrameWidth();
                                trackMetaDataInfo.iTrackHeight = h263PayloadInfo->getFrameHeight();
                            }
                        }

                        trackMetaDataInfo.iTrackBitRate = (uint32)(mInfo->getBitrate());

                        RtspRangeType *mediaRange = mInfo->getRtspRange();
                        if (mediaRange->end_is_set == true)
                        {
                            int32 mediaStartTime = 0, mediaStopTime = 0;
                            mediaRange->convertToMilliSec(mediaStartTime, mediaStopTime);
                            uint32 trackduration = 0;
                            if (mediaStopTime > mediaStartTime && mediaStartTime >= 0)
                            {
                                trackduration = (uint32)(mediaStopTime - mediaStartTime);
                            }
                            uint64 trackduration64 = 0;
                            Oscl_Int64_Utils::set_uint64(trackduration64, 0, trackduration);
                            trackMetaDataInfo.iTrackDuration = trackduration64;
                            trackMetaDataInfo.iTrackDurationTimeScale = 1000;
                            trackMetaDataInfo.iTrackDurationAvailable = true;
                        }
                        else
                        {
                            trackMetaDataInfo.iTrackDurationAvailable = false;
                        }
                        iMetaDataInfo.iTrackMetaDataInfoVec.push_back(trackMetaDataInfo);
                    }
                }
            }
        }
        leavecode = 0;
        OSCL_TRY(leavecode, iAvailableMetadataKeys.push_back(PVMFSTREAMINGMGRNODE_DURATION_KEY));

        if (iMetaDataInfo.iTitlePresent)
        {
            leavecode = 0;
            OSCL_TRY(leavecode, iAvailableMetadataKeys.push_back(PVMFSTREAMINGMGRNODE_TITLE_KEY));
        }
        if (iMetaDataInfo.iDescriptionPresent)
        {
            leavecode = 0;
            OSCL_TRY(leavecode, iAvailableMetadataKeys.push_back(PVMFSTREAMINGMGRNODE_DESCRIPTION_KEY));
        }
        if (iMetaDataInfo.iCopyRightPresent)
        {
            leavecode = 0;
            OSCL_TRY(leavecode, iAvailableMetadataKeys.push_back(PVMFSTREAMINGMGRNODE_COPYRIGHT_KEY));
        }
        if (iMetaDataInfo.iPerformerPresent)
        {
            leavecode = 0;
            OSCL_TRY(leavecode, iAvailableMetadataKeys.push_back(PVMFSTREAMINGMGRNODE_ARTIST_KEY));
        }
        if (iMetaDataInfo.iAuthorPresent)
        {
            leavecode = 0;
            OSCL_TRY(leavecode, iAvailableMetadataKeys.push_back(PVMFSTREAMINGMGRNODE_AUTHOR_KEY));
        }
        if (iMetaDataInfo.iGenrePresent)
        {
            leavecode = 0;
            OSCL_TRY(leavecode, iAvailableMetadataKeys.push_back(PVMFSTREAMINGMGRNODE_GENRE_KEY));
        }
        if (iMetaDataInfo.iLyricsPresent)
        {
            leavecode = 0;
            OSCL_TRY(leavecode, iAvailableMetadataKeys.push_back(PVMFSTREAMINGMGRNODE_LYRICS_KEY));
        }
        if (iMetaDataInfo.iWMPicturePresent)
        {
            leavecode = 0;
            OSCL_TRY(leavecode, iAvailableMetadataKeys.push_front(PVMFSTREAMINGMGRNODE_NUM_GRAPHICS_KEY));
        }
        if (iMetaDataInfo.iWMPicturePresent)
        {
            // Create the parameter string for the index range
            char indexparam[18];
            oscl_snprintf(indexparam, 18, ";index=0...%d", (iMetaDataInfo.iWMPictureIndexVec.size() - 1));
            indexparam[17] = NULL_TERM_CHAR;

            leavecode = 0;
            OSCL_TRY(leavecode, iAvailableMetadataKeys.push_front(PVMFSTREAMINGMGRNODE_GRAPHICS_KEY);
                     iAvailableMetadataKeys[0] += indexparam;);
        }
        if (iMetaDataInfo.iRatingPresent)
        {
            leavecode = 0;
            OSCL_TRY(leavecode, iAvailableMetadataKeys.push_back(PVMFSTREAMINGMGRNODE_RATING_KEY));
        }
        if (iMetaDataInfo.iClassificationPresent)
        {
            leavecode = 0;
            OSCL_TRY(leavecode, iAvailableMetadataKeys.push_back(PVMFSTREAMINGMGRNODE_CLASSIFICATION_KEY));
        }
        if (iMetaDataInfo.iKeyWordsPresent)
        {
            leavecode = 0;
            OSCL_TRY(leavecode, iAvailableMetadataKeys.push_back(PVMFSTREAMINGMGRNODE_KEYWORDS_KEY));
        }
        if (iMetaDataInfo.iLocationPresent)
        {
            leavecode = 0;
            OSCL_TRY(leavecode, iAvailableMetadataKeys.push_back(PVMFSTREAMINGMGRNODE_LOCATION_KEY));
        }

        leavecode = 0;
        OSCL_TRY(leavecode, iAvailableMetadataKeys.push_back(PVMFSTREAMINGMGRNODE_RANDOM_ACCESS_DENIED_KEY));

        leavecode = 0;
        OSCL_TRY(leavecode, iAvailableMetadataKeys.push_back(PVMFSTREAMINGMGRNODE_CLIP_TYPE_KEY));

        if (iMetaDataInfo.iNumTracks > 0)
        {
            leavecode = 0;
            OSCL_TRY(leavecode, iAvailableMetadataKeys.push_back(PVMFSTREAMINGMGRNODE_NUMTRACKS_KEY));

            // Create the parameter string for the index range
            char indexparam[18];
            oscl_snprintf(indexparam, 18, ";index=0...%d", (iMetaDataInfo.iNumTracks - 1));
            indexparam[17] = NULL_TERM_CHAR;

            leavecode = 0;
            OSCL_TRY(leavecode,
                     iAvailableMetadataKeys.push_front(PVMFSTREAMINGMGRNODE_TRACKINFO_TYPE_KEY);
                     iAvailableMetadataKeys[0] += indexparam;);

            leavecode = 0;
            OSCL_TRY(leavecode,
                     iAvailableMetadataKeys.push_front(PVMFSTREAMINGMGRNODE_TRACKINFO_DURATION_KEY);
                     iAvailableMetadataKeys[0] += indexparam;);

            leavecode = 0;
            OSCL_TRY(leavecode,
                     iAvailableMetadataKeys.push_front(PVMFSTREAMINGMGRNODE_TRACKINFO_SELECTED_KEY);
                     iAvailableMetadataKeys[0] += indexparam;);

            leavecode = 0;
            OSCL_TRY(leavecode,
                     iAvailableMetadataKeys.push_front(PVMFSTREAMINGMGRNODE_TRACKINFO_CODEC_NAME_KEY);
                     iAvailableMetadataKeys[0] += indexparam;);

            leavecode = 0;
            OSCL_TRY(leavecode,
                     iAvailableMetadataKeys.push_front(PVMFSTREAMINGMGRNODE_TRACKINFO_CODEC_DESCRIPTION_KEY);
                     iAvailableMetadataKeys[0] += indexparam;);

            leavecode = 0;
            OSCL_TRY(leavecode,
                     iAvailableMetadataKeys.push_front(PVMFSTREAMINGMGRNODE_TRACKINFO_CODEC_DATA_KEY);
                     iAvailableMetadataKeys[0] += indexparam;);

            leavecode = 0;
            OSCL_TRY(leavecode,
                     iAvailableMetadataKeys.push_front(PVMFSTREAMINGMGRNODE_TRACKINFO_TRACKID_KEY);
                     iAvailableMetadataKeys[0] += indexparam;);

            if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
                    (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_REAL_HTTP_CLOAKING_URL) ||
                    (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE))
            {
                leavecode = 0;
                OSCL_TRY(leavecode,
                         iAvailableMetadataKeys.push_front(PVMFSTREAMINGMGRNODE_TRACKINFO_BITRATE_KEY);
                         iAvailableMetadataKeys[0] += indexparam;);
            }
        }

        uint32 i;
        for (i = 0; i < iMetaDataInfo.iExtendedMetaDataDescriptorCount; i++)
        {
            leavecode = 0;
            OSCL_TRY(leavecode, iAvailableMetadataKeys.push_back(iMetaDataInfo.iExtendedMetaDataNameVec[i]));
        }

        for (i = 0; i < iMetaDataInfo.iTrackMetaDataInfoVec.size(); i++)
        {
            PVMFSMTrackMetaDataInfo trackMetaDataInfo = iMetaDataInfo.iTrackMetaDataInfoVec[i];

            char indexparam[18];
            oscl_snprintf(indexparam, 18, ";index=%d", (i));
            indexparam[17] = NULL;

            if (trackMetaDataInfo.iTrackWidth > 0)
            {
                leavecode = 0;
                OSCL_TRY(leavecode,
                         iAvailableMetadataKeys.push_front(PVMFSTREAMINGMGRNODE_TRACKINFO_WIDTH_KEY);
                         iAvailableMetadataKeys[0] += indexparam;);
            }
            if (trackMetaDataInfo.iTrackHeight > 0)
            {
                leavecode = 0;
                OSCL_TRY(leavecode,
                         iAvailableMetadataKeys.push_front(PVMFSTREAMINGMGRNODE_TRACKINFO_HEIGHT_KEY);
                         iAvailableMetadataKeys[0] += indexparam;);
            }
            if (trackMetaDataInfo.iVideoFrameRate > 0)
            {
                leavecode = 0;
                OSCL_TRY(leavecode,
                         iAvailableMetadataKeys.push_front(PVMFSTREAMINGMGRNODE_TRACKINFO_FRAME_RATE_KEY);
                         iAvailableMetadataKeys[0] += indexparam;);
            }
            if (trackMetaDataInfo.iAudioSampleRate > 0)
            {
                leavecode = 0;
                OSCL_TRY(leavecode,
                         iAvailableMetadataKeys.push_front(PVMFSTREAMINGMGRNODE_TRACKINFO_SAMPLERATE_KEY);
                         iAvailableMetadataKeys[0] += indexparam;);
            }
            if (trackMetaDataInfo.iAudioNumChannels > 0)
            {
                leavecode = 0;
                OSCL_TRY(leavecode,
                         iAvailableMetadataKeys.push_front(PVMFSTREAMINGMGRNODE_TRACKINFO_NUMCHANNELS_KEY);
                         iAvailableMetadataKeys[0] += indexparam;);
            }
            if (trackMetaDataInfo.iAudioBitsPerSample > 0)
            {
                leavecode = 0;
                OSCL_TRY(leavecode,
                         iAvailableMetadataKeys.push_front(PVMFSTREAMINGMGRNODE_TRACKINFO_AUDIO_BITS_PER_SAMPLE_KEY);
                         iAvailableMetadataKeys[0] += indexparam;);
            }
        }
        return PVMFSuccess;
    }
}

PVMFStatus
PVMFStreamingManagerNode::DoGetMetadataKeys(PVMFStreamingManagerNodeCommand& aCmd)
{
    if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE))
    {
        SDPInfo* sdpInfo = iSessionSourceInfo->_sdpInfo.GetRep();
        if (sdpInfo == NULL)
        {
            return PVMFErrInvalidState;
        }
    }
    return (CompleteGetMetadataKeys(aCmd));
}

PVMFStatus
PVMFStreamingManagerNode::CompleteGetMetadataKeys(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMFMetadataList* keylistptr = NULL;
    uint32 starting_index;
    int32 max_entries;
    char* query_key = NULL;

    aCmd.PVMFStreamingManagerNodeCommand::Parse(keylistptr, starting_index, max_entries, query_key);

    // Check parameters
    if (keylistptr == NULL)
    {
        // The list pointer is invalid
        return PVMFErrArgument;
    }

    if ((starting_index > (iAvailableMetadataKeys.size() - 1)) || max_entries == 0)
    {
        // Invalid starting index and/or max entries
        return PVMFErrArgument;
    }

    // Copy the requested keys
    uint32 num_entries = 0;
    int32 num_added = 0;
    int32 leavecode = 0;
    uint32 lcv = 0;
    for (lcv = 0; lcv < iAvailableMetadataKeys.size(); lcv++)
    {
        if (query_key == NULL)
        {
            // No query key so this key is counted
            ++num_entries;
            if (num_entries > starting_index)
            {
                // Past the starting index so copy the key
                leavecode = 0;
                OSCL_TRY(leavecode, keylistptr->push_back(iAvailableMetadataKeys[lcv]));
                OSCL_FIRST_CATCH_ANY(leavecode,
                                     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFStreamingManagerNode::DoGetMetadataKeys() Memory allocation failure when copying metadata key"));
                                     return PVMFErrNoMemory);
                num_added++;
            }
        }
        else
        {
            // Check if the key matche the query key
            if (pv_mime_strcmp(iAvailableMetadataKeys[lcv].get_cstr(), query_key) >= 0)
            {
                // This key is counted
                ++num_entries;
                if (num_entries > starting_index)
                {
                    // Past the starting index so copy the key
                    leavecode = 0;
                    OSCL_TRY(leavecode, keylistptr->push_back(iAvailableMetadataKeys[lcv]));
                    OSCL_FIRST_CATCH_ANY(leavecode,
                                         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFStreamingManagerNode::DoGetMetadataKeys() Memory allocation failure when copying metadata key"));
                                         return PVMFErrNoMemory);
                    num_added++;
                }
            }
        }
    }
    for (lcv = 0; lcv < iCPMMetadataKeys.size(); lcv++)
    {
        if (query_key == NULL)
        {
            /* No query key so this key is counted */
            ++num_entries;
            if (num_entries > (uint32)starting_index)
            {
                /* Past the starting index so copy the key */
                leavecode = 0;
                OSCL_TRY(leavecode, keylistptr->push_back(iCPMMetadataKeys[lcv]));
                OSCL_FIRST_CATCH_ANY(leavecode,
                                     PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFStreamingManagerNode::CompleteGetMetadataKeys() Memory allocation failure when copying metadata key"));
                                     return PVMFErrNoMemory);
                num_added++;
            }
        }
        else
        {
            /* Check if the key matches the query key */
            if (pv_mime_strcmp(iCPMMetadataKeys[lcv].get_cstr(), query_key) >= 0)
            {
                /* This key is counted */
                ++num_entries;
                if (num_entries > (uint32)starting_index)
                {
                    /* Past the starting index so copy the key */
                    leavecode = 0;
                    OSCL_TRY(leavecode, keylistptr->push_back(iCPMMetadataKeys[lcv]));
                    OSCL_FIRST_CATCH_ANY(leavecode,
                                         PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFStreamingManagerNode::CompleteGetMetadataKeys() Memory allocation failure when copying metadata key"));
                                         return PVMFErrNoMemory);
                    num_added++;
                }
            }
        }
        // Check if max number of entries have been copied
        if (max_entries > 0 && num_added >= max_entries)
        {
            break;
        }
    }

    return PVMFSuccess;
}

PVMFStatus PVMFStreamingManagerNode::GetIndexParamValues(char* aString, uint32& aStartIndex, uint32& aEndIndex)
{
    // This parses a string of the form "index=N1...N2" and extracts the integers N1 and N2.
    // If string is of the format "index=N1" then N2=N1

    if (aString == NULL)
    {
        return PVMFErrArgument;
    }

    // Go to end of "index="
    char* n1string = aString + 6;

    PV_atoi(n1string, 'd', oscl_strlen(n1string), aStartIndex);

    char* n2string = oscl_strstr(aString, _STRLIT_CHAR("..."));

    if (n2string == NULL)
    {
        aEndIndex = aStartIndex;
    }
    else
    {
        // Go to end of "index=N1..."
        n2string += 3;

        PV_atoi(n2string, 'd', oscl_strlen(n2string), aEndIndex);
    }

    return PVMFSuccess;
}

PVMFStatus
PVMFStreamingManagerNode::DoGetMetadataValues(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVMFStreamingManagerNode::DoGetMetadataValues() In"));

    SDPInfo* sdpInfo = NULL;
    if ((iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTSP_URL) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_SDP_FILE) ||
            (iSessionSourceInfo->_sessionType == PVMF_DATA_SOURCE_RTP_PACKET_SOURCE))
    {
        sdpInfo = iSessionSourceInfo->_sdpInfo.GetRep();
        if (sdpInfo == NULL)
        {
            return PVMFErrInvalidState;
        }
    }
    PVMFMetadataList* keylistptr = NULL;
    Oscl_Vector<PvmiKvp, OsclMemAllocator>* valuelistptr = NULL;
    uint32 starting_index;
    int32 max_entries;

    aCmd.PVMFStreamingManagerNodeCommand::Parse(keylistptr, valuelistptr, starting_index, max_entries);

    // Check the parameters
    if (keylistptr == NULL || valuelistptr == NULL)
    {
        return PVMFErrArgument;
    }

    uint32 numkeys = keylistptr->size();

    if (starting_index > (numkeys - 1) || numkeys <= 0 || max_entries == 0)
    {
        // Don't do anything
        return PVMFErrArgument;
    }

    uint32 numvalentries = 0;
    int32 numentriesadded = 0;
    for (uint32 lcv = 0; lcv < numkeys; lcv++)
    {
        int32 leavecode = 0;
        PvmiKvp KeyVal;
        KeyVal.key = NULL;
        KeyVal.value.pWChar_value = NULL;
        KeyVal.value.pChar_value = NULL;

        if (oscl_strcmp((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_AUTHOR_KEY) == 0 &&
                iMetaDataInfo.iAuthorPresent)
        {
            // Author
            // Increment the counter for the number of values found so far
            ++numvalentries;

            // Create a value entry if past the starting index
            if (numvalentries > starting_index)
            {
                PVMFStatus retval;
                if (iMetaDataInfo.iIsAuthorUnicode == false)
                {
                    retval = CreateKVPForCharStringValue(KeyVal,
                                                         PVMFSTREAMINGMGRNODE_AUTHOR_KEY,
                                                         iMetaDataInfo.iAuthor.get_cstr());
                }
                else
                {
                    retval = CreateKVPForWideCharStringValue(KeyVal,
                             PVMFSTREAMINGMGRNODE_AUTHOR_KEY,
                             iMetaDataInfo.iAuthorUnicode.get_cstr());
                }
                if (retval != PVMFSuccess && retval != PVMFErrArgument)
                {
                    break;
                }
            }
        }
        else if (oscl_strcmp((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_ARTIST_KEY) == 0 &&
                 iMetaDataInfo.iPerformerPresent)
        {
            // Artist/performer
            // Increment the counter for the number of values found so far
            ++numvalentries;

            // Create a value entry if past the starting index
            if (numvalentries > starting_index)
            {
                PVMFStatus retval;
                if (iMetaDataInfo.iIsPerformerUnicode == false)
                {
                    retval = CreateKVPForCharStringValue(KeyVal,
                                                         PVMFSTREAMINGMGRNODE_ARTIST_KEY,
                                                         iMetaDataInfo.iPerformer.get_cstr());
                }
                else
                {
                    retval = CreateKVPForWideCharStringValue(KeyVal,
                             PVMFSTREAMINGMGRNODE_ARTIST_KEY,
                             iMetaDataInfo.iPerformerUnicode.get_cstr());
                }
                if (retval != PVMFSuccess && retval != PVMFErrArgument)
                {
                    break;
                }
            }
        }
        else if (oscl_strcmp((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TITLE_KEY) == 0 &&
                 iMetaDataInfo.iTitlePresent)
        {
            // Title
            // Increment the counter for the number of values found so far
            ++numvalentries;

            // Create a value entry if past the starting index
            if (numvalentries > starting_index)
            {
                PVMFStatus retval;
                if (iMetaDataInfo.iIsTitleUnicode == false)
                {
                    retval = CreateKVPForCharStringValue(KeyVal,
                                                         PVMFSTREAMINGMGRNODE_TITLE_KEY,
                                                         iMetaDataInfo.iTitle.get_cstr());
                }
                else
                {
                    retval = CreateKVPForWideCharStringValue(KeyVal,
                             PVMFSTREAMINGMGRNODE_TITLE_KEY,
                             iMetaDataInfo.iTitleUnicode.get_cstr());
                }
                if (retval != PVMFSuccess && retval != PVMFErrArgument)
                {
                    break;
                }
            }
        }
        else if (oscl_strcmp((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_DESCRIPTION_KEY) == 0 &&
                 iMetaDataInfo.iDescriptionPresent)
        {
            // Description
            // Increment the counter for the number of values found so far
            ++numvalentries;

            // Create a value entry if past the starting index
            if (numvalentries > starting_index)
            {
                PVMFStatus retval;
                if (iMetaDataInfo.iIsDescriptionUnicode == false)
                {
                    retval = CreateKVPForCharStringValue(KeyVal,
                                                         PVMFSTREAMINGMGRNODE_DESCRIPTION_KEY,
                                                         iMetaDataInfo.iDescription.get_cstr());
                }
                else
                {
                    retval = CreateKVPForWideCharStringValue(KeyVal,
                             PVMFSTREAMINGMGRNODE_DESCRIPTION_KEY,
                             iMetaDataInfo.iDescriptionUnicode.get_cstr());
                }
                if (retval != PVMFSuccess && retval != PVMFErrArgument)
                {
                    break;
                }
            }
        }
        else if (oscl_strcmp((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_RATING_KEY) == 0 &&
                 iMetaDataInfo.iRatingPresent)
        {
            // Rating
            // Increment the counter for the number of values found so far
            ++numvalentries;

            // Create a value entry if past the starting index
            if (numvalentries > starting_index)
            {
                PVMFStatus retval;
                if (iMetaDataInfo.iIsRatingUnicode == false)
                {
                    retval = CreateKVPForCharStringValue(KeyVal,
                                                         PVMFSTREAMINGMGRNODE_RATING_KEY,
                                                         iMetaDataInfo.iRating.get_cstr());
                }
                else
                {
                    retval = CreateKVPForWideCharStringValue(KeyVal,
                             PVMFSTREAMINGMGRNODE_RATING_KEY,
                             iMetaDataInfo.iRatingUnicode.get_cstr());
                }
                if (retval != PVMFSuccess && retval != PVMFErrArgument)
                {
                    break;
                }
            }
        }
        else if (oscl_strcmp((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_COPYRIGHT_KEY) == 0 &&
                 iMetaDataInfo.iCopyRightPresent)
        {
            // Copyright
            // Increment the counter for the number of values found so far
            ++numvalentries;

            // Create a value entry if past the starting index
            if (numvalentries > starting_index)
            {
                PVMFStatus retval;
                if (iMetaDataInfo.iIsCopyRightUnicode == false)
                {
                    retval = CreateKVPForCharStringValue(KeyVal,
                                                         PVMFSTREAMINGMGRNODE_COPYRIGHT_KEY,
                                                         iMetaDataInfo.iCopyright.get_cstr());
                }
                else
                {
                    retval = CreateKVPForWideCharStringValue(KeyVal,
                             PVMFSTREAMINGMGRNODE_COPYRIGHT_KEY,
                             iMetaDataInfo.iCopyrightUnicode.get_cstr());
                }
                if (retval != PVMFSuccess && retval != PVMFErrArgument)
                {
                    break;
                }
            }
        }
        else if (oscl_strcmp((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_GENRE_KEY) == 0 &&
                 iMetaDataInfo.iGenrePresent)
        {
            // Genre
            // Increment the counter for the number of values found so far
            ++numvalentries;

            // Create a value entry if past the starting index
            if (numvalentries > starting_index)
            {
                PVMFStatus retval;
                if (iMetaDataInfo.iIsGenreUnicode == false)
                {
                    retval = CreateKVPForCharStringValue(KeyVal,
                                                         PVMFSTREAMINGMGRNODE_GENRE_KEY,
                                                         iMetaDataInfo.iGenre.get_cstr());
                }
                else
                {
                    retval = CreateKVPForWideCharStringValue(KeyVal,
                             PVMFSTREAMINGMGRNODE_GENRE_KEY,
                             iMetaDataInfo.iGenreUnicode.get_cstr());
                }
                if (retval != PVMFSuccess && retval != PVMFErrArgument)
                {
                    break;
                }
            }
        }
        else if (oscl_strcmp((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_LYRICS_KEY) == 0 &&
                 iMetaDataInfo.iLyricsPresent)
        {
            // Lyrics
            // Increment the counter for the number of values found so far
            ++numvalentries;

            // Create a value entry if past the starting index
            if (numvalentries > starting_index)
            {
                PVMFStatus retval;
                if (iMetaDataInfo.iIsLyricsUnicode == false)
                {
                    retval = CreateKVPForCharStringValue(KeyVal,
                                                         PVMFSTREAMINGMGRNODE_LYRICS_KEY,
                                                         iMetaDataInfo.iLyrics.get_cstr());
                }
                else
                {
                    retval = CreateKVPForWideCharStringValue(KeyVal,
                             PVMFSTREAMINGMGRNODE_LYRICS_KEY,
                             iMetaDataInfo.iLyricsUnicode.get_cstr());
                }
                if (retval != PVMFSuccess && retval != PVMFErrArgument)
                {
                    break;
                }
            }
        }
        else if (oscl_strcmp((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_NUM_GRAPHICS_KEY) == 0 &&
                 iMetaDataInfo.iWMPicturePresent)
        {
            /*
             * Num Picture
             * Increment the counter for the number of values found so far
             */
            ++numvalentries;

            /* Create a value entry if past the starting index */
            if (numvalentries > (uint32)starting_index)
            {
                PVMFStatus retval =
                    PVMFCreateKVPUtils::CreateKVPForUInt32Value(KeyVal,
                            PVMFSTREAMINGMGRNODE_NUM_GRAPHICS_KEY,
                            iMetaDataInfo.iNumWMPicture,
                            NULL);
                if (retval != PVMFSuccess && retval != PVMFErrArgument)
                {
                    break;
                }
            }
        }
        else if (oscl_strcmp((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_CLASSIFICATION_KEY) == 0 &&
                 iMetaDataInfo.iClassificationPresent)
        {
            // Classification
            // Increment the counter for the number of values found so far
            ++numvalentries;

            // Create a value entry if past the starting index
            if (numvalentries > starting_index)
            {
                PVMFStatus retval;
                if (iMetaDataInfo.iIsClassificationUnicode == false)
                {
                    retval = CreateKVPForCharStringValue(KeyVal,
                                                         PVMFSTREAMINGMGRNODE_CLASSIFICATION_KEY,
                                                         iMetaDataInfo.iClassification.get_cstr());
                }
                else
                {
                    retval = CreateKVPForWideCharStringValue(KeyVal,
                             PVMFSTREAMINGMGRNODE_CLASSIFICATION_KEY,
                             iMetaDataInfo.iClassificationUnicode.get_cstr());
                }
                if (retval != PVMFSuccess && retval != PVMFErrArgument)
                {
                    break;
                }
            }
        }
        else if (oscl_strcmp((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_KEYWORDS_KEY) == 0 &&
                 iMetaDataInfo.iKeyWordsPresent)
        {
            // Keywords
            // Increment the counter for the number of values found so far
            ++numvalentries;

            // Create a value entry if past the starting index
            if (numvalentries > starting_index)
            {
                PVMFStatus retval;
                if (iMetaDataInfo.iIsKeyWordsUnicode == false)
                {
                    retval = CreateKVPForCharStringValue(KeyVal,
                                                         PVMFSTREAMINGMGRNODE_KEYWORDS_KEY,
                                                         iMetaDataInfo.iKeyWords.get_cstr());
                }
                else
                {
                    retval = CreateKVPForWideCharStringValue(KeyVal,
                             PVMFSTREAMINGMGRNODE_KEYWORDS_KEY,
                             iMetaDataInfo.iKeyWordUnicode.get_cstr());
                }
                if (retval != PVMFSuccess && retval != PVMFErrArgument)
                {
                    break;
                }
            }
        }
        else if (oscl_strcmp((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_LOCATION_KEY) == 0 &&
                 iMetaDataInfo.iLocationPresent)
        {
            // Location
            // Increment the counter for the number of values found so far
            ++numvalentries;

            // Create a value entry if past the starting index
            if (numvalentries > starting_index)
            {
                PVMFStatus retval;
                if (iMetaDataInfo.iIsLocationUnicode == false)
                {
                    retval = CreateKVPForCharStringValue(KeyVal,
                                                         PVMFSTREAMINGMGRNODE_LOCATION_KEY,
                                                         iMetaDataInfo.iLocation.get_cstr());
                }
                else
                {
                    retval = CreateKVPForWideCharStringValue(KeyVal,
                             PVMFSTREAMINGMGRNODE_LOCATION_KEY,
                             iMetaDataInfo.iLocationUnicode.get_cstr());
                }
                if (retval != PVMFSuccess && retval != PVMFErrArgument)
                {
                    break;
                }
            }
        }
        else if (oscl_strcmp((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_DURATION_KEY) == 0)
        {
            // Session Duration
            // Increment the counter for the number of values found so far
            ++numvalentries;

            // Create a value entry if past the starting index
            if (numvalentries > starting_index)
            {
                if (iMetaDataInfo.iSessionDurationAvailable == true)
                {
                    uint32 duration = Oscl_Int64_Utils::get_uint64_lower32(iMetaDataInfo.iSessionDuration);
                    char timescalestr[20];
                    oscl_snprintf(timescalestr, 20, ";%s%d", PVMFSTREAMINGMGRNODE_TIMESCALE, iMetaDataInfo.iSessionDurationTimeScale);
                    timescalestr[19] = NULL_TERM_CHAR;
                    PVMFStatus retval = CreateKVPForUInt32Value(KeyVal,
                                        PVMFSTREAMINGMGRNODE_DURATION_KEY,
                                        duration,
                                        timescalestr);
                    if (retval != PVMFSuccess && retval != PVMFErrArgument)
                    {
                        break;
                    }
                }
                else
                {
                    OSCL_StackString<32> unknownDuration(_STRLIT_CHAR("unknown"));
                    PVMFStatus retval = CreateKVPForCharStringValue(KeyVal,
                                        PVMFSTREAMINGMGRNODE_DURATION_KEY,
                                        unknownDuration.get_cstr());
                    if (retval != PVMFSuccess && retval != PVMFErrArgument)
                    {
                        break;
                    }
                }
            }
        }
        else if (oscl_strcmp((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_NUMTRACKS_KEY) == 0 &&
                 iMetaDataInfo.iNumTracks > 0)
        {
            // Number of tracks
            // Increment the counter for the number of values found so far
            ++numvalentries;

            // Create a value entry if past the starting index
            if (numvalentries > starting_index)
            {
                PVMFStatus retval = CreateKVPForUInt32Value(KeyVal,
                                    PVMFSTREAMINGMGRNODE_NUMTRACKS_KEY,
                                    iMetaDataInfo.iNumTracks);
                if (retval != PVMFSuccess && retval != PVMFErrArgument)
                {
                    break;
                }
            }
        }
        else if (oscl_strcmp((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_RANDOM_ACCESS_DENIED_KEY) == 0)
        {
            // random access
            // Increment the counter for the number of values found so far
            ++numvalentries;

            // Create a value entry if past the starting index
            if (numvalentries > starting_index)
            {
                PVMFStatus retval = CreateKVPForBoolValue(KeyVal,
                                    PVMFSTREAMINGMGRNODE_RANDOM_ACCESS_DENIED_KEY,
                                    iMetaDataInfo.iRandomAccessDenied);
                if (retval != PVMFSuccess && retval != PVMFErrArgument)
                {
                    break;
                }
            }
        }
        else if (oscl_strcmp((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_CLIP_TYPE_KEY) == 0)
        {
            /*
             * Clip Type
             * Increment the counter for the number of values found so far
             */
            ++numvalentries;

            /* Create a value entry if past the starting index */
            if (numvalentries > (uint32)starting_index)
            {
                uint32 len = 0;
                char* clipType = NULL;
                len = oscl_strlen("streaming");
                clipType = OSCL_ARRAY_NEW(char, len + 1);
                oscl_memset(clipType, 0, len + 1);
                oscl_strncpy(clipType, ("streaming"), len);
                PVMFStatus retval =
                    PVMFCreateKVPUtils::CreateKVPForCharStringValue(KeyVal,
                            PVMFSTREAMINGMGRNODE_CLIP_TYPE_KEY,
                            clipType);

                OSCL_ARRAY_DELETE(clipType);
                if (retval != PVMFSuccess && retval != PVMFErrArgument)
                {
                    break;
                }

            }
        }
        else if (oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_TYPE_KEY) != NULL)
        {
            // Track type

            // Determine the index requested. Default to all tracks
            uint32 startindex = 0;
            uint32 endindex   = iMetaDataInfo.iNumTracks - 1;
            // Check if the index parameter is present
            char* indexstr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                // Retrieve the index values
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            // Validate the indices
            if (startindex > endindex || startindex >= iMetaDataInfo.iNumTracks || endindex >= iMetaDataInfo.iNumTracks)
            {
                continue;
            }

            // Return a KVP for each index
            for (uint32 i = startindex; i <= endindex; ++i)
            {
                if (i < iMetaDataInfo.iTrackMetaDataInfoVec.size())
                {
                    PVMFSMTrackMetaDataInfo trackMetaDataInfo = iMetaDataInfo.iTrackMetaDataInfoVec[i];

                    PvmiKvp trackkvp;
                    trackkvp.key = NULL;
                    trackkvp.value.pChar_value = NULL;

                    // Increment the counter for the number of values found so far
                    ++numvalentries;
                    // Add the value entry if past the starting index
                    PVMFStatus retval = PVMFErrArgument;
                    if (numvalentries > starting_index)
                    {
                        char indexparam[16];
                        oscl_snprintf(indexparam, 16, ";%s%d", PVMFSTREAMINGMGRNODE_INDEX, i);
                        indexparam[15] = NULL_TERM_CHAR;

                        const char* mimeType = trackMetaDataInfo.iMimeType.get_cstr();
                        retval = CreateKVPForCharStringValue(trackkvp,
                                                             PVMFSTREAMINGMGRNODE_TRACKINFO_TYPE_KEY,
                                                             mimeType,
                                                             indexparam);
                    }

                    if (retval != PVMFSuccess && retval != PVMFErrArgument)
                    {
                        break;
                    }

                    if (trackkvp.key != NULL)
                    {
                        leavecode = 0;
                        OSCL_TRY(leavecode, (*valuelistptr).push_back(trackkvp));
                        if (leavecode != 0)
                        {
                            if (trackkvp.value.pChar_value != NULL)
                            {
                                OSCL_ARRAY_DELETE(trackkvp.value.pChar_value);
                                trackkvp.value.pChar_value = NULL;
                            }

                            OSCL_ARRAY_DELETE(trackkvp.key);
                            trackkvp.key = NULL;
                        }
                        else
                        {
                            // Increment the value list entry counter
                            ++numentriesadded;
                        }

                        // Check if the max number of value entries were added
                        if (max_entries > 0 && numentriesadded >= max_entries)
                        {
                            iPVMFStreamingManagerNodeMetadataValueCount = (*valuelistptr).size();
                            return PVMFSuccess;
                        }
                    }
                }
            }
        }
        else if (oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_DURATION_KEY) != NULL)
        {
            // Track duration

            // Determine the index requested. Default to all tracks
            uint32 startindex = 0;
            uint32 endindex = iMetaDataInfo.iNumTracks - 1;
            // Check if the index parameter is present
            char* indexstr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                // Retrieve the index values
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            // Validate the indices
            if (startindex > endindex || startindex >= iMetaDataInfo.iNumTracks || endindex >= iMetaDataInfo.iNumTracks)
            {
                continue;
            }

            // Return a KVP for each index
            for (uint32 i = startindex; i <= endindex; ++i)
            {
                if (i < iMetaDataInfo.iTrackMetaDataInfoVec.size())
                {
                    PVMFSMTrackMetaDataInfo trackMetaDataInfo = iMetaDataInfo.iTrackMetaDataInfoVec[i];

                    PvmiKvp trackkvp;
                    trackkvp.key = NULL;

                    // Increment the counter for the number of values found so far
                    ++numvalentries;
                    // Add the value entry if past the starting index
                    PVMFStatus retval = PVMFErrArgument;
                    if (numvalentries > starting_index)
                    {
                        if (trackMetaDataInfo.iTrackDurationAvailable == true)
                        {
                            char indextimescaleparam[36];
                            oscl_snprintf(indextimescaleparam, 36, ";%s%d;%s%d", PVMFSTREAMINGMGRNODE_INDEX, i, PVMFSTREAMINGMGRNODE_TIMESCALE, trackMetaDataInfo.iTrackDurationTimeScale);
                            indextimescaleparam[35] = NULL_TERM_CHAR;

                            uint32 trackduration =
                                Oscl_Int64_Utils::get_uint64_lower32(trackMetaDataInfo.iTrackDuration);
                            retval = CreateKVPForUInt32Value(trackkvp,
                                                             PVMFSTREAMINGMGRNODE_TRACKINFO_DURATION_KEY,
                                                             trackduration,
                                                             indextimescaleparam);
                        }
                        else
                        {
                            char indextimescaleparam[36];
                            oscl_snprintf(indextimescaleparam, 36, ";%s%d", PVMFSTREAMINGMGRNODE_INDEX, i);
                            indextimescaleparam[35] = NULL_TERM_CHAR;

                            OSCL_StackString<32> unknownDuration(_STRLIT_CHAR("unknown"));
                            PVMFStatus retval = CreateKVPForCharStringValue(trackkvp,
                                                PVMFSTREAMINGMGRNODE_TRACKINFO_DURATION_KEY,
                                                unknownDuration.get_cstr(),
                                                indextimescaleparam);
                            if (retval != PVMFSuccess && retval != PVMFErrArgument)
                            {
                                break;
                            }
                        }

                    }

                    if (retval != PVMFSuccess && retval != PVMFErrArgument)
                    {
                        break;
                    }

                    if (trackkvp.key != NULL)
                    {
                        leavecode = 0;
                        OSCL_TRY(leavecode, (*valuelistptr).push_back(trackkvp));
                        if (leavecode != 0)
                        {
                            OSCL_ARRAY_DELETE(trackkvp.key);
                            trackkvp.key = NULL;
                        }
                        else
                        {
                            // Increment the value list entry counter
                            ++numentriesadded;
                        }

                        // Check if the max number of value entries were added
                        if (max_entries > 0 && numentriesadded >= max_entries)
                        {
                            iPVMFStreamingManagerNodeMetadataValueCount = (*valuelistptr).size();
                            return PVMFSuccess;
                        }
                    }
                }
            }
        }
        else if (oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_BITRATE_KEY) != NULL)
        {
            // Track bitrate

            // Determine the index requested. Default to all tracks
            uint32 startindex = 0;
            uint32 endindex = iMetaDataInfo.iNumTracks - 1;
            // Check if the index parameter is present
            char* indexstr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                // Retrieve the index values
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            // Validate the indices
            if (startindex > endindex || startindex >= iMetaDataInfo.iNumTracks || endindex >= iMetaDataInfo.iNumTracks)
            {
                continue;
            }

            // Return a KVP for each index
            for (uint32 i = startindex; i <= endindex; ++i)
            {
                if (i < iMetaDataInfo.iTrackMetaDataInfoVec.size())
                {
                    PVMFSMTrackMetaDataInfo trackMetaDataInfo = iMetaDataInfo.iTrackMetaDataInfoVec[i];

                    PvmiKvp trackkvp;
                    trackkvp.key = NULL;

                    // Increment the counter for the number of values found so far
                    ++numvalentries;
                    // Add the value entry if past the starting index
                    PVMFStatus retval = PVMFErrArgument;
                    if (numvalentries > starting_index)
                    {
                        char indexparam[16];
                        oscl_snprintf(indexparam, 16, ";%s%d", PVMFSTREAMINGMGRNODE_INDEX, i);
                        indexparam[15] = NULL_TERM_CHAR;

                        uint32 trackbitrate = trackMetaDataInfo.iTrackBitRate;
                        retval = CreateKVPForUInt32Value(trackkvp,
                                                         PVMFSTREAMINGMGRNODE_TRACKINFO_BITRATE_KEY,
                                                         trackbitrate,
                                                         indexparam);
                    }

                    if (retval != PVMFSuccess && retval != PVMFErrArgument)
                    {
                        break;
                    }

                    if (trackkvp.key != NULL)
                    {
                        leavecode = 0;
                        OSCL_TRY(leavecode, (*valuelistptr).push_back(trackkvp));
                        if (leavecode != 0)
                        {
                            OSCL_ARRAY_DELETE(trackkvp.key);
                            trackkvp.key = NULL;
                        }
                        else
                        {
                            // Increment the value list entry counter
                            ++numentriesadded;
                        }

                        // Check if the max number of value entries were added
                        if (max_entries > 0 && numentriesadded >= max_entries)
                        {
                            iPVMFStreamingManagerNodeMetadataValueCount = (*valuelistptr).size();
                            return PVMFSuccess;
                        }
                    }
                }
            }
        }
        else if (oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_MAX_BITRATE_KEY) != NULL)
        {
            // Track bitrate

            // Determine the index requested. Default to all tracks
            uint32 startindex = 0;
            uint32 endindex = iMetaDataInfo.iNumTracks - 1;
            // Check if the index parameter is present
            char* indexstr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                // Retrieve the index values
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            // Validate the indices
            if (startindex > endindex || startindex >= iMetaDataInfo.iNumTracks || endindex >= iMetaDataInfo.iNumTracks)
            {
                continue;
            }

            // Return a KVP for each index
            for (uint32 i = startindex; i <= endindex; ++i)
            {
                if (i < iMetaDataInfo.iTrackMetaDataInfoVec.size())
                {
                    PVMFSMTrackMetaDataInfo trackMetaDataInfo = iMetaDataInfo.iTrackMetaDataInfoVec[i];

                    PvmiKvp trackkvp;
                    trackkvp.key = NULL;

                    // Increment the counter for the number of values found so far
                    ++numvalentries;
                    // Add the value entry if past the starting index
                    PVMFStatus retval = PVMFErrArgument;
                    if (numvalentries > starting_index)
                    {
                        char indexparam[16];
                        oscl_snprintf(indexparam, 16, ";%s%d", PVMFSTREAMINGMGRNODE_INDEX, i);
                        indexparam[15] = NULL_TERM_CHAR;

                        uint32 trackbitrate = trackMetaDataInfo.iTrackMaxBitRate;
                        retval = CreateKVPForUInt32Value(trackkvp,
                                                         PVMFSTREAMINGMGRNODE_TRACKINFO_MAX_BITRATE_KEY,
                                                         trackbitrate,
                                                         indexparam);
                    }

                    if (retval != PVMFSuccess && retval != PVMFErrArgument)
                    {
                        break;
                    }

                    if (trackkvp.key != NULL)
                    {
                        leavecode = 0;
                        OSCL_TRY(leavecode, (*valuelistptr).push_back(trackkvp));
                        if (leavecode != 0)
                        {
                            OSCL_ARRAY_DELETE(trackkvp.key);
                            trackkvp.key = NULL;
                        }
                        else
                        {
                            // Increment the value list entry counter
                            ++numentriesadded;
                        }

                        // Check if the max number of value entries were added
                        if (max_entries > 0 && numentriesadded >= max_entries)
                        {
                            iPVMFStreamingManagerNodeMetadataValueCount = (*valuelistptr).size();
                            return PVMFSuccess;
                        }
                    }
                }
            }
        }
        else if (oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_SELECTED_KEY) != NULL)
        {
            // Track bitrate

            // Determine the index requested. Default to all tracks
            uint32 startindex = 0;
            uint32 endindex = iMetaDataInfo.iNumTracks - 1;
            // Check if the index parameter is present
            char* indexstr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                // Retrieve the index values
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            // Validate the indices
            if (startindex > endindex || startindex >= iMetaDataInfo.iNumTracks || endindex >= iMetaDataInfo.iNumTracks)
            {
                continue;
            }

            // Return a KVP for each index
            for (uint32 i = startindex; i <= endindex; ++i)
            {
                if (i < iMetaDataInfo.iTrackMetaDataInfoVec.size())
                {
                    PVMFSMTrackMetaDataInfo trackMetaDataInfo = iMetaDataInfo.iTrackMetaDataInfoVec[i];

                    PvmiKvp trackkvp;
                    trackkvp.key = NULL;

                    // Increment the counter for the number of values found so far
                    ++numvalentries;
                    // Add the value entry if past the starting index
                    PVMFStatus retval = PVMFErrArgument;
                    if (numvalentries > starting_index)
                    {
                        char indexparam[16];
                        oscl_snprintf(indexparam, 16, ";%s%d", PVMFSTREAMINGMGRNODE_INDEX, i);

                        indexparam[15] = NULL_TERM_CHAR;

                        bool selected = trackMetaDataInfo.iTrackSelected;
                        retval = CreateKVPForBoolValue(trackkvp,
                                                       PVMFSTREAMINGMGRNODE_TRACKINFO_SELECTED_KEY,
                                                       selected,
                                                       indexparam);
                    }

                    if (retval != PVMFSuccess && retval != PVMFErrArgument)
                    {
                        break;
                    }

                    if (trackkvp.key != NULL)
                    {
                        leavecode = 0;
                        OSCL_TRY(leavecode, (*valuelistptr).push_back(trackkvp));
                        if (leavecode != 0)
                        {
                            OSCL_ARRAY_DELETE(trackkvp.key);
                            trackkvp.key = NULL;
                        }
                        else
                        {
                            // Increment the value list entry counter
                            ++numentriesadded;
                        }

                        // Check if the max number of value entries were added
                        if (max_entries > 0 && numentriesadded >= max_entries)
                        {
                            iPVMFStreamingManagerNodeMetadataValueCount = (*valuelistptr).size();
                            return PVMFSuccess;
                        }
                    }
                }
            }
        }
        else if (oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_WIDTH_KEY) != NULL)
        {
            // Determine the index requested. Default to all tracks
            uint32 startindex = 0;
            uint32 endindex = iMetaDataInfo.iNumTracks - 1;
            // Check if the index parameter is present
            char* indexstr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                // Retrieve the index values
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            // Validate the indices
            if (startindex > endindex || startindex >= iMetaDataInfo.iNumTracks || endindex >= iMetaDataInfo.iNumTracks)
            {
                continue;
            }

            // Return a KVP for each index
            for (uint32 i = startindex; i <= endindex; ++i)
            {
                if (i < iMetaDataInfo.iTrackMetaDataInfoVec.size())
                {
                    PVMFSMTrackMetaDataInfo trackMetaDataInfo = iMetaDataInfo.iTrackMetaDataInfoVec[i];

                    PvmiKvp trackkvp;
                    trackkvp.key = NULL;

                    // Increment the counter for the number of values found so far
                    ++numvalentries;
                    // Add the value entry if past the starting index
                    PVMFStatus retval = PVMFErrArgument;
                    if (numvalentries > starting_index)
                    {
                        char indexparam[16];
                        oscl_snprintf(indexparam, 16, ";%s%d", PVMFSTREAMINGMGRNODE_INDEX, i);
                        indexparam[15] = NULL;

                        retval = CreateKVPForUInt32Value(trackkvp,
                                                         PVMFSTREAMINGMGRNODE_TRACKINFO_WIDTH_KEY,
                                                         trackMetaDataInfo.iTrackWidth,
                                                         indexparam);
                    }

                    if (retval != PVMFSuccess && retval != PVMFErrArgument)
                    {
                        break;
                    }

                    if (trackkvp.key != NULL)
                    {
                        leavecode = 0;
                        OSCL_TRY(leavecode, (*valuelistptr).push_back(trackkvp));
                        if (leavecode != 0)
                        {
                            OSCL_ARRAY_DELETE(trackkvp.key);
                            trackkvp.key = NULL;
                        }
                        else
                        {
                            // Increment the value list entry counter
                            ++numentriesadded;
                        }

                        // Check if the max number of value entries were added
                        if (max_entries > 0 && numentriesadded >= max_entries)
                        {
                            iPVMFStreamingManagerNodeMetadataValueCount = (*valuelistptr).size();
                            return PVMFSuccess;
                        }
                    }
                }
            }
        }
        else if (oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_HEIGHT_KEY) != NULL)
        {
            // Determine the index requested. Default to all tracks
            uint32 startindex = 0;
            uint32 endindex = iMetaDataInfo.iNumTracks - 1;
            // Check if the index parameter is present
            char* indexstr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                // Retrieve the index values
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            // Validate the indices
            if (startindex > endindex || startindex >= iMetaDataInfo.iNumTracks || endindex >= iMetaDataInfo.iNumTracks)
            {
                continue;
            }

            // Return a KVP for each index
            for (uint32 i = startindex; i <= endindex; ++i)
            {
                if (i < iMetaDataInfo.iTrackMetaDataInfoVec.size())
                {
                    PVMFSMTrackMetaDataInfo trackMetaDataInfo = iMetaDataInfo.iTrackMetaDataInfoVec[i];

                    PvmiKvp trackkvp;
                    trackkvp.key = NULL;

                    // Increment the counter for the number of values found so far
                    ++numvalentries;
                    // Add the value entry if past the starting index
                    PVMFStatus retval = PVMFErrArgument;
                    if (numvalentries > starting_index)
                    {
                        char indexparam[16];
                        oscl_snprintf(indexparam, 16, ";%s%d", PVMFSTREAMINGMGRNODE_INDEX, i);
                        indexparam[15] = NULL;

                        retval = CreateKVPForUInt32Value(trackkvp,
                                                         PVMFSTREAMINGMGRNODE_TRACKINFO_HEIGHT_KEY,
                                                         trackMetaDataInfo.iTrackHeight,
                                                         indexparam);
                    }

                    if (retval != PVMFSuccess && retval != PVMFErrArgument)
                    {
                        break;
                    }

                    if (trackkvp.key != NULL)
                    {
                        leavecode = 0;
                        OSCL_TRY(leavecode, (*valuelistptr).push_back(trackkvp));
                        if (leavecode != 0)
                        {
                            OSCL_ARRAY_DELETE(trackkvp.key);
                            trackkvp.key = NULL;
                        }
                        else
                        {
                            // Increment the value list entry counter
                            ++numentriesadded;
                        }

                        // Check if the max number of value entries were added
                        if (max_entries > 0 && numentriesadded >= max_entries)
                        {
                            iPVMFStreamingManagerNodeMetadataValueCount = (*valuelistptr).size();
                            return PVMFSuccess;
                        }
                    }
                }
            }
        }
        else if (oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_FRAME_RATE_KEY) != NULL)
        {
            // Determine the index requested. Default to all tracks
            uint32 startindex = 0;
            uint32 endindex = iMetaDataInfo.iNumTracks - 1;
            // Check if the index parameter is present
            char* indexstr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                // Retrieve the index values
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            // Validate the indices
            if (startindex > endindex || startindex >= iMetaDataInfo.iNumTracks || endindex >= iMetaDataInfo.iNumTracks)
            {
                continue;
            }

            // Return a KVP for each index
            for (uint32 i = startindex; i <= endindex; ++i)
            {
                if (i < iMetaDataInfo.iTrackMetaDataInfoVec.size())
                {
                    PVMFSMTrackMetaDataInfo trackMetaDataInfo = iMetaDataInfo.iTrackMetaDataInfoVec[i];

                    PvmiKvp trackkvp;
                    trackkvp.key = NULL;

                    // Increment the counter for the number of values found so far
                    ++numvalentries;
                    // Add the value entry if past the starting index
                    PVMFStatus retval = PVMFErrArgument;
                    if (numvalentries > starting_index)
                    {
                        char indexparam[16];
                        oscl_snprintf(indexparam, 16, ";%s%d", PVMFSTREAMINGMGRNODE_INDEX, i);
                        indexparam[15] = NULL;

                        retval = CreateKVPForUInt32Value(trackkvp,
                                                         PVMFSTREAMINGMGRNODE_TRACKINFO_FRAME_RATE_KEY,
                                                         trackMetaDataInfo.iVideoFrameRate,
                                                         indexparam);
                    }

                    if (retval != PVMFSuccess && retval != PVMFErrArgument)
                    {
                        break;
                    }

                    if (trackkvp.key != NULL)
                    {
                        leavecode = 0;
                        OSCL_TRY(leavecode, (*valuelistptr).push_back(trackkvp));
                        if (leavecode != 0)
                        {
                            OSCL_ARRAY_DELETE(trackkvp.key);
                            trackkvp.key = NULL;
                        }
                        else
                        {
                            // Increment the value list entry counter
                            ++numentriesadded;
                        }

                        // Check if the max number of value entries were added
                        if (max_entries > 0 && numentriesadded >= max_entries)
                        {
                            iPVMFStreamingManagerNodeMetadataValueCount = (*valuelistptr).size();
                            return PVMFSuccess;
                        }
                    }
                }
            }
        }
        else if (oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_SAMPLERATE_KEY) != NULL)
        {
            // Determine the index requested. Default to all tracks
            uint32 startindex = 0;
            uint32 endindex = iMetaDataInfo.iNumTracks - 1;
            // Check if the index parameter is present
            char* indexstr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                // Retrieve the index values
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            // Validate the indices
            if (startindex > endindex || startindex >= iMetaDataInfo.iNumTracks || endindex >= iMetaDataInfo.iNumTracks)
            {
                continue;
            }

            // Return a KVP for each index
            for (uint32 i = startindex; i <= endindex; ++i)
            {
                if (i < iMetaDataInfo.iTrackMetaDataInfoVec.size())
                {
                    PVMFSMTrackMetaDataInfo trackMetaDataInfo = iMetaDataInfo.iTrackMetaDataInfoVec[i];

                    PvmiKvp trackkvp;
                    trackkvp.key = NULL;

                    // Increment the counter for the number of values found so far
                    ++numvalentries;
                    // Add the value entry if past the starting index
                    PVMFStatus retval = PVMFErrArgument;
                    if (numvalentries > starting_index)
                    {
                        char indexparam[16];
                        oscl_snprintf(indexparam, 16, ";%s%d", PVMFSTREAMINGMGRNODE_INDEX, i);
                        indexparam[15] = NULL;

                        retval = CreateKVPForUInt32Value(trackkvp,
                                                         PVMFSTREAMINGMGRNODE_TRACKINFO_SAMPLERATE_KEY,
                                                         trackMetaDataInfo.iAudioSampleRate,
                                                         indexparam);
                    }

                    if (retval != PVMFSuccess && retval != PVMFErrArgument)
                    {
                        break;
                    }

                    if (trackkvp.key != NULL)
                    {
                        leavecode = 0;
                        OSCL_TRY(leavecode, (*valuelistptr).push_back(trackkvp));
                        if (leavecode != 0)
                        {
                            OSCL_ARRAY_DELETE(trackkvp.key);
                            trackkvp.key = NULL;
                        }
                        else
                        {
                            // Increment the value list entry counter
                            ++numentriesadded;
                        }

                        // Check if the max number of value entries were added
                        if (max_entries > 0 && numentriesadded >= max_entries)
                        {
                            iPVMFStreamingManagerNodeMetadataValueCount = (*valuelistptr).size();
                            return PVMFSuccess;
                        }
                    }
                }
            }
        }
        else if (oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_NUMCHANNELS_KEY) != NULL)
        {
            // Determine the index requested. Default to all tracks
            uint32 startindex = 0;
            uint32 endindex = iMetaDataInfo.iNumTracks - 1;
            // Check if the index parameter is present
            char* indexstr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                // Retrieve the index values
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            // Validate the indices
            if (startindex > endindex || startindex >= iMetaDataInfo.iNumTracks || endindex >= iMetaDataInfo.iNumTracks)
            {
                continue;
            }

            // Return a KVP for each index
            for (uint32 i = startindex; i <= endindex; ++i)
            {
                if (i < iMetaDataInfo.iTrackMetaDataInfoVec.size())
                {
                    PVMFSMTrackMetaDataInfo trackMetaDataInfo = iMetaDataInfo.iTrackMetaDataInfoVec[i];

                    PvmiKvp trackkvp;
                    trackkvp.key = NULL;

                    // Increment the counter for the number of values found so far
                    ++numvalentries;
                    // Add the value entry if past the starting index
                    PVMFStatus retval = PVMFErrArgument;
                    if (numvalentries > starting_index)
                    {
                        char indexparam[16];
                        oscl_snprintf(indexparam, 16, ";%s%d", PVMFSTREAMINGMGRNODE_INDEX, i);
                        indexparam[15] = NULL;

                        retval = CreateKVPForUInt32Value(trackkvp,
                                                         PVMFSTREAMINGMGRNODE_TRACKINFO_NUMCHANNELS_KEY,
                                                         trackMetaDataInfo.iAudioNumChannels,
                                                         indexparam);
                    }

                    if (retval != PVMFSuccess && retval != PVMFErrArgument)
                    {
                        break;
                    }

                    if (trackkvp.key != NULL)
                    {
                        leavecode = 0;
                        OSCL_TRY(leavecode, (*valuelistptr).push_back(trackkvp));
                        if (leavecode != 0)
                        {
                            OSCL_ARRAY_DELETE(trackkvp.key);
                            trackkvp.key = NULL;
                        }
                        else
                        {
                            // Increment the value list entry counter
                            ++numentriesadded;
                        }

                        // Check if the max number of value entries were added
                        if (max_entries > 0 && numentriesadded >= max_entries)
                        {
                            iPVMFStreamingManagerNodeMetadataValueCount = (*valuelistptr).size();
                            return PVMFSuccess;
                        }
                    }
                }
            }
        }
        else if (oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_AUDIO_BITS_PER_SAMPLE_KEY) != NULL)
        {
            // Determine the index requested. Default to all tracks
            uint32 startindex = 0;
            uint32 endindex = iMetaDataInfo.iNumTracks - 1;
            // Check if the index parameter is present
            char* indexstr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                // Retrieve the index values
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            // Validate the indices
            if (startindex > endindex || startindex >= iMetaDataInfo.iNumTracks || endindex >= iMetaDataInfo.iNumTracks)
            {
                continue;
            }

            // Return a KVP for each index
            for (uint32 i = startindex; i <= endindex; ++i)
            {
                if (i < iMetaDataInfo.iTrackMetaDataInfoVec.size())
                {
                    PVMFSMTrackMetaDataInfo trackMetaDataInfo = iMetaDataInfo.iTrackMetaDataInfoVec[i];

                    PvmiKvp trackkvp;
                    trackkvp.key = NULL;

                    // Increment the counter for the number of values found so far
                    ++numvalentries;
                    // Add the value entry if past the starting index
                    PVMFStatus retval = PVMFErrArgument;
                    if (numvalentries > starting_index)
                    {
                        char indexparam[16];
                        oscl_snprintf(indexparam, 16, ";%s%d", PVMFSTREAMINGMGRNODE_INDEX, i);
                        indexparam[15] = NULL;

                        retval = CreateKVPForUInt32Value(trackkvp,
                                                         PVMFSTREAMINGMGRNODE_TRACKINFO_AUDIO_BITS_PER_SAMPLE_KEY,
                                                         trackMetaDataInfo.iAudioBitsPerSample,
                                                         indexparam);
                    }

                    if (retval != PVMFSuccess && retval != PVMFErrArgument)
                    {
                        break;
                    }

                    if (trackkvp.key != NULL)
                    {
                        leavecode = 0;
                        OSCL_TRY(leavecode, (*valuelistptr).push_back(trackkvp));
                        if (leavecode != 0)
                        {
                            OSCL_ARRAY_DELETE(trackkvp.key);
                            trackkvp.key = NULL;
                        }
                        else
                        {
                            // Increment the value list entry counter
                            ++numentriesadded;
                        }

                        // Check if the max number of value entries were added
                        if (max_entries > 0 && numentriesadded >= max_entries)
                        {
                            iPVMFStreamingManagerNodeMetadataValueCount = (*valuelistptr).size();
                            return PVMFSuccess;
                        }
                    }
                }
            }
        }
        else if (oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_CODEC_NAME_KEY) != NULL)
        {
            /* Codec Name */
            /* Determine the index requested. Default to all tracks */
            uint32 startindex = 0;
            uint32 endindex = iMetaDataInfo.iNumTracks - 1;
            /* Check if the index parameter is present */
            char* indexstr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                /* Retrieve the index values */
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            /* Validate the indices */
            if (startindex > endindex || startindex >= iMetaDataInfo.iNumTracks || endindex >= iMetaDataInfo.iNumTracks)
            {
                continue;
            }
            /* Return a KVP for each index */
            for (uint32 i = startindex; i <= endindex; ++i)
            {
                if (i < iMetaDataInfo.iTrackMetaDataInfoVec.size())
                {

                    PVMFSMTrackMetaDataInfo trackMetaDataInfo = iMetaDataInfo.iTrackMetaDataInfoVec[i];

                    PvmiKvp trackkvp;
                    trackkvp.key = NULL;
                    /* Increment the counter for the number of values found so far */
                    ++numvalentries;
                    /* Add the value entry if past the starting index */
                    PVMFStatus retval = PVMFErrArgument;
                    if (numvalentries > (uint32)starting_index)
                    {
                        char indexparam[29];
                        oscl_snprintf(indexparam, 16, ";%s%d", PVMFSTREAMINGMGRNODE_INDEX, i);

                        char* maxsizestr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_MAXSIZE);
                        char* truncatestr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRUNCATE_FLAG);
                        uint32 maxSize = 0xFFFFFFFF;
                        if (maxsizestr != NULL)
                        {
                            if (GetMaxSizeValue(maxsizestr, maxSize) != PVMFSuccess)
                            {
                                break;
                            }
                        }

                        uint32 truncateFlag = true;

                        if (truncatestr != NULL)
                        {
                            if (GetTruncateFlagValue(truncatestr, truncateFlag) != PVMFSuccess)
                            {
                                break;
                            }
                        }

                        uint32 codecNameLen = trackMetaDataInfo.iCodecName.get_size();
                        char maxsizemessage[13];
                        maxsizemessage[0] = '\0';
                        if (maxSize < codecNameLen)

                        {
                            if (!truncateFlag)
                            {
                                oscl_snprintf(maxsizemessage, 13, ";%s%d", PVMFSTREAMINGMGRNODE_REQSIZE, codecNameLen);
                                oscl_strncat(indexparam, maxsizemessage, oscl_strlen(maxsizemessage));
                            }
                        }

                        retval =
                            PVMFCreateKVPUtils::CreateKVPForWStringValue(trackkvp,
                                    PVMFSTREAMINGMGRNODE_TRACKINFO_CODEC_NAME_KEY,
                                    (trackMetaDataInfo.iCodecName),
                                    indexparam, maxSize, truncateFlag);
                    }
                    if (retval != PVMFSuccess && retval != PVMFErrArgument)
                    {
                        break;
                    }
                    if (trackkvp.key != NULL)
                    {
                        leavecode = 0;
                        OSCL_TRY(leavecode, (*valuelistptr).push_back(trackkvp));
                        if (leavecode != 0)
                        {
                            OSCL_ARRAY_DELETE(trackkvp.key);
                            trackkvp.key = NULL;
                        }
                        else
                        {
                            // Increment the value list entry counter
                            ++numentriesadded;
                        }

                        // Check if the max number of value entries were added
                        if (max_entries > 0 && numentriesadded >= max_entries)
                        {
                            iPVMFStreamingManagerNodeMetadataValueCount = (*valuelistptr).size();
                            return PVMFSuccess;
                        }
                    }

                }
            }
        }
        else if (oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_CODEC_DESCRIPTION_KEY) != NULL)
        {
            /* Codec Description */
            /* Determine the index requested. Default to all tracks */
            uint32 startindex = 0;
            uint32 endindex = (uint32)iMetaDataInfo.iNumTracks - 1;
            /* Check if the index parameter is present */
            char* indexstr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                /* Retrieve the index values */
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            /* Validate the indices */
            if (startindex > endindex || startindex >= iMetaDataInfo.iNumTracks || endindex >= iMetaDataInfo.iNumTracks)
            {
                continue;
            }
            /* Return a KVP for each index */
            for (uint32 i = startindex; i <= endindex; ++i)
            {
                if (i < iMetaDataInfo.iTrackMetaDataInfoVec.size())
                {
                    PVMFSMTrackMetaDataInfo trackInfo = iMetaDataInfo.iTrackMetaDataInfoVec[i];
                    PvmiKvp trackkvp;
                    trackkvp.key = NULL;
                    /* Increment the counter for the number of values found so far */
                    ++numvalentries;
                    /* Add the value entry if past the starting index */
                    PVMFStatus retval = PVMFErrArgument;
                    if (numvalentries > (uint32)starting_index)
                    {
                        char indexparam[29];
                        oscl_snprintf(indexparam, 16, ";%s%d", PVMFSTREAMINGMGRNODE_INDEX, i);

                        char* maxsizestr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_MAXSIZE);
                        char* truncatestr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRUNCATE_FLAG);
                        uint32 maxSize = 0xFFFFFFFF;
                        if (maxsizestr != NULL)
                        {
                            if (GetMaxSizeValue(maxsizestr, maxSize) != PVMFSuccess)
                            {
                                break;
                            }
                        }

                        uint32 truncateFlag = true;

                        if (truncatestr != NULL)
                        {
                            if (GetTruncateFlagValue(truncatestr, truncateFlag) != PVMFSuccess)
                            {
                                break;
                            }
                        }

                        uint32 codecDescLen = trackInfo.iCodecDescription.get_size();
                        char maxsizemessage[13];
                        maxsizemessage[0] = '\0';
                        if (maxSize < codecDescLen)
                        {
                            if (!truncateFlag)
                            {
                                oscl_snprintf(maxsizemessage, 13, ";%s%d", PVMFSTREAMINGMGRNODE_REQSIZE, codecDescLen);
                                oscl_strncat(indexparam, maxsizemessage, oscl_strlen(maxsizemessage));
                            }
                        }

                        retval =
                            PVMFCreateKVPUtils::CreateKVPForWStringValue(trackkvp,
                                    PVMFSTREAMINGMGRNODE_TRACKINFO_CODEC_DESCRIPTION_KEY,
                                    (trackInfo.iCodecDescription),
                                    indexparam, maxSize, truncateFlag);
                    }
                    if (retval != PVMFSuccess && retval != PVMFErrArgument)
                    {
                        break;
                    }
                    if (trackkvp.key != NULL)
                    {
                        leavecode = 0;
                        OSCL_TRY(leavecode, (*valuelistptr).push_back(trackkvp));
                        if (leavecode != 0)
                        {
                            OSCL_ARRAY_DELETE(trackkvp.key);
                            trackkvp.key = NULL;
                        }
                        else
                        {
                            // Increment the value list entry counter
                            ++numentriesadded;
                        }

                        // Check if the max number of value entries were added
                        if (max_entries > 0 && numentriesadded >= max_entries)
                        {
                            iPVMFStreamingManagerNodeMetadataValueCount = (*valuelistptr).size();
                            return PVMFSuccess;
                        }
                    }
                }
            }
        }
        else if (oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_CODEC_DATA_KEY) != NULL)
        {
            /* Codec Description */
            /* Determine the index requested. Default to all tracks */
            uint32 startindex = 0;
            uint32 endindex = (uint32)iMetaDataInfo.iNumTracks - 1;
            /* Check if the index parameter is present */
            char* indexstr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                /* Retrieve the index values */
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            /* Validate the indices */
            if (startindex > endindex || startindex >= iMetaDataInfo.iNumTracks || endindex >= iMetaDataInfo.iNumTracks)
            {
                continue;
            }
            /* Return a KVP for each index */
            for (uint32 i = startindex; i <= endindex; ++i)
            {
                if (i < iMetaDataInfo.iTrackMetaDataInfoVec.size())
                {
                    PVMFSMTrackMetaDataInfo trackInfo = iMetaDataInfo.iTrackMetaDataInfoVec[i];
                    PvmiKvp trackkvp;
                    trackkvp.key = NULL;
                    /* Increment the counter for the number of values found so far */
                    ++numvalentries;
                    /* Add the value entry if past the starting index */
                    PVMFStatus retval = PVMFErrArgument;
                    if (numvalentries > (uint32)starting_index)
                    {
                        char indexparam[29];
                        oscl_snprintf(indexparam, 16, ";%s%d", PVMFSTREAMINGMGRNODE_INDEX, i);

                        retval =
                            PVMFCreateKVPUtils::CreateKVPForByteArrayValue(trackkvp,
                                    PVMFSTREAMINGMGRNODE_TRACKINFO_CODEC_DATA_KEY,
                                    (uint8*)(trackInfo.iCodecSpecificInfo.getMemFragPtr()),
                                    (uint32)trackInfo.iCodecSpecificInfo.getMemFragSize()
                                    , indexparam);
                    }
                    if (retval != PVMFSuccess && retval != PVMFErrArgument)
                    {
                        break;
                    }
                    if (trackkvp.key != NULL)
                    {
                        leavecode = 0;
                        OSCL_TRY(leavecode, (*valuelistptr).push_back(trackkvp));
                        if (leavecode != 0)
                        {
                            OSCL_ARRAY_DELETE(trackkvp.key);
                            trackkvp.key = NULL;
                        }
                        else
                        {
                            // Increment the value list entry counter
                            ++numentriesadded;
                        }

                        // Check if the max number of value entries were added
                        if (max_entries > 0 && numentriesadded >= max_entries)
                        {
                            iPVMFStreamingManagerNodeMetadataValueCount = (*valuelistptr).size();
                            return PVMFSuccess;
                        }
                    }
                }
            }
        }
        else if (oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_TRACKINFO_TRACKID_KEY) != NULL)
        {
            /* Codec Description */
            /* Determine the index requested. Default to all tracks */
            uint32 startindex = 0;
            uint32 endindex = (uint32)iMetaDataInfo.iNumTracks - 1;
            /* Check if the index parameter is present */
            char* indexstr = oscl_strstr((*keylistptr)[lcv].get_cstr(), PVMFSTREAMINGMGRNODE_INDEX);
            if (indexstr != NULL)
            {
                /* Retrieve the index values */
                GetIndexParamValues(indexstr, startindex, endindex);
            }
            /* Validate the indices */
            if (startindex > endindex || startindex >= iMetaDataInfo.iNumTracks || endindex >= iMetaDataInfo.iNumTracks)
            {
                continue;
            }
            /* Return a KVP for each index */
            for (uint32 i = startindex; i <= endindex; ++i)
            {
                if (i < iMetaDataInfo.iTrackMetaDataInfoVec.size())
                {
                    PVMFSMTrackMetaDataInfo trackInfo = iMetaDataInfo.iTrackMetaDataInfoVec[i];
                    PvmiKvp trackkvp;
                    trackkvp.key = NULL;
                    /* Increment the counter for the number of values found so far */
                    ++numvalentries;
                    /* Add the value entry if past the starting index */
                    PVMFStatus retval = PVMFErrArgument;
                    if (numvalentries > (uint32)starting_index)
                    {
                        char indexparam[29];
                        oscl_snprintf(indexparam, 16, ";%s%d", PVMFSTREAMINGMGRNODE_INDEX, i);

                        retval = CreateKVPForUInt32Value(trackkvp,
                                                         PVMFSTREAMINGMGRNODE_TRACKINFO_TRACKID_KEY,
                                                         trackInfo.iTrackID,
                                                         indexparam);
                    }
                    if (retval != PVMFSuccess && retval != PVMFErrArgument)
                    {
                        break;
                    }
                    if (trackkvp.key != NULL)
                    {
                        leavecode = 0;
                        OSCL_TRY(leavecode, (*valuelistptr).push_back(trackkvp));
                        if (leavecode != 0)
                        {
                            OSCL_ARRAY_DELETE(trackkvp.key);
                            trackkvp.key = NULL;
                        }
                        else
                        {
                            // Increment the value list entry counter
                            ++numentriesadded;
                        }

                        // Check if the max number of value entries were added
                        if (max_entries > 0 && numentriesadded >= max_entries)
                        {
                            iPVMFStreamingManagerNodeMetadataValueCount = (*valuelistptr).size();
                            return PVMFSuccess;
                        }
                    }
                }
            }
        }
        // Add the KVP to the list if the key string was created
        if (KeyVal.key != NULL)
        {
            leavecode = 0;
            OSCL_TRY(leavecode, (*valuelistptr).push_back(KeyVal));
            if (leavecode != 0)
            {
                switch (GetValTypeFromKeyString(KeyVal.key))
                {
                    case PVMI_KVPVALTYPE_CHARPTR:
                        if (KeyVal.value.pChar_value != NULL)
                        {
                            OSCL_ARRAY_DELETE(KeyVal.value.pChar_value);
                            KeyVal.value.pChar_value = NULL;
                        }
                        break;

                    default:
                        // Add more case statements if other value types are returned
                        break;
                }

                OSCL_ARRAY_DELETE(KeyVal.key);
                KeyVal.key = NULL;
            }
            else
            {
                // Increment the counter for number of value entries added to the list
                ++numentriesadded;
            }

            // Check if the max number of value entries were added
            if (max_entries > 0 && numentriesadded >= max_entries)
            {
                // Maximum number of values added so break out of the loop
                break;
            }
        }
    }

    iPVMFStreamingManagerNodeMetadataValueCount = (*valuelistptr).size();

    return PVMFSuccess;
}

PVMFStatus PVMFStreamingManagerNode::CreateKVPForCharStringValue(PvmiKvp& aKeyVal, const char* aKeyTypeString, const char* aValString, char* aMiscKeyParam)
{
    // Check parameters
    if (aKeyVal.key != NULL || aKeyTypeString == NULL)
    {
        return PVMFErrArgument;
    }

    // Determine the length of strings
    uint32 keylen = oscl_strlen(aKeyTypeString) + 1; // for key string and ";"
    keylen += oscl_strlen(PVMI_KVPVALTYPE_STRING_CONSTCHAR); // for "valtype="
    keylen += oscl_strlen(PVMI_KVPVALTYPE_CHARPTR_STRING_CONSTCHAR) + 1; // for "char*" and NULL terminator
    if (aMiscKeyParam)
    {
        keylen += oscl_strlen(aMiscKeyParam);
    }

    uint32 valuelen = oscl_strlen(aValString) + 1;

    // Allocate memory for the strings
    int32 leavecode = 0;
    OSCL_TRY(leavecode,
             aKeyVal.key = OSCL_ARRAY_NEW(char, keylen);
             aKeyVal.value.pChar_value = OSCL_ARRAY_NEW(char, valuelen);
            );

    if (leavecode == 0)
    {
        // Copy the key string
        oscl_strncpy(aKeyVal.key, aKeyTypeString, oscl_strlen(aKeyTypeString) + 1);
        oscl_strncat(aKeyVal.key, PVMFSTREAMINGMGRNODE_SEMICOLON, oscl_strlen(PVMFSTREAMINGMGRNODE_SEMICOLON));
        oscl_strncat(aKeyVal.key, PVMI_KVPVALTYPE_STRING_CONSTCHAR, oscl_strlen(PVMI_KVPVALTYPE_STRING_CONSTCHAR));
        oscl_strncat(aKeyVal.key, PVMI_KVPVALTYPE_CHARPTR_STRING_CONSTCHAR, oscl_strlen(PVMI_KVPVALTYPE_CHARPTR_STRING_CONSTCHAR));
        if (aMiscKeyParam)
        {
            oscl_strncat(aKeyVal.key, aMiscKeyParam, oscl_strlen(aMiscKeyParam));
        }
        aKeyVal.key[keylen-1] = NULL_TERM_CHAR;
        // Copy the value
        oscl_strncpy(aKeyVal.value.pChar_value, aValString, valuelen);
        aKeyVal.value.pChar_value[valuelen-1] = NULL_TERM_CHAR;
        // Set the length and capacity
        aKeyVal.length = valuelen;
        aKeyVal.capacity = valuelen;
    }
    else
    {
        // Memory allocation failed so clean up
        if (aKeyVal.key)
        {
            OSCL_ARRAY_DELETE(aKeyVal.key);
            aKeyVal.key = NULL;
        }
        if (aKeyVal.value.pChar_value)
        {
            OSCL_ARRAY_DELETE(aKeyVal.value.pChar_value);
        }

        return PVMFErrNoMemory;
    }

    return PVMFSuccess;
}


PVMFStatus PVMFStreamingManagerNode::CreateKVPForWideCharStringValue(PvmiKvp& aKeyVal, const char* aKeyTypeString, const oscl_wchar* aValString, char* aMiscKeyParam)
{
    // Check parameters
    if (aKeyVal.key != NULL || aKeyTypeString == NULL)
    {
        return PVMFErrArgument;
    }

    // Determine the length of strings
    uint32 keylen = oscl_strlen(aKeyTypeString) + 1; // for key string and ";"
    keylen += oscl_strlen(PVMI_KVPVALTYPE_STRING_CONSTCHAR); // for "valtype="
    keylen += oscl_strlen(PVMI_KVPVALTYPE_WCHARPTR_STRING_CONSTCHAR) + 1; // for "wchar*" and NULL terminator
    if (aMiscKeyParam)
    {
        keylen += oscl_strlen(aMiscKeyParam);
    }

    uint32 valuelen = oscl_strlen(aValString) + 1;

    // Allocate memory for the strings
    int32 leavecode = 0;
    OSCL_TRY(leavecode,
             aKeyVal.key = OSCL_ARRAY_NEW(char, keylen);
             aKeyVal.value.pWChar_value = OSCL_ARRAY_NEW(oscl_wchar, valuelen);
            );

    if (leavecode == 0)
    {
        // Copy the key string
        oscl_strncpy(aKeyVal.key, aKeyTypeString, oscl_strlen(aKeyTypeString) + 1);
        oscl_strncat(aKeyVal.key, PVMFSTREAMINGMGRNODE_SEMICOLON, oscl_strlen(PVMFSTREAMINGMGRNODE_SEMICOLON));
        oscl_strncat(aKeyVal.key, PVMI_KVPVALTYPE_STRING_CONSTCHAR, oscl_strlen(PVMI_KVPVALTYPE_STRING_CONSTCHAR));
        oscl_strncat(aKeyVal.key, PVMI_KVPVALTYPE_WCHARPTR_STRING_CONSTCHAR, oscl_strlen(PVMI_KVPVALTYPE_WCHARPTR_STRING_CONSTCHAR));
        if (aMiscKeyParam)
        {
            oscl_strncat(aKeyVal.key, aMiscKeyParam, oscl_strlen(aMiscKeyParam));
        }
        aKeyVal.key[keylen-1] = NULL_TERM_CHAR;
        // Copy the value
        oscl_strncpy(aKeyVal.value.pWChar_value, aValString, valuelen);
        aKeyVal.value.pWChar_value[valuelen-1] = NULL_TERM_CHAR;
        // Set the length and capacity
        aKeyVal.length = valuelen;
        aKeyVal.capacity = valuelen;
    }
    else
    {
        // Memory allocation failed so clean up
        if (aKeyVal.key)
        {
            OSCL_ARRAY_DELETE(aKeyVal.key);
            aKeyVal.key = NULL;
        }
        if (aKeyVal.value.pChar_value)
        {
            OSCL_ARRAY_DELETE(aKeyVal.value.pWChar_value);
        }

        return PVMFErrNoMemory;
    }

    return PVMFSuccess;
}

PVMFStatus PVMFStreamingManagerNode::CreateKVPForUInt32Value(PvmiKvp& aKeyVal, const char* aKeyTypeString, uint32& aValueUInt32, char* aMiscKeyParam)
{
    // Check parameters
    if (aKeyVal.key != NULL || aKeyTypeString == NULL)
    {
        return PVMFErrArgument;
    }

    // Determine the length of strings
    uint32 keylen = oscl_strlen(aKeyTypeString) + 1; // for key string and ";"
    keylen += oscl_strlen(PVMI_KVPVALTYPE_STRING_CONSTCHAR); // for "valtype="
    keylen += oscl_strlen(PVMI_KVPVALTYPE_UINT32_STRING_CONSTCHAR) + 1; // for "uint32" and NULL terminator
    if (aMiscKeyParam)
    {
        keylen += oscl_strlen(aMiscKeyParam);
    }

    // Allocate memory for the strings
    int32 leavecode = 0;
    OSCL_TRY(leavecode,
             aKeyVal.key = OSCL_ARRAY_NEW(char, keylen);
            );

    if (leavecode == 0)
    {
        // Copy the key string
        oscl_strncpy(aKeyVal.key, aKeyTypeString, oscl_strlen(aKeyTypeString) + 1);
        oscl_strncat(aKeyVal.key, PVMFSTREAMINGMGRNODE_SEMICOLON, oscl_strlen(PVMFSTREAMINGMGRNODE_SEMICOLON));
        oscl_strncat(aKeyVal.key, PVMI_KVPVALTYPE_STRING_CONSTCHAR, oscl_strlen(PVMI_KVPVALTYPE_STRING_CONSTCHAR));
        oscl_strncat(aKeyVal.key, PVMI_KVPVALTYPE_UINT32_STRING_CONSTCHAR, oscl_strlen(PVMI_KVPVALTYPE_UINT32_STRING_CONSTCHAR));
        if (aMiscKeyParam)
        {
            oscl_strncat(aKeyVal.key, aMiscKeyParam, oscl_strlen(aMiscKeyParam));
        }
        aKeyVal.key[keylen-1] = NULL_TERM_CHAR;
        // Copy the value
        aKeyVal.value.uint32_value = aValueUInt32;
        // Set the length and capacity
        aKeyVal.length = 1;
        aKeyVal.capacity = 1;
    }
    else
    {
        // Memory allocation failed so clean up
        if (aKeyVal.key)
        {
            OSCL_ARRAY_DELETE(aKeyVal.key);
            aKeyVal.key = NULL;
        }

        return PVMFErrNoMemory;
    }

    return PVMFSuccess;
}

PVMFStatus PVMFStreamingManagerNode::CreateKVPForBoolValue(PvmiKvp& aKeyVal, const char* aKeyTypeString, bool& aValueBool, char* aMiscKeyParam)
{
    // Check parameters
    if (aKeyVal.key != NULL || aKeyTypeString == NULL)
    {
        return PVMFErrArgument;
    }

    // Determine the length of strings
    uint32 keylen = oscl_strlen(aKeyTypeString) + 1; // for key string and ";"
    keylen += oscl_strlen(PVMI_KVPVALTYPE_STRING_CONSTCHAR); // for "valtype="
    keylen += oscl_strlen(PVMI_KVPVALTYPE_BOOL_STRING_CONSTCHAR) + 1; // for "bool" and NULL terminator
    if (aMiscKeyParam)
    {
        keylen += oscl_strlen(aMiscKeyParam);
    }

    // Allocate memory for the strings
    int32 leavecode = 0;
    OSCL_TRY(leavecode,
             aKeyVal.key = OSCL_ARRAY_NEW(char, keylen);
            );

    if (leavecode == 0)
    {
        // Copy the key string
        oscl_strncpy(aKeyVal.key, aKeyTypeString, oscl_strlen(aKeyTypeString) + 1);
        oscl_strncat(aKeyVal.key, PVMFSTREAMINGMGRNODE_SEMICOLON, oscl_strlen(PVMFSTREAMINGMGRNODE_SEMICOLON));
        oscl_strncat(aKeyVal.key, PVMI_KVPVALTYPE_STRING_CONSTCHAR, oscl_strlen(PVMI_KVPVALTYPE_STRING_CONSTCHAR));
        oscl_strncat(aKeyVal.key, PVMI_KVPVALTYPE_BOOL_STRING_CONSTCHAR, oscl_strlen(PVMI_KVPVALTYPE_BOOL_STRING_CONSTCHAR));
        if (aMiscKeyParam)
        {
            oscl_strncat(aKeyVal.key, aMiscKeyParam, oscl_strlen(aMiscKeyParam));
        }
        aKeyVal.key[keylen-1] = NULL_TERM_CHAR;
        // Copy the value
        aKeyVal.value.bool_value = aValueBool;
        // Set the length and capacity
        aKeyVal.length = 1;
        aKeyVal.capacity = 1;
    }
    else
    {
        // Memory allocation failed so clean up
        if (aKeyVal.key)
        {
            OSCL_ARRAY_DELETE(aKeyVal.key);
            aKeyVal.key = NULL;
        }

        return PVMFErrNoMemory;
    }

    return PVMFSuccess;
}


PVMFCommandId
PVMFStreamingManagerNode::GetNodeMetadataKeys(PVMFSessionId aSessionId,
        PVMFMetadataList& aKeyList,
        uint32 starting_index,
        int32 max_entries,
        char* query_key,
        const OsclAny* aContextData)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::GetNodeMetadataKeys - In"));
    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommand::Construct(aSessionId,
            PVMF_STREAMING_MANAGER_NODE_GETNODEMETADATAKEYS,
            aKeyList,
            starting_index,
            max_entries,
            query_key,
            aContextData);
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::GetNodeMetadataKeys - Out"));
    return QueueCommandL(cmd);
}

PVMFCommandId
PVMFStreamingManagerNode::GetNodeMetadataValues(PVMFSessionId aSessionId,
        PVMFMetadataList& aKeyList,
        Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList,
        uint32 starting_index,
        int32 max_entries,
        const OsclAny* aContextData)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::GetNodeMetadataValues - In"));
    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommand::Construct(aSessionId,
            PVMF_STREAMING_MANAGER_NODE_GETNODEMETADATAVALUES,
            aKeyList,
            aValueList,
            starting_index,
            max_entries,
            aContextData);
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::GetNodeMetadataValues - Out"));
    return QueueCommandL(cmd);
}

// From PVMFMetadataExtensionInterface
PVMFStatus PVMFStreamingManagerNode::ReleaseNodeMetadataKeys(PVMFMetadataList& ,
        uint32 ,
        uint32)
{
    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVMFStreamingManagerNode::ReleaseNodeMetadataKeys() called"));
    //nothing needed-- there's no dynamic allocation in this node's key list
    return PVMFSuccess;
}

// From PVMFMetadataExtensionInterface
PVMFStatus PVMFStreamingManagerNode::ReleaseNodeMetadataValues(Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList,
        uint32 start,
        uint32 end)
{
    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVMFStreamingManagerNode::ReleaseNodeMetadataValues() called"));

    if (start > end || aValueList.size() == 0)
    {
        PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFStreamingManagerNode::ReleaseNodeMetadataValues() Invalid start/end index"));
        return PVMFErrArgument;
    }

    //Only CPM related metadata is retrived. Then this one should be 0.
    if (iPVMFStreamingManagerNodeMetadataValueCount == 0) return PVMFSuccess;

    //To remove madatada related with un-drm value
    end = iPVMFStreamingManagerNodeMetadataValueCount - 1;
    if (end >= aValueList.size())
    {
        end = aValueList.size() - 1;
    }

    for (uint32 i = start; i <= end; i++)
    {
        if (aValueList[i].key != NULL)
        {
            switch (GetValTypeFromKeyString(aValueList[i].key))
            {
                case PVMI_KVPVALTYPE_WCHARPTR:
                    if (aValueList[i].value.pWChar_value != NULL)
                    {
                        OSCL_ARRAY_DELETE(aValueList[i].value.pWChar_value);
                        aValueList[i].value.pWChar_value = NULL;
                    }
                    break;

                case PVMI_KVPVALTYPE_CHARPTR:
                    if (aValueList[i].value.pChar_value != NULL)
                    {
                        OSCL_ARRAY_DELETE(aValueList[i].value.pChar_value);
                        aValueList[i].value.pChar_value = NULL;
                    }
                    break;

                case PVMI_KVPVALTYPE_UINT8PTR:
                    if (aValueList[i].value.pUint8_value != NULL)
                    {
                        OSCL_ARRAY_DELETE(aValueList[i].value.pUint8_value);
                        aValueList[i].value.pUint8_value = NULL;
                    }
                    break;

                case PVMI_KVPVALTYPE_UINT32:
                case PVMI_KVPVALTYPE_FLOAT:
                case PVMI_KVPVALTYPE_BOOL:
                    // No need to free memory for this valtype
                    break;

                default:
                    // Should not get a value that wasn't created from this node
                    OSCL_ASSERT(false);
                    break;
            }

            OSCL_ARRAY_DELETE(aValueList[i].key);
            aValueList[i].key = NULL;
        }
    }

    return PVMFSuccess;
}


PVMFStatus PVMFStreamingManagerNode::getParametersSync(
    PvmiMIOSession aSession, PvmiKeyType aIdentifier,
    PvmiKvp*& aParameters, int& aNumParamElements,
    PvmiCapabilityContext aContext)
{
    OSCL_UNUSED_ARG(aSession);
    OSCL_UNUSED_ARG(aContext);
    // Initialize the output parameters
    aNumParamElements = 0;
    aParameters = NULL;

    // Count the number of components and parameters in the key
    int compcount = pv_mime_string_compcnt(aIdentifier);
    // Retrieve the first component from the key string
    char* compstr = NULL;
    pv_mime_string_extract_type(0, aIdentifier, compstr);

    if ((pv_mime_strcmp(compstr, _STRLIT_CHAR("x-pvmf")) < 0) || compcount < 2)
    {
        // First component should be "x-pvmf" and there must
        // be at least two components to go past x-pvmf
        PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFStreamingManagerNode::getParametersSync() Invalid key string"));
        return PVMFErrArgument;
    }

    // Retrieve the second component from the key string
    pv_mime_string_extract_type(1, aIdentifier, compstr);

    // Check if it is key string for streaming manager
    if (pv_mime_strcmp(compstr, _STRLIT_CHAR("net")) < 0)
    {
        PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFStreamingManagerNode::getParametersSync() Unsupported key"));
        return PVMFFailure;
    }


    if (compcount == 2)
    {
        // Since key is "x-pvmf/net" return all
        // nodes available at this level. Ignore attribute
        // since capability is only allowed

        // Allocate memory for the KVP list
        aParameters = (PvmiKvp*)oscl_malloc(StreamingManagerConfig_NumBaseKeys * sizeof(PvmiKvp));
        if (aParameters == NULL)
        {
            PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFStreamingManagerNode::getParametersSync() Memory allocation for KVP failed"));
            return PVMFErrNoMemory;
        }
        oscl_memset(aParameters, 0, StreamingManagerConfig_NumBaseKeys*sizeof(PvmiKvp));
        // Allocate memory for the key strings in each KVP
        PvmiKeyType memblock = (PvmiKeyType)oscl_malloc(StreamingManagerConfig_NumBaseKeys * SMCONFIG_KEYSTRING_SIZE * sizeof(char));
        if (memblock == NULL)
        {
            oscl_free(aParameters);
            PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFStreamingManagerNode::getParametersSync() Memory allocation for key string failed"));
            return PVMFErrNoMemory;
        }
        oscl_strset(memblock, 0, StreamingManagerConfig_NumBaseKeys*SMCONFIG_KEYSTRING_SIZE*sizeof(char));
        // Assign the key string buffer to each KVP
        uint32 j;
        for (j = 0; j < StreamingManagerConfig_NumBaseKeys; ++j)
        {
            aParameters[j].key = memblock + (j * SMCONFIG_KEYSTRING_SIZE);
        }
        // Copy the requested info
        for (j = 0; j < StreamingManagerConfig_NumBaseKeys; ++j)
        {
            oscl_strncat(aParameters[j].key, _STRLIT_CHAR("x-pvmf/net/"), 17);
            oscl_strncat(aParameters[j].key, StreamingManagerConfig_BaseKeys[j].iString, oscl_strlen(StreamingManagerConfig_BaseKeys[j].iString));
            oscl_strncat(aParameters[j].key, _STRLIT_CHAR(";type="), 6);
            switch (StreamingManagerConfig_BaseKeys[j].iType)
            {
                case PVMI_KVPTYPE_AGGREGATE:
                    oscl_strncat(aParameters[j].key, _STRLIT_CHAR(PVMI_KVPTYPE_AGGREGATE_STRING), oscl_strlen(PVMI_KVPTYPE_AGGREGATE_STRING));
                    break;

                case PVMI_KVPTYPE_POINTER:
                    oscl_strncat(aParameters[j].key, _STRLIT_CHAR(PVMI_KVPTYPE_POINTER_STRING), oscl_strlen(PVMI_KVPTYPE_POINTER_STRING));
                    break;

                case PVMI_KVPTYPE_VALUE:
                default:
                    oscl_strncat(aParameters[j].key, _STRLIT_CHAR(PVMI_KVPTYPE_VALUE_STRING), oscl_strlen(PVMI_KVPTYPE_VALUE_STRING));
                    break;
            }
            oscl_strncat(aParameters[j].key, _STRLIT_CHAR(";valtype="), 9);
            switch (StreamingManagerConfig_BaseKeys[j].iValueType)
            {
                case PVMI_KVPVALTYPE_RANGE_INT32:
                    oscl_strncat(aParameters[j].key, _STRLIT_CHAR(PVMI_KVPVALTYPE_RANGE_INT32_STRING), oscl_strlen(PVMI_KVPVALTYPE_RANGE_INT32_STRING));
                    break;

                case PVMI_KVPVALTYPE_KSV:
                    oscl_strncat(aParameters[j].key, _STRLIT_CHAR(PVMI_KVPVALTYPE_KSV_STRING), oscl_strlen(PVMI_KVPVALTYPE_KSV_STRING));
                    break;

                case PVMI_KVPVALTYPE_CHARPTR:
                    oscl_strncat(aParameters[j].key, _STRLIT_CHAR(PVMI_KVPVALTYPE_CHARPTR_STRING), oscl_strlen(PVMI_KVPVALTYPE_CHARPTR_STRING));
                    break;

                case PVMI_KVPVALTYPE_BOOL:
                    oscl_strncat(aParameters[j].key, _STRLIT_CHAR(PVMI_KVPVALTYPE_BOOL_STRING), oscl_strlen(PVMI_KVPVALTYPE_BOOL_STRING));
                    break;

                case PVMI_KVPVALTYPE_UINT32:
                default:
                    oscl_strncat(aParameters[j].key, _STRLIT_CHAR(PVMI_KVPVALTYPE_UINT32_STRING), oscl_strlen(PVMI_KVPVALTYPE_UINT32_STRING));
                    break;
            }
            aParameters[j].key[SMCONFIG_KEYSTRING_SIZE-1] = 0;
        }

        aNumParamElements = StreamingManagerConfig_NumBaseKeys;
    }
    else if (compcount == 3)
    {
        pv_mime_string_extract_type(2, aIdentifier, compstr);

        // Determine what is requested
        PvmiKvpAttr reqattr = GetAttrTypeFromKeyString(aIdentifier);
        if (reqattr == PVMI_KVPATTR_UNKNOWN)
        {
            reqattr = PVMI_KVPATTR_CUR;
        }
        uint i;
        for (i = 0; i < StreamingManagerConfig_NumBaseKeys; i++)
        {
            if (pv_mime_strcmp(compstr, (char*)(StreamingManagerConfig_BaseKeys[i].iString)) >= 0)
            {
                break;
            }
        }

        if (i == StreamingManagerConfig_NumBaseKeys)
        {
            // no match found
            PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR,
                            (0, "PVMFStreamingManagerNode::getParametersSync() Unsupported key"));
            return PVMFErrNoMemory;
        }

        PVMFStatus retval = GetConfigParameter(aParameters, aNumParamElements, i, reqattr);
        if (retval != PVMFSuccess)
        {
            PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR,
                            (0, "PVMFStreamingManagerNode::getParametersSync() "
                             "Retrieving streaming manager parameter failed"));
            return retval;
        }
    }
    else
    {
        PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFStreamingManagerNode::getParametersSync() Unsupported key"));
        return PVMFErrArgument;
    }

    return PVMFSuccess;
}

PVMFStatus PVMFStreamingManagerNode::releaseParameters(PvmiMIOSession aSession,
        PvmiKvp* aParameters,
        int num_elements)
{
    OSCL_UNUSED_ARG(aSession);

    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
                    (0, "PVMFStreamingManagerNode::releaseParameters() In"));

    if (aParameters == NULL || num_elements < 1)
    {
        PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR,
                        (0, "PVMFStreamingManagerNode::releaseParameters() KVP list is NULL or number of elements is 0"));
        return PVMFErrArgument;
    }

    // Count the number of components and parameters in the key
    int compcount = pv_mime_string_compcnt(aParameters[0].key);
    // Retrieve the first component from the key string
    char* compstr = NULL;
    pv_mime_string_extract_type(0, aParameters[0].key, compstr);

    if ((pv_mime_strcmp(compstr, _STRLIT_CHAR("x-pvmf")) < 0) || compcount < 2)
    {
        // First component should be "x-pvmf" and there must
        // be at least two components to go past x-pvmf
        PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR,
                        (0, "PVMFStreamingManagerNode::releaseParameters() Unsupported key"));
        return PVMFErrArgument;
    }

    // Retrieve the second component from the key string
    pv_mime_string_extract_type(1, aParameters[0].key, compstr);

    // Assume all the parameters come from the same component so the base components are the same
    if (pv_mime_strcmp(compstr, _STRLIT_CHAR("net")) >= 0)
    {
        // Go through each KVP and release memory for value if allocated from heap
        for (int32 i = 0; i < num_elements; ++i)
        {
            // Next check if it is a value type that allocated memory
            PvmiKvpType kvptype = GetTypeFromKeyString(aParameters[i].key);
            if (kvptype == PVMI_KVPTYPE_VALUE || kvptype == PVMI_KVPTYPE_UNKNOWN)
            {
                PvmiKvpValueType keyvaltype = GetValTypeFromKeyString(aParameters[i].key);
                if (keyvaltype == PVMI_KVPVALTYPE_UNKNOWN)
                {
                    PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR,
                                    (0, "PVMFStreamingManagerNode::releaseParameters() Valtype not specified in key string"));
                    return PVMFErrArgument;
                }

                if (keyvaltype == PVMI_KVPVALTYPE_CHARPTR && aParameters[i].value.pChar_value != NULL)
                {
                    oscl_free(aParameters[i].value.pChar_value);
                    aParameters[i].value.pChar_value = NULL;
                }
                else if (keyvaltype == PVMI_KVPVALTYPE_WCHARPTR && aParameters[i].value.pWChar_value != NULL)
                {
                    oscl_free(aParameters[i].value.pWChar_value);
                    aParameters[i].value.pWChar_value = NULL;
                }
                else if (keyvaltype == PVMI_KVPVALTYPE_CHARPTR && aParameters[i].value.pChar_value != NULL)
                {
                    oscl_free(aParameters[i].value.pChar_value);
                    aParameters[i].value.pChar_value = NULL;
                }
                else if (keyvaltype == PVMI_KVPVALTYPE_KSV && aParameters[i].value.key_specific_value != NULL)
                {
                    oscl_free(aParameters[i].value.key_specific_value);
                    aParameters[i].value.key_specific_value = NULL;
                }
                else if (keyvaltype == PVMI_KVPVALTYPE_RANGE_INT32 && aParameters[i].value.key_specific_value != NULL)
                {
                    range_int32* ri32 = (range_int32*)aParameters[i].value.key_specific_value;
                    aParameters[i].value.key_specific_value = NULL;
                    oscl_free(ri32);
                }
                else if (keyvaltype == PVMI_KVPVALTYPE_RANGE_UINT32 && aParameters[i].value.key_specific_value != NULL)
                {
                    range_uint32* rui32 = (range_uint32*)aParameters[i].value.key_specific_value;
                    aParameters[i].value.key_specific_value = NULL;
                    oscl_free(rui32);
                }
            }
        }

        oscl_free(aParameters[0].key);

        // Free memory for the parameter list
        oscl_free(aParameters);
        aParameters = NULL;
    }
    else
    {
        // Unknown key string
        return PVMFErrArgument;
    }

    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
                    (0, "PVMFStreamingManagerNode::releaseParameters() Out"));
    return PVMFSuccess;
}

void PVMFStreamingManagerNode::createContext(PvmiMIOSession aSession,
        PvmiCapabilityContext& aContext)
{
    OSCL_UNUSED_ARG(aSession);
    OSCL_UNUSED_ARG(aContext);
    // not supported
    OSCL_LEAVE(PVMFErrNotSupported);
}

void PVMFStreamingManagerNode::setContextParameters(PvmiMIOSession aSession,
        PvmiCapabilityContext& aContext,
        PvmiKvp* aParameters,
        int num_parameter_elements)
{
    OSCL_UNUSED_ARG(aSession);
    OSCL_UNUSED_ARG(aContext);
    OSCL_UNUSED_ARG(aParameters);
    OSCL_UNUSED_ARG(num_parameter_elements);
    // not supported
    OSCL_LEAVE(PVMFErrNotSupported);
}

void PVMFStreamingManagerNode::DeleteContext(PvmiMIOSession aSession,
        PvmiCapabilityContext& aContext)
{
    OSCL_UNUSED_ARG(aSession);
    OSCL_UNUSED_ARG(aContext);
    // not supported
    OSCL_LEAVE(PVMFErrNotSupported);
}

void PVMFStreamingManagerNode::setParametersSync(PvmiMIOSession aSession, PvmiKvp* aParameters,
        int num_elements, PvmiKvp* &aRet_kvp)
{
    OSCL_UNUSED_ARG(aSession);

    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
                    (0, "PVMFStreamingManagerNode::setParametersSync() In"));


    // Go through each parameter
    for (int paramind = 0; paramind < num_elements; ++paramind)
    {
        // Count the number of components and parameters in the key
        int compcount = pv_mime_string_compcnt(aParameters[paramind].key);

        // Retrieve the first component from the key string
        char* compstr = NULL;
        pv_mime_string_extract_type(0, aParameters[paramind].key, compstr);

        if ((pv_mime_strcmp(compstr, _STRLIT_CHAR("x-pvmf")) < 0) || compcount < 2)
        {
            // First component should be "x-pvmf" and there must
            // be at least two components to go past x-pvmf
            aRet_kvp = &aParameters[paramind];
            PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR,
                            (0, "PVMFStreamingManagerNode::setParametersSync() Unsupported key"));
            return;
        }

        // Retrieve the second component from the key string
        pv_mime_string_extract_type(1, aParameters[paramind].key, compstr);

        // First check if it is key string for the streaming manager
        if (pv_mime_strcmp(compstr, _STRLIT_CHAR("net")) >= 0)
        {
            if (compcount == 3)
            {
                pv_mime_string_extract_type(2, aParameters[paramind].key, compstr);
                uint i;
                for (i = 0; i < StreamingManagerConfig_NumBaseKeys; i++)
                {
                    if (pv_mime_strcmp(compstr, (char*)(StreamingManagerConfig_BaseKeys[i].iString)) >= 0)
                    {
                        break;
                    }
                }

                if (StreamingManagerConfig_NumBaseKeys == i)
                {
                    // invalid third component
                    aRet_kvp = &aParameters[paramind];
                    PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR,
                                    (0, "PVMFStreamingManagerNode::setParametersSync() Unsupported key"));
                    return;
                }

                // Verify and set the passed-in setting
                PVMFStatus retval = VerifyAndSetConfigParameter(i, aParameters[paramind], true);
                if (retval != PVMFSuccess)
                {
                    aRet_kvp = &aParameters[paramind];
                    PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR,
                                    (0, "PVMFStreamingManagerNode::setParametersSync() Setting "
                                     "parameter %d failed", paramind));
                    return;
                }
            }
            else
            {
                // Do not support more than 3 components right now
                aRet_kvp = &aParameters[paramind];
                PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR,
                                (0, "PVMFStreamingManagerNode::setParametersSync() Unsupported key"));
                return;
            }
        }
        else
        {
            // Unknown key string
            PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR,
                            (0, "PVMFStreamingManagerNode::setParametersSync() Unsupported key"));
            return;
        }
    }

    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
                    (0, "PVMFStreamingManagerNode::setParametersSync() Out"));
}

PVMFCommandId PVMFStreamingManagerNode::setParametersAsync(PvmiMIOSession aSession,
        PvmiKvp* aParameters,
        int num_elements,
        PvmiKvp*& aRet_kvp,
        OsclAny* context)
{

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::setParametersAsync - In"));
    PVMFStreamingManagerNodeCommand cmd;
    cmd.PVMFStreamingManagerNodeCommand::Construct(0,
            PVMF_STREAMING_MANAGER_NODE_CAPCONFIG_SETPARAMS,
            aSession, aParameters, num_elements, aRet_kvp, context);
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::setParametersAsync - Out"));
    return QueueCommandL(cmd);
}

uint32 PVMFStreamingManagerNode::getCapabilityMetric(PvmiMIOSession aSession)
{
    OSCL_UNUSED_ARG(aSession);
    return 0;
}

PVMFStatus PVMFStreamingManagerNode::verifyParametersSync(PvmiMIOSession aSession,
        PvmiKvp* aParameters,
        int num_elements)
{
    OSCL_UNUSED_ARG(aSession);

    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
                    (0, "PVMFStreamingManagerNode::verifyParametersSync() In"));

    if (aParameters == NULL || num_elements < 1)
    {
        PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR,
                        (0, "PVMFStreamingManagerNode::verifyParametersSync() Passed in parameter invalid"));
        return PVMFErrArgument;
    }

    // Go through each parameter and verify
    for (int32 paramind = 0; paramind < num_elements; ++paramind)
    {
        // Count the number of components and parameters in the key
        int compcount = pv_mime_string_compcnt(aParameters[paramind].key);
        // Retrieve the first component from the key string
        char* compstr = NULL;
        pv_mime_string_extract_type(0, aParameters[paramind].key, compstr);

        if ((pv_mime_strcmp(compstr, _STRLIT_CHAR("x-pvmf")) < 0) || compcount < 2)
        {
            // First component should be "x-pvmf" and there must
            // be at least two components to go past x-pvmf
            PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVPlayerEngine::verifyParametersSync() Unsupported key"));
            return PVMFErrArgument;
        }

        // Retrieve the second component from the key string
        pv_mime_string_extract_type(1, aParameters[paramind].key, compstr);

        // First check if it is key string for this node
        if ((pv_mime_strcmp(compstr, _STRLIT_CHAR("net")) >= 0) && (compcount == 3))
        {
            pv_mime_string_extract_type(2, aParameters[paramind].key, compstr);
            uint i;
            for (i = 0; i < StreamingManagerConfig_NumBaseKeys; i++)
            {
                if (pv_mime_strcmp(compstr, (char*)(StreamingManagerConfig_BaseKeys[i].iString)) >= 0)
                {
                    break;
                }
            }

            if (StreamingManagerConfig_NumBaseKeys == i)
            {
                return PVMFErrArgument;
            }

            // Verify the passed-in player setting
            PVMFStatus retval = VerifyAndSetConfigParameter(i, aParameters[paramind], false);
            if (retval != PVMFSuccess)
            {
                PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVPlayerEngine::DoCapConfigVerifyParameters() Verifying parameter %d failed", paramind));
                return retval;
            }
        }
        else
        {
            // Unknown key string
            return PVMFErrArgument;
        }
    }

    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerEngine::DoCapConfigVerifyParameters() Out"));
    return PVMFSuccess;
}

PVMFStatus PVMFStreamingManagerNode::GetConfigParameter(PvmiKvp*& aParameters,
        int& aNumParamElements,
        int32 aIndex, PvmiKvpAttr reqattr)
{
    PVMF_SM_LOGINFO((0, "PVMFStreamingManagerNode::GetConfigParameter() In"));

    aNumParamElements = 0;

    // Allocate memory for the KVP
    aParameters = (PvmiKvp*)oscl_malloc(sizeof(PvmiKvp));
    if (aParameters == NULL)
    {
        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::GetConfigParameter() Memory allocation for KVP failed"));
        return PVMFErrNoMemory;
    }
    oscl_memset(aParameters, 0, sizeof(PvmiKvp));

    // Allocate memory for the key string in KVP
    PvmiKeyType memblock = (PvmiKeyType)oscl_malloc(SMCONFIG_KEYSTRING_SIZE * sizeof(char));
    if (memblock == NULL)
    {
        oscl_free(aParameters);
        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::GetConfigParameter() Memory allocation for key string failed"));
        return PVMFErrNoMemory;
    }
    oscl_strset(memblock, 0, SMCONFIG_KEYSTRING_SIZE*sizeof(char));

    // Assign the key string buffer to KVP
    aParameters[0].key = memblock;

    // Copy the key string
    oscl_strncat(aParameters[0].key, _STRLIT_CHAR("x-pvmf/net/"), 17);
    oscl_strncat(aParameters[0].key, StreamingManagerConfig_BaseKeys[aIndex].iString,
                 oscl_strlen(StreamingManagerConfig_BaseKeys[aIndex].iString));
    oscl_strncat(aParameters[0].key, _STRLIT_CHAR(";type=value;valtype="), 20);
    switch (StreamingManagerConfig_BaseKeys[aIndex].iValueType)
    {
        case PVMI_KVPVALTYPE_RANGE_INT32:
            oscl_strncat(aParameters[0].key,
                         _STRLIT_CHAR(PVMI_KVPVALTYPE_RANGE_INT32_STRING),
                         oscl_strlen(PVMI_KVPVALTYPE_RANGE_INT32_STRING));
            break;

        case PVMI_KVPVALTYPE_KSV:
            oscl_strncat(aParameters[0].key,
                         _STRLIT_CHAR(PVMI_KVPVALTYPE_KSV_STRING),
                         oscl_strlen(PVMI_KVPVALTYPE_KSV_STRING));
            break;

        case PVMI_KVPVALTYPE_CHARPTR:
            oscl_strncat(aParameters[0].key,
                         _STRLIT_CHAR(PVMI_KVPVALTYPE_CHARPTR_STRING),
                         oscl_strlen(PVMI_KVPVALTYPE_CHARPTR_STRING));
            break;

        case PVMI_KVPVALTYPE_WCHARPTR:
            oscl_strncat(aParameters[0].key,
                         _STRLIT_CHAR(PVMI_KVPVALTYPE_WCHARPTR_STRING),
                         oscl_strlen(PVMI_KVPVALTYPE_WCHARPTR_STRING));
            break;

        case PVMI_KVPVALTYPE_BOOL:
            oscl_strncat(aParameters[0].key,
                         _STRLIT_CHAR(PVMI_KVPVALTYPE_BOOL_STRING),
                         oscl_strlen(PVMI_KVPVALTYPE_BOOL_STRING));
            break;

        case PVMI_KVPVALTYPE_UINT32:
        default:
            if (reqattr == PVMI_KVPATTR_CAP)
            {
                oscl_strncat(aParameters[0].key,
                             _STRLIT_CHAR(PVMI_KVPVALTYPE_RANGE_UINT32_STRING),
                             oscl_strlen(PVMI_KVPVALTYPE_RANGE_UINT32_STRING));
            }
            else
            {
                oscl_strncat(aParameters[0].key,
                             _STRLIT_CHAR(PVMI_KVPVALTYPE_UINT32_STRING),
                             oscl_strlen(PVMI_KVPVALTYPE_UINT32_STRING));
            }
            break;
    }
    aParameters[0].key[SMCONFIG_KEYSTRING_SIZE-1] = 0;

    // Copy the requested info
    switch (aIndex)
    {
        case BASEKEY_DELAY:
            if (reqattr == PVMI_KVPATTR_CUR)
            {
                // Return current value
                PVMFSMNodeContainer* iJitterBufferNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
                PVMFJitterBufferExtensionInterface* jbExtIntf =
                    (PVMFJitterBufferExtensionInterface*)iJitterBufferNodeContainer->iExtensions[0];
                jbExtIntf->getJitterBufferDurationInMilliSeconds(aParameters[0].value.uint32_value);
            }
            else if (reqattr == PVMI_KVPATTR_DEF)
            {
                // Return default
                aParameters[0].value.uint32_value = DEFAULT_JITTER_BUFFER_DURATION_IN_MS;
            }
            else
            {
                // Return capability
                range_uint32* rui32 = (range_uint32*)oscl_malloc(sizeof(range_uint32));
                if (rui32 == NULL)
                {
                    oscl_free(aParameters[0].key);
                    oscl_free(aParameters);
                    PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::GetConfigParameter() "
                                      "Memory allocation for range uint32 failed"));
                    return PVMFErrNoMemory;
                }
                rui32->min = MIN_JITTER_BUFFER_DURATION_IN_MS;
                rui32->max = MAX_JITTER_BUFFER_DURATION_IN_MS;
                aParameters[0].value.key_specific_value = (void*)rui32;
            }
            break;
        case BASEKEY_REBUFFERING_THRESHOLD:
        {
            if (reqattr == PVMI_KVPATTR_CUR)
            {
                // Return current value
                PVMFSMNodeContainer* iJitterBufferNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
                PVMFJitterBufferExtensionInterface* jbExtIntf =
                    (PVMFJitterBufferExtensionInterface*)iJitterBufferNodeContainer->iExtensions[0];
                jbExtIntf->getJitterBufferRebufferingThresholdInMilliSeconds(aParameters[0].value.uint32_value);
            }
            else if (reqattr == PVMI_KVPATTR_DEF)
            {
                // Return default
                aParameters[0].value.uint32_value = DEFAULT_JITTER_BUFFER_UNDERFLOW_THRESHOLD_IN_MS;
            }
            else
            {
                // Return capability
                range_uint32* rui32 = (range_uint32*)oscl_malloc(sizeof(range_uint32));
                if (rui32 == NULL)
                {
                    oscl_free(aParameters[0].key);
                    oscl_free(aParameters);
                    PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::GetConfigParameter() "
                                      "Memory allocation for range uint32 failed"));
                    return PVMFErrNoMemory;
                }
                rui32->min = DEFAULT_JITTER_BUFFER_UNDERFLOW_THRESHOLD_IN_MS;
                rui32->max = DEFAULT_JITTER_BUFFER_UNDERFLOW_THRESHOLD_IN_MS;
                aParameters[0].value.key_specific_value = (void*)rui32;
            }
        }
        break;
        case BASEKEY_JITTERBUFFER_NUMRESIZE:
            if (reqattr == PVMI_KVPATTR_CUR)
            {
                // Return current value
                uint32 numResize, resizeSize;
                PVMFSMNodeContainer* iJitterBufferNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
                PVMFJitterBufferExtensionInterface* jbExtIntf =
                    (PVMFJitterBufferExtensionInterface*)iJitterBufferNodeContainer->iExtensions[0];
                jbExtIntf->GetSharedBufferResizeParams(numResize, resizeSize);
                aParameters[0].value.uint32_value = numResize;
            }
            else if (reqattr == PVMI_KVPATTR_DEF)
            {
                // Return default
                aParameters[0].value.uint32_value = DEFAULT_MAX_NUM_SOCKETMEMPOOL_RESIZES;
            }
            else
            {
                // Return capability
                range_uint32* rui32 = (range_uint32*)oscl_malloc(sizeof(range_uint32));
                if (rui32 == NULL)
                {
                    oscl_free(aParameters[0].key);
                    oscl_free(aParameters);
                    PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::GetConfigParameter() "
                                      "Memory allocation for range uint32 failed"));
                    return PVMFErrNoMemory;
                }
                rui32->min = MIN_NUM_SOCKETMEMPOOL_RESIZES;
                rui32->max = MAX_NUM_SOCKETMEMPOOL_RESIZES;
                aParameters[0].value.key_specific_value = (void*)rui32;
            }
            break;
        case BASEKEY_JITTERBUFFER_RESIZESIZE:
            if (reqattr == PVMI_KVPATTR_CUR)
            {
                // Return current value
                uint32 numResize, resizeSize;
                PVMFSMNodeContainer* iJitterBufferNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
                PVMFJitterBufferExtensionInterface* jbExtIntf =
                    (PVMFJitterBufferExtensionInterface*)iJitterBufferNodeContainer->iExtensions[0];
                jbExtIntf->GetSharedBufferResizeParams(numResize, resizeSize);
                aParameters[0].value.uint32_value = resizeSize;
            }
            else if (reqattr == PVMI_KVPATTR_DEF)
            {
                // Return default
                aParameters[0].value.uint32_value = DEFAULT_MAX_SOCKETMEMPOOL_RESIZELEN_INPUT_PORT;
            }
            else
            {
                // Return capability
                range_uint32* rui32 = (range_uint32*)oscl_malloc(sizeof(range_uint32));
                if (rui32 == NULL)
                {
                    oscl_free(aParameters[0].key);
                    oscl_free(aParameters);
                    PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::GetConfigParameter() "
                                      "Memory allocation for range uint32 failed"));
                    return PVMFErrNoMemory;
                }
                rui32->min = MIN_SOCKETMEMPOOL_RESIZELEN_INPUT_PORT;
                rui32->max = MAX_SOCKETMEMPOOL_RESIZELEN_INPUT_PORT;
                aParameters[0].value.key_specific_value = (void*)rui32;
            }
            break;
        case BASEKEY_SESSION_CONTROLLER_USER_AGENT:
            if ((reqattr == PVMI_KVPATTR_CUR) || (reqattr == PVMI_KVPATTR_DEF))
            {
                aParameters[0].value.pWChar_value = NULL;
                /* As of now just RTSP node supports an external config of user agent */
                PVMFSMNodeContainer* iSessionControllerNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);
                if (iSessionControllerNodeContainer != NULL)
                {
                    PVRTSPEngineNodeExtensionInterface* rtspExtIntf =
                        (PVRTSPEngineNodeExtensionInterface*)
                        (iSessionControllerNodeContainer->iExtensions[0]);

                    OSCL_wHeapString<OsclMemAllocator> userAgent;
                    if (rtspExtIntf->GetUserAgent(userAgent) == PVMFSuccess)
                    {
                        // Return current value
                        oscl_wchar* ptr = (oscl_wchar*)oscl_malloc(sizeof(oscl_wchar) * (userAgent.get_size()));
                        if (ptr)
                        {
                            oscl_memcpy(ptr, userAgent.get_cstr(), userAgent.get_size());
                            aParameters[0].value.pWChar_value = ptr;
                        }
                        else
                        {
                            oscl_free(aParameters[0].key);
                            oscl_free(aParameters);
                            PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::GetConfigParameter() "
                                              "Memory allocation for user agent failed"));
                            return PVMFErrNoMemory;
                        }
                    }
                }
            }
            else
            {
                // Return capability - no concept of capability for user agent
                // do nothing
            }
            break;
        case BASEKEY_SESSION_CONTROLLER_KEEP_ALIVE_INTERVAL:
        case BASEKEY_SESSION_CONTROLLER_KEEP_ALIVE_DURING_PLAY:
            if ((reqattr == PVMI_KVPATTR_CUR) || (reqattr == PVMI_KVPATTR_DEF))
            {
                if (aIndex == BASEKEY_SESSION_CONTROLLER_KEEP_ALIVE_INTERVAL)
                {
                    aParameters[0].value.uint32_value = PVRTSPENGINENODE_DEFAULT_KEEP_ALIVE_INTERVAL;
                }
                else
                {
                    aParameters[0].value.bool_value = false;
                }
                /* As of now just RTSP node supports an external config of user agent */
                PVMFSMNodeContainer* iSessionControllerNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);
                if (iSessionControllerNodeContainer != NULL)
                {
                    PVRTSPEngineNodeExtensionInterface* rtspExtIntf =
                        (PVRTSPEngineNodeExtensionInterface*)
                        (iSessionControllerNodeContainer->iExtensions[0]);
                    uint32 timeout;
                    bool okeepalivemethod;
                    bool okeepaliveinplay;
                    rtspExtIntf->GetKeepAliveMethod((int32&)timeout, okeepalivemethod, okeepaliveinplay);
                    if (aIndex == BASEKEY_SESSION_CONTROLLER_KEEP_ALIVE_INTERVAL)
                    {
                        aParameters[0].value.uint32_value = timeout;
                    }
                    else
                    {
                        aParameters[0].value.bool_value = okeepaliveinplay;
                    }
                }
            }
            else
            {
                // Return capability - no concept of capability for keep alive interval
                // do nothing
            }
            break;

        case BASEKEY_STREAMING_MGR_SWITCH_STREAMS:
            /* Do nothing - things like current, default, and capability do not make sense here */
            break;

        case BASEKEY_STREAMING_SPEED:
        {
            if ((reqattr == PVMI_KVPATTR_CUR) || (reqattr == PVMI_KVPATTR_DEF))
            {
                {
                    aParameters[0].value.uint32_value = 1;
                }
            }
            else
            {
                // Return capability - no concept of capability for streaming speed
                // do nothing
            }
        }
        break;

        case BASEKEY_HTTP_VERSION:
        {
            if ((reqattr == PVMI_KVPATTR_CUR) || (reqattr == PVMI_KVPATTR_DEF))
            {
                {
                    oscl_free(aParameters[0].key);
                    oscl_free(aParameters);
                    PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::GetConfigParameter - HTTP Version Not Supported"));
                    return PVMFErrArgument;
                }
            }
            else
            {
                // Return capability - no concept of capability for http version
                // do nothing
            }
        }
        break;

        case BASEKEY_NUM_REDIRECT_ATTEMPTS:
        {
            if ((reqattr == PVMI_KVPATTR_CUR) || (reqattr == PVMI_KVPATTR_DEF))
            {
                {
                    //seems like there is no reasonable default here ??
                    aParameters[0].value.uint32_value = 0;
                }
            }
            else
            {
                // Return capability - no concept of capability for num redirect attempts
                // do nothing
            }
        }
        break;

        case BASEKEY_PROTOCOL_EXTENSION_HEADER:
            /* Do nothing - things like current, default, and capability do not make sense here */
            break;

        case BASEKEY_SESSION_CONTROLLER_HTTP_TIMEOUT:
            break;

        case BASEKEY_SESSION_CONTROLLER_HTTP_STREAMING_LOGGING_TIMEOUT:
            break;

        case BASEKEY_ACCEL_BITRATE:
            /* Do nothing - things like current, default, and capability do not make sense here */
            break;

        case BASEKEY_ACCEL_DURATION:
            /* Do nothing - things like current, default, and capability do not make sense here */
            break;
        case BASEKEY_MAX_TCP_RECV_BUFFER_SIZE:
        {
            if (IsHttpExtensionHeaderValid(aParameters[0]))
            {
                PVMFSMNodeContainer* iSocketNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_SOCKET_NODE);
                if (iSocketNodeContainer != NULL)
                {
                    PVMFSocketNode* socketNode =
                        (PVMFSocketNode*)(iSocketNodeContainer->iNode);
                    if ((reqattr == PVMI_KVPATTR_CUR) || (reqattr == PVMI_KVPATTR_DEF))
                    {
                        uint32 size = 0;
                        socketNode->GetMaxTCPRecvBufferSize(size);
                        aParameters[0].value.uint32_value = size;
                    }
                }
            }
        }
        break;

        case BASEKEY_DISABLE_FIREWALL_PACKETS:
        {
            if ((reqattr == PVMI_KVPATTR_CUR) || (reqattr == PVMI_KVPATTR_DEF))
            {
                aParameters[0].value.bool_value = false;
            }
        }
        break;

        default:
            // Invalid index
            oscl_free(aParameters[0].key);
            oscl_free(aParameters);
            PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVPlayerEngine::DoGetPlayerParameter() Invalid index to player parameter"));
            return PVMFErrArgument;
    }

    aNumParamElements = 1;

    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVPlayerEngine::DoGetPlayerParameter() Out"));
    return PVMFSuccess;
}

PVMFStatus PVMFStreamingManagerNode::VerifyAndSetConfigParameter(int index, PvmiKvp& aParameter, bool set)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::VerifyAndSetConfigParameter() In"));

    // Determine the valtype
    PvmiKvpValueType keyvaltype = GetValTypeFromKeyString(aParameter.key);
    if (keyvaltype == PVMI_KVPVALTYPE_UNKNOWN)
    {
        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::VerifyAndSetConfigParameter() "
                          "Valtype in key string unknown"));
        return PVMFErrArgument;
    }

    // Verify the valtype
    if (keyvaltype != StreamingManagerConfig_BaseKeys[index].iValueType)
    {
        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::VerifyAndSetConfigParameter() "
                          "Valtype does not match for key"));
        return PVMFErrArgument;
    }

    switch (index)
    {
        case BASEKEY_DELAY:
        {
            // Validate
            if ((aParameter.value.uint32_value < MIN_JITTER_BUFFER_DURATION_IN_MS) ||
                    (aParameter.value.uint32_value > MAX_JITTER_BUFFER_DURATION_IN_MS))
            {
                PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::VerifyAndSetConfigParameter() "
                                  "Trying to set delay to 0"));
                return PVMFErrArgument;
            }

            if (set)
            {
                // save value locally
                setJitterBufferDurationInMilliSeconds(aParameter.value.uint32_value);

                // pass the value on to the jitter buffer node
                PVMFSMNodeContainer* iJitterBufferNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
                PVMFJitterBufferExtensionInterface* jbExtIntf =
                    (PVMFJitterBufferExtensionInterface*)iJitterBufferNodeContainer->iExtensions[0];
                jbExtIntf->setJitterBufferDurationInMilliSeconds(aParameter.value.uint32_value);
            }
        }
        break;
        case BASEKEY_REBUFFERING_THRESHOLD:
        {
            uint32 jbDuration = 0;
            PVMFSMNodeContainer* iJitterBufferNodeContainer =
                getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
            PVMFJitterBufferExtensionInterface* jbExtIntf =
                (PVMFJitterBufferExtensionInterface*)iJitterBufferNodeContainer->iExtensions[0];
            jbExtIntf->getJitterBufferDurationInMilliSeconds(jbDuration);
            // Validate
            if (aParameter.value.uint32_value >= jbDuration)
            {
                PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::VerifyAndSetConfigParameter() "
                                  "Trying to set rebuffering threshold greater than equal to jitter buffer duration"));
                return PVMFErrArgument;
            }
            if (set)
            {
                // pass the value on to the jitter buffer node
                jbExtIntf->setJitterBufferRebufferingThresholdInMilliSeconds(aParameter.value.uint32_value);
            }
        }
        break;
        case BASEKEY_JITTERBUFFER_NUMRESIZE:
        {
            if (set)
            {
                // retrieve and update
                uint32 numResize, resizeSize;
                PVMFSMNodeContainer* iJitterBufferNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
                PVMFJitterBufferExtensionInterface* jbExtIntf =
                    (PVMFJitterBufferExtensionInterface*)iJitterBufferNodeContainer->iExtensions[0];
                jbExtIntf->GetSharedBufferResizeParams(numResize, resizeSize);
                jbExtIntf->SetSharedBufferResizeParams(aParameter.value.uint32_value, resizeSize);
            }
        }
        break;
        case BASEKEY_JITTERBUFFER_RESIZESIZE:
        {
            if (set)
            {
                // retrieve and update
                uint32 numResize, resizeSize;
                PVMFSMNodeContainer* iJitterBufferNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
                PVMFJitterBufferExtensionInterface* jbExtIntf =
                    (PVMFJitterBufferExtensionInterface*)iJitterBufferNodeContainer->iExtensions[0];
                jbExtIntf->GetSharedBufferResizeParams(numResize, resizeSize);
                jbExtIntf->SetSharedBufferResizeParams(numResize, aParameter.value.uint32_value);
            }
        }
        break;
        case BASEKEY_SESSION_CONTROLLER_USER_AGENT:
        {
            if (set)
            {
                // user agent update
                PVMFSMNodeContainer* iSessionControllerNodeContainer = NULL;
                iSessionControllerNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);
                if (iSessionControllerNodeContainer != NULL)
                {
                    PVRTSPEngineNodeExtensionInterface* rtspExtIntf =
                        (PVRTSPEngineNodeExtensionInterface*)
                        (iSessionControllerNodeContainer->iExtensions[0]);

                    OSCL_wHeapString<OsclMemAllocator> userAgent;
                    OSCL_wHeapString<OsclMemAllocator> dummy;
                    userAgent = aParameter.value.pWChar_value;
                    rtspExtIntf->SetClientParameters(userAgent, dummy, dummy);
                }
                iSessionControllerNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_HTTP_SESSION_CONTROLLER_NODE);
                OSCL_wHeapString<OsclMemAllocator> userAgent = aParameter.value.pWChar_value;
                if (iSessionControllerNodeContainer != NULL)
                {
                    PVMFProtocolEngineNodeMSHTTPStreamingExtensionInterface* httpExtIntf =
                        (PVMFProtocolEngineNodeMSHTTPStreamingExtensionInterface*)
                        (iSessionControllerNodeContainer->iExtensions[0]);

                    httpExtIntf->SetUserAgent(userAgent);
                }
                // save user-agent kvp for cpm
                if (iCPM)
                {
                    PVMFStatus status = iCPMKvpStore.addKVPString(aParameter.key, userAgent);
                    if (status != PVMFSuccess) return status;
                }

            }
        }
        break;

        case BASEKEY_HTTP_VERSION:
        {
            if (set)
            {
                PVMFSMNodeContainer* iSessionControllerNodeContainer = NULL;
                iSessionControllerNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_HTTP_SESSION_CONTROLLER_NODE);
                if (iSessionControllerNodeContainer != NULL)
                {
                    PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::VerifyAndSetConfigParameter() "
                                      "Setting HTTP Protocol Version Not supported"));
                    return PVMFErrNotSupported;
                }
            }
        }
        break;

        case BASEKEY_NUM_REDIRECT_ATTEMPTS:
        {
            if (set)
            {
                if (IsHttpExtensionHeaderValid(aParameter))
                {
                    PVMFSMNodeContainer* iSessionControllerNodeContainer = NULL;
                    iSessionControllerNodeContainer =
                        getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);
                    if (iSessionControllerNodeContainer != NULL)
                    {
                        //do nothing for now - till RTSP node has an api to set this
                    }
                    iSessionControllerNodeContainer =
                        getNodeContainer(PVMF_STREAMING_MANAGER_HTTP_SESSION_CONTROLLER_NODE);
                    if (iSessionControllerNodeContainer != NULL)
                    {
                        PVMFProtocolEngineNodeMSHTTPStreamingExtensionInterface* httpExtIntf =
                            (PVMFProtocolEngineNodeMSHTTPStreamingExtensionInterface*)
                            (iSessionControllerNodeContainer->iExtensions[0]);

                        httpExtIntf->SetNumRedirectTrials(aParameter.value.uint32_value);
                    }
                }
                else
                {
                    OSCL_StackString<32> dlamode(_STRLIT_CHAR("mode=dla"));
                    bool isDlaMode  = (oscl_strstr(OSCL_CONST_CAST(char*, aParameter.key), dlamode.get_cstr())  != NULL);
                    if (isDlaMode)
                    {
                        if (iCPM)
                        {
                            PVMFStatus status = iCPMKvpStore.addKVPuint32Value(aParameter.key, aParameter.value.uint32_value);
                            if (status != PVMFSuccess)
                                return status;
                        }
                    }
                }
            }
        }
        break;

        case BASEKEY_SESSION_CONTROLLER_KEEP_ALIVE_INTERVAL:
        {
            if (set)
            {
                // user agent update
                /* As of now just RTSP node supports an external config of user agent */
                PVMFSMNodeContainer* iSessionControllerNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);
                if (iSessionControllerNodeContainer != NULL)
                {
                    PVRTSPEngineNodeExtensionInterface* rtspExtIntf =
                        (PVRTSPEngineNodeExtensionInterface*)
                        (iSessionControllerNodeContainer->iExtensions[0]);
                    rtspExtIntf->SetKeepAliveMethod_timeout(aParameter.value.uint32_value);
                }
                iSessionControllerNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_HTTP_SESSION_CONTROLLER_NODE);
                if (iSessionControllerNodeContainer != NULL)
                {
                    PVMFProtocolEngineNodeMSHTTPStreamingExtensionInterface* httpExtIntf =
                        (PVMFProtocolEngineNodeMSHTTPStreamingExtensionInterface*)
                        (iSessionControllerNodeContainer->iExtensions[0]);
                    httpExtIntf->SetKeepAliveTimeout(aParameter.value.uint32_value);
                }

            }
        }
        break;

        case BASEKEY_SESSION_CONTROLLER_KEEP_ALIVE_DURING_PLAY:
        {
            if (set)
            {
                // keep-alive during play update
                /* As of now just RTSP node supports an external config of keep-alive during play */
                PVMFSMNodeContainer* iSessionControllerNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_RTSP_SESSION_CONTROLLER_NODE);
                if (iSessionControllerNodeContainer != NULL)
                {
                    PVRTSPEngineNodeExtensionInterface* rtspExtIntf =
                        (PVRTSPEngineNodeExtensionInterface*)
                        (iSessionControllerNodeContainer->iExtensions[0]);
                    rtspExtIntf->SetKeepAliveMethod_keep_alive_in_play(aParameter.value.bool_value);
                }
            }
        }
        break;


        case BASEKEY_MAX_TCP_RECV_BUFFER_SIZE:
        {
            if (IsHttpExtensionHeaderValid(aParameter))
            {
                if (set)
                {
                    PVMFSMNodeContainer* iSocketNodeContainer =
                        getNodeContainer(PVMF_STREAMING_MANAGER_SOCKET_NODE);
                    if (iSocketNodeContainer != NULL)
                    {
                        PVMFSocketNode* socketNode =
                            (PVMFSocketNode*)(iSocketNodeContainer->iNode);
                        socketNode->SetMaxTCPRecvBufferSize(aParameter.value.uint32_value);
                    }
                }
            }
        }
        break;

        case BASEKEY_DISABLE_FIREWALL_PACKETS:
        {
            if (set)
            {
                PVMFSMNodeContainer* iJitterBufferNodeContainer =
                    getNodeContainer(PVMF_STREAMING_MANAGER_JITTER_BUFFER_NODE);
                PVMFJitterBufferExtensionInterface* jbExtIntf =
                    (PVMFJitterBufferExtensionInterface*)iJitterBufferNodeContainer->iExtensions[0];
                jbExtIntf->DisableFireWallPackets();
            }
        }
        break;

        default:
            return PVMFErrNotSupported;
    }

    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
                    (0, "PVMFStreamingManagerNode::VerifyAndSetPlayerParameter() Out"));

    return PVMFSuccess;
}

// remove the ending ';', ',' or ' ' and calulate value length
uint32 PVMFStreamingManagerNode::getItemLen(char *ptrItemStart, char *ptrItemEnd)
{
    char *ptr = ptrItemEnd - 1;
    uint32 itemLen = ptr - ptrItemStart;
    for (uint32 i = 0; i < itemLen; i++)
    {
        if (*ptr == ';' || *ptr == ',' || *ptr == ' ') --ptr;
        else break;
    }
    itemLen = ptr - ptrItemStart + 1;
    return itemLen;
}


bool PVMFStreamingManagerNode::IsInternalCmd(PVMFCommandId aId)
{
    if ((aId == PVMF_STREAMING_MANAGER_NODE_CONSTRUCT_SESSION) ||
            (aId == PVMF_STREAMING_MANAGER_NODE_AUTO_PAUSE) ||
            (aId == PVMF_STREAMING_MANAGER_NODE_AUTO_RESUME) ||
            (aId == PVMF_STREAMING_MANAGER_NODE_THIN_STREAM))
    {
        return true;
    }
    return false;
}

bool PVMFStreamingManagerNode::IsHttpExtensionHeaderValid(PvmiKvp &aParameter)
{
    OSCL_StackString<32> downloadMode(_STRLIT_CHAR("mode=download"));
    OSCL_StackString<32> streamingMode(_STRLIT_CHAR("mode=streaming"));
    OSCL_StackString<32> dlaMode(_STRLIT_CHAR("mode=dla"));

    bool isDownloadMode  = (oscl_strstr(OSCL_CONST_CAST(char*, aParameter.key), downloadMode.get_cstr())  != NULL);
    bool isStreamingMode = (oscl_strstr(OSCL_CONST_CAST(char*, aParameter.key), streamingMode.get_cstr()) != NULL);
    bool isDlaMode = (oscl_strstr(OSCL_CONST_CAST(char*, aParameter.key), dlaMode.get_cstr()) != NULL);


    // download mode only would fail, streaming mode specified or not specified will be viewed as true
    if (isDownloadMode && !isStreamingMode) return false;

    // dla mode only would fail, streaming mode specified or not specified will be viewed as true
    if (isDlaMode && !isStreamingMode) return false;


    return true;
}


PVMFStatus
PVMFStreamingManagerNode::GetMaxSizeValue(char* aString, uint32& aMaxSize)
{
    aMaxSize = 0xFFFFFFFF;
    /*
     * This parses a string of the form "maxsize=N1" and extracts the integer N1.
     */
    if (aString == NULL)
    {
        return PVMFErrArgument;
    }

    /* Go to end of "maxsize=" */
    char* n1string = aString + 8;
    char* truncatestr = oscl_strstr(n1string, PVMFSTREAMINGMGRNODE_TRUNCATE_FLAG);

    uint32 maxsizelen = 0;

    if (truncatestr != NULL)
    {
        maxsizelen = oscl_strlen(n1string) - (oscl_strlen(truncatestr) + 1);
        n1string[maxsizelen] = '\0';
    }

    if (PV_atoi(n1string, 'd', oscl_strlen(n1string), aMaxSize))
    {
        return PVMFSuccess;
    }
    return PVMFFailure;
}

PVMFStatus
PVMFStreamingManagerNode::GetTruncateFlagValue(char* aString, uint32& aTruncateFlag)
{
    aTruncateFlag = 0;
    /*
     * This parses a string of the form "truncate=N1" and extracts the integer N1.
     */
    if (aString == NULL)
    {
        return PVMFErrArgument;
    }

    /* Go to end of "truncate=" */
    char* n1string = aString + 9;

    if (!oscl_strcmp(n1string, "true"))
    {
        aTruncateFlag = true;
    }
    else if (!oscl_strcmp(n1string, "false"))
    {
        aTruncateFlag = false;
    }
    else
    {
        return PVMFFailure;
    }
    return PVMFSuccess;

}


void
PVMFStreamingManagerNode::ResetNodeContainerCmdState()
{
    for (uint32 i = 0; i < iNodeContainerVec.size(); i++)
    {
        if (iNodeContainerVec[i].iNodeCmdState == PVMFSM_NODE_CMD_COMPLETE)
        {
            iNodeContainerVec[i].iNodeCmdState = PVMFSM_NODE_CMD_NO_PENDING;
        }
        else if (iNodeContainerVec[i].iNodeCmdState == PVMFSM_NODE_CMD_CANCEL_PENDING)
        {
            iNodeContainerVec[i].iNodeCmdState = PVMFSM_NODE_CMD_CANCEL_COMPLETE;
        }
    }
}

//////////////////// PVMFSMNodeKVPStore Implementation /////////////////////////////////////////////////////////

// add kvp string with W-string value
PVMFStatus PVMFSMNodeKVPStore::addKVPString(const char* aKeyTypeString, OSCL_wString& aValString)
{
    PvmiKvp aKeyVal;
    aKeyVal.key = NULL;
    PVMFStatus status = PVMFCreateKVPUtils::CreateKVPForWStringValue(aKeyVal, aKeyTypeString, aValString);
    if (status != PVMFSuccess) return status;

    int32 err = 0;
    OSCL_TRY(err,
             iKvpVector.push_back(aKeyVal);
             KVPValueTypeForMemoryRelease valType = KVPValueTypeForMemoryRelease_WString;
             iKVPValueTypeForMemoryRelease.push_back((uint32)valType);
            );
    return (err == 0 ? PVMFSuccess : PVMFErrNoMemory);
}

// add kvp string with normal string value
PVMFStatus PVMFSMNodeKVPStore::addKVPString(const char* aKeyTypeString, const char* aValString)
{
    PvmiKvp aKeyVal;
    aKeyVal.key = NULL;
    PVMFStatus status = PVMFCreateKVPUtils::CreateKVPForCharStringValue(aKeyVal, aKeyTypeString, aValString);
    if (status != PVMFSuccess) return status;

    int32 err = 0;
    OSCL_TRY(err,
             iKvpVector.push_back(aKeyVal);
             KVPValueTypeForMemoryRelease valType = KVPValueTypeForMemoryRelease_String;
             iKVPValueTypeForMemoryRelease.push_back((uint32)valType);
            );
    return (err == 0 ? PVMFSuccess : PVMFErrNoMemory);
}

void PVMFSMNodeKVPStore::releaseMemory()
{
    OSCL_ASSERT(iKvpVector.size() == iKVPValueTypeForMemoryRelease.size());

    for (uint32 i = 0; i < iKvpVector.size(); i++)
    {
        if (iKvpVector[i].key) OSCL_ARRAY_DELETE(iKvpVector[i].key);

        // release memory for appropriate types of KVP value
        if ((KVPValueTypeForMemoryRelease)iKVPValueTypeForMemoryRelease[i] == KVPValueTypeForMemoryRelease_WString &&
                iKvpVector[i].value.pWChar_value) OSCL_ARRAY_DELETE(iKvpVector[i].value.pWChar_value);
        if ((KVPValueTypeForMemoryRelease)iKVPValueTypeForMemoryRelease[i] == KVPValueTypeForMemoryRelease_String &&
                iKvpVector[i].value.pChar_value) OSCL_ARRAY_DELETE(iKvpVector[i].value.pChar_value);
    }
}


PVMFStatus PVMFSMNodeKVPStore::addKVPuint32Value(const char* aKeyTypeString, uint32 aValue)
{
    PvmiKvp aKeyVal;
    aKeyVal.key = NULL;
    PVMFStatus status = PVMFCreateKVPUtils::CreateKVPForUInt32Value(aKeyVal, aKeyTypeString, aValue);
    if (status != PVMFSuccess) return status;

    int32 err = 0;
    OSCL_TRY(err,
             iKvpVector.push_back(aKeyVal);
             KVPValueTypeForMemoryRelease valType = KVPValueTypeForMemoryRelease_NoInterest;
             iKVPValueTypeForMemoryRelease.push_back((uint32)valType);
            );
    return (err == 0 ? PVMFSuccess : PVMFErrNoMemory);
}

//Check for RTP packet source
bool
PVMFStreamingManagerNode::IsRTPPacketSourcePresent()
{
    return false;
}