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

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

Symbian

开发平台：

C/C++

mpadecl2.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 "mpadecl2.h"
  43. #include "mpalow.h"     // low level extern C prototypes
  44. ///////////////////////////////////////////////////////////////////////////////
  45. // Static Data:
  46. ///////////////////////////////////////////////////////////////////////////////
  47. static const int look_joint_L2[16] = {  /* lookup stereo sb's by mode+ext */
  48. 64, 64, 64, 64,         /* stereo */
  49. 2*4, 2*8, 2*12, 2*16,   /* joint */
  50. 64, 64, 64, 64,         /* dual */
  51. 32, 32, 32, 32,         /* mono */
  52. };
  53. static const int bat_bit_master_L2[] = {
  54.   0, 5, 7, 9, 10, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48 };
  55. //
  56. // -------- init data -----------------
  57. //
  58. static const int steps[18] = {
  59. 0, 3, 5, 7, 9, 15, 31, 63, 127,
  60. 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535 };
  63. /*  ABCD_INDEX = lookqt[mode][sr_index][br_index]  */
  64. /*   -1 = invalid  */
  65. static const signed char lookqt[4][3][16]={ /* Flawfinder: ignore */
  66.   1,-1,-1,-1,2,-1,2,0,0,0,1,1,1,1,1,-1,           /*  44ks stereo */
  67.   0,-1,-1,-1,2,-1,2,0,0,0,0,0,0,0,0,-1,           /*  48ks */
  68.   1,-1,-1,-1,3,-1,3,0,0,0,1,1,1,1,1,-1,           /*  32ks */
  69.   1,-1,-1,-1,2,-1,2,0,0,0,1,1,1,1,1,-1,           /*  44ks joint stereo */
  70.   0,-1,-1,-1,2,-1,2,0,0,0,0,0,0,0,0,-1,           /*  48ks */
  71.   1,-1,-1,-1,3,-1,3,0,0,0,1,1,1,1,1,-1,           /*  32ks */
  72.   1,-1,-1,-1,2,-1,2,0,0,0,1,1,1,1,1,-1,           /*  44ks dual chan */
  73.   0,-1,-1,-1,2,-1,2,0,0,0,0,0,0,0,0,-1,           /*  48ks */
  74.   1,-1,-1,-1,3,-1,3,0,0,0,1,1,1,1,1,-1,           /*  32ks */
  75. // mono extended beyond legal br index
  76. //  1,2,2,0,0,0,1,1,1,1,1,1,1,1,1,-1,          /*  44ks single chan */
  77. //  0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,-1,          /*  48ks */
  78. //  1,3,3,0,0,0,1,1,1,1,1,1,1,1,1,-1,          /*  32ks */
  79. // legal mono
  80.  1,2,2,0,0,0,1,1,1,1,1,-1,-1,-1,-1,-1,          /*  44ks single chan */
  81.  0,2,2,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,          /*  48ks */
  82.  1,3,3,0,0,0,1,1,1,1,1,-1,-1,-1,-1,-1,          /*  32ks */
  83. };
  85. static const int sr_table_L2[8] =
  86.     { 22050, 24000, 16000, 1,
  87.       44100, 48000, 32000, 1 };
  89. /* bit allocation table look up */
  90. /* table per mpeg spec tables 3b2a/b/c/d  /e is mpeg2 */
  91. /* look_bat[abcd_index][4][16]  */
  92. static const unsigned char look_bat[5][4][16] = { /* Flawfinder: ignore */
  93. /* LOOK_BATA */
  94.  0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
  95.  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17,
  96.  0, 1, 2, 3, 4, 5, 6, 17, 0,0,0,0, 0,0,0,0,
  97.  0, 1, 2, 17,  0,0,0,0, 0,0,0,0, 0,0,0,0,
  98. /* LOOK_BATB */
  99.  0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
  100.  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17,
  101.  0, 1, 2, 3, 4, 5, 6, 17, 0,0,0,0, 0,0,0,0,
  102.  0, 1, 2, 17,  0,0,0,0, 0,0,0,0, 0,0,0,0,
  103. /* LOOK_BATC */
  104.  0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
  105.  0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
  106.  0, 1, 2, 4, 5, 6, 7, 8,   0,0,0,0, 0,0,0,0,
  107.  0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
  108. /* LOOK_BATD */
  109.  0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
  110.  0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
  111.  0, 1, 2, 4, 5, 6, 7, 8, 0,0,0,0, 0,0,0,0,
  112.  0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
  113. /* LOOK_BATE */
  114.  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
  115.  0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
  116.  0, 1, 2, 4, 5, 6, 7, 8, 0,0,0,0, 0,0,0,0,
  117.  0, 1, 2, 4, 0,0,0,0, 0,0,0,0, 0,0,0,0,
  118. };
  119. /* look_nbat[abcd_index]][4] */
  120. static const unsigned char look_nbat[5][4] = { /* Flawfinder: ignore */
  121.   3, 8, 12, 4,
  122.   3, 8, 12, 7,
  123.   2, 0, 6, 0,
  124.   2, 0, 10, 0,
  125.   4, 0, 7, 19,
  126. };
  128. static const int  out_chans_L2[5] = { 1, 2, 1, 1, 1 };
  131. static const SBT_FUNCTION  sbt_table_L2[2][3][5] = {
  132. // 16 bit (usually short) pcm output
  133.     sbt_mono,   
  134.     sbt_dual,   
  135.     sbt_dual_mono, 
  136. #ifdef REDUCTION
  137.     sbt_dual_left, 
  138.     sbt_dual_right,
  139.     sbt16_mono, 
  140.     sbt16_dual, 
  141.     sbt16_dual_mono, 
  142.     sbt16_dual_left, 
  143.     sbt16_dual_right,
  144.     sbt8_mono,  
  145.     sbt8_dual,  
  146.     sbt8_dual_mono, 
  147.     sbt8_dual_left, 
  148.     sbt8_dual_right,
  149. #else     // no reduction
  150.     NULL, NULL, NULL, NULL, NULL, NULL, 
  151.     NULL, NULL, NULL, NULL, NULL, NULL, 
  152. #endif
  153. // 8 bit pcm output
  154. #ifdef EIGHT_BIT
  155.     sbtB_mono,
  156.     sbtB_dual,
  157.     sbtB_dual_mono,
  158. #ifdef REDUCTION
  159.     sbtB_dual_left,
  160.     sbtB_dual_right,
  161.     sbtB16_mono,
  162.     sbtB16_dual,
  163.     sbtB16_dual_mono,
  164.     sbtB16_dual_left,
  165.     sbtB16_dual_right,
  166.     sbtB8_mono,
  167.     sbtB8_dual,
  168.     sbtB8_dual_mono,
  169.     sbtB8_dual_left,
  170.     sbtB8_dual_right,
  171. #else   // no reduction
  172.     NULL, NULL, NULL, NULL, NULL, NULL, 
  173.     NULL, NULL, NULL, NULL, NULL, NULL, 
  174. #endif
  175. #else       // no eight_bit
  176.     NULL, NULL, NULL,
  177.     NULL, NULL, NULL, NULL, NULL, NULL, 
  178.     NULL, NULL, NULL, NULL, NULL, NULL, 
  179. #endif
  180.  
  181. };
  183. ///////////////////////////////////////////////////////////////////////////////
  184. // Public Functions
  185. ///////////////////////////////////////////////////////////////////////////////
  186. CMpaDecoderL2::CMpaDecoderL2()
  187.  :  CMpaDecoder()
  190. {
  191. table_init();
  192. }
  194. CMpaDecoderL2::~CMpaDecoderL2()
  195. {
  196. }
  198. #ifdef REFORMAT
  199. IN_OUT  CMpaDecoderL2::audio_decode_reformat(unsigned char *bs,
  200.                          unsigned char *bs_out)
  201. {
  202.     IN_OUT x;
  203.     x.in_bytes = 0;     // signal fail, not relevant for Layer 2
  204.     x.out_bytes = 0;
  205.     return x;
  206. }
  207. #endif
  209. //================================================================
  210. int CMpaDecoderL2::audio_decode_init(MPEG_HEAD *h,
  211.                                        int framebytes_arg,
  212.                                        int reduction_code,
  213.                                        int transform_code,
  214.                                        int convert_code,
  215.                                        int freq_limit,
  216.                                        int conceal_enable)
  217. {
  218. int i, j, k;
  219. int abcd_index;
  220. long samprate;
  221. int limit;
  222. int bit_code;
  224. /* check if code handles */
  225. if( h->option != 2 )  return 0;  /* layer II only */
  227. #ifndef REDUCTION
  228.     reduction_code = 0;
  229. #endif
  230. #ifndef EIGHT_BIT
  231.     convert_code = 0;
  232. #endif
  235. m_bMpeg1 = h->id;
  236. m_nSampsPerFrame = 1152;
  238. transform_code = transform_code;    /* not used, asm compatability */
  239. bit_code = 0;
  240. if( convert_code & 8 ) bit_code = 1;
  241. convert_code = convert_code & 3;    /* higher bits used by dec8 freq cvt */
  242. if( reduction_code < 0 ) reduction_code = 0;
  243. if( reduction_code > 2 ) reduction_code = 2;
  244. if( freq_limit < 1000 ) freq_limit = 1000;
  247. framebytes = framebytes_arg;
  248. /* check if code handles */
  249. if( h->sr_index == 3 ) return 0;       /* reserved */
  251. /* compute abcd index for bit allo table selection */
  252. if( h->id )                /* mpeg 1 */
  253.    abcd_index = lookqt[h->mode][h->sr_index][h->br_index];
  254. else  abcd_index = 4;      /* mpeg 2 */
  256. if( abcd_index < 0 ) return 0;  // fail invalid Layer II bit rate index
  258. for(i=0;i<4;i++) {
  259.     for(j=0;j<16;j++) bat[i][j] = look_bat[abcd_index][i][j];
  260. }
  261. for(i=0;i<4;i++) nbat[i] = look_nbat[abcd_index][i];
  262. max_sb = nbat[0] + nbat[1] + nbat[2] + nbat[3];
  263. /*----- compute nsb_limit --------*/
  264. samprate = sr_table_L2[4*h->id + h->sr_index];
  265. nsb_limit = (freq_limit*64L + samprate/2)/samprate;   /*- caller limit -*/
  266. /*---- limit = 0.94*(32>>reduction_code);  ----*/
  267. limit = (32>>reduction_code);
  268. if( limit > 8 ) limit--;
  269. if( nsb_limit > limit )  nsb_limit = limit;
  270. if( nsb_limit > max_sb ) nsb_limit = max_sb;
  272. outvalues = 1152 >> reduction_code;
  273. if( h->mode != 3 ) {         /* adjust for 2 channel modes */
  274.           for(i=0;i<4;i++) nbat[i] *= 2;
  275.           max_sb *= 2;
  276.           nsb_limit *= 2;
  277. }
  279. /* set sbt function */
  280. k = 1 + convert_code;
  281. if( h->mode == 3 ) {
  282.           k = 0;
  283.           }
  284. sbt = sbt_table_L2[bit_code][reduction_code][k];
  285. outvalues *= out_chans_L2[k];
  286. if( bit_code )  outbytes = outvalues;
  287. else            outbytes = sizeof(short)*outvalues;
  288. decinfo.channels  = out_chans_L2[k];
  289. decinfo.outvalues = outvalues;
  290. decinfo.samprate =  samprate >> reduction_code;
  291. if( bit_code ) decinfo.bits     = 8;
  292. else           decinfo.bits     = sizeof(short)*8;
  293. decinfo.framebytes = framebytes;
  294. decinfo.type = 0;
  296. /* clear sample buffer, unused sub bands must be 0 */
  297. for(i=0;i<2304;i++) sample[i] = 0.0F;
  299. return 1;
  300. }
  301. /*---------------------------------------------------------*/
  302. IN_OUT CMpaDecoderL2::audio_decode(unsigned char *bs,
  303.                                    unsigned char *pcm,
  304.                                    int size)
  305. {
  306. int sync, prot;
  307. IN_OUT in_out;
  309. load_init(bs);          /* initialize bit getter */
  310. /* test sync */
  311. in_out.in_bytes = 0;     /* assume fail */
  312. in_out.out_bytes = 0;
  313. sync = load(12);
  314. if( sync != 0xFFF ) return in_out;       /* sync fail */
  316. load(3);   /* skip id and option (checked by init) */
  317. prot = load(1);     /* load prot bit */
  318. load(6);            /* skip to pad */
  319. pad = load(1);
  320. load(1);            /* skip to mode */
  321. stereo_sb = look_joint_L2[load(4)];
  322. if( prot ) load(4);           /* skip to data */
  323. else       load(20);          /* skip crc */
  325. unpack_ba();        /* unpack bit allocation */
  326. unpack_sfs();       /* unpack scale factor selectors */
  327. unpack_sf();        /* unpack scale factor */
  328. unpack_samp();      /* unpack samples */
  331. sbt(sample, pcm, 36, vbuf, vb_ptr);
  332. /*-----------*/
  333. in_out.in_bytes = framebytes + pad;
  334. in_out.out_bytes = outbytes;
  336. return in_out;
  337. }
  338. ///////////////////////////////////////////////////////////////////////////////
  339. // Private Functions
  340. ///////////////////////////////////////////////////////////////////////////////
  341. void CMpaDecoderL2::table_init()
  342. {
  343. int i, j;
  344. int code;
  346. /*--  c_values (dequant) --*/
  347. for(i=1;i<18;i++) look_c_value[i] = 2.0F/steps[i];
  349. /*--  scale factor table, scale by 32768 for 16 pcm output  --*/
  350. for(i=0;i<64;i++) sf_table[i] = (float)(32768.0*2.0*pow(2.0,-i/3.0));
  352. /*--  grouped 3 level lookup table 5 bit token --*/
  353. for(i=0;i<32;i++) {
  354.    code = i;
  355.    for(j=0;j<3;j++) {
  356.       group3_table[i][j] = (char)(( code % 3 ) - 1);
  357.       code /= 3;
  358.   }
  359. }
  360. /*--  grouped 5 level lookup table 7 bit token --*/
  361. for(i=0;i<128;i++) {
  362.    code = i;
  363.    for(j=0;j<3;j++) {
  364.       group5_table[i][j] = (char)(( code % 5 ) - 2);
  365.       code /= 5;
  366.   }
  367. }
  368. /*--  grouped 9 level lookup table 10 bit token --*/
  369. for(i=0;i<1024;i++) {
  370.    code = i;
  371.    for(j=0;j<3;j++) {
  372.       group9_table[i][j] = (short)(( code % 9 ) - 4);
  373.       code /= 9;
  374.   }
  375. }
  378. }
  379. /*---------------------------------------------------------*/
  380. /*------------- bit getter --------------------------------*/
  381. /*---------------------------------------------------------*/
  382. void CMpaDecoderL2::load_init( unsigned char *buf)
  383. {
  384. bs_ptr = buf;
  385. bits = 0;
  386. bitbuf = 0;
  387. }
  388. /*------------- get n bits from bitstream -------------*/
  389. int CMpaDecoderL2::load( int n)
  390. {
  391. unsigned int x;
  392. if( bits < n ) {           /* refill bit buf if necessary */
  393.           while( bits <= 24 ) {
  394.              bitbuf = (bitbuf << 8) | *bs_ptr++;
  395.              bits += 8;
  396.           }
  397. }
  398. bits -= n;
  399. x = bitbuf >> bits;
  400. bitbuf -= x << bits;
  401. return x;
  402. }
  403. /*------------- skip over n bits in bitstream -------------*/
  404. void CMpaDecoderL2::skip( int n)
  405. {
  406. int k;
  407. if( bits < n ) {
  408.           n -= bits;
  409.           k = n >> 3;     /*--- bytes = n/8 --*/
  410.           bs_ptr+=k;
  411.           n -= k << 3;
  412.           bitbuf =  *bs_ptr++;
  413.           bits = 8;
  414.           }
  415. bits -= n;
  416. bitbuf -= (bitbuf >> bits) << bits;
  417. }
  418. /*--------------------------------------------------------------*/
  419. #define mac_load_check(n)                     
  420.    if( bits < (n) ) {                           
  421.           while( bits <= 24 ) {               
  422.              bitbuf = (bitbuf << 8) | *bs_ptr++;  
  423.              bits += 8;                       
  424.           }                                   
  425.    }
  426. /*--------------------------------------------------------------*/
  427. #define mac_load(n)                    
  428.        ( bits -= n,                    
  429.          bitval = bitbuf >> bits,      
  430.          bitbuf -= bitval << bits,     
  431.          bitval )
  433. static const int nbit[4] = { 4, 4, 3, 2 };
  435. /*======================================================================*/
  436. void CMpaDecoderL2::unpack_ba()
  437. {
  438. int i, j, k;
  439. int nstereo;
  441. bit_skip = 0;
  442. nstereo = stereo_sb;
  443. k = 0;
  444. for(i=0;i<4;i++) {
  445.    for(j=0;j<nbat[i]; j++, k++) {
  446.    mac_load_check(4);
  447.    ballo[k] = samp_dispatch[k] = bat[i][mac_load(nbit[i])];
  448.    if( k >= nsb_limit )  bit_skip += bat_bit_master_L2[samp_dispatch[k]];
  449.    c_value[k] = look_c_value[samp_dispatch[k]];
  450.    if( --nstereo < 0 ) {
  451.        ballo[k+1] = ballo[k];
  452.        samp_dispatch[k] += 18;  /* flag as joint */
  453.        samp_dispatch[k+1] = samp_dispatch[k];  /* flag for sf */
  454.        c_value[k+1] = c_value[k];
  455.        k++;
  456.        j++;
  457.    }
  458.    }
  459. }
  460. samp_dispatch[nsb_limit] = 37;   /* terminate the dispatcher with skip */
  461. samp_dispatch[k] = 36;           /* terminate the dispatcher */
  463. }
  464. /*-------------------------------------------------------------------------*/
  465. void CMpaDecoderL2::unpack_sfs()    /* unpack scale factor selectors */
  466. {
  467. int i;
  469. for(i=0;i<max_sb;i++) {
  470.   mac_load_check(2);
  471.   if( ballo[i] ) sf_dispatch[i] = mac_load(2);
  472.   else           sf_dispatch[i] = 4;           /* no allo */
  473. }
  474. sf_dispatch[i] = 5;    /* terminate dispatcher */
  475. }
  476. /*-------------------------------------------------------------------------*/
  477. void CMpaDecoderL2::unpack_sf()    /* unpack scale factor */
  478. {                          /* combine dequant and scale factors */
  479. int i;
  480. i = -1;
  481. dispatch:   switch (sf_dispatch[++i]) {
  482. case 0:              /* 3 factors 012 */
  483.   mac_load_check(18);
  484.   cs_factor[0][i] = c_value[i]*sf_table[mac_load(6)];
  485.   cs_factor[1][i] = c_value[i]*sf_table[mac_load(6)];
  486.   cs_factor[2][i] = c_value[i]*sf_table[mac_load(6)];
  487.   goto dispatch;
  488. case 1:             /* 2 factors 002 */
  489.   mac_load_check(12);
  490.   cs_factor[1][i] = cs_factor[0][i] = c_value[i]*sf_table[mac_load(6)];
  491.   cs_factor[2][i] = c_value[i]*sf_table[mac_load(6)];
  492.   goto dispatch;
  493. case 2:             /* 1 factor 000 */
  494.   mac_load_check(6);
  495.   cs_factor[2][i] = cs_factor[1][i] = cs_factor[0][i] =
  496.                                        c_value[i]*sf_table[mac_load(6)];
  497.   goto dispatch;
  498. case 3:             /* 2 factors 022 */
  499.   mac_load_check(12);
  500.   cs_factor[0][i] = c_value[i]*sf_table[mac_load(6)];
  501.   cs_factor[2][i] = cs_factor[1][i] = c_value[i]*sf_table[mac_load(6)];
  502.   goto dispatch;
  503. case 4:             /* no allo */
  504.   /*-- cs_factor[2][i] = cs_factor[1][i] = cs_factor[0][i] = 0.0;  --*/
  505.   goto dispatch;
  506. case 5:             /* all done */
  507. ;
  508. } /* end switch */
  511. }
  512. /*-------------------------------------------------------------------------*/
  513. #define UNPACK_N(n)                                          
  514.     s[k]     =  cs_factor[i][k]*(load(n)-((1 << n-1) -1));   
  515.     s[k+64]  =  cs_factor[i][k]*(load(n)-((1 << n-1) -1));   
  516.     s[k+128] =  cs_factor[i][k]*(load(n)-((1 << n-1) -1));   
  517.     goto dispatch;
  518. #define UNPACK_N2(n)                                             
  519.     mac_load_check(3*n);                                         
  520.     s[k]     =  cs_factor[i][k]*(mac_load(n)-((1 << n-1) -1));   
  521.     s[k+64]  =  cs_factor[i][k]*(mac_load(n)-((1 << n-1) -1));   
  522.     s[k+128] =  cs_factor[i][k]*(mac_load(n)-((1 << n-1) -1));   
  523.     goto dispatch;
  524. #define UNPACK_N3(n)                                             
  525.     mac_load_check(2*n);                                         
  526.     s[k]     =  cs_factor[i][k]*(mac_load(n)-((1 << n-1) -1));   
  527.     s[k+64]  =  cs_factor[i][k]*(mac_load(n)-((1 << n-1) -1));   
  528.     mac_load_check(n);                                           
  529.     s[k+128] =  cs_factor[i][k]*(mac_load(n)-((1 << n-1) -1));   
  530.     goto dispatch;
  531. #define UNPACKJ_N(n)                                         
  532.     tmp        =  (load(n)-((1 << n-1) -1));                 
  533.     s[k]       =  cs_factor[i][k]*tmp;                       
  534.     s[k+1]     =  cs_factor[i][k+1]*tmp;                     
  535.     tmp        =  (load(n)-((1 << n-1) -1));                 
  536.     s[k+64]    =  cs_factor[i][k]*tmp;                       
  537.     s[k+64+1]  =  cs_factor[i][k+1]*tmp;                     
  538.     tmp        =  (load(n)-((1 << n-1) -1));                 
  539.     s[k+128]   =  cs_factor[i][k]*tmp;                       
  540.     s[k+128+1] =  cs_factor[i][k+1]*tmp;                     
  541.     k++;       /* skip right chan dispatch */                
  542.     goto dispatch;
  543. /*-------------------------------------------------------------------------*/
  544. void CMpaDecoderL2::unpack_samp()    /* unpack samples */
  545. {
  546. int i, j, k;
  547. float *s;
  548. int n;
  549. long tmp;
  551. s = sample;
  552. for(i=0;i<3;i++)  {           /* 3 groups of scale factors */
  553. for(j=0;j<4;j++)  {
  554. k = -1;
  555. dispatch:   switch (samp_dispatch[++k]) {
  556. case 0:
  557.    s[k+128] = s[k+64] = s[k] =  0.0F;
  558.    goto dispatch;
  559. case 1:                     /* 3 levels grouped 5 bits */
  560.     mac_load_check(5);
  561.     n = mac_load(5);
  562.     s[k]     =  cs_factor[i][k]*group3_table[n][0];
  563.     s[k+64]  =  cs_factor[i][k]*group3_table[n][1];
  564.     s[k+128] =  cs_factor[i][k]*group3_table[n][2];
  565.     goto dispatch;
  566. case 2:                     /* 5 levels grouped 7 bits */
  567.     mac_load_check(7);
  568.     n = mac_load(7);
  569.     s[k]     =  cs_factor[i][k]*group5_table[n][0];
  570.     s[k+64]  =  cs_factor[i][k]*group5_table[n][1];
  571.     s[k+128] =  cs_factor[i][k]*group5_table[n][2];
  572.     goto dispatch;
  573. case 3:     UNPACK_N2(3)     /* 7 levels */
  574. case 4:                     /* 9 levels grouped 10 bits */
  575.     mac_load_check(10);
  576.     n = mac_load(10);
  577.     s[k]     =  cs_factor[i][k]*group9_table[n][0];
  578.     s[k+64]  =  cs_factor[i][k]*group9_table[n][1];
  579.     s[k+128] =  cs_factor[i][k]*group9_table[n][2];
  580.     goto dispatch;
  581. case 5:     UNPACK_N2(4)     /* 15 levels */
  582. case 6:     UNPACK_N2(5)     /* 31 levels */
  583. case 7:     UNPACK_N2(6)     /* 63 levels */
  584. case 8:     UNPACK_N2(7)     /* 127 levels */
  585. case 9:     UNPACK_N2(8)     /* 255 levels */
  586. case 10:    UNPACK_N3(9)     /* 511 levels */
  587. case 11:    UNPACK_N3(10)    /* 1023 levels */
  588. case 12:    UNPACK_N3(11)    /* 2047 levels */
  589. case 13:    UNPACK_N3(12)    /* 4095 levels */
  590. case 14:    UNPACK_N(13)    /* 8191 levels */
  591. case 15:    UNPACK_N(14)    /* 16383 levels */
  592. case 16:    UNPACK_N(15)    /* 32767 levels */
  593. case 17:    UNPACK_N(16)    /* 65535 levels */
  594. /* -- joint ---- */
  595. case 18+0:
  596.     s[k+128+1] = s[k+128] = s[k+64+1] = s[k+64] = s[k+1] = s[k] =  0.0F;
  597.     k++;       /* skip right chan dispatch */
  598.     goto dispatch;
  599. case 18+1:                    /* 3 levels grouped 5 bits */
  600.     n = load(5);
  601.     s[k]       =  cs_factor[i][k]*group3_table[n][0];
  602.     s[k+1]     =  cs_factor[i][k+1]*group3_table[n][0];
  603.     s[k+64]    =  cs_factor[i][k]*group3_table[n][1];
  604.     s[k+64+1]  =  cs_factor[i][k+1]*group3_table[n][1];
  605.     s[k+128]   =  cs_factor[i][k]*group3_table[n][2];
  606.     s[k+128+1] =  cs_factor[i][k+1]*group3_table[n][2];
  607.     k++;       /* skip right chan dispatch */
  608.     goto dispatch;
  609. case 18+2:                     /* 5 levels grouped 7 bits */
  610.     n = load(7);
  611.     s[k]       =  cs_factor[i][k]*group5_table[n][0];
  612.     s[k+1]     =  cs_factor[i][k+1]*group5_table[n][0];
  613.     s[k+64]    =  cs_factor[i][k]*group5_table[n][1];
  614.     s[k+64+1]  =  cs_factor[i][k+1]*group5_table[n][1];
  615.     s[k+128]   =  cs_factor[i][k]*group5_table[n][2];
  616.     s[k+128+1] =  cs_factor[i][k+1]*group5_table[n][2];
  617.     k++;       /* skip right chan dispatch */
  618.     goto dispatch;
  619. case 18+3:     UNPACKJ_N(3)     /* 7 levels */
  620. case 18+4:                     /* 9 levels grouped 10 bits */
  621.     n = load(10);
  622.     s[k]      =  cs_factor[i][k]*group9_table[n][0];
  623.     s[k+1]    =  cs_factor[i][k+1]*group9_table[n][0];
  624.     s[k+64]   =  cs_factor[i][k]*group9_table[n][1];
  625.     s[k+64+1] =  cs_factor[i][k+1]*group9_table[n][1];
  626.     s[k+128]  =  cs_factor[i][k]*group9_table[n][2];
  627.     s[k+128+1]=  cs_factor[i][k+1]*group9_table[n][2];
  628.     k++;       /* skip right chan dispatch */
  629.     goto dispatch;
  630. case 18+5:     UNPACKJ_N(4)     /* 15 levels */
  631. case 18+6:     UNPACKJ_N(5)     /* 31 levels */
  632. case 18+7:     UNPACKJ_N(6)     /* 63 levels */
  633. case 18+8:     UNPACKJ_N(7)     /* 127 levels */
  634. case 18+9:     UNPACKJ_N(8)     /* 255 levels */
  635. case 18+10:    UNPACKJ_N(9)     /* 511 levels */
  636. case 18+11:    UNPACKJ_N(10)    /* 1023 levels */
  637. case 18+12:    UNPACKJ_N(11)    /* 2047 levels */
  638. case 18+13:    UNPACKJ_N(12)    /* 4095 levels */
  639. case 18+14:    UNPACKJ_N(13)    /* 8191 levels */
  640. case 18+15:    UNPACKJ_N(14)    /* 16383 levels */
  641. case 18+16:    UNPACKJ_N(15)    /* 32767 levels */
  642. case 18+17:    UNPACKJ_N(16)    /* 65535 levels */
  643. /* -- end of dispatch -- */
  644. case 37:
  645.    skip(bit_skip);
  646. case 36:
  647.    s += 3*64;
  648. } /* end switch */
  649. } /* end j loop */
  650. } /* end i loop */
  653. }
  654. /*-------------------------------------------------------------------------*/