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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
gaConfig.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：10k
源码类别：

Symbian

开发平台：

Visual C++

gaConfig.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. /* parse an MPEG-4 general audio specific config structure from a bitstream */
  38. #include "gaConfig.h"
  39. #include "bitstream.h"
  41. CGASpecificConfig::CGASpecificConfig()
  42. : mFrameLengthFlag   (1)
  43. , mDependsOnCoreCoder(1)
  44. , mCoreCoderDelay    (14,0)
  45. , mExtensionFlag     (1)
  46. {
  47. }
  49. CGASpecificConfig::~CGASpecificConfig() {}
  51. HX_RESULT CGASpecificConfig::Read(struct BITSTREAM &bs,
  52. UINT32 samplingFrequency,
  53. UINT32 ChannelConfiguration,
  54. UINT32 AudioObjectType)
  55. {
  56. mFrameLengthFlag.Read(bs) ;
  57. mFrameLength = mFrameLengthFlag ? 960 : 1024 ;
  59. if (mDependsOnCoreCoder.Read(bs))
  60. mCoreCoderDelay.Read(bs) ;
  62. mExtensionFlag.Read(bs) ;
  64. if (ChannelConfiguration == 0)
  65. {
  66. mPCE.Read(bs) ;
  67. }
  68. else
  69. {
  70. HX_RESULT res = mPCE.SetChannelConfiguration(ChannelConfiguration) ;
  71. if (FAILED(res))
  72. return res ;
  73. }
  75. if (mExtensionFlag)
  76. {
  77. // to be defined in mpeg4 phase 2
  78. // should we return HXR_FAIL?
  79. }
  80. return HXR_OK ;
  81. }
  83. UINT32 CGASpecificConfig::GetFrameLength() const
  84. {
  85. return mFrameLength ;
  86. }
  88. CPCE::CPCE()
  89. : element_instance_tag         (4)
  90. , object_type                  (2)
  91. , sampling_frequency_index     (4)
  92. , num_front_channel_elements   (4)
  93. , num_side_channel_elements    (4)
  94. , num_back_channel_elements    (4)
  95. , num_lfe_channel_elements     (2)
  96. , num_assoc_data_elements      (3)
  97. , num_valid_cc_elements        (4)
  98. , mono_mixdown_present         (1)
  99. , mono_mixdown_element_number  (4,0)
  100. , stereo_mixdown_present       (1)
  101. , stereo_mixdown_element_number(4,0)
  102. , matrix_mixdown_idx_present   (1)
  103. , matrix_mixdown_idx           (2)
  104. , pseudo_surround_enable       (1)
  105. , comment_field_bytes          (8)
  106. , comment_field_data           (0)
  107. {
  108. }
  110. CPCE::~CPCE()
  111. {
  112. if (comment_field_data) delete[] comment_field_data ;
  113. }
  115. UINT32 CPCE::GetNChannels() const
  116. {
  117. return
  118. num_front_channels +
  119. num_side_channels +
  120. num_back_channels +
  121. num_lfe_channel_elements ;
  122. }
  124. const int CPCE::channelMapping[][4] =
  125. {
  126. {0,0,0,0},
  127. {1,0,0,0}, // center front speaker
  128. {2,0,0,0}, // left, right front speakers
  129. {3,0,0,0}, // center front speaker, left, right front speakers
  130. {3,0,1,0}, // center front speaker, left, right center front speakers, rear surround speakers
  131. {3,0,2,0}, // center front speaker, left, right front speakers, left surround, right surround rear speakers
  132. {3,0,2,1}, //  center front speaker, left, right front speakers, left surround, right surround rear speakers, front low frequency effects speaker
  133. {5,0,2,1}, // center front speaker left, right center front speakers, left, right outside front speakers, left surround, right surround rear speakers, front low frequency effects speaker
  134. } ;
  136. /* Utility function for implizit channel config signalling.
  137.    Initialize the channel pair information and return the number of channel elements. */
  139. static int initChannelPairs(int n, int isCpe[])
  140. {
  141. int nElem = (n+1)>>1 ;
  142. int i ;
  144. isCpe[0] = 0 ;
  145. for (i = (n & 1); i < nElem; i++)
  146. isCpe[i] = 1 ;
  148. return nElem ;
  149. }
  151. HX_RESULT CPCE::SetChannelConfiguration(UINT32 channelConfig)
  152. {
  153. if (channelConfig >= 8)
  154. return HXR_FAIL ;
  156. num_front_channels = channelMapping[channelConfig][0] ;
  157. num_side_channels  = channelMapping[channelConfig][1] ;
  158. num_back_channels  = channelMapping[channelConfig][2] ;
  159. num_lfe_channel_elements = channelMapping[channelConfig][3] ;
  161. num_front_channel_elements = initChannelPairs(num_front_channels, front_element_is_cpe) ;
  162. num_side_channel_elements  = initChannelPairs(num_side_channels, side_element_is_cpe) ;
  163. num_back_channel_elements  = initChannelPairs(num_back_channels, back_element_is_cpe) ;
  165. return HXR_OK ;
  166. }
  168. HX_RESULT CPCE::Read(struct BITSTREAM &bs)
  169. {
  170. UINT32 i ;
  172. num_front_channels = 0 ;
  173. num_side_channels  = 0 ;
  174. num_back_channels  = 0 ;
  176. /* should check here whether we have enough bits in the bitstream */
  178. element_instance_tag.Read(bs) ;
  179. object_type.Read(bs) ;
  180. sampling_frequency_index.Read(bs) ;
  181. num_front_channel_elements.Read(bs) ;
  182. num_side_channel_elements.Read(bs) ;
  183. num_back_channel_elements.Read(bs) ;
  184. num_lfe_channel_elements.Read(bs) ;
  185. num_assoc_data_elements.Read(bs) ;
  186. num_valid_cc_elements.Read(bs) ;
  188. if (mono_mixdown_present.Read(bs))
  189. mono_mixdown_element_number.Read(bs) ;
  191. if (stereo_mixdown_present.Read(bs))
  192. stereo_mixdown_element_number.Read(bs) ;
  194. if (matrix_mixdown_idx_present.Read(bs))
  195. {
  196. matrix_mixdown_idx.Read(bs) ;
  197. pseudo_surround_enable.Read(bs) ;
  198. }
  200. for ( i = 0; i < num_front_channel_elements; i++) {
  201. front_element_is_cpe[i] = readBits(&bs,1) ;
  202. num_front_channels += (1+front_element_is_cpe[i]) ;
  203. front_element_tag_select[i] = readBits(&bs,4) ;
  204. }
  205. for ( i = 0; i < num_side_channel_elements; i++) {
  206. side_element_is_cpe[i] = readBits(&bs,1) ;
  207. num_side_channels += (1+side_element_is_cpe[i]) ;
  208. side_element_tag_select[i] = readBits(&bs,4) ;
  209. }
  210. for ( i = 0; i < num_back_channel_elements; i++) {
  211. back_element_is_cpe[i] = readBits(&bs,1) ;
  212. num_back_channels += (1+back_element_is_cpe[i]) ;
  213. back_element_tag_select[i] = readBits(&bs,4) ;
  214. }
  215. for ( i = 0; i < num_lfe_channel_elements; i++)
  216. lfe_element_tag_select[i] = readBits(&bs,4) ;
  217. for ( i = 0; i < num_assoc_data_elements; i++)
  218. assoc_data_element_tag_select[i] = readBits(&bs,4) ;
  219. for ( i = 0; i < num_valid_cc_elements; i++) {
  220. cc_element_is_ind_sw[i] = readBits(&bs,1) ;
  221. valid_cc_element_tag_select[i] = readBits(&bs,4) ;
  222. }
  224. byteAlign(&bs) ;
  226. comment_field_bytes.Read(bs) ;
  228. if (comment_field_bytes)
  229. {
  230. // this is a slow way to read characters, but since we don't
  231. // parse many GAconfigs, I think that's OK
  232. CBitstreamInt t(8) ;
  234. comment_field_data = new char[(UINT32)comment_field_bytes] ;
  235. for (i = 0 ; i < comment_field_bytes ; i++)
  236. {
  237. comment_field_data[i] = (char)t.Read(bs) ;
  238. }
  239. }
  241. return HXR_OK ;
  242. }
  244. CAudioSpecificConfig::CAudioSpecificConfig()
  245. : AudioObjectType        (5)
  246. , samplingFrequencyIndex (4)
  247. , samplingFrequency     (24)
  248. , extensionSamplingFrequencyIndex (4)
  249. , extensionSamplingFrequency     (24)
  250. , channelConfiguration   (4)
  251. {
  252. }
  254. CAudioSpecificConfig::~CAudioSpecificConfig() {}
  256. const UINT32 CAudioSpecificConfig::aSampleRate[13] =
  257. {
  258. 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000,
  259. 11025, 8000, 7350
  260. } ;
  262. HX_RESULT CAudioSpecificConfig::Read(struct BITSTREAM &bs)
  263. {
  264. HX_RESULT res = HXR_OK;
  266. AudioObjectType.Read(bs) ;
  267. samplingFrequencyIndex.Read(bs) ;
  268. extensionSamplingFrequencyIndex = samplingFrequencyIndex ;
  270. switch (samplingFrequencyIndex)
  271. {
  272. case 0xf: // ESC, read sr from bitstream
  273. samplingFrequency.Read(bs) ;
  274. break ;
  275. case 0xd: case 0xe: // these are reserved.
  276. return HXR_FAIL ;
  277. break ;
  278. default: // the normal case
  279. samplingFrequency = aSampleRate[samplingFrequencyIndex] ;
  280. }
  281. extensionSamplingFrequency = samplingFrequency ;
  283. channelConfiguration.Read(bs) ;
  285. m_bSBR = (AudioObjectType == AACSBR) ;
  286. if (m_bSBR)
  287. {
  288. extensionSamplingFrequencyIndex.Read(bs) ;
  289. switch (extensionSamplingFrequencyIndex)
  290. {
  291. case 0xf: // ESC, read sr from bitstream
  292. extensionSamplingFrequency.Read(bs) ;
  293. break ;
  294. case 0xd: case 0xe: // these are reserved.
  295. return HXR_FAIL ;
  296. break ;
  297. default: // the normal case
  298. extensionSamplingFrequency = aSampleRate[extensionSamplingFrequencyIndex] ;
  299. }
  300. AudioObjectType.Read(bs) ;
  301. }
  303. switch (AudioObjectType)
  304. {
  305. case AACMAIN: case AACLC: case AACLTP:
  306. res = GASpecificConfig.Read(bs,
  307. samplingFrequency,channelConfiguration,AudioObjectType) ;
  308. break ;
  310. default:
  311. // no other audio types supported
  312. return HXR_FAIL ;
  313. }
  315. if (!m_bSBR && bitsLeftInBitstream(&bs) >= 16)
  316. // if SBR info has not been read before, but there are more bytes to follow...
  317. {
  318. if (readBits(&bs,11) == 0x2b7)
  319. {
  320. if (readBits(&bs,5) == 5)
  321. {
  322. m_bSBR = readBits(&bs,1) ;
  323. if (m_bSBR)
  324. {
  325. extensionSamplingFrequencyIndex.Read(bs) ;
  326. switch (extensionSamplingFrequencyIndex)
  327. {
  328. case 0xf: // ESC, read sr from bitstream
  329. extensionSamplingFrequency.Read(bs) ;
  330. break ;
  331. case 0xd: case 0xe: // these are reserved.
  332. return HXR_FAIL ;
  333. break ;
  334. default: // the normal case
  335. extensionSamplingFrequency = aSampleRate[extensionSamplingFrequencyIndex] ;
  336. }
  337. }
  338. }
  339. }
  340. }
  342. return HXR_OK ;
  343. }
  345. UINT32 CAudioSpecificConfig::GetSampleRate() const
  346. {
  347. return extensionSamplingFrequency ;
  348. }
  350. UINT32 CAudioSpecificConfig::GetCoreSampleRate() const
  351. {
  352. return samplingFrequency ;
  353. }
  355. UINT32 CAudioSpecificConfig::GetCoreSamplingFrequencyIndex() const
  356. {
  357.     return samplingFrequencyIndex;
  358. }
  360. UINT32 CAudioSpecificConfig::GetObjectType() const
  361. {
  362. return AudioObjectType ;
  363. }