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

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

Symbian

开发平台：

C/C++

sdppyldinfo.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 "hlxclib/string.h"
  39. #include "rtptypes.h"
  41. /****************************************************************************
  42.  *  Defines
  43.  */
  44. #define RTP_PAYLOAD_MAP_SIZE 35
  45. #define RTP_BAD_PAYLOAD_TYPE 0xFFFFFFFF
  47. /****************************************************************************
  48.  *  Global - Types
  49.  */
  50. struct RTPPayloadInfo 
  51. {
  52.     const char* pEncoding;
  53.     UINT32  ulRTPFactor;
  54.     UINT32  ulHXFactor;
  55.     BOOL    bTimestampDeliv;
  56.     UINT32  ulBitRate;
  57.     UINT16  usChannels;
  58. };
  60. struct MimeTypeToClockRateInfo
  61. {
  62.     const char* pMimeType;
  63.     UINT32 ulSamplesPerSecond;    
  64. };
  66. struct RTPPayloadHeaderPair
  67. {
  68.     ULONG32 ulPayloadType;
  69.     const BYTE* pHeader;
  70.     ULONG32 ulHeaderSize;
  71. };
  74. /* opaque data for known RTP payloads */
  75. const BYTE p_zPCMU_DATA[] = 
  76. {
  77.     0x01, 0x00, 0x01, 0x00, 0x40, 0x1f, 0x00, 0x00,
  78.     0x40, 0x1f, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 
  79.     0x00, 0x00, 0x26, 0x26 
  80. };
  82. const BYTE p_zPCMA_DATA[] =
  83. {
  84.     0x06, 0x00, 0x01, 0x00, 0x40, 0x1f, 0x00, 0x00,
  85.     0x40, 0x1f, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 
  86.     0x00, 0x00, 0x26, 0x26 
  87. };
  89. const BYTE p_zL162CH_DATA[] =
  90. {
  91.     0x00, 0x00, 0x43, 0x50, 0x00, 0x01, 0x00, 0x02, 
  92.     0x00, 0x00, 0xac, 0x44, 0x00, 0x10, 0x00, 0x00
  93. };
  95. const BYTE p_zL161CH_DATA[] =
  96. {
  97.     0x00, 0x00, 0x43, 0x50, 0x00, 0x01, 0x00, 0x01, 
  98.     0x00, 0x00, 0xac, 0x44, 0x00, 0x10, 0x00, 0x00
  99. };
  101. const BYTE p_zGSM_DATA[] =
  102. {
  103.     0x31, 0x00, 0x01, 0x00, 0x40, 0x1f, 0x00, 0x00,
  104.     0x59, 0x06, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00,
  105.     0x02, 0x00, 0x40, 0x01, 0x26, 0x26
  106. };
  108. typedef struct tPCMHEADER
  109. {
  110.     UINT16      usFormatTag;  /* format type */
  111.     UINT16      usChannels;   /* number of channels (i.e. mono, stereo..*/
  112.     UINT32      ulSamplesPerSec;   /* sample rate */
  113.     UINT16      usBitsPerSample;   /* number of bits per sample of mono data*/
  114.     UINT16      usSampleEndianness; /* for 16-bit samples, 0==little, 1==big */
  115. } PCMHEADER;
  117. /****************************************************************************
  118.  *  Payload to header table - must be NULL entry terminated
  119.  */
  120. const RTPPayloadHeaderPair z_PayloadHeaderPairList[] =
  121. {
  122.     { RTP_PAYLOAD_PCMU,     p_zPCMU_DATA,   sizeof(p_zPCMU_DATA)    },
  123.     { RTP_PAYLOAD_PCMA,     p_zPCMA_DATA,   sizeof(p_zPCMA_DATA)    },
  124.     { RTP_PAYLOAD_L16_2CH,  p_zL162CH_DATA, sizeof(p_zL162CH_DATA)  },
  125.     { RTP_PAYLOAD_L16_1CH,  p_zL161CH_DATA, sizeof(p_zL161CH_DATA)  },
  126.     { RTP_PAYLOAD_GSM,     p_zGSM_DATA,    sizeof(p_zGSM_DATA)     },
  127.     { RTP_BAD_PAYLOAD_TYPE, NULL,     0     }
  128. };
  130. /****************************************************************************
  131.  *  Payload to RN MimeType Table
  132.  *  This table identifies payloads RN can render and the mappings from
  133.  *  the payloads to renderer mime types.
  134.  *  With the transition to standard mime types supported by renderers,
  135.  *  this table will lose the function of mapping but will continue to
  136.  *  identify the renderer supported payloads.
  137.  */
  138. const char* const z_PayloadToRNMimeMap[RTP_PAYLOAD_MAP_SIZE] =
  139. {
  140.     "audio/PCMU", // 0
  141.     NULL, // 1
  142.     NULL, // 2
  143.     "audio/x-pn-gsm610", // 3
  144.     NULL, // 4
  145.     "audio/x-pn-dvi4", // 5
  146.     "audio/x-pn-dvi4", // 6
  147.     NULL, // 7
  148.     "audio/PCMA", // 8
  149.     NULL, // 9
  150.     "audio/L16", // 10
  151.     "audio/L16", // 11
  152.     NULL, // 12
  153.     NULL, // 13
  154.     "audio/MPA", // 14
  155.     NULL, // 15
  156.     NULL, // 16
  157.     NULL, // 17
  158.     NULL, // 18
  159.     NULL, // 19
  160.     NULL, // 20
  161.     NULL, // 21
  162.     NULL, // 22
  163.     NULL, // 23
  164.     NULL, // 24
  165.     NULL, // 25
  166.     "video/x-pn-jpeg-plugin", // 26
  167.     NULL, // 27
  168.     NULL, // 28
  169.     NULL, // 29
  170.     NULL, // 30
  171.     "video/H261", // 31
  172.     "video/MPV", // 32
  173.     NULL, // 33
  174.     "video/H263" // 34
  175. };
  177. /*
  178.  * Payload timestamp conversion table - contains the RTPTimestamp to
  179.  * HXTimestamp ratio factor as well as whether or not this payload
  180.  * is frame based or not.  Since packet size is not included in the To compute the timestamp conversion ratio
  181.  * use this formula for sample based payloads:
  182.  *
  183.  * ClockRate (sam/sec) * SampleSize (Bytes/Sample * Channels) / 1000 = 
  184.  * RTPFactor/HXFactor
  185.  *
  186.  * The stream headers RTPTimestampConversionFactor, HXTimestampConversionFactor
  187.  * and TimestampDelivery are added for known and supported payload types.
  188.  *
  189.  * To convert RTP to RMA time multiply the RTP timestamp by the fraction:
  190.  * RTPTimestampConversionFactor / HXTimestampConversionFactor
  191.  * To convert RMA to RTP time multiply the RMA timestamp by the fraction:
  192.  * HXTimestampConversionFactor / RTPTimestampConversionFactor
  193.  *
  194.  * This information should be exposed with IHXRTPTimestampConverter
  195.  */
  196. /* taken from draft-ietf-avt-profile-new-08.txt */ 
  197. const RTPPayloadInfo z_pPayloads[RTP_PAYLOAD_MAP_SIZE] = 
  198. {
  199. /*   encoding   RTP     RMA     TSD     BW Channels */
  200.     { "PCMU", 8, 1, 0, 64000,     1 }, // 0   8000/8/1
  201.     { "1016", 8, 1, 1, 0,     1 }, // 1   8000/N/1
  202.     { "G726-32",8, 1, 0, 32000,     1 }, // 2   8000/4/1
  203.     { "GSM", 8, 1, 1, 0,     1 }, // 3   8000/N/1
  204.     { "G723", 8, 1, 1, 0,     1 }, // 4   8000/N/1
  205.     { "DVI4", 8, 1, 0, 32000,     1 }, // 5   8000/4/1
  206.     { "DVI4", 16, 1, 0, 64000,     1 }, // 6  16000/4/1
  207.     { "LPC", 8, 1, 1, 0,     1 }, // 7   8000/N/1
  208.     { "PCMA", 8, 1, 0, 64000,     1 }, // 8   8000/8/1
  209.     { "G722", 8, 1, 0, 64000,     1 }, // 9   8000/8/1
  210.     { "L16", 441, 10, 0, 1411200,    2 }, // 10 44100/16/2
  211.     { "L16", 441, 10, 0, 705600,     1 }, // 11 44100/16/1
  212.     { "QCELP", 8, 1, 1, 0,     1 }, // 12  8000/N/1
  213.     { NULL, 0, 0, 0, 0,     0 }, // 13 reserved
  214.     { "MPA", 90, 1, 1, 0,     0 }, // 14 90000/N
  215.     { "G728", 8, 1, 1, 0,     1 }, // 15  8000/N/1
  216.     { "DVI4", 441, 40, 0, 44100,     1 }, // 16 11025/4/1
  217.     { "DVI4", 441, 20, 0, 88200,     1 }, // 17 22050/4/1
  218.     { "G729", 8, 1, 1, 0,     1 }, // 18  8000/N/1
  219.     { NULL, 0, 0, 0, 0,     0 }, // 19 reserved
  220.     { NULL, 0, 0, 0, 0,     0 }, // 20 unassigned
  221.     { NULL, 0, 0, 0, 0,     0 }, // 21 unassigned
  222.     { NULL, 0, 0, 0, 0,     0 }, // 22 unassigned
  223.     { NULL, 0, 0, 0, 0,     0 }, // 23 unassigned
  224.     { NULL, 0, 0, 0, 0,     0 }, // 24 unassigned
  225.     { "CelB", 90, 1, 1, 0,     0 }, // 25 90000/N
  226.     { "JPEG", 90, 1, 1, 0,     0 }, // 26 90000/N
  227.     { NULL, 0, 0, 0, 0,     0 }, // 27 unassigned
  228.     { "nv", 90, 1, 1, 0,     0 }, // 28 90000/N
  229.     { NULL, 0, 0, 0, 0,     0 }, // 29 unassigned
  230.     { NULL, 0, 0, 0, 0,     0 }, // 30 unassigned
  231.     { "H261", 90, 1, 1, 0,     0 }, // 31 90000/N
  232.     { "MPV", 90, 1, 1, 0,     0 }, // 32 90000/N  
  233.     { "MP2T", 90, 1, 1, 0,     0 }, // 33 90000/N
  234.     { "H263", 90, 1, 1, 0,     0 }, // 34 90000/N
  235. };
  237. const UINT32 z_cPayloads = 
  238.     sizeof(z_pPayloads) / 
  239.     sizeof(z_pPayloads[0]);
  241. /*
  242.  *  yet another table for mimetype to samplespersecond
  243.  */
  244. const MimeTypeToClockRateInfo z_pMimeTypeToClockRate[] = 
  245. {
  246.     { "video/H263-1998",    90000},
  247.     { "audio/mpa-robust",   90000}
  248. };
  250. const UINT32 z_cMimeTypeToClockRate = 
  251.     sizeof(z_pMimeTypeToClockRate) / 
  252.     sizeof(z_pMimeTypeToClockRate[0]);
  254. const UINT8* SDPGetGSMOpaqueData()
  255. {
  256.     return p_zGSM_DATA;
  257. }
  259. ULONG32 SDPGetGSMOpaqueDataSize()
  260. {
  261.     return sizeof(p_zGSM_DATA);
  262. }
  264. /****************************************************************************
  265.  *  SDPIsStaticPayload
  266.  */
  267. BOOL SDPIsStaticPayload(ULONG32 ulPayloadType)
  268. {
  269.     return (ulPayloadType < RTP_PAYLOAD_MAP_SIZE);
  270. }
  272. /****************************************************************************
  273.  *  SDPMapPayloadToRTPFactor
  274.  */
  275. UINT32 SDPMapPayloadToRTPFactor(ULONG32 ulPayloadType)
  276. {
  277.     HX_ASSERT(SDPIsStaticPayload(ulPayloadType));
  278.     return z_pPayloads[ulPayloadType].ulRTPFactor;
  279. }
  281. /****************************************************************************
  282.  *  SDPMapPayloadToRMAFactor
  283.  */
  284. UINT32 SDPMapPayloadToRMAFactor(ULONG32 ulPayloadType)
  285. {
  286.     HX_ASSERT(SDPIsStaticPayload(ulPayloadType));
  287.     return z_pPayloads[ulPayloadType].ulHXFactor;
  288. }
  290. /****************************************************************************
  291.  *  SDPMapPayloadToSamplesPerSecond
  292.  */
  293. ULONG32 SDPMapPayloadToSamplesPerSecond(ULONG32 ulPayloadType)
  294. {
  295.     if (SDPIsStaticPayload(ulPayloadType))
  296.     {
  297.         return (ULONG32) (1000.0 *
  298.                           ((double) SDPMapPayloadToRTPFactor(ulPayloadType)) /
  299.                           ((double) SDPMapPayloadToRMAFactor(ulPayloadType)));
  300.     }
  302.     return 0;
  303. }
  305. /****************************************************************************
  306.  *  SDPIsTimestampDeliverable
  307.  */
  308. BOOL SDPIsTimestampDeliverable(ULONG32 ulPayloadType)
  309. {
  310.     HX_ASSERT(SDPIsStaticPayload(ulPayloadType));
  311.     return z_pPayloads[ulPayloadType].bTimestampDeliv;
  312. }
  314. /****************************************************************************
  315.  *  SDPMapPayloadToEncodingName
  316.  */
  317. const char* SDPMapPayloadToEncodingName(ULONG32 ulPayloadType)
  318. {
  319.     if (SDPIsStaticPayload(ulPayloadType))
  320.     {
  321.         return z_pPayloads[ulPayloadType].pEncoding;
  322.     }
  324.     return NULL;
  325. }
  327. /****************************************************************************
  328.  *  SDPMapPayloadToEncodingName
  329.  */
  330. const char* SDPMapPayloadToMimeType(ULONG32 ulPayloadType)
  331. {
  332.     if (SDPIsStaticPayload(ulPayloadType))
  333.     {
  334.         return z_PayloadToRNMimeMap[ulPayloadType];
  335.     }
  337.     return NULL;
  338. }
  340. /****************************************************************************
  341.  *  SDPMapPayloadToChannels
  342.  */
  343. UINT16 SDPMapPayloadToChannels(ULONG32 ulPayloadType)
  344. {
  345.     if (SDPIsStaticPayload(ulPayloadType))
  346.     {
  347.         return z_pPayloads[ulPayloadType].usChannels;   
  348.     }
  350.     return 0;
  351. }
  353. /****************************************************************************
  354.  *  SDPMapPayloadToBitrate
  355.  */
  356. ULONG32 SDPMapPayloadToBitrate(ULONG32 ulPayloadType)
  357. {
  358.     if (SDPIsStaticPayload(ulPayloadType))
  359.     {
  360.         return z_pPayloads[ulPayloadType].ulBitRate;   
  361.     }
  363.     return 0;
  364. }
  366. /****************************************************************************
  367.  *  SDPMapMimeTypeToSampleRate
  368.  */
  369. ULONG32 SDPMapMimeTypeToSampleRate(const char* pMimeType)
  370. {
  371.     ULONG32 ulSamplesPerSecond = 0;
  373.     for (ULONG32 ulIdx = 0; 
  374.          ulIdx < z_cMimeTypeToClockRate; 
  375.          ulIdx++)
  376.     {
  377.         if (z_pMimeTypeToClockRate[ulIdx].pMimeType &&
  378.             !strcasecmp(
  379.                 z_pMimeTypeToClockRate[ulIdx].pMimeType,
  380.                 pMimeType))
  381.         {
  382.             ulSamplesPerSecond = 
  383.                 z_pMimeTypeToClockRate[ulIdx].ulSamplesPerSecond;
  384.             break;
  385.         }
  386.     }
  388.     return ulSamplesPerSecond;
  389. }
  391. /****************************************************************************
  392.  *  SDPMapPayloadToHeaderData
  393.  */
  394. const UCHAR* SDPMapPayloadToHeaderData(ULONG32 ulPayloadType,
  395.                                        ULONG32& ulDataSize)
  396. {
  397.     const RTPPayloadHeaderPair* pPair;
  399.     for (pPair = z_PayloadHeaderPairList;
  400.          pPair->pHeader;
  401.          pPair++)
  402.     {
  403.         if (pPair->ulPayloadType == ulPayloadType)
  404.         {
  405.             ulDataSize = pPair->ulHeaderSize;
  406.             return pPair->pHeader;
  407.         }
  408.     }
  409.     
  410.     ulDataSize = 0;
  411.     return NULL;
  412. }