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

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. /****************************************************************************
  36.  *  Defines
  37.  */
  38. #define AUDIO_MIMETYPE_PREFIX     "audio/"
  39. #define AUDIO_MIMETYPE_PREFIX_SIZE  (sizeof(AUDIO_MIMETYPE_PREFIX) - 1)
  40. #define VIDEO_MIMETYPE_PREFIX     "video/"
  41. #define VIDEO_MIMETYPE_PREFIX_SIZE  (sizeof(VIDEO_MIMETYPE_PREFIX) - 1)
  42. #define APP_MIMETYPE_PREFIX     "application/"
  43. #define APP_MIMETYPE_PREFIX_SIZE    (sizeof(APP_MIMETYPE_PREFIX) - 1)
  44. /****************************************************************************
  45.  *  Includes
  46.  */
  47. //#include "hlxclib/stdlib.h"
  48. #include "sdptools.h"
  49. #include "hxstrutl.h"
  50. #include "hxassert.h"
  51. #include "hxstring.h"
  52. #include "hxinline.h"
  53. /****************************************************************************
  54.  *  Locals
  55.  */
  56. HX_INLINE HX_RESULT _HexCharPairToByte(UINT8* pByte, const char* pCharPair);
  57. HX_INLINE void _ByteToHexCharPair(const UINT8 pByte, char* pCharPair);
  58. /****************************************************************************
  59.  *  Tools
  60.  */
  61. HX_RESULT HexStringToBinary(UINT8* pOutBuffer, const char* pString)
  62. {
  63.     HX_RESULT retVal = HXR_OK;
  64.     HX_ASSERT(pOutBuffer);
  65.     HX_ASSERT(pString);
  66.     while (SUCCEEDED(retVal) && ((*pString) != ''))
  67.     {
  68. retVal = _HexCharPairToByte(pOutBuffer, pString);
  69. pOutBuffer++;
  70. pString += 2;
  71.     }
  72.     return retVal;
  73. }
  74. HX_RESULT HexCharPairToByte(UINT8* pByte, const char* pCharPair)
  75. {
  76.     return _HexCharPairToByte(pByte, pCharPair);
  77. }
  78. HX_INLINE HX_RESULT _HexCharPairToByte(UINT8* pByte, const char* pCharPair)
  79. {
  80.     UINT8 uIdx = 2;
  81.     UINT8 uByte = 0;
  82.     UINT8 uAddVal;
  83.     char cBits;
  84.     do
  85.     {
  86. uIdx--;
  87. cBits = *pCharPair;
  88. if ((cBits >= '0') && (cBits <= '9'))
  89. {
  90.     uAddVal = cBits - '0';
  91. }
  92. else if ((cBits >= 'a') && (cBits <= 'f'))
  93. {
  94.     uAddVal = cBits - 'a' + 10;
  95. }
  96. else if ((cBits >= 'A') && (cBits <= 'F'))
  97. {
  98.     uAddVal = cBits - 'A' + 10;
  99. }
  100. else
  101. {
  102.     return HXR_FAIL;
  103. }
  104. uByte += (uAddVal << (4 * uIdx));
  105. pCharPair++;
  106.     } while ((uIdx != 0) && (*pCharPair != ''));
  107.     *pByte = uByte;
  108.     return HXR_OK;
  109. }
  110. void BinaryToHexString(const UINT8* pBuffer, UINT32 ulSize, char* pString)
  111. {
  112.     HX_ASSERT(pBuffer);
  113.     HX_ASSERT(pString);
  114.     for(UINT32 i = 0; i < ulSize; i++)
  115.     {
  116. _ByteToHexCharPair(pBuffer[i], &pString[i*2]);
  117.     }
  118.     pString[ulSize*2] = '';
  119. }
  120. void ByteToHexCharPair(const UINT8 uByte, char* pCharPair)
  121. {
  122.     _ByteToHexCharPair(uByte, pCharPair);
  123. }
  124. HX_INLINE void _ByteToHexCharPair(const UINT8 uByte, char* pCharPair)
  125. {
  126.     HX_ASSERT(pCharPair);
  127.     char c = (char)((uByte >> 4) & 0x0f);
  128.     pCharPair[0] = c < 0xa ? c + '0' : c - 0xa + 'a';
  129.     c = (char)(uByte & 0x0f);
  130.     pCharPair[1] = c < 0xa ? c + '0' : c - 0xa + 'a';
  131. }
  132. RTSPMediaType SDPMapMimeToMediaType(const char* pMimeType)
  133. {
  134.     RTSPMediaType eMediaType = RTSPMEDIA_TYPE_UNKNOWN;
  135.     if (pMimeType)
  136.     {
  137. if (strncasecmp(AUDIO_MIMETYPE_PREFIX, 
  138. pMimeType, 
  139. AUDIO_MIMETYPE_PREFIX_SIZE) == 0)
  140. {
  141.     eMediaType = RTSPMEDIA_TYPE_AUDIO;
  142. }
  143. else if (strncasecmp(VIDEO_MIMETYPE_PREFIX, 
  144. pMimeType, 
  145. VIDEO_MIMETYPE_PREFIX_SIZE) == 0)
  146. {
  147.     eMediaType = RTSPMEDIA_TYPE_VIDEO;
  148. }
  149. else if (strncasecmp(APP_MIMETYPE_PREFIX, 
  150. pMimeType, 
  151. APP_MIMETYPE_PREFIX_SIZE) == 0)
  152. {
  153.     eMediaType = RTSPMEDIA_TYPE_APP;
  154. }
  155.     }
  156.     return eMediaType;
  157. }
  158. /*
  159.  * Copies SDPData from pSDP tp pNewSDP, removing any tokens matching pTokens
  160.  * pTokens is a NULL terminated list of strings
  161.  */
  162. UINT32 RemoveSDPTokens(const char* pTokens[], const UINT32 ulTokenLen[],
  163.                       const char* pSDP, UINT32 ulSDPLen, 
  164.                       char* pNewSDP, UINT32 ulNewSDPSize)
  165. {
  166.     UINT32 ulBytesCopied = 0;
  167.     UINT32 i = 0;
  168.     UINT32 ulEnd;
  169.     UINT32 ulCopySize;
  170.     char* pWriter = pNewSDP;
  171.     while(pSDP[i] != '' && i < ulSDPLen)
  172.     {
  173.         // ignore trailing white space
  174.         for( ; i < ulSDPLen && isspace(pSDP[i]); i++);
  175.         // Find the end of the line
  176.         for(ulEnd = i; ulEnd < ulSDPLen && pSDP[ulEnd] != ''; ulEnd++)
  177.         {
  178.             if(pSDP[ulEnd] == 'r' && ulEnd + 1 < ulSDPLen && 
  179.                 pSDP[ulEnd + 1] == 'n')
  180.             {
  181.                 ulEnd +=2;
  182.                 break;
  183.             }
  184.         }
  185.         // See if this one is to be removed
  186.         BOOL bRemove = FALSE;
  187.         for(int j=0; pTokens[j] && !bRemove; j++)
  188.         {
  189.             if(ulTokenLen[j] < ulSDPLen - i &&
  190.                 strncasecmp(&pSDP[i], pTokens[j], ulTokenLen[j]) == 0)
  191.             {
  192.                 bRemove = TRUE;
  193.             }
  194.         }
  195.         // copy it if it doesn't match a remove token
  196.         if(!bRemove)
  197.         {
  198.             HX_ASSERT(strncasecmp(&pSDP[i], "a=", 2) == 0);
  199.             ulCopySize = ulEnd - i;
  200.             if(ulCopySize < ulNewSDPSize)
  201.             {
  202.                 memcpy(pWriter, &pSDP[i], ulCopySize);
  203.                 ulNewSDPSize -= ulCopySize;
  204.                 pWriter += ulCopySize;
  205.             }
  206.         }
  207.         i = ulEnd;
  208.     }
  209.     return pWriter - pNewSDP;
  210. }