开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
rtsptran.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：40k
源码类别：

Symbian

开发平台：

C/C++

rtsptran.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #include "hxtypes.h"
  37. #include "hxassert.h"
  38. #include "debug.h"
  39. #include "hxcom.h"
  40. #include "hxmarsh.h"
  41. #include "hxstrutl.h"
  42. #include "netbyte.h"
  43. #include "hxengin.h"
  44. #include "ihxpckts.h"
  45. #include "hxcomm.h"
  46. #include "hxmon.h"
  47. #include "netbyte.h"
  48. #include "hxstring.h"
  49. #include "chxpckts.h"
  50. #include "hxslist.h"
  51. #include "hxmap.h"
  52. #include "hxdeque.h"
  53. #include "hxbitset.h"
  54. #include "timebuff.h"
  55. #include "timeval.h"
  56. #include "tconverter.h"
  57. #include "rtptypes.h"
  58. #include "rtspmsg.h"
  59. #include "hxcorgui.h"
  61. #include "ntptime.h"
  63. #include "rtspif.h"
  64. #include "rtsptran.h"
  65. //#include "rtpwrap.h" // Wrappers for PMC generated base classes
  66. #include "basepkt.h"
  67. #include "hxtbuf.h"
  68. #include "transbuf.h"
  69. #include "hxtick.h"
  70. #include "random32.h" // random32()
  71. #include "pkthndlr.h" // in rtpmisc for RTCP routine
  72. #include "rtcputil.h" // takes care of RTCP in RTP mode
  73. #include "hxprefs.h" // IHXPreferences
  74. #include "hxmime.h"
  75. #include "hxcore.h"
  77. #include "hxheap.h"
  78. #ifdef PAULM_IHXTCPSCAR
  79. #include "objdbg.h"
  80. #endif
  82. #ifdef PAULM_TNGTCPTRANSTIMING
  83. #include "classtimer.h"
  84. ClassTimer g_TNGTCPTransTimer("TNGTCPTransport", 0, 3600);
  85. #endif
  87. #ifdef _DEBUG
  88. #undef HX_THIS_FILE
  89. static const char HX_THIS_FILE[] = __FILE__;
  90. #endif
  92. #define STREAM_END_DELAY_BASE_TOLERANCE 3000
  94. static const UINT32 TRANSPORT_BUF_GROWTH_RATE  = 1000;
  96. void
  97. dump(const char* pFile, const char* pc)
  98. {
  99.     FILE* fp = fopen(pFile, "a");
  100.     if(!fp)
  101.     {
  102.     return;
  103.     }
  104.     fprintf(fp, "%s", pc);
  105.     fclose(fp);    
  106. }
  109. RTSPStreamData::RTSPStreamData(BOOL needReliable):
  110.     m_seqNo(0),
  111.     m_streamNumber(0),
  112.     m_reliableSeqNo(0),
  113.     m_lastTimestamp(0),
  114.     m_pTransportBuffer(0),
  115.     m_pResendBuffer(0),
  116.     m_pStreamStats(0),
  117.     m_bNeedReliable(needReliable),
  118.     m_packetSent(FALSE),
  119.     m_bReceivedAllPackets(FALSE),
  120.     m_bNeedToACK(FALSE),
  121.     m_bFirstPacket(TRUE),
  122.     m_bUsesRTPPackets(FALSE),
  123.     m_pTSConverter(NULL),
  124.     m_pTSOrderHack(NULL),
  125.     m_eMediaType(RTSPMEDIA_TYPE_UNKNOWN)
  126. {
  127.     ;
  128. }
  130. RTSPStreamData::~RTSPStreamData()
  131. {
  132.     if (m_pTransportBuffer)
  133.     {
  134. delete m_pTransportBuffer;
  135.     }
  137.     if (m_pResendBuffer)
  138.     {
  139. delete m_pResendBuffer;
  140.     }
  142.     HX_DELETE(m_pTSConverter);
  143.     HX_DELETE(m_pTSOrderHack);
  144. }
  146. RTSPStreamHandler::RTSPStreamHandler(RTSPTransport* pOwner)
  147.     : m_pOwner(pOwner)
  148.     , m_lRefCount(0)
  149. {
  150.     m_pStreamDataMap = new CHXMapLongToObj;
  151. }
  153. RTSPStreamHandler::~RTSPStreamHandler()
  154. {
  155.     CHXMapLongToObj::Iterator i;
  156.     RTSPStreamData* pStreamData;
  158.     for(i=m_pStreamDataMap->Begin();i!=m_pStreamDataMap->End();++i)
  159.     {
  160. pStreamData = (RTSPStreamData*)(*i);
  161. delete pStreamData;
  162.     }
  163.     delete m_pStreamDataMap;
  164. }
  167. HX_RESULT
  168. RTSPStreamHandler::initStreamData(
  169.     UINT16 streamNumber, BOOL needReliable, BOOL bIsSource, INT16 rtpPayloadType,
  170.     BOOL bRecordFlag, UINT32 wrapSequenceNumber, UINT32 ulBufferDepth,
  171.     BOOL bHasOutOfOrderTS, CHXTimestampConverter* pTSConverter,
  172.     RTSPMediaType eMediaType)
  173. {
  174.     RTSPStreamData* pStreamData;
  176.     if(!m_pStreamDataMap->Lookup(streamNumber, (void*&)pStreamData))
  177.     {
  178. pStreamData = new RTSPStreamData(needReliable);
  179. pStreamData->m_streamNumber = streamNumber;
  180.         pStreamData->m_pTSConverter = pTSConverter;
  181. pStreamData->m_eMediaType = eMediaType;
  182. pStreamData->m_lastSeqNo = 0;
  183. (*m_pStreamDataMap)[streamNumber] = pStreamData;
  185. if (!bIsSource)
  186. {
  187.     UINT32 ulSetMaximumBufferDepth;
  188.     UINT32 ulSetBufferDepth;
  190.     if (bRecordFlag && ulBufferDepth != TRANSPORT_BUF_DURATION_UNDEF)
  191.     {
  192.      ulSetMaximumBufferDepth = ulBufferDepth;
  193.      ulSetBufferDepth = ulBufferDepth;
  194.     }
  195.     else if (bRecordFlag)
  196.     {
  197.      ulSetMaximumBufferDepth = MAX_TRANSPORT_BUF_DURATION;
  198.      ulSetBufferDepth = MAX_TRANSPORT_BUF_DURATION;
  199.     }
  200.     else
  201.     {
  202.      ulSetMaximumBufferDepth = MAX_TRANSPORT_BUF_DURATION;
  203.      ulSetBufferDepth = TRANSPORT_BUF_DURATION;
  204.     }
  206.     RTSPTransportBuffer* pTransportBuffer = 
  207. new RTSPTransportBuffer(m_pOwner,
  208.                                 streamNumber,
  209.                                 ulSetBufferDepth,
  210.                                 ulSetMaximumBufferDepth,
  211.                                 TRANSPORT_BUF_GROWTH_RATE,
  212.                                 wrapSequenceNumber);
  215.     pStreamData->m_pTransportBuffer = pTransportBuffer;
  216.     pStreamData->m_pStreamStats = NULL;
  217.     pStreamData->m_bUsesRTPPackets = bHasOutOfOrderTS;
  218. }
  220. return HXR_OK;
  221.     }
  223.     return HXR_FAIL;
  224. }
  226. RTSPStreamData*
  227. RTSPStreamHandler::getStreamData(UINT16 streamNumber)
  228. {
  229.     RTSPStreamData* pStreamData = 0;
  231.     if(!m_pStreamDataMap->Lookup(streamNumber, (void*&)pStreamData))
  232.     {
  233. return 0;
  234.     }
  236.     return pStreamData;
  237. }
  239. RTSPStreamData*
  240. RTSPStreamHandler::firstStreamData()
  241. {
  242.     streamIterator = m_pStreamDataMap->Begin();
  243.     if(streamIterator == m_pStreamDataMap->End())
  244.     {
  245. return 0;
  246.     }
  247.     return (RTSPStreamData*)(*streamIterator);
  248. }
  250. RTSPStreamData*
  251. RTSPStreamHandler::nextStreamData()
  252. {
  253.     ++streamIterator;
  254.     if(streamIterator == m_pStreamDataMap->End())
  255.     {
  256. return 0;
  257.     }
  258.     return (RTSPStreamData*)(*streamIterator);
  259. }
  261. BOOL
  262. RTSPStreamHandler::endStreamData()
  263. {
  264.     return (streamIterator == m_pStreamDataMap->End());
  265. }
  267. HX_RESULT
  268. RTSPStreamHandler::createResendBuffer(UINT16 streamNumber,
  269.       UINT32 wrapSequenceNumber)
  270. {
  271.     RTSPStreamData* pStreamData;
  273.     if(!m_pStreamDataMap->Lookup(streamNumber, (void*&)pStreamData))
  274.     {
  275. return HXR_FAILED;
  276.     }
  278.     RTSPResendBuffer* pResendBuffer;
  280.     pResendBuffer = new RTSPResendBuffer(RESEND_BUF_DURATION,
  281.                                          MAX_RESEND_BUF_DURATION,
  282.                                          RESEND_BUF_GROWTH_RATE,
  283.                                          wrapSequenceNumber);
  285.     pStreamData->m_pResendBuffer = pResendBuffer;
  286.     return HXR_OK;
  287. }
  289. RTSPResendBuffer*
  290. RTSPStreamHandler::getResendBuffer(UINT16 streamNumber)
  291. {
  292.     RTSPStreamData* pStreamData = 0;
  294.     if(!m_pStreamDataMap->Lookup(streamNumber, (void*&)pStreamData))
  295.     {
  296. return 0;
  297.     }
  298.     return pStreamData->m_pResendBuffer;
  299. }
  301. /*
  302.  * RTSPTransport methods
  303.  */
  305. RTSPTransport::RTSPTransport(BOOL bIsSource):
  306.     m_pContext(NULL),
  307.     m_pCommonClassFactory(0),
  308.     m_pScheduler(0),
  309.     m_pResp(0),
  310.     m_pStreamHandler(0),
  311.     m_pRegistry(0),
  312.     m_pInternalReset(0),
  313.     m_pSrcBufferStats(0),
  314.     m_bIsSource(bIsSource),
  315.     m_bIsInitialized(FALSE),
  316.     m_bIsUpdated(FALSE),
  317.     m_ulPacketsSent(0),
  318.     m_lBytesSent(0),
  319.     m_bIsReceivedData(FALSE),
  320.     m_bSourceDone(FALSE),
  321.     m_bHackedRecordFlag(FALSE),
  322.     m_wrapSequenceNumber(0),
  323.     m_bMulticast(FALSE),
  324.     m_pPlayerState(NULL),
  325.     m_pPacketFilter(NULL),
  326.     m_pClientPacketList(NULL),
  327.     m_bPrefetch(FALSE),
  328.     m_bFastStart(FALSE),
  329.     m_ulPlayRangeFrom(RTSP_PLAY_RANGE_BLANK),
  330.     m_ulPlayRangeTo(RTSP_PLAY_RANGE_BLANK),
  331.     m_bPlayRequestSent(FALSE),
  332.     m_packets_since_last_drop(0),
  333.     m_ulTotalSuccessfulResends(0),
  334.     m_ulTotalFailedResends(0),
  335.     m_ulSendingTime(0),
  336.     m_drop_packets(FALSE),
  337.     m_bSkipTimeAdjustment(FALSE)
  338. #ifdef RDT_MESSAGE_DEBUG
  339.     ,m_bRDTMessageDebug(FALSE)
  340. #endif    
  341. {
  342.     m_ulStartTime = HX_GET_TICKCOUNT();
  343. }
  345. RTSPTransport::~RTSPTransport()
  346. {
  347.     HX_RELEASE(m_pCommonClassFactory);
  348.     HX_RELEASE(m_pScheduler);
  349.     HX_RELEASE(m_pResp);
  350.     HX_RELEASE(m_pRegistry);
  351.     if (m_pStreamHandler)
  352.     {
  353.         m_pStreamHandler->Release();
  354.         m_pStreamHandler = NULL;
  355.     }
  356.     HX_RELEASE(m_pInternalReset);
  357.     HX_RELEASE(m_pSrcBufferStats);
  358.     HX_RELEASE(m_pPlayerState);
  359.     HX_RELEASE(m_pPacketFilter);
  360.     HX_RELEASE(m_pContext);
  362.     HX_DELETE(m_pClientPacketList);
  363. }
  365. void
  366. RTSPTransport::addStreamInfo(RTSPStreamInfo* pStreamInfo, UINT32 ulBufferDepth)
  367. {
  368.     if(pStreamInfo)
  369.     {
  370. if(!m_pStreamHandler)
  371. {
  372.     m_pStreamHandler = new RTSPStreamHandler(this);
  373.     m_pStreamHandler->AddRef();
  374. }
  376. CHXTimestampConverter*  pTSConverter = NULL;
  378. if (pStreamInfo->m_HXFactor && pStreamInfo->m_RTPFactor)
  379. {
  380.     pTSConverter = new CHXTimestampConverter(CHXTimestampConverter::FACTORS,
  381.      pStreamInfo->m_HXFactor,
  382.      pStreamInfo->m_RTPFactor);
  383.  }
  384.  else if (pStreamInfo->m_sampleRate)
  385.  {
  386.      
  387.      pTSConverter =  new CHXTimestampConverter(CHXTimestampConverter::SAMPLES,
  388.        pStreamInfo->m_sampleRate);
  389.  }
  391.  m_pStreamHandler->initStreamData(
  392.      pStreamInfo->m_streamNumber,
  393.      pStreamInfo->m_bNeedReliablePackets,
  394.      m_bIsSource,
  395.      pStreamInfo->m_rtpPayloadType,
  396.      m_bHackedRecordFlag,
  397.      m_wrapSequenceNumber,
  398.      ulBufferDepth,
  399.      pStreamInfo->m_bHasOutOfOrderTS,
  400.      pTSConverter,
  401.      pStreamInfo->m_eMediaType);
  403.         m_bSkipTimeAdjustment = pStreamInfo->m_bRealMedia;
  405. RTSPStreamData* pStreamData = NULL;
  406. pStreamData = m_pStreamHandler->getStreamData(pStreamInfo->m_streamNumber);
  407. if (pStreamData && pStreamData->m_pTransportBuffer && m_bPrefetch)
  408. {
  409.     pStreamData->m_pTransportBuffer->EnterPrefetch();
  410. }
  411.     }
  412. }
  414. void
  415. RTSPTransport::setFirstTimeStamp(UINT16 uStreamNumber, UINT32 ulTS, 
  416.                                  BOOL bIsRaw)
  417. {
  418.     RTSPStreamData* pStreamData = 
  419. m_pStreamHandler->getStreamData(uStreamNumber);
  421.     if (pStreamData)
  422.     {
  423. if (pStreamData->m_pTSConverter)
  424. {
  425.     pStreamData->m_pTSConverter->setHXAnchor(ulTS);
  426. }
  427.          
  428. HX_DELETE(pStreamData->m_pTSOrderHack);
  429.     }
  431.     if (!m_bIsSource)
  432.     {
  433. RTSPTransportBuffer* pTransportBuffer = pStreamData->m_pTransportBuffer;
  435. if (pTransportBuffer && pStreamData)
  436. {
  437.     if ((m_ulPlayRangeFrom != RTSP_PLAY_RANGE_BLANK) &&
  438. (m_ulPlayRangeTo != RTSP_PLAY_RANGE_BLANK))
  439.     {
  440. if ((pStreamData->m_eMediaType == RTSPMEDIA_TYPE_AUDIO) ||
  441.     (pStreamData->m_eMediaType == RTSPMEDIA_TYPE_VIDEO))
  442. {
  443.     // For audio & video media, we'll inform transport of
  444.     // the media duration to help determining stream termination
  445.     pStreamData->m_pTransportBuffer->InformTimestampRange(
  446. m_ulPlayRangeFrom,
  447. m_ulPlayRangeTo,
  448. STREAM_END_DELAY_BASE_TOLERANCE);
  449. }
  450.     }
  451. }
  452.     }
  453. }
  455. void 
  456. RTSPTransport::setPlayRange(UINT32 ulFrom, UINT32 ulTo)
  457. {
  458.     // this is the Range values in PLAY request in RMA time (ms) called on PLAY 
  459.     // request
  460.     m_ulPlayRangeFrom = ulFrom; 
  461.     m_ulPlayRangeTo = ulTo;
  462. }
  464. void
  465. RTSPTransport::setSessionID(const char* pSessionID)
  466. {
  467.     m_sessionID = pSessionID;
  468. }
  470. UINT16
  471. RTSPTransport::getSeqNum(UINT16 streamNumber)
  472. {
  473.     RTSPStreamData* pStreamData;
  475.     pStreamData = m_pStreamHandler->getStreamData(streamNumber);
  477.     if(pStreamData)
  478.     {
  479. return pStreamData->m_seqNo;
  480.     }
  481.     else
  482.     {
  483. return 0; //XXXBAB - 0xffff?
  484.     }
  485. }
  487. UINT32
  488. RTSPTransport::getTimestamp(UINT16 streamNumber)
  489. {
  490.     RTSPStreamData* pStreamData;
  492.     pStreamData = m_pStreamHandler->getStreamData(streamNumber);
  494.     if(pStreamData)
  495.     {
  496. // XXXGo - this is RTP time w/ offset (NOT RMA time) if RTPUDPTransprot...
  497. return pStreamData->m_lastTimestamp;
  498.     }
  499.     else
  500.     {
  501. return 0;
  502.     }
  503. }
  505. HX_RESULT
  506. RTSPTransport::getPacket(UINT16 uStreamNumber, IHXPacket*& pPacket)
  507. {
  508.     RTSPTransportBuffer* pTransportBuffer = getTransportBuffer(uStreamNumber);
  509.     RTSPStreamData* pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);
  511.     if ((!pTransportBuffer) || (!pStreamData))
  512.     {
  513. return HXR_FAIL;
  514.     }
  516.     ClientPacket* clientPacket;
  518.     HX_RESULT result = pTransportBuffer->GetPacket(clientPacket);
  520.     if (result != HXR_OK)
  521.     {
  522. return result;
  523.     }
  525.     pPacket = clientPacket->GetPacket();
  527.     if (!pPacket)
  528.     {
  529. /*
  530.  * This is a lost packet
  531.  */
  533. result = m_pCommonClassFactory->CreateInstance(CLSID_IHXPacket,
  534.                                                (void**)&pPacket);
  536. if (result != HXR_OK)
  537. {
  538.     return result;
  539. }
  541. UINT8 unASMFlags = 0;
  542. UINT32 ulTime = 0;
  543. if (clientPacket->IsDroppedPacket())
  544. {
  545.     // Preserve dropped flag as an ASM flag.
  546.     // This allows other code along the packet
  547.     // path to differentiate this packet from a 
  548.     // true lost packet.
  549.     unASMFlags |= HX_ASM_DROPPED_PKT;
  551.     // We have a valid timestamp for a dropped
  552.     // packet so lets put it in the IHXPacket
  553.     ulTime = clientPacket->GetTime();
  554. }
  556. pPacket->Set(0, ulTime, uStreamNumber, unASMFlags, 0);
  557. pPacket->SetAsLost();
  558.     }
  559.     else if (pStreamData->m_bUsesRTPPackets)
  560.     {
  561. if (!pStreamData->m_pTSOrderHack)
  562. {
  563.     pStreamData->m_pTSOrderHack = new RTSPStreamData::TSOrderHackInfo();
  564.     
  565.     if (pStreamData->m_pTSOrderHack)
  566.     {
  567. pStreamData->m_pTSOrderHack->m_ulLastSentTS = 
  568.     pPacket->GetTime();
  569. pStreamData->m_pTSOrderHack->m_ulLastRecvTS = 
  570.     pStreamData->m_pTSOrderHack->m_ulLastSentTS;
  571.     }
  572. }
  574. if (pStreamData->m_pTSOrderHack)
  575. {
  576.     IHXBuffer* pBuf=NULL;     
  577.     UINT32 ulHX;
  578.     UINT32 ulRTP;
  579.     UINT16 unStrmNo;
  580.     UINT8  uchASMFlag;
  581.     UINT16 unRuleNo;
  583.     // pkts've been sorted based on seq_no
  584.     IHXRTPPacket* pRTPPacket = NULL;
  586.     pPacket->QueryInterface(IID_IHXRTPPacket, (void**) &pRTPPacket);
  588.     if (pRTPPacket)
  589.     {
  590. // RTP transport generates RTP packets
  591. result = pRTPPacket->GetRTP(pBuf, ulHX, ulRTP, 
  592.     unStrmNo, uchASMFlag, unRuleNo);
  593.     }
  594.     else
  595.     {
  596. // RDT transport generates RMA packets
  597. result = pPacket->Get(pBuf, ulHX,
  598.       unStrmNo, uchASMFlag, unRuleNo);
  600. if (pStreamData->m_pTSConverter)
  601. {
  602.     ulRTP = pStreamData->m_pTSConverter->hxa2rtp(ulHX);
  603. }
  604. else
  605. {
  606.     ulRTP = ulHX;
  607. }
  608.     }
  610.     HX_ASSERT(result == HXR_OK);
  612.     if (result == HXR_OK)
  613.     {
  614. if (((LONG32) (ulHX - pStreamData->m_pTSOrderHack->m_ulLastSentTS)) > 0)
  615. {
  616.     pStreamData->m_pTSOrderHack->m_ulLastSentTS = ulHX;
  617.     pStreamData->m_pTSOrderHack->m_ulLastRecvTS = ulHX;
  618. }
  619. else if (ulHX == pStreamData->m_pTSOrderHack->m_ulLastRecvTS)
  620. {
  621.     ulHX = pStreamData->m_pTSOrderHack->m_ulLastSentTS;          
  622. }
  623. else
  624. {
  625.     pStreamData->m_pTSOrderHack->m_ulLastRecvTS = ulHX;
  626.     ulHX = (++pStreamData->m_pTSOrderHack->m_ulLastSentTS);
  627. }
  629. HX_RELEASE(pRTPPacket);
  630. HX_RELEASE(pPacket);
  631. pRTPPacket = new CHXRTPPacket;
  632. pRTPPacket->AddRef();
  633. result = pRTPPacket->SetRTP(pBuf,
  634.     ulHX,
  635.     ulRTP,
  636.     unStrmNo,
  637.     uchASMFlag,
  638.     unRuleNo);
  639. HX_ASSERT(result == HXR_OK);
  640. pRTPPacket->QueryInterface(IID_IHXPacket, (void**) &pPacket);
  641. HX_ASSERT(pPacket);
  642.     }
  643.     HX_RELEASE(pBuf);
  645.     HX_RELEASE(pRTPPacket);
  646. }
  647.     }
  649.     /*
  650.      * No longer need the ClientPacket wrapper
  651.      */
  652.     HX_RELEASE(clientPacket);    
  654.     return HXR_OK;
  655. }
  657. HX_RESULT
  658. RTSPTransport::startPackets(UINT16 uStreamNumber)
  659. {
  660.     RTSPTransportBuffer* pTransportBuffer = getTransportBuffer(uStreamNumber);
  662.     if (!pTransportBuffer)
  663.     {
  664. return HXR_FAIL;
  665.     }
  667.     return pTransportBuffer->StartPackets();
  668. }
  670. HX_RESULT
  671. RTSPTransport::stopPackets(UINT16 uStreamNumber)
  672. {
  673.     RTSPTransportBuffer* pTransportBuffer = getTransportBuffer(uStreamNumber);
  675.     if (!pTransportBuffer)
  676.     {
  677. return HXR_FAIL;
  678.     }
  680.     return pTransportBuffer->StopPackets();
  681. }
  683. void
  684. RTSPTransport::SetFilterResponse(RawPacketFilter* pResp)
  685. {
  686.     HX_RELEASE(m_pPacketFilter);
  687.     m_pPacketFilter = pResp;
  688.     if (m_pPacketFilter)
  689.     {
  690. m_pPacketFilter->AddRef();
  691.     }
  692. }
  694. void
  695. RTSPTransport::FilterPacket(IHXPacket* pPacket)
  696. {
  697.     UINT16 uStreamNumber;
  699.     ClientPacket* clientPacket = 0;
  700.     clientPacket = (ClientPacket*)m_pClientPacketList->RemoveTail();
  701.     clientPacket->SetPacket(pPacket);
  702.     
  703.     uStreamNumber = clientPacket->GetStreamNumber();
  704.     RTSPTransportBuffer* pTransportBuffer = getTransportBuffer(uStreamNumber);
  705.     pTransportBuffer->Add(clientPacket);
  706. }
  708. void RTSPTransport::GetContext(IUnknown*& pContext)   
  709. {   
  710. pContext = m_pContext;   
  712. if (pContext)   
  713. {   
  714. pContext->AddRef();   
  715. }   
  716. } 
  718. void 
  719. RTSPTransport::LeavePrefetch(void)
  720. {
  721.     RTSPStreamData* pStreamData = NULL; 
  722.     
  723.     m_bPrefetch = FALSE;
  725.     HX_ASSERT(m_pStreamHandler);
  727.     pStreamData = m_pStreamHandler->firstStreamData();
  728.     while(pStreamData)    
  729.     {
  730. if (pStreamData->m_pTransportBuffer)
  731. {
  732.     pStreamData->m_pTransportBuffer->LeavePrefetch();
  733. }
  734. pStreamData = m_pStreamHandler->nextStreamData();
  735.     }
  737.     return;
  738. }
  740. void 
  741. RTSPTransport::EnterFastStart(void)
  742. {
  743.     RTSPStreamData* pStreamData = NULL; 
  744.     
  745.     m_bFastStart = TRUE;
  747.     HX_ASSERT(m_pStreamHandler);
  749.     pStreamData = m_pStreamHandler->firstStreamData();
  750.     while(pStreamData)    
  751.     {
  752. if (pStreamData->m_pTransportBuffer)
  753. {
  754.     pStreamData->m_pTransportBuffer->EnterFastStart();
  755. }
  756. pStreamData = m_pStreamHandler->nextStreamData();
  757.     }
  759.     return;
  760. }
  762. void 
  763. RTSPTransport::LeaveFastStart(void)
  764. {
  765.     RTSPStreamData* pStreamData = NULL; 
  766.     
  767.     m_bFastStart = FALSE;
  769.     HX_ASSERT(m_pStreamHandler);
  771.     pStreamData = m_pStreamHandler->firstStreamData();
  772.     while(pStreamData)    
  773.     {
  774. if (pStreamData->m_pTransportBuffer)
  775. {
  776.     pStreamData->m_pTransportBuffer->LeaveFastStart();
  777. }
  778. pStreamData = m_pStreamHandler->nextStreamData();
  779.     }
  781.     return;
  782. }
  784. BOOL 
  785. RTSPTransport::isSparseStream(UINT16 uStreamNumber)
  786. {
  787.     BOOL bResult = FALSE;
  788.     const char* pMimeType = NULL;
  789.     IUnknown* pUnknown = NULL;
  790.     IHXStreamSource* pStreamSource = NULL;    
  791.     IHXStream* pStream = NULL;
  793.     if (m_pContext  &&
  794. HXR_OK == m_pContext->QueryInterface(IID_IHXStreamSource, (void**)&pStreamSource))
  795.     {
  796. if (HXR_OK == pStreamSource->GetStream(uStreamNumber, pUnknown))
  797. {
  798.     if (HXR_OK == pUnknown->QueryInterface(IID_IHXStream, (void**)&pStream))
  799.     {
  800. pMimeType = pStream->GetStreamType();
  802. // special handling for sparsed streams for multicast
  803. if (pMimeType &&
  804.     (strcasecmp(SYNCMM_MIME_TYPE, pMimeType) == 0 ||
  805.      strcasecmp(REALEVENT_MIME_TYPE, pMimeType) == 0 ||
  806.      strcasecmp("application/vnd.rn-realtext", pMimeType) == 0 ||
  807.      strcasecmp("application/x-pn-realtext", pMimeType) == 0))
  808. {
  809.     bResult = TRUE;
  810. }
  811.     }
  812.     HX_RELEASE(pStream);
  813. }
  814. HX_RELEASE(pUnknown);
  815.     }
  816.     HX_RELEASE(pStreamSource);
  818.     return bResult;
  819. }
  821. HX_RESULT
  822. RTSPTransport::storePacket(IHXPacket* pPacket,
  823.                            UINT16 uStreamNumber,
  824.                            UINT16 uSeqNo,
  825.                            UINT16 uReliableSeqNo,
  826.                            BOOL isReliable)
  827. {
  828.     RTSPTransportBuffer* pTransportBuffer = getTransportBuffer(uStreamNumber);
  830.     if (!pTransportBuffer)
  831.     {
  832. return HXR_FAIL;
  833.     }
  835.     ClientPacket* clientPacket = 0;
  836.     
  837.     m_bIsReceivedData = TRUE;
  839.     if (pPacket->IsLost())
  840.     {
  841.         clientPacket = new ClientPacket(uSeqNo, uReliableSeqNo,
  842.                         pPacket->GetTime(), 0, isReliable,
  843.                         0, pTransportBuffer->GetTime(), FALSE);
  845. clientPacket->AddRef();
  847. return pTransportBuffer->Add(clientPacket);
  848.     }
  849.     
  850.     IHXBuffer* pBuffer = pPacket->GetBuffer();
  852.     if (m_pPacketFilter)
  853.     {
  854. if (!m_pClientPacketList)
  855. {
  856.     m_pClientPacketList = new CHXSimpleList;
  857.     m_pPacketFilter->SetFilterResponse(this);
  858. }
  859. clientPacket = new ClientPacket(uSeqNo, uReliableSeqNo,
  860. pPacket->GetTime(), pBuffer->GetSize(), isReliable,
  861. NULL, pTransportBuffer->GetTime(),
  862. FALSE);
  864. clientPacket->AddRef();
  865. pBuffer->Release();
  867. m_pClientPacketList->AddHead((void*)clientPacket);
  868. m_pPacketFilter->FilterPacket(pPacket);
  870. // just guessing on what this should be?????
  871.         return HXR_OK;
  872.     }
  873.     else
  874.     {
  875.        clientPacket = new ClientPacket(uSeqNo, uReliableSeqNo,
  876. pPacket->GetTime(), pBuffer->GetSize(), isReliable,
  877. pPacket, pTransportBuffer->GetTime(), FALSE);
  879. clientPacket->AddRef();
  880. pBuffer->Release();
  882. return pTransportBuffer->Add(clientPacket);
  883.     }
  884. }
  886. HX_RESULT
  887. RTSPTransport::packetReady(HX_RESULT status, RTSPStreamData* pStreamData, IHXPacket* pPacket)
  888. {
  889.     HX_RESULT result = HXR_OK;
  891.     ASSERT(!m_bIsSource);
  893.     if (!pStreamData)
  894.     {
  895. return HXR_UNEXPECTED;
  896.     }
  898.     HX_ASSERT(pStreamData);
  899.     
  900.     if (pPacket)
  901.     {
  902. if (pStreamData->m_bUsesRTPPackets)
  903. {
  904.     IHXRTPPacket* pRTPPacket = NULL;
  906.     pPacket->QueryInterface(IID_IHXRTPPacket, (void**) &pRTPPacket);
  908.     if (pRTPPacket)
  909.     {
  910. // This already is RTP Packet - proceed
  911. pRTPPacket->Release();
  912.     }
  913.     else
  914.     {
  915. // Must Transfer to an RTP Packet
  916. result = m_pCommonClassFactory->CreateInstance(
  917. CLSID_IHXRTPPacket,
  918. (void**) &pRTPPacket);
  920. if (pRTPPacket)
  921. {
  922.     ULONG32 ulTime;
  923.     ULONG32 ulRTPTime;
  924.     UINT16 uStreamNumber;
  925.     UINT8 unASMFlags;
  926.     UINT16 unASMRuleNumber;
  927.     BOOL bIsLost = pPacket->IsLost();
  928.     IHXBuffer* pBuffer = NULL;
  930.     pPacket->Get(pBuffer,
  931.  ulTime,
  932.  uStreamNumber,
  933.  unASMFlags,
  934.  unASMRuleNumber);
  936.     if (pStreamData->m_pTSConverter)
  937.     {
  938. ulRTPTime = pStreamData->m_pTSConverter->hxa2rtp(ulTime);
  939.     }
  940.     else
  941.     {
  942. ulRTPTime = ulTime;
  943.     }
  945.     pRTPPacket->SetRTP(pBuffer,
  946.        ulTime,
  947.        ulRTPTime,
  948.        uStreamNumber,
  949.        unASMFlags,
  950.        unASMRuleNumber);
  952.     if (bIsLost)
  953.     {
  954. pRTPPacket->SetAsLost();
  955.     }
  957.     HX_RELEASE(pBuffer);
  959.     result = m_pResp->PacketReady(status, m_sessionID, pRTPPacket);
  960.     pRTPPacket->Release();
  961. }
  963. return result;
  964.     }
  965. }
  966.     }
  967.     else
  968.     {
  969. /*
  970.  * This is a lost packet
  971.  */
  972. if (pStreamData->m_bUsesRTPPackets)
  973. {
  974.     result = m_pCommonClassFactory->CreateInstance(
  975. CLSID_IHXRTPPacket,
  976. (void**) &pPacket);
  977. }
  978. else
  979. {
  980.     result = m_pCommonClassFactory->CreateInstance(
  981. CLSID_IHXPacket,
  982. (void**) &pPacket);
  983. }
  984.     
  985. if (pPacket)
  986. {
  987.     pPacket->Set(0, 0, pStreamData->m_streamNumber, 0, 0);
  988.     pPacket->SetAsLost();
  989.     result = m_pResp->PacketReady(status, m_sessionID, pPacket);
  990.     pPacket->Release();
  991. }
  992. return result;
  993.     }
  995.     return m_pResp->PacketReady(status, m_sessionID, pPacket);
  996. }
  998. HX_RESULT
  999. RTSPTransport::packetReady(HX_RESULT status, UINT16 uStreamNumber, IHXPacket* pPacket)
  1000. {
  1001.     RTSPStreamData* pStreamData = NULL;
  1003.     ASSERT(!m_bIsSource);
  1005.     pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);
  1007.     HX_ASSERT(pStreamData);
  1009.     return packetReady(status, pStreamData, pPacket);
  1010. }
  1012. HX_RESULT
  1013. RTSPTransport::getStatus
  1014. (
  1015.     UINT16& uStatusCode, 
  1016.     IHXBuffer*& pStatusDesc, 
  1017.     UINT16& ulPercentDone
  1018. )
  1019. {
  1020. #if 0
  1021.     if (!m_pStreamHandler)
  1022.     {
  1023. uStatusCode = HX_STATUS_INITIALIZING;
  1024. pStatusDesc = 0;
  1025. ulPercentDone = 0;
  1027. return HXR_OK;
  1028.     }
  1030.     uStatusCode = HX_STATUS_READY;
  1031.     pStatusDesc = 0;
  1032.     ulPercentDone = 100;
  1034.     RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1036.     ASSERT(pStreamData);
  1038.     while(pStreamData)
  1039.     {
  1040. UINT16 tempStatusCode;
  1041. UINT16 tempPercentDone;
  1043. pStreamData->m_pTransportBuffer->GetStatus(tempStatusCode,
  1044.                                            tempPercentDone);
  1046. /*
  1047.  * The status is always that of the stream which is least ready
  1048.  */
  1050. if (tempStatusCode < uStatusCode)
  1051. {
  1052.     uStatusCode     = tempStatusCode;
  1053.     ulPercentDone   = tempPercentDone;
  1054. }
  1055. else if (tempStatusCode == uStatusCode && 
  1056.  tempPercentDone < ulPercentDone)
  1057. {
  1058.     ulPercentDone = tempPercentDone;
  1059. }
  1061. pStreamData = m_pStreamHandler->nextStreamData();
  1062.     }
  1064.     return HXR_OK;
  1065. #else
  1066.     return HXR_NOTIMPL;
  1067. #endif
  1068. }
  1070. HX_RESULT
  1071. RTSPTransport::GetCurrentBuffering(UINT16  uStreamNumber,
  1072.    INT64&  llLowestTimestamp, 
  1073.    INT64&  llHighestTimestamp,
  1074.    UINT32& ulNumBytes,
  1075.    BOOL&   bDone)
  1076. {
  1077.     if (!m_pStreamHandler)
  1078.     {
  1079. return HXR_OK;
  1080.     }
  1082.     RTSPStreamData* pStreamData;
  1084.     pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);
  1086.     HX_ASSERT(pStreamData);
  1088.     return pStreamData ? 
  1089.            pStreamData->m_pTransportBuffer->GetCurrentBuffering(
  1090.                                             llLowestTimestamp,
  1091.                                             llHighestTimestamp,
  1092.                                             ulNumBytes,
  1093.                                             bDone) : HXR_OK;
  1094. }
  1096. HX_RESULT
  1097. RTSPTransport::SeekFlush(UINT16 uStreamNumber)
  1098. {
  1099.     if (!m_pStreamHandler)
  1100.     {
  1101. return HXR_OK;
  1102.     }
  1104.     RTSPStreamData* pStreamData;
  1106.     pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);
  1108.     HX_ASSERT(pStreamData);
  1110.     if (pStreamData)
  1111.     {
  1112. pStreamData->m_pTransportBuffer->SeekFlush();
  1113.     }
  1115.     return HXR_OK;
  1116. }
  1118. BOOL
  1119. RTSPTransport::IsSourceDone(void)
  1120. {
  1121.     return m_bSourceDone;
  1122. }
  1124. void      
  1125. RTSPTransport::CheckForSourceDone(UINT16 uStreamNumber)
  1126. {
  1127.     if (m_bSourceDone)
  1128.     {
  1129. return;
  1130.     }
  1132.     HX_ASSERT(m_pStreamHandler);
  1134.     if (!m_pStreamHandler)
  1135.     {
  1136. return;
  1137.     }
  1139.     RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1140.     HX_ASSERT(pStreamData);
  1142.     m_bSourceDone = TRUE;
  1143.     while(pStreamData)
  1144.     {
  1145. if (pStreamData->m_streamNumber == uStreamNumber)
  1146. {
  1147.     pStreamData->m_bReceivedAllPackets = TRUE;
  1148. }
  1149. else if (!pStreamData->m_bReceivedAllPackets)
  1150. {
  1151.     m_bSourceDone = FALSE;
  1152.     return;
  1153. }
  1155. pStreamData = m_pStreamHandler->nextStreamData();
  1156.     }
  1158.     /* We have received all the packets... Tell the reposnse object */
  1159.     if (!m_bIsSource)
  1160.     {
  1161. m_pResp->OnSourceDone();
  1162.     }
  1164. }    
  1166. void      
  1167. RTSPTransport::HandleBufferError()
  1168. {
  1169.     if (m_pResp)
  1170.     {
  1171. m_pResp->OnProtocolError(HXR_BUFFERING);
  1172.     }
  1173. }
  1175. RTSPResendBuffer*
  1176. RTSPTransport::getResendBuffer(UINT16 uStreamNumber)
  1177. {
  1178.     return m_pStreamHandler->getResendBuffer(uStreamNumber);
  1179. }
  1181. HX_RESULT
  1182. RTSPTransport::initializeStatistics
  1183. (
  1184.     UINT32 ulRegistryID
  1185. )
  1186. {
  1187.     m_bIsInitialized = TRUE;
  1189.     if (m_bIsSource)
  1190.     {
  1191. m_ulRegistryID = ulRegistryID;
  1192.     }
  1193.     else
  1194.     {
  1195. // XXX HP
  1196. // rather than create a new copy of STREAM_STATS, we simply
  1197. // obtain the same STREAM_STATS* from RTSPProtocol via SetStatistics().
  1198. // this could save us on both the memory and several ms during the startup
  1199. /*
  1200. IHXBuffer* pParentName = NULL;
  1201. CHAR RegKeyName[MAX_DISPLAY_NAME] = {0};
  1203. RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1205. ASSERT(pStreamData);
  1207. if (!m_pRegistry)
  1208. {
  1209.     return HXR_FAIL;
  1210. }
  1212. HX_RESULT result = m_pRegistry->GetPropName(ulRegistryID, pParentName);
  1214. if (result != HXR_OK)
  1215. {
  1216.     return result;
  1217. }
  1219. // create registry entries of each stream
  1220. while (pStreamData)
  1221. {
  1222.     UINT16 uStreamNumber = pStreamData->m_streamNumber;
  1224.     sprintf(RegKeyName, "%s.Stream%d", pParentName->GetBuffer(),
  1225.                                        uStreamNumber);
  1227.     UINT32 uStreamId = m_pRegistry->GetId(RegKeyName);
  1229.     // create stream reg key if it has not been created
  1230.     // by the source yet
  1231.     if (!uStreamId)
  1232.     {
  1233. return HXR_FAIL;
  1234.     }
  1236.     pStreamData->m_pStreamStats = new STREAM_STATS(m_pRegistry,
  1237.                                                    uStreamId);
  1238.    
  1239.     pStreamData = m_pStreamHandler->nextStreamData();
  1240. }
  1242. pParentName->Release();
  1243. */
  1244.     }
  1246.     return HXR_OK;
  1247. }
  1249. HX_RESULT
  1250. RTSPTransport::SetStatistics(UINT16 uStreamNumber, STREAM_STATS* pStats)
  1251. {
  1252.     HX_RESULT     rc = HXR_OK;
  1253. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  1254.     RTSPStreamData* pStreamData = NULL;
  1256.     if (!m_pStreamHandler)
  1257.     {
  1258. rc = HXR_FAILED;
  1259. goto cleanup;
  1260.     }
  1262.     pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);
  1263.     if (!pStreamData)
  1264.     {
  1265. rc = HXR_FAILED;
  1266. goto cleanup;
  1267.     }
  1269.     pStreamData->m_pStreamStats = pStats;
  1271. cleanup:
  1272. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  1274.     return rc;
  1275. }
  1277. HX_RESULT 
  1278. RTSPTransport::updateStatistics(BOOL bUseRegistry)
  1279. {
  1280.     m_bIsUpdated = TRUE;
  1282. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  1283.     if (m_bIsSource)
  1284.     {
  1285. RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1287. if (!pStreamData)
  1288. {
  1289.     return HXR_FAIL;
  1290. }
  1292. /*
  1293.  * XXXGH...streams are managed by the PPM and should not show up
  1294.  *         under the transport
  1295.  */
  1296. while (pStreamData)
  1297. {
  1298.     UINT32 ulResendSuccess = 0;
  1299.     UINT32 ulResendFailure = 0;
  1301.     if (pStreamData->m_pResendBuffer)
  1302.     {
  1303. pStreamData->m_pResendBuffer->UpdateStatistics(ulResendSuccess,
  1304.                                                ulResendFailure);
  1305.     }
  1307.     m_ulTotalSuccessfulResends += ulResendSuccess;
  1308.     m_ulTotalFailedResends += ulResendFailure;
  1310.     pStreamData = m_pStreamHandler->nextStreamData();
  1311. }
  1313.         m_ulSendingTime = CALCULATE_ELAPSED_TICKS(m_ulStartTime, HX_GET_TICKCOUNT()) / 1000;
  1315. IHXBuffer* pName;
  1317. if (bUseRegistry
  1318.         &&  m_pRegistry 
  1319.         &&  HXR_OK == m_pRegistry->GetPropName(m_ulRegistryID, pName))
  1320. {
  1321.     char str[512]; /* Flawfinder: ignore */
  1322.     const char* name = (const char*)pName->GetBuffer();
  1323.     char pTemp[32]; /* Flawfinder: ignore */
  1325.     i64toa(m_lBytesSent, pTemp, 10);
  1327.     sprintf(str, "%-.400s.PacketsSent", name); /* Flawfinder: ignore */
  1328.     m_pRegistry->AddInt(str, m_ulPacketsSent);
  1329.     sprintf(str, "%-.400s.BytesSent", name); /* Flawfinder: ignore */
  1330.     m_pRegistry->AddInt(str, INT64_TO_INT32(m_lBytesSent));
  1332.     // Add the total bytes sent as a string because we don't want
  1333.     // to have to truncate the INT64 value that is storing it
  1334.     sprintf(str, "%-.400s.TotalBytesSent", name); /* Flawfinder: ignore */
  1335.     IHXBuffer* pBuffer = new CHXBuffer();
  1336.     pBuffer->AddRef();
  1337.     pBuffer->Set((UCHAR*)pTemp, strlen(pTemp) + 1);
  1338.     m_pRegistry->AddStr(str, pBuffer);
  1339.     HX_RELEASE(pBuffer);
  1341.     sprintf(str, "%-.400s.SendingTime", name); /* Flawfinder: ignore */
  1342.     m_pRegistry->AddInt(str, m_ulSendingTime); 
  1343.     sprintf(str, "%-.400s.ResendSuccess", name); /* Flawfinder: ignore */
  1344.     m_pRegistry->AddInt(str, m_ulTotalSuccessfulResends);
  1345.     sprintf(str, "%-.400s.ResendFailure", name); /* Flawfinder: ignore */
  1346.     m_pRegistry->AddInt(str, m_ulTotalFailedResends);
  1347.     pName->Release();
  1348. }
  1349.     }
  1350.     else
  1351.     {
  1352. ULONG32 ulNormal = 0;
  1353. ULONG32 ulReceived = 0;
  1354. ULONG32 ulLost = 0;
  1355. ULONG32 ulLate = 0;
  1356. ULONG32 ulTotal = 0;
  1357. ULONG32 ulResendRequested = 0;
  1358. ULONG32 ulResendReceived = 0;
  1359. ULONG32 ulAvgBandwidth = 0;
  1360. ULONG32 ulCurBandwidth = 0;
  1362. UINT32 ulTotal30 = 0;
  1363. UINT32 ulLost30 = 0;
  1364. UINT32  ulDuplicate = 0;
  1365. UINT32 ulOutOfOrder = 0;
  1367. RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1369. if (!pStreamData)
  1370. {
  1371.     return HXR_FAIL;
  1372. }
  1374. while (pStreamData)
  1375. {
  1376.     STREAM_STATS* pStreamStats = pStreamData->m_pStreamStats;
  1378.             if (!pStreamStats || !pStreamStats->m_bInitialized)
  1379.     {
  1380. goto updateContinue;
  1381.     }
  1383.     pStreamData->m_pTransportBuffer->UpdateStatistics(ulNormal,
  1384.                                                       ulLost,
  1385.                                                       ulLate,
  1386.                                                       ulResendRequested,
  1387.                                                       ulResendReceived,
  1388.                                                       ulAvgBandwidth,
  1389.                                                       ulCurBandwidth,
  1390.       ulTotal30,
  1391.       ulLost30,
  1392.       ulDuplicate,
  1393.       ulOutOfOrder);
  1394.                   
  1395.     ulReceived = ulNormal + ulResendReceived;
  1396.     ulTotal = ulReceived + ulLost + ulLate;
  1398.     pStreamStats->m_pNormal->SetInt((INT32)ulNormal);
  1399.     pStreamStats->m_pRecovered->SetInt((INT32)ulResendReceived);
  1400.     pStreamStats->m_pReceived->SetInt((INT32)ulReceived);
  1401.     pStreamStats->m_pLost->SetInt((INT32)ulLost);
  1402.     pStreamStats->m_pLate->SetInt((INT32)ulLate);
  1403.     pStreamStats->m_pDuplicate->SetInt((INT32)ulDuplicate);
  1404.     pStreamStats->m_pOutOfOrder->SetInt((INT32)ulOutOfOrder);
  1405.     pStreamStats->m_pTotal->SetInt((INT32)ulTotal);
  1406.     pStreamStats->m_pLost30->SetInt((INT32)ulLost30);
  1407.     pStreamStats->m_pTotal30->SetInt((INT32)ulTotal30);
  1408.     pStreamStats->m_pResendRequested->SetInt((INT32)ulResendRequested);
  1409.     pStreamStats->m_pResendReceived->SetInt((INT32)ulResendReceived);
  1410.     pStreamStats->m_pAvgBandwidth->SetInt((INT32)ulAvgBandwidth);
  1411.     pStreamStats->m_pCurBandwidth->SetInt((INT32)ulCurBandwidth);
  1413. updateContinue:
  1415.     pStreamData = m_pStreamHandler->nextStreamData();
  1416. }
  1417.     }
  1418. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  1420.     return HXR_OK;
  1421. }
  1423. HX_RESULT 
  1424. RTSPTransport::UpdateRegistry(UINT32 ulStreamNumber,
  1425.       UINT32 ulRegistryID)
  1426. {
  1427.     if (m_bIsSource)
  1428.     {
  1429. m_ulRegistryID = ulRegistryID;
  1430.     }
  1431.     else
  1432.     {
  1433. // XXX HP
  1434. // rather than create a new copy of STREAM_STATS, we simply
  1435. // obtain the same STREAM_STATS* from RTSPProtocol via SetStatistics().
  1436. // this could save us on both the memory and several ms during the startup
  1437. /*
  1438. if (!m_pRegistry)
  1439. {
  1440.     return HXR_FAIL;
  1441. }
  1443. RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1444. while (pStreamData)
  1445. {
  1446.     if (pStreamData->m_streamNumber == (UINT16)ulStreamNumber)
  1447.     {
  1448. HX_DELETE(pStreamData->m_pStreamStats);
  1449. pStreamData->m_pStreamStats = new STREAM_STATS(m_pRegistry,
  1450.        ulRegistryID);
  1451. break;
  1452.     }    
  1453.     pStreamData = m_pStreamHandler->nextStreamData();
  1454. }
  1455. */
  1456.     }
  1458.     return HXR_OK;
  1459. }
  1461. RTSPTransportBuffer*
  1462. RTSPTransport::getTransportBuffer(UINT16 uStreamNumber)
  1463. {
  1464.     if (!m_pStreamHandler)
  1465.     {
  1466. return NULL;
  1467.     }
  1469.     RTSPStreamData* pStreamData;     
  1471.     pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);
  1473.     if (!pStreamData)
  1474.     {
  1475. return NULL;
  1476.     }
  1478.     return pStreamData->m_pTransportBuffer;
  1479. }
  1481. HX_RESULT
  1482. RTSPTransport::playReset()
  1483. {
  1484.     m_bSourceDone = FALSE;
  1486.     if(m_pStreamHandler)
  1487.     {
  1488. RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1490. while(pStreamData)
  1491. {
  1492.     if (m_bIsSource)
  1493.     {
  1494. pStreamData->m_packetSent = FALSE;
  1495.     }
  1496.     else
  1497.     {
  1498. pStreamData->m_pTransportBuffer->Reset();
  1499. pStreamData->m_bReceivedAllPackets = FALSE;
  1500.     }
  1502.     pStreamData = m_pStreamHandler->nextStreamData();
  1503. }
  1504.     }
  1505.     return HXR_OK;
  1506. }
  1508. HX_RESULT
  1509. RTSPTransport::pauseBuffers()
  1510. {
  1511.     if (m_pStreamHandler)
  1512.     {
  1513. RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1515. ASSERT(pStreamData);
  1517. while(pStreamData)
  1518. {
  1519.     pStreamData->m_pTransportBuffer->Pause();
  1521.     pStreamData = m_pStreamHandler->nextStreamData();
  1522. }
  1523.     }
  1525.     return HXR_OK;
  1526. }
  1528. HX_RESULT
  1529. RTSPTransport::resumeBuffers()
  1530. {
  1531.     m_bIsReceivedData = FALSE;
  1533.     if (m_pStreamHandler)
  1534.     {
  1535. RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1537. ASSERT(pStreamData);
  1539. while(pStreamData)
  1540. {
  1541.     pStreamData->m_pTransportBuffer->Resume();
  1542.     pStreamData = m_pStreamHandler->nextStreamData();
  1543. }
  1544.     }
  1546.     return HXR_OK;
  1547. }
  1549. HX_RESULT
  1550. RTSPTransport::setFirstSeqNum(UINT16 uStreamNumber, UINT16 uSeqNum)
  1551. {
  1552.     RTSPStreamData* pStreamData;
  1554.     pStreamData = m_pStreamHandler->getStreamData(uStreamNumber);
  1556.     if(pStreamData)
  1557.     {
  1558. if (m_bIsSource)
  1559. {     
  1560.     pStreamData->m_seqNo = uSeqNum;
  1562.     if(pStreamData->m_pResendBuffer)
  1563.     {
  1564. pStreamData->m_pResendBuffer->SetFirstSequenceNumber(uSeqNum);
  1565.     }
  1566. }
  1567. else
  1568. {
  1569.     if (!pStreamData->m_pTransportBuffer)
  1570.     {
  1571. return HXR_FAIL;
  1572.     }
  1574.     if (!m_bMulticast)
  1575.     {
  1576. pStreamData->m_lastSeqNo = uSeqNum;
  1577.      pStreamData->m_pTransportBuffer->Init(uSeqNum);
  1578.     }
  1579. }
  1580.     }
  1582.     return HXR_OK;
  1583. }
  1585. HX_RESULT
  1586. RTSPTransport::Init(IUnknown* pContext)
  1587. {
  1588.     HX_RESULT hresult;
  1589.     
  1590.     if (!m_pContext)
  1591.     {
  1592. m_pContext = pContext;
  1593. m_pContext->AddRef();
  1594.     }
  1596.     hresult = pContext->QueryInterface(IID_IHXCommonClassFactory,
  1597.        (void**)&m_pCommonClassFactory);
  1599.     if (HXR_OK != hresult)
  1600.     {
  1601. return hresult;
  1602.     }
  1603.     
  1604.     hresult = pContext->QueryInterface(IID_IHXScheduler,
  1605.                                        (void**)&m_pScheduler);
  1607.     if (HXR_OK != hresult)
  1608.     {
  1609. DPRINTF(D_INFO, ("could not get scheduler...n"));
  1610. return hresult;
  1611.     }
  1613.     pContext->QueryInterface(IID_IHXRegistry, (void**)&m_pRegistry);
  1615.     pContext->QueryInterface(IID_IHXInternalReset,
  1616.                                (void**)&m_pInternalReset);
  1618.     pContext->QueryInterface(IID_IHXPlayerState,
  1619.                                (void**)&m_pPlayerState);
  1621.     pContext->QueryInterface(IID_IHXSourceBufferingStats2,
  1622.      (void**)&m_pSrcBufferStats);
  1624. #ifdef RDT_MESSAGE_DEBUG
  1625.     IHXPreferences* pPreferences = NULL;
  1626.     
  1627.     if (pContext &&
  1628. (HXR_OK == pContext->QueryInterface(IID_IHXPreferences,
  1629.                                             (void**) &pPreferences)))
  1630.     {
  1631. IHXBuffer* pBuffer = NULL;
  1633.         ReadPrefBOOL(pPreferences, "RDTMessageDebug", m_bRDTMessageDebug);
  1634. if (m_bRDTMessageDebug)
  1635. {
  1636.     if (HXR_OK == pPreferences->ReadPref("RDTMessageDebugFile", pBuffer))
  1637.     {
  1638. if (pBuffer->GetSize() <= 0)
  1639. {
  1640.     // no file name, no log
  1641.     m_bRDTMessageDebug = FALSE;
  1642. }
  1643. else
  1644. {
  1645.     m_RDTmessageDebugFileName = (const char*) pBuffer->GetBuffer();
  1646. }
  1647.     }
  1648.             HX_RELEASE(pBuffer);
  1649. }
  1650.     }
  1652.     HX_RELEASE(pPreferences);
  1653. #endif // RDT_MESSAGE_DEBUG
  1654.     
  1655.     return HXR_OK;
  1656. }
  1658. HX_RESULT
  1659. RTSPTransport::SetResendBufferDepth(UINT32 uMilliseconds)
  1660. {
  1661.     RTSPStreamData* pStreamData = m_pStreamHandler->firstStreamData();
  1663.     ASSERT(pStreamData);
  1665.     while (pStreamData)
  1666.     {
  1667. if (m_bIsSource)
  1668. {
  1669.     if (pStreamData->m_pResendBuffer)
  1670.     {
  1671. pStreamData->m_pResendBuffer->SetBufferDepth(uMilliseconds);
  1672.     }
  1673. }
  1674. else
  1675. {
  1676.     if (pStreamData->m_pTransportBuffer)
  1677.     {
  1678. pStreamData->m_pTransportBuffer->SetBufferDepth(uMilliseconds);
  1679.     }
  1680. }
  1682. pStreamData = m_pStreamHandler->nextStreamData();
  1683.     }
  1685.     return HXR_OK;
  1686. }
  1688. #ifdef RDT_MESSAGE_DEBUG
  1689. void RTSPTransport::RDTmessageFormatDebugFileOut(const char* fmt, ...)
  1690. {
  1691.     if(m_bRDTMessageDebug)
  1692.     {
  1693.         char buf[4096]; /* Flawfinder: ignore */
  1694. va_list args;
  1695. va_start(args, fmt);
  1696. FILE* fp = fopen((const char*)m_RDTmessageDebugFileName, "a");
  1697. if (fp)
  1698. {
  1699.     vsprintf(buf, fmt, args);
  1700.     fprintf(fp, "%sn", buf);
  1701.     fclose(fp);
  1702. }
  1704. va_end(args);
  1705.     }
  1706. }
  1707. #endif // RDT_MESSAGE_DEBUG