rtspmdsc.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:8k
源码类别:

Symbian

开发平台:

C/C++

  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 ***** */ 
  35. //#include "hlxclib/stdlib.h"
  36. //#include "hlxclib/stdio.h"
  37. #include "hxtypes.h"
  38. #include "hxcom.h"
  39. #include "ihxpckts.h"
  40. #include "hxstrutl.h"
  41. #include "chxpckts.h"
  42. #include "rtsputil.h"
  43. #include "cbqueue.h"
  44. #include "hxslist.h"
  45. #include "looseprs.h"
  46. #include "rtspprop.h"
  47. #include "mhprop.h"
  48. #include "rtspmdsc.h"
  49. #include "hxheap.h"
  50. #ifdef _DEBUG
  51. #undef HX_THIS_FILE
  52. static const char HX_THIS_FILE[] = __FILE__;
  53. #endif
  54. RTSPMediaDesc::RTSPMediaDesc():
  55.     m_pFileHeader(0)
  56. {
  57.     m_streams = new CHXSimpleList;
  58. }
  59. RTSPMediaDesc::~RTSPMediaDesc()
  60. {
  61.     delete m_pFileHeader;
  62.     clearStreamList();
  63.     delete m_streams;
  64. }
  65. HX_RESULT
  66. RTSPMediaDesc::fromExternalRep(char* pData)
  67. {
  68.     XMLParser parser;
  69.     XMLTag* pTag = 0;
  70.     CByteQueue* pQueue = new CByteQueue(strlen(pData));
  71.     BOOL inMediaHeader = FALSE;
  72.     BOOL inMediaStream = FALSE;
  73.     HX_RESULT hresult = HXR_OK;
  74.     RTSPPropertyList* pMediaHeader = 0;
  75.     RTSPPropertyList* pMediaStream = 0;
  76.     pQueue->EnQueue(pData, strlen(pData));
  77.     for(;;)
  78.     {
  79. UINT32 bytesUsed;
  80. UINT32 bytesAvail = pQueue->GetQueuedItemCount();
  81. if(bytesAvail <= 0)
  82. {
  83.     break;
  84. }
  85. BYTE* pBuf = new BYTE[bytesAvail];
  86. BYTE* p = pBuf;
  87. HX_ASSERT(bytesAvail == (UINT16)bytesAvail);
  88. pQueue->DeQueue(pBuf, (UINT16)bytesAvail);
  89. bytesUsed = bytesAvail;
  90. if(pTag)
  91. {
  92.     delete pTag;
  93.     pTag = 0;
  94. }
  95. XMLParseResult rc = parser.Parse((const char*&)p, bytesAvail, pTag);
  96. HX_ASSERT(bytesAvail == (UINT16)bytesAvail);
  97. pQueue->EnQueue(p, (UINT16)bytesAvail - (p - pBuf));
  98. switch(rc)
  99. {
  100.     case XMLPTag:
  101.     {
  102. switch(pTag->m_type)
  103. {
  104.     case XMLPlainTag:
  105.     {
  106. if(strcasecmp(pTag->m_name, "MediaHeader") == 0)
  107. {
  108.     if(inMediaHeader)
  109.     {
  110. //XXXBAB parse error
  111.     }
  112.     if(pMediaHeader)
  113.     {
  114. delete pMediaHeader;
  115.     }
  116.     pMediaHeader = new RTSPPropertyList;
  117.     inMediaHeader = TRUE;
  118.     inMediaStream = FALSE;
  119. }
  120. else if(strcasecmp(pTag->m_name, "MediaStream") == 0)
  121. {
  122.     if(inMediaStream)
  123.     {
  124. //XXXBAB parse error
  125.     }
  126.     pMediaStream = new RTSPPropertyList;
  127.     inMediaHeader = FALSE;
  128.     inMediaStream = TRUE;
  129. }
  130. else
  131. {
  132.     RTSPProperty* pProp = makeProperty(pTag);
  133.     if(pProp)
  134.     {
  135. if(inMediaHeader)
  136. {
  137.     pMediaHeader->addProperty(pProp);
  138. }
  139. else if(inMediaStream)
  140. {
  141.     pMediaStream->addProperty(pProp);
  142. }
  143.     }
  144. }
  145.     }
  146.     break;
  147.     case XMLEndTag:
  148.     {
  149. if(strcasecmp(pTag->m_name, "MediaHeader") == 0)
  150. {
  151.     if(inMediaHeader)
  152.     {
  153. m_pFileHeader = pMediaHeader;
  154.     }
  155.     else
  156.     {
  157. // error
  158.     }
  159.     inMediaHeader = FALSE;
  160. }
  161. else if(strcasecmp(pTag->m_name, "MediaStream") == 0)
  162. {
  163.     if(inMediaStream)
  164.     {
  165. m_streams->AddTail(pMediaStream);
  166.     }
  167.     else
  168.     {
  169. // error
  170.     }
  171.     inMediaStream = FALSE;
  172. }
  173.     }
  174.     break;
  175.     default:
  176.     {
  177. // unexpected
  178.     }
  179.     break;
  180. }
  181.     }
  182.     break;
  183.     case XMLPPlainText:
  184.     {
  185. // unexpected
  186.     }
  187.     break;
  188.     case XMLPComment:
  189.     {
  190. // oh, yeah?
  191.     }
  192.     break;
  193.     default:
  194.     {
  195. // unexpected
  196.     }
  197.     break;
  198. }
  199. delete[] pBuf;
  200.     }
  201.     if(pTag)
  202.     {
  203. delete pTag;
  204.     }
  205.     delete pQueue;
  206.     return hresult;
  207. }
  208.  
  209. HX_RESULT
  210. RTSPMediaDesc::toExternalRep(char *pBuf)
  211. {
  212.     CHXString mDesc = toExternalRep();
  213.     strcpy(pBuf, mDesc);
  214.     return HXR_OK;
  215. }
  216. CHXString
  217. RTSPMediaDesc::toExternalRep()
  218. {
  219.     CHXString mDesc;
  220.    
  221.     mDesc =  "<MediaDescription>rn";
  222.     
  223.     if(m_pFileHeader)
  224.     {
  225. mDesc += "    <MediaHeader>rn";
  226. RTSPProperty* pProp = m_pFileHeader->getFirstProperty();
  227. while(pProp)
  228. {
  229.     mDesc += "        " + pProp->asString() + "rn";
  230.     pProp = m_pFileHeader->getNextProperty();
  231. }
  232. mDesc += "    </MediaHeader>rn";
  233.     }
  234.     CHXSimpleList::Iterator i;
  235.     for (i = m_streams->Begin();
  236.      i != m_streams->End();
  237.      ++i)
  238.     {
  239. RTSPPropertyList* pStream = (RTSPPropertyList*)*i;
  240. if(pStream)
  241. {
  242.     mDesc += "    <MediaStream>rn";
  243.     RTSPProperty* pProp = pStream->getFirstProperty();
  244.     while(pProp)
  245.     {
  246. mDesc += "        " + pProp->asString() + "rn";
  247. pProp = pStream->getNextProperty();
  248.     }
  249.     mDesc += "    </MediaStream>rn";
  250. }
  251.     }
  252.     mDesc += "</MediaDescription>rn";
  253.     return mDesc;
  254. }
  255. RTSPPropertyList*
  256. RTSPMediaDesc::getFirstStream()
  257. {
  258.     m_listPos = m_streams->GetHeadPosition();
  259.     if(m_listPos)
  260.     {
  261. RTSPPropertyList* pStream = 
  262.     (RTSPPropertyList*)m_streams->GetNext(m_listPos);
  263. return pStream;
  264.     }
  265.     return 0;
  266. }
  267. RTSPPropertyList*
  268. RTSPMediaDesc::getNextStream()
  269. {
  270.     RTSPPropertyList* pStream = 0;
  271.     if(m_listPos)
  272.     {
  273. pStream = (RTSPPropertyList*)m_streams->GetNext(m_listPos);
  274.     }
  275.     return pStream;
  276. }
  277. CHXSimpleList*
  278. RTSPMediaDesc::getStreamList()
  279. {
  280.     return m_streams;
  281. }
  282. void 
  283. RTSPMediaDesc::addStream(RTSPPropertyList* pStream)
  284. {
  285.     m_streams->AddTail(pStream);
  286. }
  287. void
  288. RTSPMediaDesc::addHeader(RTSPPropertyList* pHeader)
  289. {
  290.     m_pFileHeader = pHeader;
  291. }
  292. RTSPPropertyList*
  293. RTSPMediaDesc::getFileHeader()
  294. {
  295.     return m_pFileHeader;
  296. }
  297. void
  298. RTSPMediaDesc::clearStreamList()
  299. {
  300.     LISTPOSITION pos = m_streams->GetHeadPosition();
  301.     while(pos)
  302.     {
  303. RTSPPropertyList* pStream = (RTSPPropertyList*)m_streams->GetNext(pos);
  304. delete pStream;
  305.     }
  306.     m_streams->RemoveAll();
  307. }
  308. RTSPProperty*
  309. RTSPMediaDesc::makeProperty(XMLTag* pTag)
  310. {
  311.     const char* pDataName = pTag->m_name;
  312.     const char* pDataType = pTag->get_attribute("type");
  313.     if(pDataType)
  314.     {
  315. const char* pDataValue = pTag->get_attribute("value");
  316. if(strcasecmp(pDataType, "integer") == 0)
  317. {
  318.     INT32 dataValue = strtol(pDataValue, 0, 10);
  319.     return new MHIntegerProperty(pDataName, dataValue);
  320. }
  321. else if(strcasecmp(pDataType, "string") == 0)
  322. {
  323.     return new MHStringProperty(pDataName, pDataValue);
  324. }
  325. else if(strcasecmp(pDataType, "buffer") == 0)
  326. {
  327.     char* pTmpBuf = new char[strlen(pDataValue)];
  328.     UINT32 dataLen = BinFrom64(pDataValue,
  329. strlen(pDataValue), (BYTE*)pTmpBuf);
  330.     CHXBuffer* pBuffer = new CHXBuffer;
  331.     pBuffer->AddRef();
  332.     pBuffer->Set((BYTE*)pTmpBuf, dataLen);
  333.     RTSPBufferProperty* pProp =
  334. new MHBufferProperty(pDataName, pBuffer);
  335.     pBuffer->Release();
  336.     delete[] pTmpBuf;
  337.     return pProp;
  338. }
  339.     }
  340.     return 0;
  341. }