Category

Development Platform
Home > SourceCode/Document > Communication-Mobile > Symbian > View Code
rtsptran.cpp
Package: 142_61_thumb_advanced.rar　[view]
Upload User: dangjiwu
Upload Date: 2013-07-19
Package Size: 42019k
Code Size: 41k
Category:

Symbian

Development Platform:

Visual C++

rtsptran.cpp：Code Content
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: rtsptran.cpp,v 1.22.8.1 2004/07/09 02:04:41 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. #include "hxtypes.h"
  51. #include "hxassert.h"
  52. #include "debug.h"
  53. #include "hxcom.h"
  54. #include "hxmarsh.h"
  55. #include "hxstrutl.h"
  56. #include "netbyte.h"
  57. #include "hxengin.h"
  58. #include "ihxpckts.h"
  59. #include "hxcomm.h"
  60. #include "hxmon.h"
  61. #include "netbyte.h"
  62. #include "hxstring.h"
  63. #include "chxpckts.h"
  64. #include "hxslist.h"
  65. #include "hxmap.h"
  66. #include "hxdeque.h"
  67. #include "hxbitset.h"
  68. #include "timebuff.h"
  69. #include "timeval.h"
  70. #include "tconverter.h"
  71. #include "rtptypes.h"
  72. #include "rtspmsg.h"
  73. #include "hxcorgui.h"
  75. #include "ntptime.h"
  77. #include "rtspif.h"
  78. #include "rtsptran.h"
  79. //#include "rtpwrap.h" // Wrappers for PMC generated base classes
  80. #include "basepkt.h"
  81. #include "hxtbuf.h"
  82. #include "transbuf.h"
  83. #include "hxtick.h"
  84. #include "random32.h" // random32()
  85. #include "pkthndlr.h" // in rtpmisc for RTCP routine
  86. #include "rtcputil.h" // takes care of RTCP in RTP mode
  87. #include "hxprefs.h" // IHXPreferences
  88. #include "hxmime.h"
  89. #include "hxcore.h"
  91. #include "hxheap.h"
  92. #ifdef PAULM_IHXTCPSCAR
  93. #include "objdbg.h"
  94. #endif
  96. #ifdef PAULM_TNGTCPTRANSTIMING
  97. #include "classtimer.h"
  98. ClassTimer g_TNGTCPTransTimer("TNGTCPTransport", 0, 3600);
  99. #endif
  101. #ifdef _DEBUG
  102. #undef HX_THIS_FILE
  103. static const char HX_THIS_FILE[] = __FILE__;
  104. #endif
  106. #define STREAM_END_DELAY_BASE_TOLERANCE 3000
  108. static const UINT32 TRANSPORT_BUF_GROWTH_RATE  = 1000;
  110. void
  111. dump(const char* pFile, const char* pc)
  112. {
  113.     FILE* fp = fopen(pFile, "a");
  114.     if(!fp)
  115.     {
  116.     return;
  117.     }
  118.     fprintf(fp, "%s", pc);
  119.     fclose(fp);    
  120. }
  123. RTSPStreamData::RTSPStreamData(BOOL needReliable):
  124.     m_seqNo(0),
  125.     m_streamNumber(0),
  126.     m_reliableSeqNo(0),
  127.     m_lastTimestamp(0),
  128.     m_pTransportBuffer(0),
  129.     m_pResendBuffer(0),
  130.     m_pStreamStats(0),
  131.     m_bNeedReliable(needReliable),
  132.     m_packetSent(FALSE),
  133.     m_bReceivedAllPackets(FALSE),
  134.     m_bNeedToACK(FALSE),
  135.     m_bFirstPacket(TRUE),
  136.     m_bUsesRTPPackets(FALSE),
  137.     m_pTSConverter(NULL),
  138.     m_pTSOrderHack(NULL),
  139.     m_eMediaType(RTSPMEDIA_TYPE_UNKNOWN)
  140. {
  141.     ;
  142. }
  144. RTSPStreamData::~RTSPStreamData()
  145. {
  146.     if (m_pTransportBuffer)
  147.     {
  148. delete m_pTransportBuffer;
  149.     }
  151.     if (m_pResendBuffer)
  152.     {
  153. delete m_pResendBuffer;
  154.     }
  156.     HX_DELETE(m_pTSConverter);
  157.     HX_DELETE(m_pTSOrderHack);
  158. }
  160. RTSPStreamHandler::RTSPStreamHandler(RTSPTransport* pOwner)
  161.     : m_pOwner(pOwner)
  162.     , m_lRefCount(0)
  163. {
  164.     m_pStreamDataMap = new CHXMapLongToObj;
  165. }
  167. RTSPStreamHandler::~RTSPStreamHandler()
  168. {
  169.     CHXMapLongToObj::Iterator i;
  170.     RTSPStreamData* pStreamData;
  172.     for(i=m_pStreamDataMap->Begin();i!=m_pStreamDataMap->End();++i)
  173.     {
  174. pStreamData = (RTSPStreamData*)(*i);
  175. delete pStreamData;
  176.     }
  177.     delete m_pStreamDataMap;
  178. }
  181. HX_RESULT
  182. RTSPStreamHandler::initStreamData(
  183.     UINT16 streamNumber, BOOL needReliable, BOOL bIsSource, INT16 rtpPayloadType,
  184.     BOOL bRecordFlag, UINT32 wrapSequenceNumber, UINT32 ulBufferDepth,
  185.     BOOL bHasOutOfOrderTS, CHXTimestampConverter* pTSConverter,
  186.     RTSPMediaType eMediaType)
  187. {
  188.     RTSPStreamData* pStreamData;
  190.     if(!m_pStreamDataMap->Lookup(streamNumber, (void*&)pStreamData))
  191.     {
  192. pStreamData = new RTSPStreamData(needReliable);
  193. pStreamData->m_streamNumber = streamNumber;
  194.         pStreamData->m_pTSConverter = pTSConverter;
  195. pStreamData->m_eMediaType = eMediaType;
  196. pStreamData->m_lastSeqNo = 0;
  197. (*m_pStreamDataMap)[streamNumber] = pStreamData;
  199. if (!bIsSource)
  200. {
  201.     UINT32 ulSetMaximumBufferDepth;
  202.     UINT32 ulSetBufferDepth;
  204.     if (bRecordFlag && ulBufferDepth != TRANSPORT_BUF_DURATION_UNDEF)
  205.     {
  206.      ulSetMaximumBufferDepth = ulBufferDepth;
  207.      ulSetBufferDepth = ulBufferDepth;
  208.     }
  209.     else if (bRecordFlag)
  210.     {
  211.      ulSetMaximumBufferDepth = MAX_TRANSPORT_BUF_DURATION;
  212.      ulSetBufferDepth = MAX_TRANSPORT_BUF_DURATION;
  213.     }
  214.     else
  215.     {
  216.      ulSetMaximumBufferDepth = MAX_TRANSPORT_BUF_DURATION;
  217.      ulSetBufferDepth = TRANSPORT_BUF_DURATION;
  218.     }
  220.     RTSPTransportBuffer* pTransportBuffer = 
  221. new RTSPTransportBuffer(m_pOwner,
  222.                                 streamNumber,
  223.                                 ulSetBufferDepth,
  224.                                 ulSetMaximumBufferDepth,
  225.                                 TRANSPORT_BUF_GROWTH_RATE,
  226.                                 wrapSequenceNumber);
  229.     pStreamData->m_pTransportBuffer = pTransportBuffer;
  230.     pStreamData->m_pStreamStats = NULL;
  231.     pStreamData->m_bUsesRTPPackets = bHasOutOfOrderTS;
  232. }
  234. return HXR_OK;
  235.     }
  237.     return HXR_FAIL;
  238. }
  240. RTSPStreamData*
  241. RTSPStreamHandler::getStreamData(UINT16 streamNumber)
  242. {
  243.     RTSPStreamData* pStreamData = 0;
  245.     if(!m_pStreamDataMap->Lookup(streamNumber, (void*&)pStreamData))
  246.     {
  247. return 0;
  248.     }
  250.     return pStreamData;
  251. }
  253. RTSPStreamData*
  254. RTSPStreamHandler::firstStreamData()
  255. {
  256.     streamIterator = m_pStreamDataMap->Begin();
  257.     if(streamIterator == m_pStreamDataMap->End())
  258.     {
  259. return 0;
  260.     }
  261.     return (RTSPStreamData*)(*streamIterator);
  262. }
  264. RTSPStreamData*
  265. RTSPStreamHandler::nextStreamData()
  266. {
  267.     ++streamIterator;
  268.     if(streamIterator == m_pStreamDataMap->End())
  269.     {
  270. return 0;
  271.     }
  272.     return (RTSPStreamData*)(*streamIterator);
  273. }
  275. BOOL
  276. RTSPStreamHandler::endStreamData()
  277. {
  278.     return (streamIterator == m_pStreamDataMap->End());
  279. }
  281. HX_RESULT
  282. RTSPStreamHandler::createResendBuffer(UINT16 streamNumber,
  283.       UINT32 wrapSequenceNumber)
  284. {
  285.     RTSPStreamData* pStreamData;
  287.     if(!m_pStreamDataMap->Lookup(streamNumber, (void*&)pStreamData))
  288.     {
  289. return HXR_FAILED;
  290.     }
  292.     RTSPResendBuffer* pResendBuffer;
  294.     pResendBuffer = new RTSPResendBuffer(RESEND_BUF_DURATION,
  295.                                          MAX_RESEND_BUF_DURATION,
  296.                                          RESEND_BUF_GROWTH_RATE,
  297.                                          wrapSequenceNumber);
  299.     pStreamData->m_pResendBuffer = pResendBuffer;
  300.     return HXR_OK;
  301. }
  303. RTSPResendBuffer*
  304. RTSPStreamHandler::getResendBuffer(UINT16 streamNumber)
  305. {
  306.     RTSPStreamData* pStreamData = 0;
  308.     if(!m_pStreamDataMap->Lookup(streamNumber, (void*&)pStreamData))
  309.     {
  310. return 0;
  311.     }
  312.     return pStreamData->m_pResendBuffer;
  313. }
  315. /*
  316.  * RTSPTransport methods
  317.  */
  319. RTSPTransport::RTSPTransport(BOOL bIsSource):
  320.     m_pContext(NULL),
  321.     m_pCommonClassFactory(0),
  322.     m_pScheduler(0),
  323.     m_pResp(0),
  324.     m_pStreamHandler(0),
  325.     m_pRegistry(0),
  326.     m_pInternalReset(0),
  327.     m_pSrcBufferStats(0),
  328.     m_bIsSource(bIsSource),
  329.     m_bIsInitialized(FALSE),
  330.     m_bIsUpdated(FALSE),
  331.     m_ulPacketsSent(0),
  332.     m_lBytesSent(0),
  333.     m_bIsReceivedData(FALSE),
  334.     m_bSourceDone(FALSE),
  335.     m_bHackedRecordFlag(FALSE),
  336.     m_wrapSequenceNumber(0),
  337.     m_bMulticast(FALSE),
  338.     m_pPlayerState(NULL),
  339.     m_pPacketFilter(NULL),
  340.     m_pClientPacketList(NULL),
  341.     m_bPrefetch(FALSE),
  342.     m_bFastStart(FALSE),
  343.     m_ulPlayRangeFrom(RTSP_PLAY_RANGE_BLANK),
  344.     m_ulPlayRangeTo(RTSP_PLAY_RANGE_BLANK),
  345.     m_bPlayRequestSent(FALSE),
  346.     m_packets_since_last_drop(0),
  347.     m_ulTotalSuccessfulResends(0),
  348.     m_ulTotalFailedResends(0),
  349.     m_ulSendingTime(0),
  350.     m_drop_packets(FALSE),
  351.     m_bSkipTimeAdjustment(FALSE)
  352. #ifdef RDT_MESSAGE_DEBUG
  353.     ,m_bRDTMessageDebug(FALSE)
  354. #endif    
  355. {
  356.     m_ulStartTime = HX_GET_TICKCOUNT();
  357. }
  359. RTSPTransport::~RTSPTransport()
  360. {
  361.     HX_RELEASE(m_pCommonClassFactory);
  362.     HX_RELEASE(m_pScheduler);
  363.     HX_RELEASE(m_pResp);
  364.     HX_RELEASE(m_pRegistry);
  365.     if (m_pStreamHandler)
  366.     {
  367.         m_pStreamHandler->Release();
  368.         m_pStreamHandler = NULL;
  369.     }
  370.     HX_RELEASE(m_pInternalReset);
  371.     HX_RELEASE(m_pSrcBufferStats);
  372.     HX_RELEASE(m_pPlayerState);
  373.     HX_RELEASE(m_pPacketFilter);
  374.     HX_RELEASE(m_pContext);
  376.     HX_DELETE(m_pClientPacketList);
  377. }
  379. void
  380. RTSPTransport::addStreamInfo(RTSPStreamInfo* pStreamInfo, UINT32 ulBufferDepth)
  381. {
  382.     if(pStreamInfo)
  383.     {
  384. if(!m_pStreamHandler)
  385. {
  386.     m_pStreamHandler = new RTSPStreamHandler(this);
  387.     m_pStreamHandler->AddRef();
  388. }
  390. CHXTimestampConverter*  pTSConverter = NULL;
  392. if (pStreamInfo->m_HXFactor && pStreamInfo->m_RTPFactor)
  393. {
  394.     pTSConverter = new CHXTimestampConverter(CHXTimestampConverter::FACTORS,
  395.      pStreamInfo->m_HXFactor,
  396.      pStreamInfo->m_RTPFactor);
  397.  }
  398.  else if (pStreamInfo->m_sampleRate)
  399.  {
  400.      
  401.      pTSConverter =  new CHXTimestampConverter(CHXTimestampConverter::SAMPLES,
  402.        pStreamInfo->m_sampleRate);
  403.  }
  405.  m_pStreamHandler->initStreamData(
  406.      pStreamInfo->m_streamNumber,
  407.      pStreamInfo->m_bNeedReliablePackets,
  408.      m_bIsSource,
  409.      pStreamInfo->m_rtpPayloadType,
  410.      m_bHackedRecordFlag,
  411.      m_wrapSequenceNumber,
  412.      ulBufferDepth,
  413.      pStreamInfo->m_bHasOutOfOrderTS,
  414.      pTSConverter,
  415.      pStreamInfo->m_eMediaType);
  417.         m_bSkipTimeAdjustment = pStreamInfo->m_bRealMedia;
  419. RTSPStreamData* pStreamData = NULL;
  420. pStreamData = m_pStreamHandler->getStreamData(pStreamInfo->m_streamNumber);
  421. if (pStreamData && pStreamData->m_pTransportBuffer && m_bPrefetch)
  422. {
  423.     pStreamData->m_pTransportBuffer->EnterPrefetch();
  424. }
  425.     }
  426. }
  428. void
  429. RTSPTransport::setFirstTimeStamp(UINT16 uStreamNumber, UINT32 ulTS, 
  430.                                  BOOL bIsRaw)
  431. {
  432.     RTSPStreamData* pStreamData = 
  433. m_pStreamHandler->getStreamData(uStreamNumber);
  435.     if (pStreamData)
  436.     {
  437. if (pStreamData->m_pTSConverter)
  438. {
  439.     pStreamData->m_pTSConverter->setHXAnchor(ulTS);
  440. }
  441.          
  442. HX_DELETE(pStreamData->m_pTSOrderHack);
  443.     }
  445.     if (!m_bIsSource)
  446.     {
  447. RTSPTransportBuffer* pTransportBuffer = pStreamData->m_pTransportBuffer;
  449. if (pTransportBuffer && pStreamData)
  450. {
  451.     if ((m_ulPlayRangeFrom != RTSP_PLAY_RANGE_BLANK) &&
  452. (m_ulPlayRangeTo != RTSP_PLAY_RANGE_BLANK))
  453.     {
  454. if ((pStreamData->m_eMediaType == RTSPMEDIA_TYPE_AUDIO) ||
  455.     (pStreamData->m_eMediaType == RTSPMEDIA_TYPE_VIDEO))
  456. {
  457.     // For audio & video media, we'll inform transport of
  458.     // the media duration to help determining stream termination
  459.     pStreamData->m_pTransportBuffer->InformTimestampRange(
  460. m_ulPlayRangeFrom,
  461. m_ulPlayRangeTo,
  462. STREAM_END_DELAY_BASE_TOLERANCE);
  463. }
  464.     }
  465. }
  466.     }
  467. }
  469. void 
  470. RTSPTransport::setPlayRange(UINT32 ulFrom, UINT32 ulTo)
  471. {
  472.     // this is the Range values in PLAY request in RMA time (ms) called on PLAY 
  473.     // request
  474.     m_ulPlayRangeFrom = ulFrom; 
  475.     m_ulPlayRangeTo = ulTo;
  476. }
  478. void
  479. RTSPTransport::setSessionID(const char* pSessionID)
  480. {
  481.     m_sessionID = pSessionID;
  482. }
  484. UINT16
  485. RTSPTransport::getSeqNum(UINT16 streamNumber)
  486. {
  487.     RTSPStreamData* pStreamData;
  489.     pStreamData = m_pStreamHandler->getStreamData(streamNumber);
  491.     if(pStreamData)
  492.     {
  493. return pStreamData->m_seqNo;
  494.     }
  495.     else
  496.     {
  497. return 0; //XXXBAB - 0xffff?
  498.     }
  499. }
  501. UINT32
  502. RTSPTransport::getTimestamp(UINT16 streamNumber)
  503. {
  504.     RTSPStreamData* pStreamData;
  506.     pStreamData = m_pStreamHandler->getStreamData(streamNumber);
  508.     if(pStreamData)
  509.     {
  510. // XXXGo - this is RTP time w/ offset (NOT RMA time) if RTPUDPTransprot...
  511. return pStreamData->m_lastTimestamp;
  512.     }
  513.     else
  514.     {
  515. return 0;
  516.     }
  517. }
  519. HX_RESULT
  520. RTSPTransport::getPacket(UINT16 uStreamNumber, IHXPacket*& pPacket)
  521. {
  522.     RTSPTransportBuffer* pTransportBuffer = getTransportBuffer(uStreamNumber);
  523.     RTSPStreamData* pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);
  525.     if ((!pTransportBuffer) || (!pStreamData))
  526.     {
  527. return HXR_FAIL;
  528.     }
  530.     ClientPacket* clientPacket;
  532.     HX_RESULT result = pTransportBuffer->GetPacket(clientPacket);
  534.     if (result != HXR_OK)
  535.     {
  536. return result;
  537.     }
  539.     pPacket = clientPacket->GetPacket();
  541.     if (!pPacket)
  542.     {
  543. /*
  544.  * This is a lost packet
  545.  */
  547. result = m_pCommonClassFactory->CreateInstance(CLSID_IHXPacket,
  548.                                                (void**)&pPacket);
  550. if (result != HXR_OK)
  551. {
  552.     return result;
  553. }
  555. UINT8 unASMFlags = 0;
  556. UINT32 ulTime = 0;
  557. if (clientPacket->IsDroppedPacket())
  558. {
  559.     // Preserve dropped flag as an ASM flag.
  560.     // This allows other code along the packet
  561.     // path to differentiate this packet from a 
  562.     // true lost packet.
  563.     unASMFlags |= HX_ASM_DROPPED_PKT;
  565.     // We have a valid timestamp for a dropped
  566.     // packet so lets put it in the IHXPacket
  567.     ulTime = clientPacket->GetTime();
  568. }
  570. pPacket->Set(0, ulTime, uStreamNumber, unASMFlags, 0);
  571. pPacket->SetAsLost();
  572.     }
  573.     else if (pStreamData->m_bUsesRTPPackets)
  574.     {
  575. if (!pStreamData->m_pTSOrderHack)
  576. {
  577.     pStreamData->m_pTSOrderHack = new RTSPStreamData::TSOrderHackInfo();
  578.     
  579.     if (pStreamData->m_pTSOrderHack)
  580.     {
  581. pStreamData->m_pTSOrderHack->m_ulLastSentTS = 
  582.     pPacket->GetTime();
  583. pStreamData->m_pTSOrderHack->m_ulLastRecvTS = 
  584.     pStreamData->m_pTSOrderHack->m_ulLastSentTS;
  585.     }
  586. }
  588. if (pStreamData->m_pTSOrderHack)
  589. {
  590.     IHXBuffer* pBuf=NULL;     
  591.     UINT32 ulHX;
  592.     UINT32 ulRTP;
  593.     UINT16 unStrmNo;
  594.     UINT8  uchASMFlag;
  595.     UINT16 unRuleNo;
  597.     // pkts've been sorted based on seq_no
  598.     IHXRTPPacket* pRTPPacket = NULL;
  600.     pPacket->QueryInterface(IID_IHXRTPPacket, (void**) &pRTPPacket);
  602.     if (pRTPPacket)
  603.     {
  604. // RTP transport generates RTP packets
  605. result = pRTPPacket->GetRTP(pBuf, ulHX, ulRTP, 
  606.     unStrmNo, uchASMFlag, unRuleNo);
  607.     }
  608.     else
  609.     {
  610. // RDT transport generates RMA packets
  611. result = pPacket->Get(pBuf, ulHX,
  612.       unStrmNo, uchASMFlag, unRuleNo);
  614. if (pStreamData->m_pTSConverter)
  615. {
  616.     ulRTP = pStreamData->m_pTSConverter->hxa2rtp(ulHX);
  617. }
  618. else
  619. {
  620.     ulRTP = ulHX;
  621. }
  622.     }
  624.     HX_ASSERT(result == HXR_OK);
  626.     if (result == HXR_OK)
  627.     {
  628. if (((LONG32) (ulHX - pStreamData->m_pTSOrderHack->m_ulLastSentTS)) > 0)
  629. {
  630.     pStreamData->m_pTSOrderHack->m_ulLastSentTS = ulHX;
  631.     pStreamData->m_pTSOrderHack->m_ulLastRecvTS = ulHX;
  632. }
  633. else if (ulHX == pStreamData->m_pTSOrderHack->m_ulLastRecvTS)
  634. {
  635.     ulHX = pStreamData->m_pTSOrderHack->m_ulLastSentTS;          
  636. }
  637. else
  638. {
  639.     pStreamData->m_pTSOrderHack->m_ulLastRecvTS = ulHX;
  640.     ulHX = (++pStreamData->m_pTSOrderHack->m_ulLastSentTS);
  641. }
  643. HX_RELEASE(pRTPPacket);
  644. HX_RELEASE(pPacket);
  645. pRTPPacket = new CHXRTPPacket;
  646. pRTPPacket->AddRef();
  647. result = pRTPPacket->SetRTP(pBuf,
  648.     ulHX,
  649.     ulRTP,
  650.     unStrmNo,
  651.     uchASMFlag,
  652.     unRuleNo);
  653. HX_ASSERT(result == HXR_OK);
  654. pRTPPacket->QueryInterface(IID_IHXPacket, (void**) &pPacket);
  655. HX_ASSERT(pPacket);
  656.     }
  657.     HX_RELEASE(pBuf);
  659.     HX_RELEASE(pRTPPacket);
  660. }
  661.     }
  663.     /*
  664.      * No longer need the ClientPacket wrapper
  665.      */
  666.     HX_RELEASE(clientPacket);    
  668.     return HXR_OK;
  669. }
  671. HX_RESULT
  672. RTSPTransport::startPackets(UINT16 uStreamNumber)
  673. {
  674.     RTSPTransportBuffer* pTransportBuffer = getTransportBuffer(uStreamNumber);
  676.     if (!pTransportBuffer)
  677.     {
  678. return HXR_FAIL;
  679.     }
  681.     return pTransportBuffer->StartPackets();
  682. }
  684. HX_RESULT
  685. RTSPTransport::stopPackets(UINT16 uStreamNumber)
  686. {
  687.     RTSPTransportBuffer* pTransportBuffer = getTransportBuffer(uStreamNumber);
  689.     if (!pTransportBuffer)
  690.     {
  691. return HXR_FAIL;
  692.     }
  694.     return pTransportBuffer->StopPackets();
  695. }
  697. void
  698. RTSPTransport::SetFilterResponse(RawPacketFilter* pResp)
  699. {
  700.     HX_RELEASE(m_pPacketFilter);
  701.     m_pPacketFilter = pResp;
  702.     if (m_pPacketFilter)
  703.     {
  704. m_pPacketFilter->AddRef();
  705.     }
  706. }
  708. void
  709. RTSPTransport::FilterPacket(IHXPacket* pPacket)
  710. {
  711.     UINT16 uStreamNumber;
  713.     ClientPacket* clientPacket = 0;
  714.     clientPacket = (ClientPacket*)m_pClientPacketList->RemoveTail();
  715.     clientPacket->SetPacket(pPacket);
  716.     
  717.     uStreamNumber = clientPacket->GetStreamNumber();
  718.     RTSPTransportBuffer* pTransportBuffer = getTransportBuffer(uStreamNumber);
  719.     pTransportBuffer->Add(clientPacket);
  720. }
  722. void RTSPTransport::GetContext(IUnknown*& pContext)   
  723. {   
  724. pContext = m_pContext;   
  726. if (pContext)   
  727. {   
  728. pContext->AddRef();   
  729. }   
  730. } 
  732. void 
  733. RTSPTransport::LeavePrefetch(void)
  734. {
  735.     RTSPStreamData* pStreamData = NULL; 
  736.     
  737.     m_bPrefetch = FALSE;
  739.     HX_ASSERT(m_pStreamHandler);
  741.     pStreamData = m_pStreamHandler->firstStreamData();
  742.     while(pStreamData)    
  743.     {
  744. if (pStreamData->m_pTransportBuffer)
  745. {
  746.     pStreamData->m_pTransportBuffer->LeavePrefetch();
  747. }
  748. pStreamData = m_pStreamHandler->nextStreamData();
  749.     }
  751.     return;
  752. }
  754. void 
  755. RTSPTransport::EnterFastStart(void)
  756. {
  757.     RTSPStreamData* pStreamData = NULL; 
  758.     
  759.     m_bFastStart = TRUE;
  761.     HX_ASSERT(m_pStreamHandler);
  763.     pStreamData = m_pStreamHandler->firstStreamData();
  764.     while(pStreamData)    
  765.     {
  766. if (pStreamData->m_pTransportBuffer)
  767. {
  768.     pStreamData->m_pTransportBuffer->EnterFastStart();
  769. }
  770. pStreamData = m_pStreamHandler->nextStreamData();
  771.     }
  773.     return;
  774. }
  776. void 
  777. RTSPTransport::LeaveFastStart(void)
  778. {
  779.     RTSPStreamData* pStreamData = NULL; 
  780.     
  781.     m_bFastStart = FALSE;
  783.     HX_ASSERT(m_pStreamHandler);
  785.     pStreamData = m_pStreamHandler->firstStreamData();
  786.     while(pStreamData)    
  787.     {
  788. if (pStreamData->m_pTransportBuffer)
  789. {
  790.     pStreamData->m_pTransportBuffer->LeaveFastStart();
  791. }
  792. pStreamData = m_pStreamHandler->nextStreamData();
  793.     }
  795.     return;
  796. }
  798. BOOL 
  799. RTSPTransport::isSparseStream(UINT16 uStreamNumber)
  800. {
  801.     BOOL bResult = FALSE;
  802.     const char* pMimeType = NULL;
  803.     IUnknown* pUnknown = NULL;
  804.     IHXStreamSource* pStreamSource = NULL;    
  805.     IHXStream* pStream = NULL;
  807.     if (m_pContext  &&
  808. HXR_OK == m_pContext->QueryInterface(IID_IHXStreamSource, (void**)&pStreamSource))
  809.     {
  810. if (HXR_OK == pStreamSource->GetStream(uStreamNumber, pUnknown))
  811. {
  812.     if (HXR_OK == pUnknown->QueryInterface(IID_IHXStream, (void**)&pStream))
  813.     {
  814. pMimeType = pStream->GetStreamType();
  816. // special handling for sparsed streams for multicast
  817. if (pMimeType &&
  818.     (strcasecmp(SYNCMM_MIME_TYPE, pMimeType) == 0 ||
  819.      strcasecmp(REALEVENT_MIME_TYPE, pMimeType) == 0 ||
  820.      strcasecmp("application/vnd.rn-realtext", pMimeType) == 0 ||
  821.      strcasecmp("application/x-pn-realtext", pMimeType) == 0))
  822. {
  823.     bResult = TRUE;
  824. }
  825.     }
  826.     HX_RELEASE(pStream);
  827. }
  828. HX_RELEASE(pUnknown);
  829.     }
  830.     HX_RELEASE(pStreamSource);
  832.     return bResult;
  833. }
  835. HX_RESULT
  836. RTSPTransport::storePacket(IHXPacket* pPacket,
  837.                            UINT16 uStreamNumber,
  838.                            UINT16 uSeqNo,
  839.                            UINT16 uReliableSeqNo,
  840.                            BOOL isReliable)
  841. {
  842.     RTSPTransportBuffer* pTransportBuffer = getTransportBuffer(uStreamNumber);
  844.     if (!pTransportBuffer)
  845.     {
  846. return HXR_FAIL;
  847.     }
  849.     ClientPacket* clientPacket = 0;
  850.     
  851.     m_bIsReceivedData = TRUE;
  853.     if (pPacket->IsLost())
  854.     {
  855.         clientPacket = new ClientPacket(uSeqNo, uReliableSeqNo,
  856.                         pPacket->GetTime(), 0, isReliable,
  857.                         0, pTransportBuffer->GetTime(), FALSE);
  859. clientPacket->AddRef();
  861. return pTransportBuffer->Add(clientPacket);
  862.     }
  863.     
  864.     IHXBuffer* pBuffer = pPacket->GetBuffer();
  866.     if (m_pPacketFilter)
  867.     {
  868. if (!m_pClientPacketList)
  869. {
  870.     m_pClientPacketList = new CHXSimpleList;
  871.     m_pPacketFilter->SetFilterResponse(this);
  872. }
  873. clientPacket = new ClientPacket(uSeqNo, uReliableSeqNo,
  874. pPacket->GetTime(), pBuffer->GetSize(), isReliable,
  875. NULL, pTransportBuffer->GetTime(),
  876. FALSE);
  878. clientPacket->AddRef();
  879. pBuffer->Release();
  881. m_pClientPacketList->AddHead((void*)clientPacket);
  882. m_pPacketFilter->FilterPacket(pPacket);
  884. // just guessing on what this should be?????
  885.         return HXR_OK;
  886.     }
  887.     else
  888.     {
  889.        clientPacket = new ClientPacket(uSeqNo, uReliableSeqNo,
  890. pPacket->GetTime(), pBuffer->GetSize(), isReliable,
  891. pPacket, pTransportBuffer->GetTime(), FALSE);
  893. clientPacket->AddRef();
  894. pBuffer->Release();
  896. return pTransportBuffer->Add(clientPacket);
  897.     }
  898. }
  900. HX_RESULT
  901. RTSPTransport::packetReady(HX_RESULT status, RTSPStreamData* pStreamData, IHXPacket* pPacket)
  902. {
  903.     HX_RESULT result = HXR_OK;
  905.     ASSERT(!m_bIsSource);
  907.     if (!pStreamData)
  908.     {
  909. return HXR_UNEXPECTED;
  910.     }
  912.     HX_ASSERT(pStreamData);
  913.     
  914.     if (pPacket)
  915.     {
  916. if (pStreamData->m_bUsesRTPPackets)
  917. {
  918.     IHXRTPPacket* pRTPPacket = NULL;
  920.     pPacket->QueryInterface(IID_IHXRTPPacket, (void**) &pRTPPacket);
  922.     if (pRTPPacket)
  923.     {
  924. // This already is RTP Packet - proceed
  925. pRTPPacket->Release();
  926.     }
  927.     else
  928.     {
  929. // Must Transfer to an RTP Packet
  930. result = m_pCommonClassFactory->CreateInstance(
  931. CLSID_IHXRTPPacket,
  932. (void**) &pRTPPacket);
  934. if (pRTPPacket)
  935. {
  936.     ULONG32 ulTime;
  937.     ULONG32 ulRTPTime;
  938.     UINT16 uStreamNumber;
  939.     UINT8 unASMFlags;
  940.     UINT16 unASMRuleNumber;
  941.     BOOL bIsLost = pPacket->IsLost();
  942.     IHXBuffer* pBuffer = NULL;
  944.     pPacket->Get(pBuffer,
  945.  ulTime,
  946.  uStreamNumber,
  947.  unASMFlags,
  948.  unASMRuleNumber);
  950.     if (pStreamData->m_pTSConverter)
  951.     {
  952. ulRTPTime = pStreamData->m_pTSConverter->hxa2rtp(ulTime);
  953.     }
  954.     else
  955.     {
  956. ulRTPTime = ulTime;
  957.     }
  959.     pRTPPacket->SetRTP(pBuffer,
  960.        ulTime,
  961.        ulRTPTime,
  962.        uStreamNumber,
  963.        unASMFlags,
  964.        unASMRuleNumber);
  966.     if (bIsLost)
  967.     {
  968. pRTPPacket->SetAsLost();
  969.     }
  971.     HX_RELEASE(pBuffer);
  973.     result = m_pResp->PacketReady(status, m_sessionID, pRTPPacket);
  974.     pRTPPacket->Release();
  975. }
  977. return result;
  978.     }
  979. }
  980.     }
  981.     else
  982.     {
  983. /*
  984.  * This is a lost packet
  985.  */
  986. if (pStreamData->m_bUsesRTPPackets)
  987. {
  988.     result = m_pCommonClassFactory->CreateInstance(
  989. CLSID_IHXRTPPacket,
  990. (void**) &pPacket);
  991. }
  992. else
  993. {
  994.     result = m_pCommonClassFactory->CreateInstance(
  995. CLSID_IHXPacket,
  996. (void**) &pPacket);
  997. }
  998.     
  999. if (pPacket)
  1000. {
  1001.     pPacket->Set(0, 0, pStreamData->m_streamNumber, 0, 0);
  1002.     pPacket->SetAsLost();
  1003.     result = m_pResp->PacketReady(status, m_sessionID, pPacket);
  1004.     pPacket->Release();
  1005. }
  1006. return result;
  1007.     }
  1009.     return m_pResp->PacketReady(status, m_sessionID, pPacket);
  1010. }
  1012. HX_RESULT
  1013. RTSPTransport::packetReady(HX_RESULT status, UINT16 uStreamNumber, IHXPacket* pPacket)
  1014. {
  1015.     RTSPStreamData* pStreamData = NULL;
  1017.     ASSERT(!m_bIsSource);
  1019.     pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);
  1021.     HX_ASSERT(pStreamData);
  1023.     return packetReady(status, pStreamData, pPacket);
  1024. }
  1026. HX_RESULT
  1027. RTSPTransport::getStatus
  1028. (
  1029.     UINT16& uStatusCode, 
  1030.     IHXBuffer*& pStatusDesc, 
  1031.     UINT16& ulPercentDone
  1032. )
  1033. {
  1034. #if 0
  1035.     if (!m_pStreamHandler)
  1036.     {
  1037. uStatusCode = HX_STATUS_INITIALIZING;
  1038. pStatusDesc = 0;
  1039. ulPercentDone = 0;
  1041. return HXR_OK;
  1042.     }
  1044.     uStatusCode = HX_STATUS_READY;
  1045.     pStatusDesc = 0;
  1046.     ulPercentDone = 100;
  1048.     RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1050.     ASSERT(pStreamData);
  1052.     while(pStreamData)
  1053.     {
  1054. UINT16 tempStatusCode;
  1055. UINT16 tempPercentDone;
  1057. pStreamData->m_pTransportBuffer->GetStatus(tempStatusCode,
  1058.                                            tempPercentDone);
  1060. /*
  1061.  * The status is always that of the stream which is least ready
  1062.  */
  1064. if (tempStatusCode < uStatusCode)
  1065. {
  1066.     uStatusCode     = tempStatusCode;
  1067.     ulPercentDone   = tempPercentDone;
  1068. }
  1069. else if (tempStatusCode == uStatusCode && 
  1070.  tempPercentDone < ulPercentDone)
  1071. {
  1072.     ulPercentDone = tempPercentDone;
  1073. }
  1075. pStreamData = m_pStreamHandler->nextStreamData();
  1076.     }
  1078.     return HXR_OK;
  1079. #else
  1080.     return HXR_NOTIMPL;
  1081. #endif
  1082. }
  1084. HX_RESULT
  1085. RTSPTransport::GetCurrentBuffering(UINT16  uStreamNumber,
  1086.    INT64&  llLowestTimestamp, 
  1087.    INT64&  llHighestTimestamp,
  1088.    UINT32& ulNumBytes,
  1089.    BOOL&   bDone)
  1090. {
  1091.     if (!m_pStreamHandler)
  1092.     {
  1093. return HXR_OK;
  1094.     }
  1096.     RTSPStreamData* pStreamData;
  1098.     pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);
  1100.     HX_ASSERT(pStreamData);
  1102.     return pStreamData ? 
  1103.            pStreamData->m_pTransportBuffer->GetCurrentBuffering(
  1104.                                             llLowestTimestamp,
  1105.                                             llHighestTimestamp,
  1106.                                             ulNumBytes,
  1107.                                             bDone) : HXR_OK;
  1108. }
  1110. HX_RESULT
  1111. RTSPTransport::SeekFlush(UINT16 uStreamNumber)
  1112. {
  1113.     if (!m_pStreamHandler)
  1114.     {
  1115. return HXR_OK;
  1116.     }
  1118.     RTSPStreamData* pStreamData;
  1120.     pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);
  1122.     HX_ASSERT(pStreamData);
  1124.     if (pStreamData)
  1125.     {
  1126. pStreamData->m_pTransportBuffer->SeekFlush();
  1127.     }
  1129.     return HXR_OK;
  1130. }
  1132. BOOL
  1133. RTSPTransport::IsSourceDone(void)
  1134. {
  1135.     return m_bSourceDone;
  1136. }
  1138. void      
  1139. RTSPTransport::CheckForSourceDone(UINT16 uStreamNumber)
  1140. {
  1141.     if (m_bSourceDone)
  1142.     {
  1143. return;
  1144.     }
  1146.     HX_ASSERT(m_pStreamHandler);
  1148.     if (!m_pStreamHandler)
  1149.     {
  1150. return;
  1151.     }
  1153.     RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1154.     HX_ASSERT(pStreamData);
  1156.     m_bSourceDone = TRUE;
  1157.     while(pStreamData)
  1158.     {
  1159. if (pStreamData->m_streamNumber == uStreamNumber)
  1160. {
  1161.     pStreamData->m_bReceivedAllPackets = TRUE;
  1162. }
  1163. else if (!pStreamData->m_bReceivedAllPackets)
  1164. {
  1165.     m_bSourceDone = FALSE;
  1166.     return;
  1167. }
  1169. pStreamData = m_pStreamHandler->nextStreamData();
  1170.     }
  1172.     /* We have received all the packets... Tell the reposnse object */
  1173.     if (!m_bIsSource)
  1174.     {
  1175. m_pResp->OnSourceDone();
  1176.     }
  1178. }    
  1180. void      
  1181. RTSPTransport::HandleBufferError()
  1182. {
  1183.     if (m_pResp)
  1184.     {
  1185. m_pResp->OnProtocolError(HXR_BUFFERING);
  1186.     }
  1187. }
  1189. RTSPResendBuffer*
  1190. RTSPTransport::getResendBuffer(UINT16 uStreamNumber)
  1191. {
  1192.     return m_pStreamHandler->getResendBuffer(uStreamNumber);
  1193. }
  1195. HX_RESULT
  1196. RTSPTransport::initializeStatistics
  1197. (
  1198.     UINT32 ulRegistryID
  1199. )
  1200. {
  1201.     m_bIsInitialized = TRUE;
  1203.     if (m_bIsSource)
  1204.     {
  1205. m_ulRegistryID = ulRegistryID;
  1206.     }
  1207.     else
  1208.     {
  1209. // XXX HP
  1210. // rather than create a new copy of STREAM_STATS, we simply
  1211. // obtain the same STREAM_STATS* from RTSPProtocol via SetStatistics().
  1212. // this could save us on both the memory and several ms during the startup
  1213. /*
  1214. IHXBuffer* pParentName = NULL;
  1215. CHAR RegKeyName[MAX_DISPLAY_NAME] = {0};
  1217. RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1219. ASSERT(pStreamData);
  1221. if (!m_pRegistry)
  1222. {
  1223.     return HXR_FAIL;
  1224. }
  1226. HX_RESULT result = m_pRegistry->GetPropName(ulRegistryID, pParentName);
  1228. if (result != HXR_OK)
  1229. {
  1230.     return result;
  1231. }
  1233. // create registry entries of each stream
  1234. while (pStreamData)
  1235. {
  1236.     UINT16 uStreamNumber = pStreamData->m_streamNumber;
  1238.     sprintf(RegKeyName, "%s.Stream%d", pParentName->GetBuffer(),
  1239.                                        uStreamNumber);
  1241.     UINT32 uStreamId = m_pRegistry->GetId(RegKeyName);
  1243.     // create stream reg key if it has not been created
  1244.     // by the source yet
  1245.     if (!uStreamId)
  1246.     {
  1247. return HXR_FAIL;
  1248.     }
  1250.     pStreamData->m_pStreamStats = new STREAM_STATS(m_pRegistry,
  1251.                                                    uStreamId);
  1252.    
  1253.     pStreamData = m_pStreamHandler->nextStreamData();
  1254. }
  1256. pParentName->Release();
  1257. */
  1258.     }
  1260.     return HXR_OK;
  1261. }
  1263. HX_RESULT
  1264. RTSPTransport::SetStatistics(UINT16 uStreamNumber, STREAM_STATS* pStats)
  1265. {
  1266.     HX_RESULT     rc = HXR_OK;
  1267. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  1268.     RTSPStreamData* pStreamData = NULL;
  1270.     if (!m_pStreamHandler)
  1271.     {
  1272. rc = HXR_FAILED;
  1273. goto cleanup;
  1274.     }
  1276.     pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);
  1277.     if (!pStreamData)
  1278.     {
  1279. rc = HXR_FAILED;
  1280. goto cleanup;
  1281.     }
  1283.     pStreamData->m_pStreamStats = pStats;
  1285. cleanup:
  1286. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  1288.     return rc;
  1289. }
  1291. HX_RESULT 
  1292. RTSPTransport::updateStatistics(BOOL bUseRegistry)
  1293. {
  1294.     m_bIsUpdated = TRUE;
  1296. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  1297.     if (m_bIsSource)
  1298.     {
  1299. RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1301. if (!pStreamData)
  1302. {
  1303.     return HXR_FAIL;
  1304. }
  1306. /*
  1307.  * XXXGH...streams are managed by the PPM and should not show up
  1308.  *         under the transport
  1309.  */
  1310. while (pStreamData)
  1311. {
  1312.     UINT32 ulResendSuccess = 0;
  1313.     UINT32 ulResendFailure = 0;
  1315.     if (pStreamData->m_pResendBuffer)
  1316.     {
  1317. pStreamData->m_pResendBuffer->UpdateStatistics(ulResendSuccess,
  1318.                                                ulResendFailure);
  1319.     }
  1321.     m_ulTotalSuccessfulResends += ulResendSuccess;
  1322.     m_ulTotalFailedResends += ulResendFailure;
  1324.     pStreamData = m_pStreamHandler->nextStreamData();
  1325. }
  1327.         m_ulSendingTime = CALCULATE_ELAPSED_TICKS(m_ulStartTime, HX_GET_TICKCOUNT()) / 1000;
  1329. IHXBuffer* pName;
  1331. if (bUseRegistry
  1332.         &&  m_pRegistry 
  1333.         &&  HXR_OK == m_pRegistry->GetPropName(m_ulRegistryID, pName))
  1334. {
  1335.     char str[512]; /* Flawfinder: ignore */
  1336.     const char* name = (const char*)pName->GetBuffer();
  1337.     char pTemp[32]; /* Flawfinder: ignore */
  1339.     i64toa(m_lBytesSent, pTemp, 10);
  1341.     sprintf(str, "%-.400s.PacketsSent", name); /* Flawfinder: ignore */
  1342.     m_pRegistry->AddInt(str, m_ulPacketsSent);
  1343.     sprintf(str, "%-.400s.BytesSent", name); /* Flawfinder: ignore */
  1344.     m_pRegistry->AddInt(str, INT64_TO_INT32(m_lBytesSent));
  1346.     // Add the total bytes sent as a string because we don't want
  1347.     // to have to truncate the INT64 value that is storing it
  1348.     sprintf(str, "%-.400s.TotalBytesSent", name); /* Flawfinder: ignore */
  1349.     IHXBuffer* pBuffer = new CHXBuffer();
  1350.     pBuffer->AddRef();
  1351.     pBuffer->Set((UCHAR*)pTemp, strlen(pTemp) + 1);
  1352.     m_pRegistry->AddStr(str, pBuffer);
  1353.     HX_RELEASE(pBuffer);
  1355.     sprintf(str, "%-.400s.SendingTime", name); /* Flawfinder: ignore */
  1356.     m_pRegistry->AddInt(str, m_ulSendingTime); 
  1357.     sprintf(str, "%-.400s.ResendSuccess", name); /* Flawfinder: ignore */
  1358.     m_pRegistry->AddInt(str, m_ulTotalSuccessfulResends);
  1359.     sprintf(str, "%-.400s.ResendFailure", name); /* Flawfinder: ignore */
  1360.     m_pRegistry->AddInt(str, m_ulTotalFailedResends);
  1361.     pName->Release();
  1362. }
  1363.     }
  1364.     else
  1365.     {
  1366. ULONG32 ulNormal = 0;
  1367. ULONG32 ulReceived = 0;
  1368. ULONG32 ulLost = 0;
  1369. ULONG32 ulLate = 0;
  1370. ULONG32 ulTotal = 0;
  1371. ULONG32 ulResendRequested = 0;
  1372. ULONG32 ulResendReceived = 0;
  1373. ULONG32 ulAvgBandwidth = 0;
  1374. ULONG32 ulCurBandwidth = 0;
  1376. UINT32 ulTotal30 = 0;
  1377. UINT32 ulLost30 = 0;
  1378. UINT32  ulDuplicate = 0;
  1379. UINT32 ulOutOfOrder = 0;
  1381. RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1383. if (!pStreamData)
  1384. {
  1385.     return HXR_FAIL;
  1386. }
  1388. while (pStreamData)
  1389. {
  1390.     STREAM_STATS* pStreamStats = pStreamData->m_pStreamStats;
  1392.             if (!pStreamStats || !pStreamStats->m_bInitialized)
  1393.     {
  1394. goto updateContinue;
  1395.     }
  1397.     pStreamData->m_pTransportBuffer->UpdateStatistics(ulNormal,
  1398.                                                       ulLost,
  1399.                                                       ulLate,
  1400.                                                       ulResendRequested,
  1401.                                                       ulResendReceived,
  1402.                                                       ulAvgBandwidth,
  1403.                                                       ulCurBandwidth,
  1404.       ulTotal30,
  1405.       ulLost30,
  1406.       ulDuplicate,
  1407.       ulOutOfOrder);
  1408.                   
  1409.     ulReceived = ulNormal + ulResendReceived;
  1410.     ulTotal = ulReceived + ulLost + ulLate;
  1412.     pStreamStats->m_pNormal->SetInt((INT32)ulNormal);
  1413.     pStreamStats->m_pRecovered->SetInt((INT32)ulResendReceived);
  1414.     pStreamStats->m_pReceived->SetInt((INT32)ulReceived);
  1415.     pStreamStats->m_pLost->SetInt((INT32)ulLost);
  1416.     pStreamStats->m_pLate->SetInt((INT32)ulLate);
  1417.     pStreamStats->m_pDuplicate->SetInt((INT32)ulDuplicate);
  1418.     pStreamStats->m_pOutOfOrder->SetInt((INT32)ulOutOfOrder);
  1419.     pStreamStats->m_pTotal->SetInt((INT32)ulTotal);
  1420.     pStreamStats->m_pLost30->SetInt((INT32)ulLost30);
  1421.     pStreamStats->m_pTotal30->SetInt((INT32)ulTotal30);
  1422.     pStreamStats->m_pResendRequested->SetInt((INT32)ulResendRequested);
  1423.     pStreamStats->m_pResendReceived->SetInt((INT32)ulResendReceived);
  1424.     pStreamStats->m_pAvgBandwidth->SetInt((INT32)ulAvgBandwidth);
  1425.     pStreamStats->m_pCurBandwidth->SetInt((INT32)ulCurBandwidth);
  1427. updateContinue:
  1429.     pStreamData = m_pStreamHandler->nextStreamData();
  1430. }
  1431.     }
  1432. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  1434.     return HXR_OK;
  1435. }
  1437. HX_RESULT 
  1438. RTSPTransport::UpdateRegistry(UINT32 ulStreamNumber,
  1439.       UINT32 ulRegistryID)
  1440. {
  1441.     if (m_bIsSource)
  1442.     {
  1443. m_ulRegistryID = ulRegistryID;
  1444.     }
  1445.     else
  1446.     {
  1447. // XXX HP
  1448. // rather than create a new copy of STREAM_STATS, we simply
  1449. // obtain the same STREAM_STATS* from RTSPProtocol via SetStatistics().
  1450. // this could save us on both the memory and several ms during the startup
  1451. /*
  1452. if (!m_pRegistry)
  1453. {
  1454.     return HXR_FAIL;
  1455. }
  1457. RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1458. while (pStreamData)
  1459. {
  1460.     if (pStreamData->m_streamNumber == (UINT16)ulStreamNumber)
  1461.     {
  1462. HX_DELETE(pStreamData->m_pStreamStats);
  1463. pStreamData->m_pStreamStats = new STREAM_STATS(m_pRegistry,
  1464.        ulRegistryID);
  1465. break;
  1466.     }    
  1467.     pStreamData = m_pStreamHandler->nextStreamData();
  1468. }
  1469. */
  1470.     }
  1472.     return HXR_OK;
  1473. }
  1475. RTSPTransportBuffer*
  1476. RTSPTransport::getTransportBuffer(UINT16 uStreamNumber)
  1477. {
  1478.     if (!m_pStreamHandler)
  1479.     {
  1480. return NULL;
  1481.     }
  1483.     RTSPStreamData* pStreamData;     
  1485.     pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);
  1487.     if (!pStreamData)
  1488.     {
  1489. return NULL;
  1490.     }
  1492.     return pStreamData->m_pTransportBuffer;
  1493. }
  1495. HX_RESULT
  1496. RTSPTransport::playReset()
  1497. {
  1498.     m_bSourceDone = FALSE;
  1500.     if(m_pStreamHandler)
  1501.     {
  1502. RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1504. while(pStreamData)
  1505. {
  1506.     if (m_bIsSource)
  1507.     {
  1508. pStreamData->m_packetSent = FALSE;
  1509.     }
  1510.     else
  1511.     {
  1512. pStreamData->m_pTransportBuffer->Reset();
  1513. pStreamData->m_bReceivedAllPackets = FALSE;
  1514.     }
  1516.     pStreamData = m_pStreamHandler->nextStreamData();
  1517. }
  1518.     }
  1519.     return HXR_OK;
  1520. }
  1522. HX_RESULT
  1523. RTSPTransport::pauseBuffers()
  1524. {
  1525.     if (m_pStreamHandler)
  1526.     {
  1527. RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1529. ASSERT(pStreamData);
  1531. while(pStreamData)
  1532. {
  1533.     pStreamData->m_pTransportBuffer->Pause();
  1535.     pStreamData = m_pStreamHandler->nextStreamData();
  1536. }
  1537.     }
  1539.     return HXR_OK;
  1540. }
  1542. HX_RESULT
  1543. RTSPTransport::resumeBuffers()
  1544. {
  1545.     m_bIsReceivedData = FALSE;
  1547.     if (m_pStreamHandler)
  1548.     {
  1549. RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1551. ASSERT(pStreamData);
  1553. while(pStreamData)
  1554. {
  1555.     pStreamData->m_pTransportBuffer->Resume();
  1556.     pStreamData = m_pStreamHandler->nextStreamData();
  1557. }
  1558.     }
  1560.     return HXR_OK;
  1561. }
  1563. HX_RESULT
  1564. RTSPTransport::setFirstSeqNum(UINT16 uStreamNumber, UINT16 uSeqNum)
  1565. {
  1566.     RTSPStreamData* pStreamData;
  1568.     pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);
  1570.     if(pStreamData)
  1571.     {
  1572. if (m_bIsSource)
  1573. {     
  1574.     pStreamData->m_seqNo = uSeqNum;
  1576.     if(pStreamData->m_pResendBuffer)
  1577.     {
  1578. pStreamData->m_pResendBuffer->SetFirstSequenceNumber(uSeqNum);
  1579.     }
  1580. }
  1581. else
  1582. {
  1583.     if (!pStreamData->m_pTransportBuffer)
  1584.     {
  1585. return HXR_FAIL;
  1586.     }
  1588.     if (!m_bMulticast)
  1589.     {
  1590. pStreamData->m_lastSeqNo = uSeqNum;
  1591.      pStreamData->m_pTransportBuffer->Init(uSeqNum);
  1592.     }
  1593. }
  1594.     }
  1596.     return HXR_OK;
  1597. }
  1599. HX_RESULT
  1600. RTSPTransport::Init(IUnknown* pContext)
  1601. {
  1602.     HX_RESULT hresult;
  1603.     
  1604.     if (!m_pContext)
  1605.     {
  1606. m_pContext = pContext;
  1607. m_pContext->AddRef();
  1608.     }
  1610.     hresult = pContext->QueryInterface(IID_IHXCommonClassFactory,
  1611.        (void**)&m_pCommonClassFactory);
  1613.     if (HXR_OK != hresult)
  1614.     {
  1615. return hresult;
  1616.     }
  1617.     
  1618.     hresult = pContext->QueryInterface(IID_IHXScheduler,
  1619.                                        (void**)&m_pScheduler);
  1621.     if (HXR_OK != hresult)
  1622.     {
  1623. DPRINTF(D_INFO, ("could not get scheduler...n"));
  1624. return hresult;
  1625.     }
  1627.     pContext->QueryInterface(IID_IHXRegistry, (void**)&m_pRegistry);
  1629.     pContext->QueryInterface(IID_IHXInternalReset,
  1630.                                (void**)&m_pInternalReset);
  1632.     pContext->QueryInterface(IID_IHXPlayerState,
  1633.                                (void**)&m_pPlayerState);
  1635.     pContext->QueryInterface(IID_IHXSourceBufferingStats2,
  1636.      (void**)&m_pSrcBufferStats);
  1638. #ifdef RDT_MESSAGE_DEBUG
  1639.     IHXPreferences* pPreferences = NULL;
  1640.     
  1641.     if (pContext &&
  1642. (HXR_OK == pContext->QueryInterface(IID_IHXPreferences,
  1643.                                             (void**) &pPreferences)))
  1644.     {
  1645. IHXBuffer* pBuffer = NULL;
  1647.         ReadPrefBOOL(pPreferences, "RDTMessageDebug", m_bRDTMessageDebug);
  1648. if (m_bRDTMessageDebug)
  1649. {
  1650.     if (HXR_OK == pPreferences->ReadPref("RDTMessageDebugFile", pBuffer))
  1651.     {
  1652. if (pBuffer->GetSize() <= 0)
  1653. {
  1654.     // no file name, no log
  1655.     m_bRDTMessageDebug = FALSE;
  1656. }
  1657. else
  1658. {
  1659.     m_RDTmessageDebugFileName = (const char*) pBuffer->GetBuffer();
  1660. }
  1661.     }
  1662.             HX_RELEASE(pBuffer);
  1663. }
  1664.     }
  1666.     HX_RELEASE(pPreferences);
  1667. #endif // RDT_MESSAGE_DEBUG
  1668.     
  1669.     return HXR_OK;
  1670. }
  1672. HX_RESULT
  1673. RTSPTransport::SetResendBufferDepth(UINT32 uMilliseconds)
  1674. {
  1675.     RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1677.     ASSERT(pStreamData);
  1679.     while (pStreamData)
  1680.     {
  1681. if (m_bIsSource)
  1682. {
  1683.     if (pStreamData->m_pResendBuffer)
  1684.     {
  1685. pStreamData->m_pResendBuffer->SetBufferDepth(uMilliseconds);
  1686.     }
  1687. }
  1688. else
  1689. {
  1690.     if (pStreamData->m_pTransportBuffer)
  1691.     {
  1692. pStreamData->m_pTransportBuffer->SetBufferDepth(uMilliseconds);
  1693.     }
  1694. }
  1696. pStreamData = m_pStreamHandler->nextStreamData();
  1697.     }
  1699.     return HXR_OK;
  1700. }
  1702. #ifdef RDT_MESSAGE_DEBUG
  1703. void RTSPTransport::RDTmessageFormatDebugFileOut(const char* fmt, ...)
  1704. {
  1705.     if(m_bRDTMessageDebug)
  1706.     {
  1707.         char buf[4096]; /* Flawfinder: ignore */
  1708. va_list args;
  1709. va_start(args, fmt);
  1710. FILE* fp = fopen((const char*)m_RDTmessageDebugFileName, "a");
  1711. if (fp)
  1712. {
  1713.     vsprintf(buf, fmt, args);
  1714.     fprintf(fp, "%sn", buf);
  1715.     fclose(fp);
  1716. }
  1718. va_end(args);
  1719.     }
  1720. }
  1721. #endif // RDT_MESSAGE_DEBUG