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

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

Symbian

开发平台：

C/C++

mpadecl1.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 "statname.h"
  38. #include "hlxclib/string.h"
  39. #include "hlxclib/math.h"
  40. #include "mhead.h"
  41. #include "mpadecl1.h"
  43. #include "mpalow.h"     // low level extern C prototypes
  44. ///////////////////////////////////////////////////////////////////////////////
  45. // Static Data:
  46. ///////////////////////////////////////////////////////////////////////////////
  47. static const int sr_table_L1[8] =
  48.     { 22050, 24000, 16000, 1,
  49.       44100, 48000, 32000, 1 };
  51. static const int  out_chans_L1[5] = { 1, 2, 1, 1, 1 };
  53. static const int look_joint_L1[16] = {  /* lookup stereo sb's by mode+ext */
  54. 64, 64, 64, 64,         /* stereo */
  55. 2*4, 2*8, 2*12, 2*16,   /* joint */
  56. 64, 64, 64, 64,         /* dual */
  57. 32, 32, 32, 32,         /* mono */
  58. };
  60. static const int bat_bit_master_L1[] = {
  61. 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
  63. static const SBT_FUNCTION  sbt_table_L1[2][3][5] = {
  64. // 16 bit (usually short) pcm output
  65.     sbt_mono,   
  66.     sbt_dual,   
  67.     sbt_dual_mono, 
  68. #ifdef REDUCTION
  69.     sbt_dual_left, 
  70.     sbt_dual_right,
  71.     sbt16_mono, 
  72.     sbt16_dual, 
  73.     sbt16_dual_mono, 
  74.     sbt16_dual_left, 
  75.     sbt16_dual_right,
  76.     sbt8_mono,  
  77.     sbt8_dual,  
  78.     sbt8_dual_mono, 
  79.     sbt8_dual_left, 
  80.     sbt8_dual_right,
  81. #else     // no reduction
  82.     NULL, NULL, NULL, NULL, NULL, NULL, 
  83.     NULL, NULL, NULL, NULL, NULL, NULL, 
  84. #endif
  85. // 8 bit pcm output
  86. #ifdef EIGHT_BIT
  87.     sbtB_mono,
  88.     sbtB_dual,
  89.     sbtB_dual_mono,
  90. #ifdef REDUCTION
  91.     sbtB_dual_left,
  92.     sbtB_dual_right,
  93.     sbtB16_mono,
  94.     sbtB16_dual,
  95.     sbtB16_dual_mono,
  96.     sbtB16_dual_left,
  97.     sbtB16_dual_right,
  98.     sbtB8_mono,
  99.     sbtB8_dual,
  100.     sbtB8_dual_mono,
  101.     sbtB8_dual_left,
  102.     sbtB8_dual_right,
  103. #else   // no reduction
  104.     NULL, NULL, NULL, NULL, NULL, NULL, 
  105.     NULL, NULL, NULL, NULL, NULL, NULL, 
  106. #endif
  107. #else       // no eight_bit
  108.     NULL, NULL, NULL,
  109.     NULL, NULL, NULL, NULL, NULL, NULL, 
  110.     NULL, NULL, NULL, NULL, NULL, NULL, 
  111. #endif
  112.  
  113. };
  114. ///////////////////////////////////////////////////////////////////////////////
  115. // Public Functions
  116. ///////////////////////////////////////////////////////////////////////////////
  117. CMpaDecoderL1::CMpaDecoderL1()
  118.  :  CMpaDecoder()
  119. {
  120.     table_init();
  121. }
  123. CMpaDecoderL1::~CMpaDecoderL1()
  124. {
  125. }
  127. //IN_OUT CMpaDecoderL1::audio_decode(unsigned char *bs, unsigned char *pcm, int size)
  128. //{
  129. //return audio_decode(bs, pcm);
  130. //}
  132. #ifdef REFORMAT
  133. IN_OUT  CMpaDecoderL1::audio_decode_reformat(unsigned char *bs,
  134.                          unsigned char *bs_out)
  135. {
  136.     IN_OUT x;
  137.     x.in_bytes = 0;     // signal fail, not relevant Layer 1
  138.     x.out_bytes = 0;
  139.     return x;
  140. }
  141. #endif
  142. //=======================================================================
  143. int CMpaDecoderL1::audio_decode_init(MPEG_HEAD *h,
  144.                                   int framebytes_arg,
  145.                                   int reduction_code,
  146.                                   int transform_code,
  147.                                   int convert_code,
  148.                                   int freq_limit,
  149.                                   int conceal_enable)
  150. {
  151. int i,k;
  152. int samprate;
  153. int limit;
  154. int bit_code;
  156. /* check if code handles */
  157. if( h->option != 3 )  return 0;  /* layer I only */
  159. #ifndef REDUCTION
  160.     reduction_code = 0;
  161. #endif
  162. #ifndef EIGHT_BIT
  163.     convert_code = 0;
  164. #endif
  166. m_bMpeg1 = h->id;
  167. m_nSampsPerFrame = 384;
  169. transform_code = transform_code;    /* not used, asm compatability */
  171. bit_code = 0;
  172. if( convert_code & 8 ) bit_code = 1;
  173. convert_code = convert_code & 3;    /* higher bits used by dec8 freq cvt */
  174. if( reduction_code < 0 ) reduction_code = 0;
  175. if( reduction_code > 2 ) reduction_code = 2;
  176. if( freq_limit < 1000 ) freq_limit = 1000;
  179. framebytes = framebytes_arg;
  180. /* check if code handles */
  181. if( h->option != 3 ) return 0;         /* layer I only */
  183. nbatL1 = 32;
  184. max_sb = nbatL1;
  185. /*----- compute nsb_limit --------*/
  186. samprate = sr_table_L1[4*h->id + h->sr_index];
  187. nsb_limit = (freq_limit*64L + samprate/2)/samprate;   /*- caller limit -*/
  188. /*---- limit = 0.94*(32>>reduction_code);  ----*/
  189. limit = (32>>reduction_code);
  190. if( limit > 8 ) limit--;
  191. if( nsb_limit > limit )  nsb_limit = limit;
  192. if( nsb_limit > max_sb ) nsb_limit = max_sb;
  194. outvalues = 384 >> reduction_code;
  195. if( h->mode != 3 ) {         /* adjust for 2 channel modes */
  196.           nbatL1    *= 2;
  197.           max_sb    *= 2;
  198.           nsb_limit *= 2;
  199. }
  201. /* set sbt function */
  202. k = 1 + convert_code;
  203. if( h->mode == 3 ) {
  204.           k = 0;
  205.           }
  206. sbt = sbt_table_L1[bit_code][reduction_code][k];
  207. outvalues *= out_chans_L1[k];
  209. if( bit_code ) outbytes = outvalues;
  210. else           outbytes = sizeof(short)*outvalues;
  211. decinfo.channels  = out_chans_L1[k];
  212. decinfo.outvalues = outvalues;
  213. decinfo.samprate =  samprate >> reduction_code;
  214. if( bit_code ) decinfo.bits     = 8;
  215. else           decinfo.bits     = sizeof(short)*8;
  216. decinfo.framebytes = framebytes;
  217. decinfo.type = 0;
  219. /* clear sample buffer, unused sub bands must be 0 */
  220. for(i=0;i<768;i++) sample[i] = 0.0F;
  222. return 1;
  223. }
  224. //=========================================================================
  225. IN_OUT CMpaDecoderL1::audio_decode(unsigned char *bs, unsigned char *pcm, int size)
  226. {
  227. int sync, prot;
  228. IN_OUT in_out;
  230. load_init(bs);          /* initialize bit getter */
  231. /* test sync */
  232. in_out.in_bytes = 0;     /* assume fail */
  233. in_out.out_bytes = 0;
  234. sync = load(12);
  235. if( sync != 0xFFF ) return in_out;       /* sync fail */
  238. load(3);   /* skip id and option (checked by init) */
  239. prot = load(1);     /* load prot bit */
  240. load(6);            /* skip to pad */
  241. pad = (load(1)) << 2;
  242. load(1);            /* skip to mode */
  243. stereo_sb = look_joint_L1[load(4)];
  244. if( prot ) load(4);           /* skip to data */
  245. else       load(20);          /* skip crc */
  247. unpack_baL1();        /* unpack bit allocation */
  248. unpack_sfL1();        /* unpack scale factor */
  249. unpack_sampL1();      /* unpack samples */
  251. sbt(sample, pcm, 12, vbuf, vb_ptr);
  252. /*-----------*/
  253. in_out.in_bytes = framebytes + pad;
  254. in_out.out_bytes = outbytes;
  256. return in_out;
  257. }
  258. ///////////////////////////////////////////////////////////////////////////////
  259. // Private Functions
  260. ///////////////////////////////////////////////////////////////////////////////
  261. void CMpaDecoderL1::table_init()
  262. {
  263. int i;
  264. int step;
  266. /*--  c_values (dequant) --*/
  267. for(step=4, i=1; i<16; i++, step<<=1)
  268.                    look_c_valueL1[i] = (float)(2.0/(step-1));
  270. /*--  scale factor table, scale by 32768 for 16 pcm output  --*/
  271. for(i=0;i<64;i++) sf_table[i] = (float)(32768.0*2.0*pow(2.0,-i/3.0));
  274. }
  275. /*---------------------------------------------------------*/
  276. /*---------------------------------------------------------*/
  277. /*------------- bit getter --------------------------------*/
  278. /*---------------------------------------------------------*/
  279. void CMpaDecoderL1::load_init( unsigned char *buf)
  280. {
  281. bs_ptr = buf;
  282. bits = 0;
  283. bitbuf = 0;
  284. }
  285. /*------------- get n bits from bitstream -------------*/
  286. int CMpaDecoderL1::load( int n)
  287. {
  288. unsigned int x;
  289. if( bits < n ) {           /* refill bit buf if necessary */
  290.           while( bits <= 24 ) {
  291.              bitbuf = (bitbuf << 8) | *bs_ptr++;
  292.              bits += 8;
  293.           }
  294. }
  295. bits -= n;
  296. x = bitbuf >> bits;
  297. bitbuf -= x << bits;
  298. return x;
  299. }
  300. /*------------- skip over n bits in bitstream -------------*/
  301. void CMpaDecoderL1::skip( int n)
  302. {
  303. int k;
  304. if( bits < n ) {
  305.           n -= bits;
  306.           k = n >> 3;     /*--- bytes = n/8 --*/
  307.           bs_ptr+=k;
  308.           n -= k << 3;
  309.           bitbuf =  *bs_ptr++;
  310.           bits = 8;
  311.           }
  312. bits -= n;
  313. bitbuf -= (bitbuf >> bits) << bits;
  314. }
  315. /*--------------------------------------------------------------*/
  316. #define mac_load_check(n)                     
  317.    if( bits < (n) ) {                           
  318.           while( bits <= 24 ) {               
  319.              bitbuf = (bitbuf << 8) | *bs_ptr++;  
  320.              bits += 8;                       
  321.           }                                   
  322.    }
  323. /*--------------------------------------------------------------*/
  324. #define mac_load(n)                    
  325.        ( bits -= n,                    
  326.          bitval = bitbuf >> bits,      
  327.          bitbuf -= bitval << bits,     
  328.          bitval )
  329. /*======================================================================*/
  330. void CMpaDecoderL1::unpack_baL1()
  331. {
  332. int j;
  333. int nstereo;
  335. bit_skip = 0;
  336. nstereo = stereo_sb;
  338. for(j=0;j<nbatL1; j++) {
  339.   mac_load_check(4);
  340.   ballo[j] = samp_dispatch[j] =  mac_load(4);
  341.   if( j >= nsb_limit )  bit_skip += bat_bit_master_L1[samp_dispatch[j]];
  342.   c_value[j] = look_c_valueL1[samp_dispatch[j]];
  343.   if( --nstereo < 0 ) {
  344.       ballo[j+1] = ballo[j];
  345.       samp_dispatch[j] += 15;  /* flag as joint */
  346.       samp_dispatch[j+1] = samp_dispatch[j];  /* flag for sf */
  347.       c_value[j+1] = c_value[j];
  348.       j++;
  349.   }
  350. }
  351. /*-- terminate with bit skip and end --*/
  352. samp_dispatch[nsb_limit] = 31;
  353. samp_dispatch[j]         = 30;
  354. }
  355. /*-------------------------------------------------------------------------*/
  356. void CMpaDecoderL1::unpack_sfL1(void)    /* unpack scale factor */
  357. {                          /* combine dequant and scale factors */
  358. int i;
  360. for(i=0;i<nbatL1;i++) {
  361.   if( ballo[i] ) {
  362.     mac_load_check(6);
  363.     cs_factorL1[i] = c_value[i]*sf_table[mac_load(6)];
  364.   }
  365. }
  366. /*-- done --*/
  367. }
  368. /*-------------------------------------------------------------------------*/
  369. #define UNPACKL1_N(n)                                        
  370.     s[k]     =  cs_factorL1[k]*(load(n)-((1 << n-1) -1));    
  371.     goto dispatch;
  372. #define UNPACKL1J_N(n)                                       
  373.     tmp        =  (load(n)-((1 << n-1) -1));                 
  374.     s[k]       =  cs_factorL1[k]*tmp;                        
  375.     s[k+1]     =  cs_factorL1[k+1]*tmp;                      
  376.     k++;                                                     
  377.     goto dispatch;
  378. /*-------------------------------------------------------------------------*/
  379. /*-------------------------------------------------------------------------*/
  380. void CMpaDecoderL1::unpack_sampL1()    /* unpack samples */
  381. {
  382. int j, k;
  383. float *s;
  384. long tmp;
  386. s = sample;
  387. for(j=0;j<12;j++)  {
  388. k = -1;
  389. dispatch:   switch (samp_dispatch[++k]) {
  390. case 0:
  391.     s[k]     =  0.0F;
  392.     goto dispatch;
  393. case 1:     UNPACKL1_N(2)     /*  3 levels */
  394. case 2:     UNPACKL1_N(3)     /*  7 levels */
  395. case 3:     UNPACKL1_N(4)     /* 15 levels */
  396. case 4:     UNPACKL1_N(5)     /* 31 levels */
  397. case 5:     UNPACKL1_N(6)     /* 63 levels */
  398. case 6:     UNPACKL1_N(7)     /* 127 levels */
  399. case 7:     UNPACKL1_N(8)     /* 255 levels */
  400. case 8:     UNPACKL1_N(9)     /* 511 levels */
  401. case 9:     UNPACKL1_N(10)    /* 1023 levels */
  402. case 10:    UNPACKL1_N(11)    /* 2047 levels */
  403. case 11:    UNPACKL1_N(12)    /* 4095 levels */
  404. case 12:    UNPACKL1_N(13)    /* 8191 levels */
  405. case 13:    UNPACKL1_N(14)    /* 16383 levels */
  406. case 14:    UNPACKL1_N(15)    /* 32767 levels */
  407. /* -- joint ---- */
  408. case 15+0:
  409.     s[k+1] = s[k] =  0.0F;
  410.     k++;       /* skip right chan dispatch */
  411.     goto dispatch;
  412. /* -- joint ---- */
  413. case 15+1:     UNPACKL1J_N(2)     /*  3 levels */
  414. case 15+2:     UNPACKL1J_N(3)     /*  7 levels */
  415. case 15+3:     UNPACKL1J_N(4)     /* 15 levels */
  416. case 15+4:     UNPACKL1J_N(5)     /* 31 levels */
  417. case 15+5:     UNPACKL1J_N(6)     /* 63 levels */
  418. case 15+6:     UNPACKL1J_N(7)     /* 127 levels */
  419. case 15+7:     UNPACKL1J_N(8)     /* 255 levels */
  420. case 15+8:     UNPACKL1J_N(9)     /* 511 levels */
  421. case 15+9:     UNPACKL1J_N(10)    /* 1023 levels */
  422. case 15+10:    UNPACKL1J_N(11)    /* 2047 levels */
  423. case 15+11:    UNPACKL1J_N(12)    /* 4095 levels */
  424. case 15+12:    UNPACKL1J_N(13)     /* 8191 levels */
  425. case 15+13:    UNPACKL1J_N(14)     /* 16383 levels */
  426. case 15+14:    UNPACKL1J_N(15)     /* 32767 levels */
  428. /* -- end of dispatch -- */
  429. case 31:
  430.    skip(bit_skip);
  431. case 30:
  432.    s += 64;
  433. } /* end switch */
  434. } /* end j loop */
  436. /*-- done --*/
  437. }
  438. /*-------------------------------------------------------------------*/