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

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

Symbian

开发平台：

C/C++

mpadecl3.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 "mhead.h"
  40. #include "mpadecl3.h"
  42. #define min(a,b)  ((((a)>=(b))?(b):(a))) 
  44. #include "mpalowl3.h"     // low level extern C prototypes
  45. ///////////////////////////////////////////////////////////////////////////////
  46. // Static Data:
  47. ///////////////////////////////////////////////////////////////////////////////
  48. static const int mp_sr20_table_L3[2][4]={441,480,320,-999, 882,960,640,-999};
  49. static const int mp_br_table_L3[2][16]=
  50.     {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,0,    /* mpeg 2 */
  51.      0,32,40,48,56,64,80,96,112,128,160,192,224,256,320,0};
  53. static const int sr_table_L3[8] =
  54.     { 22050, 24000, 16000, 1,
  55.       44100, 48000, 32000, 1 };
  57. // shorts used to save a few bytes
  58. static const struct  {
  59. short l[23];
  60. short s[14];} sfBandIndexTable[3][3] =   {
  61. /* mpeg-2 */
  62. {
  63. {{0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  64.  {0,4,8,12,18,24,32,42,56,74,100,132,174,192}},
  65. {{0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,332,394,464,540,576},
  66.  {0,4,8,12,18,26,36,48,62,80,104,136,180,192}},
  67. {{0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  68.  {0,4,8,12,18,26,36,48,62,80,104,134,174,192}},
  69. },
  70. /* mpeg-1 */
  71. {
  72. {{0,4,8,12,16,20,24,30,36,44,52,62,74,90,110,134,162,196,238,288,342,418,576},
  73.  {0,4,8,12,16,22,30,40,52,66,84,106,136,192}},
  74. {{0,4,8,12,16,20,24,30,36,42,50,60,72,88,106,128,156,190,230,276,330,384,576},
  75.  {0,4,8,12,16,22,28,38,50,64,80,100,126,192}},
  76. {{0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576},
  77.  {0,4,8,12,16,22,30,42,58,78,104,138,180,192}}
  78. },
  80. /* mpeg-2.5, 11 & 12 KHz seem ok, 8 ok */
  81. {
  82. {{0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  83.  {0,4,8,12,18,26,36,48,62,80,104,134,174,192}},
  84. {{0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  85.  {0,4,8,12,18,26,36,48,62,80,104,134,174,192}},
  86. // this 8khz table, and only 8khz, from mpeg123)
  87. {{0,12,24,36,48,60,72,88,108,132,160,192,232,280,336,400,476,566,568,570,572,574,576},
  88.  {0,8,16,24,36,52,72,96,124,160,162,164,166,192}},
  89. },
  90. };
  93. static const SBT_FUNCTION_L3  sbt_table_L3[2][3][2] = {
  94.     sbt_mono_L3,
  95.     sbt_dual_L3,
  96. #ifdef REDUCTION
  97.     sbt16_mono_L3,
  98.     sbt16_dual_L3,
  99.     sbt8_mono_L3,
  100.     sbt8_dual_L3,
  101. #else
  102.   NULL, NULL, NULL, NULL,
  103. #endif
  105. #ifdef EIGHT_BIT  
  106. /*-- 8 bit output -*/
  107.     sbtB_mono_L3,
  108.     sbtB_dual_L3,
  109. #ifdef REDUCTION
  110.     sbtB16_mono_L3,
  111.     sbtB16_dual_L3,
  112.     sbtB8_mono_L3,
  113.     sbtB8_dual_L3,
  114. #else 
  115.   NULL, NULL, NULL, NULL,
  116. #endif
  117. #endif
  118. };
  119. ///////////////////////////////////////////////////////////////////////////////
  120. // Public Functions
  121. ///////////////////////////////////////////////////////////////////////////////
  122. CMpaDecoderL3::CMpaDecoderL3()
  123.  :  CMpaDecoder(),
  124.     mpeg25_flag(0),
  125.     stereo_flag(0),
  126.     igr(0),
  127.     band_limit(576),
  128.     band_limit21(576),
  129.     band_limit12(576),
  130.     band_limit_nsb(32),
  131.     gain_adjust(0),
  132.     id(1),
  133.     ncbl_mixed(0),
  134.     half_outbytes(0),
  135.     zero_level_pcm(0),
  136.     buf_ptr0(0),
  137.     buf_ptr1(0),
  138.     main_pos_bit(0),
  139. #ifdef REFORMAT
  140.     reformat_bytes(0),
  141.     reformat_side_bytes(0),
  142. #endif
  143.     conceal_flag(0)
  145. {
  146.     // memsets not really needed
  147.     //memset(samp_save, 0, sizeof(samp_save));
  148.     memset(nBand, 0, sizeof(nBand));
  149.     memset(sfBandIndex, 0, sizeof(sfBandIndex));
  150.     memset(cb_info, 0, sizeof(cb_info));
  151.     memset(&is_sf_info, 0, sizeof(is_sf_info));
  152.     memset(buf, 0, sizeof(buf));
  153.     memset(&side_info, 0, sizeof(side_info));
  154.     memset(sf, 0, sizeof(sf));
  155.     memset(nsamp, 0, sizeof(nsamp));
  156.     memset(yout, 0, sizeof(yout));
  157.     memset(sample, 0, sizeof(sample));
  159.     conceal[0] = conceal[1] = NULL;
  161. }
  163. CMpaDecoderL3::~CMpaDecoderL3()
  164. {
  165. int i;
  166.     for(i=0;i<2;i++) {
  167. #if defined (MP3_CONCEAL_LOSS)
  168.         if( conceal[i] != NULL ) delete conceal[i];
  169. #endif //MP3_CONCEAL_LOSS
  170.     }
  171. }
  173. //=======================================================================
  174. int CMpaDecoderL3::audio_decode_init(MPEG_HEAD *h,
  175.                                   int framebytes_arg,
  176.                                   int reduction_code,
  177.                                   int transform_code,
  178.                                   int convert_code,
  179.                                   int freq_limit,
  180.                                   int conceal_enable)
  182. {
  183. int i, j, k;
  184. int samprate;
  185. int limit;
  186. int bit_code;
  187. int out_chans;
  189. // could have multiple inits, free error conceal class if any
  190. for(i=0;i<2;i++) {
  191.     if( conceal[i] != NULL ) {
  192. #if defined (MP3_CONCEAL_LOSS)
  193.         delete conceal[i];
  194.         conceal[i] = NULL;
  195. #endif //MP3_CONCEAL_LOSS
  196.     }
  197. }
  198. conceal_flag = 0;
  199. if( conceal_enable ) conceal_flag = 1;
  202. buf_ptr0 = 0;
  203. buf_ptr1 = 0;
  205. /* check if code handles */
  206. if( h->option != 1 ) return 0;         /* layer III only */
  208. if( h->id ) ncbl_mixed = 8;  /* mpeg-1 */
  209. else        ncbl_mixed = 6;  /* mpeg-2 */
  211. m_bMpeg1 = h->id;
  212. m_nSampsPerFrame = 1152;
  214. if (!m_bMpeg1)
  215.     m_nSampsPerFrame >>=1;
  217. framebytes = framebytes_arg;
  219. transform_code = transform_code;    /* not used, asm compatability */
  220. bit_code = 0;
  222. #ifndef REDUCTION
  223.     reduction_code = 0;
  224. #endif
  225. #ifdef EIGHT_BIT
  226. if( convert_code & 8 ) bit_code = 1;
  227. #endif
  229. convert_code = convert_code & 3;    /* higher bits used by dec8 freq cvt */
  230. if( reduction_code < 0 ) reduction_code = 0;
  231. if( reduction_code > 2 ) reduction_code = 2;
  232. if( freq_limit < 1000 ) freq_limit = 1000;
  235. samprate = sr_table_L3[4*h->id + h->sr_index];
  236. if( (h->sync & 1) == 0 ) samprate = samprate/2;  // mpeg 2.5 
  237. /*----- compute nsb_limit --------*/
  238. nsb_limit = (freq_limit*64L + samprate/2)/samprate;   /*- caller limit -*/
  239. limit = (32>>reduction_code);
  240. if( limit > 8 ) limit--;
  241. if( nsb_limit > limit )  nsb_limit = limit;
  242. limit = 18*nsb_limit;
  243. k = h->id;
  244. if( (h->sync & 1) == 0 ) k = 2;  // mpeg 2.5 
  245. if( k == 1 ) {
  246. band_limit12 = 3*sfBandIndexTable[k][h->sr_index].s[13];
  247. band_limit = band_limit21 = sfBandIndexTable[k][h->sr_index].l[22];
  248. }
  249. else {
  250. band_limit12 = 3*sfBandIndexTable[k][h->sr_index].s[12];
  251. band_limit = band_limit21 = sfBandIndexTable[k][h->sr_index].l[21];
  252. }
  253. band_limit += 8;        /* allow for antialias */
  254. if( band_limit > limit ) band_limit = limit;
  256. if( band_limit21 > band_limit ) band_limit21 = band_limit;
  257. if( band_limit12 > band_limit ) band_limit12 = band_limit;
  260. band_limit_nsb = (band_limit+17)/18;  /* limit nsb's rounded up */
  261. /*----------------------------------------------*/
  262. gain_adjust = 0;     /* adjust gain e.g. cvt to mono sum channel */
  263. if( (h->mode != 3) && (convert_code == 1) ) gain_adjust = -4;
  265. outvalues = 1152 >> reduction_code;
  266. if( h->id == 0 ) outvalues /= 2;
  268. out_chans = 2;
  269. if( h->mode == 3 ) out_chans = 1;
  270. if( convert_code ) out_chans = 1;
  272. sbt_L3 = sbt_table_L3[bit_code][reduction_code][out_chans-1];
  273. k = 1 + convert_code;
  274. if( h->mode == 3 ) k = 0;
  275. // Store the proper xform offset in Xform.  We will need to
  276. // do a switch on Xform and call the appropriate member function.
  277. iXform = k;
  279. //Xform = xform_table[k];
  281. outvalues *= out_chans;
  283. if( bit_code )  outbytes = outvalues;
  284. else            outbytes = sizeof(short)*outvalues;
  285. if( bit_code ) zero_level_pcm = 128;   /* 8 bit output */
  286. else           zero_level_pcm = 0;
  289. decinfo.channels  = out_chans;
  290. decinfo.outvalues = outvalues;
  291. decinfo.samprate =  samprate >> reduction_code;
  292. if( bit_code ) decinfo.bits     = 8;
  293. else           decinfo.bits     = sizeof(short)*8;
  294. decinfo.framebytes = framebytes;
  295. decinfo.type = 0;
  297. half_outbytes = outbytes/2;
  298. /*------------------------------------------*/
  300. /*- init band tables --*/
  303. k = h->id;
  304. if( (h->sync & 1) == 0 ) k = 2;  // mpeg 2.5 
  305. for(i=0;i<22;i++) 
  306.     sfBandIndex[0][i] = sfBandIndexTable[k][h->sr_index].l[i+1];
  307. for(i=0;i<13;i++) 
  308.     sfBandIndex[1][i] = 3*sfBandIndexTable[k][h->sr_index].s[i+1];
  309. for(i=0;i<22;i++) nBand[0][i] = 
  310.     sfBandIndexTable[k][h->sr_index].l[i+1] 
  311.         - sfBandIndexTable[k][h->sr_index].l[i];
  312. for(i=0;i<13;i++) nBand[1][i] = 
  313.     sfBandIndexTable[k][h->sr_index].s[i+1] 
  314.         - sfBandIndexTable[k][h->sr_index].s[i];
  317. /*--- clear buffers --*/
  318. for(i=0;i<576;i++) yout[i] = 0.0f;
  319. for(j=0;j<2;j++) {
  320.     for(k=0;k<2;k++) {
  321.         for(i=0;i<576;i++) {
  322.             sample[j][k][i].x = 0.0f;
  323.             sample[j][k][i].s = 0;
  324.         }
  325.     }
  326. }
  328. // h_id used to select xform routine
  329. h_id = h->id;
  331. // conceal class
  332. //conceal[0] = new CConcealment(band_limit21);
  333. //if( h->mode != 3 ) {   // need two channels of concealment
  334. //    conceal[1] = new CConcealment(band_limit21);
  335. //}
  337. if( conceal_flag ) {
  339. #if defined (MP3_CONCEAL_LOSS)    
  340.     conceal[0] = new CConcealment(576);
  341.     if( h->mode != 3 ) {   // need two channels of concealment
  342.         conceal[1] = new CConcealment(576);
  343.     }
  344. #endif //MP3_CONCEAL_LOSS
  345. }
  348. return 1;
  349. }
  350. //=========================================================================
  351. IN_OUT CMpaDecoderL3::audio_decode(unsigned char *bs, unsigned char *pcm)
  352. {
  354.     if( h_id )  {
  355.         return L3audio_decode_MPEG1(bs, pcm);
  356.     }
  357.     else {
  358.         return L3audio_decode_MPEG2(bs, pcm);
  359.     }
  360. }
  361. ///////////////////////////////////////////////////////////////////////////////
  362. // Private Functions
  363. ///////////////////////////////////////////////////////////////////////////////
  364. /*---------------------------------------------------------*/
  365. IN_OUT CMpaDecoderL3::L3audio_decode_MPEG1(unsigned char *bs, 
  366.                                            unsigned char *pcm)
  367. {
  368.     int sync;
  369.     IN_OUT in_out;
  370.     int side_bytes;
  371.     int nbytes;
  373.     iframe++;
  375.     bitget_init(&bitdat, bs); /* initialize bit getter */
  376.     /* test sync */
  377.     in_out.in_bytes = 0;      /* assume fail */
  378.     in_out.out_bytes = 0;
  379.     sync = bitget(&bitdat, 12);
  381.     if( sync != 0xFFF ) return in_out;       /* sync fail */
  382.     /*-----------*/
  384.     /*-- unpack side info --*/
  385.     side_bytes = unpack_side_MPEG1();
  386.     if( framebytes <= 0 ) return in_out;  // fail bad sr or br index
  388.     padframebytes = framebytes+pad;
  390.     in_out.in_bytes = padframebytes;
  392.     /*-- load main data and update buf pointer --*/
  393.     /*------------------------------------------- 
  394.       if start point < 0, must just cycle decoder 
  395.       if jumping into middle of stream, 
  396.       ---------------------------------------------*/
  397.     buf_ptr0 = buf_ptr1 - side_info.main_data_begin;   /* decode start point */
  398.     if( buf_ptr1 > BUF_TRIGGER ) {          /* shift buffer */
  399.         memmove(buf, buf+buf_ptr0, side_info.main_data_begin);
  400.         buf_ptr0 = 0;
  401.         buf_ptr1 = side_info.main_data_begin;
  402.     }
  403.     nbytes = padframebytes - side_bytes - crcbytes;
  404.     if( nbytes>0 )
  405.     {
  406.         memmove(buf+buf_ptr1, bs+side_bytes+crcbytes, nbytes);
  407.         buf_ptr1 += nbytes;
  408.     }
  409.     
  410.     /*-----------------------*/
  411.  
  412.     if( buf_ptr0 >= 0 ) {
  413.         main_pos_bit = buf_ptr0 << 3;
  414.         unpack_main(buf, 0);
  415.         Xform(pcm, 0);
  416.         unpack_main(buf, 1);
  417.         Xform(pcm+half_outbytes, 1);
  418.         in_out.out_bytes = outbytes;
  419.     }
  420.     else {
  421.         memset(pcm, zero_level_pcm, outbytes);  /* fill out skipped frames */
  422.         in_out.out_bytes = outbytes;
  423.     }
  425.     return in_out;
  426. }
  427. //=========================================================================
  428. IN_OUT CMpaDecoderL3::L3audio_decode_MPEG2(unsigned char *bs, unsigned char *pcm)
  429. {
  430. int sync;
  431. IN_OUT in_out;
  432. int side_bytes;
  433. int nbytes;
  435. iframe++;
  437. bitget_init(&bitdat, bs);          /* initialize bit getter */
  438. /* test sync */
  439. in_out.in_bytes = 0;     /* assume fail */
  440. in_out.out_bytes = 0;
  441. sync = bitget(&bitdat, 12);
  443. //if( sync != 0xFFF ) return in_out;       /* sync fail */
  444. mpeg25_flag = 0;
  445. if( sync != 0xFFF ) {
  446.     mpeg25_flag = 1;       /* mpeg 2.5 sync */
  447.     if( sync != 0xFFE ) return in_out;  /* sync fail */
  448. }
  449. /*-----------*/
  452. /*-- unpack side info --*/
  453. side_bytes = unpack_side_MPEG2(igr);
  454. if( framebytes <= 0 ) return in_out;  // fail bad sr or br index
  456. padframebytes = framebytes+pad;
  458. in_out.in_bytes = padframebytes;
  460. buf_ptr0 = buf_ptr1 - side_info.main_data_begin;   /* decode start point */
  461. if( buf_ptr1 > BUF_TRIGGER ) {          /* shift buffer */
  462.     memmove(buf, buf+buf_ptr0, side_info.main_data_begin);
  463.     buf_ptr0 = 0;
  464.     buf_ptr1 = side_info.main_data_begin;
  465. }
  466. nbytes = padframebytes - side_bytes - crcbytes;
  467. memmove(buf+buf_ptr1, bs+side_bytes+crcbytes, nbytes);
  468. buf_ptr1 += nbytes;
  469. /*-----------------------*/
  471. if( buf_ptr0 >= 0 ) {
  472.     main_pos_bit = buf_ptr0 << 3;
  473.     unpack_main(buf, igr);
  474.     Xform(pcm, igr);
  475.     in_out.out_bytes = outbytes;
  476. }
  477. else {
  478.     memset(pcm, zero_level_pcm, outbytes);  /* fill out skipped frames */
  479.     in_out.out_bytes = outbytes;
  480. }
  482. igr = igr^1;
  483. return in_out;
  484. }
  485. /*====================================================================*/
  486. int CMpaDecoderL3::unpack_side_MPEG1()
  487. {
  488. int prot;
  489. int br_index;
  490. int igr, ch;
  491. int side_bytes;
  493. /* decode partial header plus initial side info */
  494. /* at entry bit getter points at id, sync skipped by caller */
  496. id = bitget(&bitdat, 1);   /* id */
  497. bitget(&bitdat, 2);        /* skip layer */
  498. prot = bitget(&bitdat, 1);     /* bitget prot bit */
  499. br_index = bitget(&bitdat, 4);
  500. sr_index = bitget(&bitdat, 2);
  501. pad = bitget(&bitdat, 1);
  502. bitget(&bitdat, 1);            /* skip to mode */
  503. side_info.mode = bitget(&bitdat, 2);        /* mode */
  504. side_info.mode_ext = bitget(&bitdat, 2);    /* mode ext */
  506. if( side_info.mode != 1 ) side_info.mode_ext = 0;
  508. /* adjust global gain in ms mode to avoid having to mult by 1/sqrt(2) */
  509. ms_mode = side_info.mode_ext >> 1;
  510. is_mode = side_info.mode_ext & 1;
  513. crcbytes = 0;
  514. if( prot ) bitget(&bitdat, 4);    /* skip to data */
  515. else {
  516.     bitget(&bitdat, 20);          /* skip crc */
  517.     crcbytes = 2;
  518. }
  520. if( br_index > 0 )      /* framebytes fixed for free format */
  521.     framebytes =
  522.         2880 * mp_br_table_L3[id][br_index]/mp_sr20_table_L3[id][sr_index];
  524. side_info.main_data_begin = bitget(&bitdat, 9);
  525. if( side_info.mode == 3 ) {
  526.     side_info.private_bits  = bitget(&bitdat, 5);
  527.     nchan = 1;
  528.     stereo_flag = 0;
  529.     side_bytes = (4+17);   /*-- with header --*/
  530. }
  531. else {                      
  532.     side_info.private_bits  = bitget(&bitdat, 3);
  533.     nchan = 2;
  534.     stereo_flag = 1;
  535.     side_bytes = (4+32);   /*-- with header --*/
  536. }
  537. for(ch=0;ch<nchan;ch++) side_info.scfsi[ch] = bitget(&bitdat, 4);
  538. /* this always 0 (both igr) for short blocks */
  541. for(igr=0;igr<2;igr++) {
  542. for(ch=0;ch<nchan;ch++) {
  543.     side_info.gr[igr][ch].part2_3_length   = bitget(&bitdat, 12);
  544.     side_info.gr[igr][ch].big_values       = bitget(&bitdat, 9);
  545.     side_info.gr[igr][ch].global_gain      = bitget(&bitdat, 8) + gain_adjust;
  546.     if( ms_mode ) side_info.gr[igr][ch].global_gain -= 2;
  547.     side_info.gr[igr][ch].scalefac_compress      = bitget(&bitdat, 4);
  548.     side_info.gr[igr][ch].window_switching_flag  = bitget(&bitdat, 1);
  549.     if( side_info.gr[igr][ch].window_switching_flag ) {
  550.         side_info.gr[igr][ch].block_type          = bitget(&bitdat, 2);
  551.         side_info.gr[igr][ch].mixed_block_flag    = bitget(&bitdat, 1);
  552.         side_info.gr[igr][ch].table_select[0]     = bitget(&bitdat, 5);
  553.         side_info.gr[igr][ch].table_select[1]     = bitget(&bitdat, 5);
  554.         side_info.gr[igr][ch].subblock_gain[0]    = bitget(&bitdat, 3);
  555.         side_info.gr[igr][ch].subblock_gain[1]    = bitget(&bitdat, 3);
  556.         side_info.gr[igr][ch].subblock_gain[2]    = bitget(&bitdat, 3);
  557.         /* region count set in terms of long block cb's/bands */
  558.         /* r1 set so r0+r1+1 = 21 (lookup produces 576 bands ) */
  559.         /* if(window_switching_flag) always 36 samples in region0 */
  560.         side_info.gr[igr][ch].region0_count = (8-1);    /* 36 samples */
  561.         side_info.gr[igr][ch].region1_count = 20-(8-1);
  562.     }
  563.     else {
  564.         side_info.gr[igr][ch].mixed_block_flag    = 0;
  565.         side_info.gr[igr][ch].block_type          = 0;
  566.         side_info.gr[igr][ch].table_select[0]     = bitget(&bitdat, 5);
  567.         side_info.gr[igr][ch].table_select[1]     = bitget(&bitdat, 5);
  568.         side_info.gr[igr][ch].table_select[2]     = bitget(&bitdat, 5);
  569.         side_info.gr[igr][ch].region0_count       = bitget(&bitdat, 4);
  570.         side_info.gr[igr][ch].region1_count       = bitget(&bitdat, 3);
  571.     }
  572.     side_info.gr[igr][ch].preflag             = bitget(&bitdat, 1);
  573.     side_info.gr[igr][ch].scalefac_scale      = bitget(&bitdat, 1);
  574.     side_info.gr[igr][ch].count1table_select  = bitget(&bitdat, 1);
  575. }
  576. }    
  579. /* return  bytes in header + side info */
  580. return side_bytes;
  581. }
  582. /*====================================================================*/
  583. int CMpaDecoderL3::unpack_side_MPEG2(int igr)
  584. {
  585. int prot;
  586. int br_index;
  587. int ch;
  588. int side_bytes;
  590. /* decode partial header plus initial side info */
  591. /* at entry bit getter points at id, sync skipped by caller */
  593. id = bitget(&bitdat, 1);   /* id */
  594. bitget(&bitdat, 2);        /* skip layer */
  595. prot = bitget(&bitdat, 1);     /* bitget prot bit */
  596. br_index = bitget(&bitdat, 4);
  597. sr_index = bitget(&bitdat, 2);
  598. pad = bitget(&bitdat, 1);
  599. bitget(&bitdat, 1);            /* skip to mode */
  600. side_info.mode = bitget(&bitdat, 2);        /* mode */
  601. side_info.mode_ext = bitget(&bitdat, 2);    /* mode ext */
  603. if( side_info.mode != 1 ) side_info.mode_ext = 0;
  605. /* adjust global gain in ms mode to avoid having to mult by 1/sqrt(2) */
  606. ms_mode = side_info.mode_ext >> 1;
  607. is_mode = side_info.mode_ext & 1;
  609. crcbytes = 0;
  610. if( prot ) bitget(&bitdat, 4);    /* skip to data */
  611. else {
  612.     bitget(&bitdat, 20);          /* skip crc */
  613.     crcbytes = 2;
  614. }
  616. if( br_index > 0 )  {       /* framebytes fixed for free format */
  617.   if( mpeg25_flag == 0 ) {
  618.     framebytes =
  619.         1440 * mp_br_table_L3[id][br_index]/mp_sr20_table_L3[id][sr_index];
  620.   }
  621.   else {
  622.     framebytes =
  623.         2880 * mp_br_table_L3[id][br_index]/mp_sr20_table_L3[id][sr_index];
  624.     //if( sr_index == 2 ) return 0;  // fail mpeg25 8khz
  625.   }
  626. }
  627. side_info.main_data_begin = bitget(&bitdat, 8);
  628. if( side_info.mode == 3 ) {
  629.     side_info.private_bits  = bitget(&bitdat, 1);
  630.     nchan = 1;
  631.     stereo_flag = 0;
  632.     side_bytes = (4+9);   /*-- with header --*/
  633. }
  634. else {                      
  635.     side_info.private_bits  = bitget(&bitdat, 2);
  636.     nchan = 2;
  637.     stereo_flag = 1;
  638.     side_bytes = (4+17);   /*-- with header --*/
  639. }
  640. side_info.scfsi[1] = side_info.scfsi[0] = 0;
  643. for(ch=0;ch<nchan;ch++) {
  644.     side_info.gr[igr][ch].part2_3_length   = bitget(&bitdat, 12);
  645.     side_info.gr[igr][ch].big_values       = bitget(&bitdat, 9);
  646.     side_info.gr[igr][ch].global_gain      = bitget(&bitdat, 8) + gain_adjust;
  647.     if( ms_mode ) side_info.gr[igr][ch].global_gain -= 2;
  648.     side_info.gr[igr][ch].scalefac_compress      = bitget(&bitdat, 9);
  649.     side_info.gr[igr][ch].window_switching_flag  = bitget(&bitdat, 1);
  650.     if( side_info.gr[igr][ch].window_switching_flag ) {
  651.         side_info.gr[igr][ch].block_type          = bitget(&bitdat, 2);
  652.         side_info.gr[igr][ch].mixed_block_flag    = bitget(&bitdat, 1);
  653.         side_info.gr[igr][ch].table_select[0]     = bitget(&bitdat, 5);
  654.         side_info.gr[igr][ch].table_select[1]     = bitget(&bitdat, 5);
  655.         side_info.gr[igr][ch].subblock_gain[0]    = bitget(&bitdat, 3);
  656.         side_info.gr[igr][ch].subblock_gain[1]    = bitget(&bitdat, 3);
  657.         side_info.gr[igr][ch].subblock_gain[2]    = bitget(&bitdat, 3);
  658.         /* region count set in terms of long block cb's/bands  */
  659.         /* r1 set so r0+r1+1 = 21 (lookup produces 576 bands ) */
  660.         /* bt=1 or 3       54 samples */
  661.         /* bt=2 mixed=0    36 samples */
  662.         /* bt=2 mixed=1    54 (8 long sf) samples? or maybe 36 */
  663.         /* region0 discussion says 54 but this would mix long */
  664.         /* and short in region0 if scale factors switch */
  665.         /* at band 36 (6 long scale factors) */
  666.         if( (side_info.gr[igr][ch].block_type == 2) ) {
  667.             side_info.gr[igr][ch].region0_count = (6-1); /* 36 samples */
  668.             side_info.gr[igr][ch].region1_count = 20-(6-1);
  669.         }
  670.         else {  /* long block type 1 or 3 */
  671.             side_info.gr[igr][ch].region0_count = (8-1); /* 54 samples */
  672.             side_info.gr[igr][ch].region1_count = 20-(8-1);
  673.         }
  674.     }
  675.     else {
  676.         side_info.gr[igr][ch].mixed_block_flag    = 0;
  677.         side_info.gr[igr][ch].block_type          = 0;
  678.         side_info.gr[igr][ch].table_select[0]     = bitget(&bitdat, 5);
  679.         side_info.gr[igr][ch].table_select[1]     = bitget(&bitdat, 5);
  680.         side_info.gr[igr][ch].table_select[2]     = bitget(&bitdat, 5);
  681.         side_info.gr[igr][ch].region0_count       = bitget(&bitdat, 4);
  682.         side_info.gr[igr][ch].region1_count       = bitget(&bitdat, 3);
  683.     }
  684.     side_info.gr[igr][ch].preflag             = 0;
  685.     side_info.gr[igr][ch].scalefac_scale      = bitget(&bitdat, 1);
  686.     side_info.gr[igr][ch].count1table_select  = bitget(&bitdat, 1);
  687. }
  689. /* return  bytes in header + side info */
  690. return side_bytes;
  691. }
  692. /*====================================================================*/
  693. void CMpaDecoderL3::unpack_main(unsigned char *buf, int igr)
  694. {
  695. int ch;
  696. int bit0;
  697. int n1, n2, n3, n4, nn2, nn3;
  698. int nn4;
  699. int qbits;
  700. int m0;
  702. for(ch=0;ch<nchan;ch++) {
  703.     bitget_init(&bitdat, buf + (main_pos_bit >> 3));
  704.     bit0 = (main_pos_bit & 7);
  705.     if( bit0 ) bitget(&bitdat, bit0);
  706.     main_pos_bit +=  side_info.gr[igr][ch].part2_3_length;
  707.     bitget_init_end(&bitdat, buf + ((main_pos_bit+39) >> 3));
  708.     /*-- scale factors --*/
  709.     if( id ) 
  710.         unpack_sf_sub_MPEG1(&sf[igr][ch], 
  711.             &side_info.gr[igr][ch], side_info.scfsi[ch],  igr, &bitdat);
  712.     else 
  713.         unpack_sf_sub_MPEG2(&sf[igr][ch], 
  714.             &side_info.gr[igr][ch], is_mode & ch, &is_sf_info, &bitdat);
  715.     /*--- huff data ---*/
  716.     n1 = sfBandIndex[0][side_info.gr[igr][ch].region0_count];
  717.     n2 = sfBandIndex[0][side_info.gr[igr][ch].region0_count
  718.                         + side_info.gr[igr][ch].region1_count+1];
  719.     n3 =  side_info.gr[igr][ch].big_values;
  720.     n3 = n3 + n3;
  722.     
  723.     if( n3 > band_limit ) n3 = band_limit;
  724.     if( n2 > n3 ) n2 = n3;
  725.     if( n1 > n3 ) n1 = n3;
  726.     nn3 = n3 - n2;
  727.     nn2 = n2 - n1;
  728.     unpack_huff(sample[ch][igr],     n1, side_info.gr[igr][ch].table_select[0], &bitdat);
  729.     unpack_huff(sample[ch][igr]+n1, nn2, side_info.gr[igr][ch].table_select[1], &bitdat);
  730.     unpack_huff(sample[ch][igr]+n2, nn3, side_info.gr[igr][ch].table_select[2], &bitdat);
  731.     qbits = side_info.gr[igr][ch].part2_3_length - (bitget_bits_used(&bitdat)-bit0);
  732.     nn4 = unpack_huff_quad(sample[ch][igr]+n3, band_limit - n3, qbits, 
  733.             side_info.gr[igr][ch].count1table_select, &bitdat);
  734.     n4 = n3 + nn4;
  735.     nsamp[igr][ch] = n4;
  736.     //limit n4 or allow deqaunt to sf band 22
  737.     if( side_info.gr[igr][ch].block_type == 2 ) n4 = min(n4,band_limit12);
  738.     else  n4 = min(n4,band_limit21);
  739.     if( n4 < 576 ) memset(sample[ch][igr]+n4, 0, sizeof(SAMPLE)*(576-n4));
  740.     if(  bitget_overrun(&bitdat) ) { // bad data overrun
  741.         memset(sample[ch][igr], 0, sizeof(SAMPLE)*(576));
  742.     }
  743. }
  746. /*--- dequant ---*/
  747. for(ch=0;ch<nchan;ch++) {
  748.     dequant(sample[ch][igr], 
  749.         &nsamp[igr][ch],    /* nsamp updated for shorts */
  750.         &sf[igr][ch], &side_info.gr[igr][ch], 
  751.         &cb_info[igr][ch], ncbl_mixed, nBand, re_buf);
  752. }
  755. /*--- ms stereo processing  ---*/
  756. if( ms_mode ) {
  757.     if( is_mode == 0 ) {
  758.         m0 = nsamp[igr][0];    /* process to longer of left/right */
  759.         if( m0 < nsamp[igr][1] ) m0 = nsamp[igr][1];
  760.     }
  761.     else {  /* process to last cb in right */
  762.         m0  = sfBandIndex[cb_info[igr][1].cbtype][cb_info[igr][1].cbmax];
  763.     }
  764.     ms_process(sample[0][igr], m0);    
  765. }
  767. /*--- is stereo processing  ---*/
  768. if( is_mode ) {
  769.     if( id ) 
  770.         is_process_MPEG1(sample[0][igr], &sf[igr][1], 
  771.             cb_info[igr], nsamp[igr][0], ms_mode, nBand, sfBandIndex);
  772.     else
  773.         is_process_MPEG2(sample[0][igr], &sf[igr][1], 
  774.             cb_info[igr], &is_sf_info,
  775.             nsamp[igr][0], ms_mode, nBand, sfBandIndex);
  776. }
  778. /*-- adjust ms and is modes to max of left/right */
  779. if( side_info.mode_ext ) {
  780.     if(nsamp[igr][0] < nsamp[igr][1]) nsamp[igr][0] = nsamp[igr][1];
  781.     else  nsamp[igr][1] = nsamp[igr][0];
  782. }
  784. /*--- antialias ---*/
  785. for(ch=0;ch<nchan;ch++) {
  786.     if( cb_info[igr][ch].ncbl == 0 ) continue; /* have no long blocks */
  787.     if( side_info.gr[igr][ch].mixed_block_flag ) n1 = 1; /* 1 -> 36 samples */
  788.     else n1 = (nsamp[igr][ch]+7)/18;
  789.     if( n1 > 31 ) n1 = 31;
  790.     antialias(sample[ch][igr], n1);
  791.     n1 = 18*n1+8;       /* update number of samples */
  792.     if( n1 > nsamp[igr][ch] ) nsamp[igr][ch] = n1;
  793. }
  796. //Xform(pcm, igr);
  799. /*-- done --*/
  800. }
  801. /*====================================================================*/
  802. void CMpaDecoderL3::Xform(unsigned char *pcm, int igr)
  803. {
  804.     switch(iXform) {
  805.     default:
  806.     case 0:
  807.         Xform_mono(pcm, igr);
  808.         break;
  809.     case 1:
  810.         Xform_dual(pcm,igr);
  811.         break;
  812.     case 2:
  813.         Xform_dual_mono(pcm,igr);
  814.         break;
  815.     case 3:
  816.         Xform_mono(pcm,igr);
  817.         break;
  818.     case 4:
  819.         Xform_dual_right(pcm,igr);
  820.         break;
  821.     }
  822. }    
  823. /*====================================================================*/
  824. void CMpaDecoderL3::Xform_mono(unsigned char *pcm, int igr)
  825. {
  826. int igr_prev, n1, n2;
  828. /*--- hybrid + sbt ---*/
  829. n1 = n2 = nsamp[igr][0];   /* total number bands */
  830. if( side_info.gr[igr][0].block_type == 2 ) { /* long bands */
  831.     n1 = 0;     
  832.     if( side_info.gr[igr][0].mixed_block_flag ) 
  833.                 n1 = sfBandIndex[0][ncbl_mixed-1];
  834. }
  835. if( n1 > band_limit ) n1 = band_limit;
  836. if( n2 > band_limit ) n2 = band_limit;
  837. igr_prev = igr^1;
  839. nsamp[igr][0] = hybrid(sample[0][igr], sample[0][igr_prev], 
  840.      yout, side_info.gr[igr][0].block_type, n1, n2, nsamp[igr_prev][0], band_limit_nsb);
  841. FreqInvert(yout, nsamp[igr][0]);
  842. sbt_L3(yout, pcm, 0, vbuf, vb_ptr);
  844. }
  845. /*--------------------------------------------------------------------*/
  846. void CMpaDecoderL3::Xform_dual_right(unsigned char *pcm, int igr)
  847. {
  848. int igr_prev, n1, n2;
  850. /*--- hybrid + sbt ---*/
  851. n1 = n2 = nsamp[igr][1];   /* total number bands */
  852. if( side_info.gr[igr][1].block_type == 2 ) { /* long bands */
  853.     n1 = 0;     
  854.     if( side_info.gr[igr][1].mixed_block_flag ) 
  855.                 n1 = sfBandIndex[0][ncbl_mixed-1];
  856. }
  857. if( n1 > band_limit ) n1 = band_limit;
  858. if( n2 > band_limit ) n2 = band_limit;
  859. igr_prev = igr^1;
  860. nsamp[igr][1] = hybrid(sample[1][igr], sample[1][igr_prev], 
  861.       yout, side_info.gr[igr][1].block_type, n1, n2, nsamp[igr_prev][1], band_limit_nsb);
  862. FreqInvert(yout, nsamp[igr][1]);
  863. sbt_L3(yout, pcm, 0, vbuf, vb_ptr);
  865. }
  866. /*--------------------------------------------------------------------*/
  867. void CMpaDecoderL3::Xform_dual(unsigned char *pcm, int igr)
  868. {
  869. int ch;
  870. int igr_prev, n1, n2;
  873. /*--- hybrid + sbt ---*/
  874. igr_prev = igr^1;
  875. for(ch=0;ch<nchan;ch++) {
  876.     n1 = n2 = nsamp[igr][ch];   /* total number bands */
  877.     if( side_info.gr[igr][ch].block_type == 2 ) { /* long bands */
  878.         n1 = 0;     
  879.         if( side_info.gr[igr][ch].mixed_block_flag ) 
  880.                     n1 = sfBandIndex[0][ncbl_mixed-1];
  881.     }
  882.     if( n1 > band_limit ) n1 = band_limit;
  883.     if( n2 > band_limit ) n2 = band_limit;
  884.     nsamp[igr][ch] = hybrid(sample[ch][igr], sample[ch][igr_prev], 
  885.         yout, side_info.gr[igr][ch].block_type, n1, n2, nsamp[igr_prev][ch], band_limit_nsb);
  886.     FreqInvert(yout, nsamp[igr][ch]);
  887.     sbt_L3(yout, pcm, ch, vbuf, vb_ptr);
  888. }
  890. }
  891. /*--------------------------------------------------------------------*/
  892. void CMpaDecoderL3::Xform_dual_mono(unsigned char *pcm, int igr)
  893. {
  894. int igr_prev, n1, n2, n3;
  896. /*--- hybrid + sbt ---*/
  897. igr_prev = igr^1;
  898. if( (side_info.gr[igr][0].block_type == side_info.gr[igr][1].block_type)
  899.       && (side_info.gr[igr][0].mixed_block_flag == 0)
  900.       && (side_info.gr[igr][1].mixed_block_flag == 0) ) 
  901. {
  903.     n2 = nsamp[igr][0];   /* total number bands max of L R */
  904.     if( n2 < nsamp[igr][1] ) n2 = nsamp[igr][1];
  905.     if( n2 > band_limit ) n2 = band_limit;
  906.     n1 = n2;  /* n1 = number long bands */
  907.     if( side_info.gr[igr][0].block_type == 2 ) n1 = 0;
  908.     sum_f_bands(sample[0][igr], sample[1][igr], n2);
  909.     n3 = nsamp[igr][0] = hybrid(sample[0][igr], sample[0][igr_prev], 
  910.         yout, side_info.gr[igr][0].block_type, n1, n2, nsamp[igr_prev][0], band_limit_nsb);
  911. }
  912. else 
  913. {       /* transform and then sum (not tested - never happens in test)*/
  914.     /*-- left chan --*/
  915.     n1 = n2 = nsamp[igr][0];   /* total number bands */
  916.     if( side_info.gr[igr][0].block_type == 2 ) { 
  917.         n1 = 0;     /* long bands */
  918.         if( side_info.gr[igr][0].mixed_block_flag ) 
  919.                     n1 = sfBandIndex[0][ncbl_mixed-1];
  920.     }
  921.     n3 = nsamp[igr][0] = hybrid(sample[0][igr], sample[0][igr_prev], 
  922.         yout, side_info.gr[igr][0].block_type, n1, n2, nsamp[igr_prev][0], band_limit_nsb);
  923.     /*-- right chan --*/
  924.     n1 = n2 = nsamp[igr][1];   /* total number bands */
  925.     if( side_info.gr[igr][1].block_type == 2 ) { 
  926.         n1 = 0;     /* long bands */
  927.         if( side_info.gr[igr][1].mixed_block_flag ) 
  928.                     n1 = sfBandIndex[0][ncbl_mixed-1];
  929.     }
  930.     nsamp[igr][1] = hybrid_sum(sample[1][igr], sample[0][igr], 
  931.         yout, side_info.gr[igr][1].block_type, n1, n2);
  932.     if( n3 < nsamp[igr][1] ) n1 = nsamp[igr][1];
  933. }
  935. /*--------*/
  936. FreqInvert(yout, n3);
  937. sbt_L3(yout, pcm, 0, vbuf, vb_ptr);
  939. }
  940. /*------------------------------------------------------------------*/
  941. /*==================================================================*/
  942. /*====================concealment/reformatted frames================*/
  943. /*==================================================================*/
  944. #ifdef REFORMAT
  945. // test routine - reformats frame
  946. IN_OUT CMpaDecoderL3::audio_decode_reformat(unsigned char *bs, 
  947.                                             unsigned char *bs_out)
  948. {
  949.     if( h_id )  {
  950.         return L3reformat_MPEG1(bs, bs_out);
  951.     }
  952.     else {
  953.         return L3reformat_MPEG2(bs, bs_out);
  954.     }
  955. }
  956. //============================================================
  957. // test routine - reformats frame
  958. IN_OUT CMpaDecoderL3::L3reformat_MPEG1(unsigned char *bs, 
  959.                                        unsigned char *bs_out)
  960. {
  961. int sync;
  962. IN_OUT in_out;
  963. int side_bytes;
  964. int nbytes, nbytes_r;
  966. //iframe++;
  969. bitget_init(bs);          /* initialize bit getter */
  970. /* test sync */
  971. in_out.in_bytes = 0;     /* assume fail */
  972. in_out.out_bytes = 0;
  973. sync = bitget(&bitdat, 12);
  975. if( sync != 0xFFF ) return in_out;       /* sync fail */
  976. /*-----------*/
  978. /*-- unpack side info --*/
  979. side_bytes = unpack_side_MPEG1();
  980. if( framebytes <= 0 ) return in_out;  // fail bad sr or br index
  982. padframebytes = framebytes+pad;
  984. in_out.in_bytes = padframebytes;
  986. /*-- load main data and update buf pointer --*/
  987. /*------------------------------------------- 
  988.    if start point < 0, must just cycle decoder 
  989.    if jumping into middle of stream, 
  990. ---------------------------------------------*/
  992. nbytes_r = reformat_side_bytes + reformat_bytes - side_info.main_data_begin;
  993. if( nbytes_r > 0 ) {
  994.     memmove(bs_out, reformat_buf, nbytes_r);
  995.     in_out.out_bytes = nbytes_r;
  996. }
  999. buf_ptr0 = buf_ptr1 - side_info.main_data_begin;   /* decode start point */
  1000. if( buf_ptr1 > BUF_TRIGGER ) {          /* shift buffer */
  1001.     memmove(buf, buf+buf_ptr0, side_info.main_data_begin);
  1002.     buf_ptr0 = 0;
  1003.     buf_ptr1 = side_info.main_data_begin;
  1004. }
  1005. nbytes = padframebytes - side_bytes - crcbytes;
  1006. memmove(buf+buf_ptr1, bs+side_bytes+crcbytes, nbytes);
  1007. buf_ptr1 += nbytes;
  1008. /*-----------------------*/
  1010. if( buf_ptr0 >= 0 ) {
  1011.     reformat_side_bytes = side_bytes+crcbytes;
  1012.     memmove(reformat_buf, bs, reformat_side_bytes);
  1013.     reformat_buf[4+crcbytes]    = 0;      // set main data begin = 0
  1014.     reformat_buf[4+crcbytes+1] &= 0x7F;   // set main data begin = 0
  1015.     reformat_bytes = buf_ptr1 - buf_ptr0;
  1016.     if( reformat_bytes > 0 ) {
  1017.         memmove(reformat_buf+reformat_side_bytes, 
  1018.             buf+buf_ptr0, reformat_bytes);
  1019.     }
  1020. }
  1021. else {
  1022.     reformat_side_bytes = 0;
  1023.     reformat_bytes = 0;
  1024. }
  1026. return in_out;
  1027. }
  1028. /*=========================================================*/
  1029. // test routine - reformats frame
  1030. IN_OUT CMpaDecoderL3::L3reformat_MPEG2(unsigned char *bs, 
  1031.                                        unsigned char *bs_out)
  1032. {
  1033. int sync;
  1034. IN_OUT in_out;
  1035. int side_bytes;
  1036. int nbytes, nbytes_r;
  1038. //iframe++;
  1040. bitget_init(bs);          /* initialize bit getter */
  1041. /* test sync */
  1042. in_out.in_bytes = 0;     /* assume fail */
  1043. in_out.out_bytes = 0;
  1044. sync = bitget(&bitdat, 12);
  1046. //if( sync != 0xFFF ) return in_out;       /* sync fail */
  1047. mpeg25_flag = 0;
  1048. if( sync != 0xFFF ) {
  1049.     mpeg25_flag = 1;       /* mpeg 2.5 sync */
  1050.     if( sync != 0xFFE ) return in_out;  /* sync fail */
  1051. }
  1053. /*-- unpack side info --*/
  1054. side_bytes = unpack_side_MPEG2(igr);
  1055. if( framebytes <= 0 ) return in_out;  // fail bad sr or br index
  1057. padframebytes = framebytes+pad;
  1059. in_out.in_bytes = padframebytes;
  1061. nbytes_r = reformat_side_bytes + reformat_bytes - side_info.main_data_begin;
  1062. if( nbytes_r > 0 ) {
  1063.     memmove(bs_out, reformat_buf, nbytes_r);
  1064.     in_out.out_bytes = nbytes_r;
  1065. }
  1068. buf_ptr0 = buf_ptr1 - side_info.main_data_begin;   /* decode start point */
  1069. if( buf_ptr1 > BUF_TRIGGER ) {          /* shift buffer */
  1070.     memmove(buf, buf+buf_ptr0, side_info.main_data_begin);
  1071.     buf_ptr0 = 0;
  1072.     buf_ptr1 = side_info.main_data_begin;
  1073. }
  1074. nbytes = padframebytes - side_bytes - crcbytes;
  1075. memmove(buf+buf_ptr1, bs+side_bytes+crcbytes, nbytes);
  1076. buf_ptr1 += nbytes;
  1077. /*-----------------------*/
  1079. if( buf_ptr0 >= 0 ) {
  1080.     reformat_side_bytes = side_bytes+crcbytes;
  1081.     memmove(reformat_buf, bs, reformat_side_bytes);
  1082.     reformat_buf[4+crcbytes]    = 0;      // set main data begin = 0
  1083.     reformat_bytes = buf_ptr1 - buf_ptr0;
  1084.     if( reformat_bytes > 0 ) {
  1085.         memmove(reformat_buf+reformat_side_bytes, 
  1086.             buf+buf_ptr0, reformat_bytes);
  1087.     }
  1088. }
  1089. else {
  1090.     reformat_side_bytes = 0;
  1091.     reformat_bytes = 0;
  1092. }
  1094. //igr = igr^1;   //  must be done by decode_reformatted
  1096. return in_out;
  1097. }
  1098. #endif  // REFORMAT 
  1099. //=========================================================================
  1100. //=========================================================================
  1101. IN_OUT CMpaDecoderL3::audio_decode(unsigned char *bs, unsigned char *pcm, int size)
  1102. {
  1103.     if (!size)
  1104.         return audio_decode(bs, pcm);
  1106. // overloaded for reformatted frames.   main_data_begin == 0
  1108.     if( h_id )  {
  1109.         return L3audio_decode_reformattedMPEG1(bs, pcm, size);
  1110.     }
  1111.     else {
  1112.         return L3audio_decode_reformattedMPEG2(bs, pcm, size);
  1113.     }
  1114. }
  1115. /*====================================================================*/
  1116. IN_OUT CMpaDecoderL3::L3audio_decode_reformattedMPEG1(unsigned char *bs, 
  1117.                            unsigned char *pcm, int size)
  1118. {
  1119. int sync;
  1120. IN_OUT in_out;
  1121. int side_bytes;
  1123. // decode reformatted (self contained) frame 
  1124. // fails if main_data_begin != 0
  1127. iframe++;
  1129. in_out.in_bytes  = 0;   // assume fail  e.g. sync fail
  1130. in_out.out_bytes = 0;
  1132. if( size > 0 ) {
  1134.     bitget_init(&bitdat, bs);          /* initialize bit getter */
  1135.     /* test sync */
  1136.     sync = bitget(&bitdat, 12);
  1137.     if( sync != 0xFFF ) return in_out;       /* sync fail */
  1138.     /*-----------*/
  1140.     /*-- unpack side info --*/
  1141.     side_bytes = unpack_side_MPEG1();
  1142.     if( framebytes <= 0 ) return in_out;  // fail bad sr or br index
  1143.     if( side_info.main_data_begin ) return in_out;  // fail if data not self contained
  1145.     in_out.in_bytes = size;
  1146.     in_out.out_bytes = outbytes;
  1148.     main_pos_bit = (side_bytes+crcbytes) << 3;  // set for unpack_main
  1149.     unpack_main(bs, 0);          // first granule
  1150.     conceal_insert(0);
  1151.     Xform(pcm, 0);
  1152.     unpack_main(bs, 1);          // second granule
  1153.     conceal_insert(1);
  1154.     Xform(pcm+half_outbytes, 1);
  1156. }
  1157. else {      // size <= 0, missing frame 
  1158.     in_out.in_bytes = size;
  1159.     in_out.out_bytes = outbytes;
  1160.     conceal_fixup(0);
  1161.     Xform(pcm, 0);
  1162.     conceal_fixup(1);
  1163.     Xform(pcm+half_outbytes, 1);
  1164. }
  1169. return in_out;
  1170. }
  1171. //=========================================================================
  1172. IN_OUT CMpaDecoderL3::L3audio_decode_reformattedMPEG2(unsigned char *bs, 
  1173.                              unsigned char *pcm, int size)
  1174. {
  1175. int sync;
  1176. IN_OUT in_out;
  1177. int side_bytes;
  1179. // decode reformatted (self contained) frame 
  1180. // fails if main_data_begin != 0
  1182. iframe++;
  1184. in_out.in_bytes = 0;     /* assume fail */
  1185. in_out.out_bytes = 0;
  1187. if( size > 0 ) {
  1188.     bitget_init(&bitdat, bs);          /* initialize bit getter */
  1189.     /* test sync */
  1190.     sync = bitget(&bitdat, 12);
  1191.     //if( sync != 0xFFF ) return in_out;       /* sync fail */
  1192.     mpeg25_flag = 0;
  1193.     if( sync != 0xFFF ) {
  1194.         mpeg25_flag = 1;       /* mpeg 2.5 sync */
  1195.         if( sync != 0xFFE ) return in_out;  /* sync fail */
  1196.     }
  1198.     /*-- unpack side info --*/
  1199.     side_bytes = unpack_side_MPEG2(igr);
  1200.     if( framebytes <= 0 ) return in_out;  // fail bad sr or br index
  1201.     if( side_info.main_data_begin ) return in_out;  // fail if data not self contained
  1203.     in_out.in_bytes = size;
  1204.     in_out.out_bytes = outbytes;
  1206.     main_pos_bit = (side_bytes+crcbytes) << 3;  // set for unpack_main
  1207.     unpack_main(bs, igr);
  1208.     conceal_insert(igr);
  1209.     Xform(pcm, igr);
  1210. }
  1211. else {      // size <= 0, missing frame 
  1212.     in_out.in_bytes = size;
  1213.     in_out.out_bytes = outbytes;
  1214.     conceal_fixup(igr);
  1215.     Xform(pcm, igr);
  1216. }
  1218. igr = igr^1;
  1219. return in_out;
  1220. }
  1221. /*====================================================================*/
  1222. void CMpaDecoderL3::conceal_insert(int igr)
  1223. {
  1224. int ch, nlines, blockType, i;
  1226. if( conceal_flag ) {
  1227.     for(ch=0;ch<nchan;ch++) {
  1229. #if defined (MP3_CONCEAL_LOSS)        
  1230.         conceal[ch]->insert(&sample[ch][igr][0].x, 
  1231.             side_info.gr[igr][ch].block_type, nsamp[igr][ch]);
  1232.         nlines = conceal[ch]->retrieve(&sample[ch][igr][0].x, blockType);
  1233. #endif //MP3_CONCEAL_LOSS
  1234.         
  1235.         side_info.gr[igr][ch].mixed_block_flag      = 0;
  1236.         side_info.gr[igr][ch].block_type            = blockType;
  1237.         side_info.gr[igr][ch].window_switching_flag = (blockType != 0) ? 1 : 0;
  1238.         nsamp[igr][ch] = nlines;
  1239.         for(i=nlines;i<576;i++) sample[ch][igr][i].x = 0.0f;
  1240.     }
  1241. }
  1242. }
  1243. /*====================================================================*/
  1244. void CMpaDecoderL3::conceal_fixup(int igr)
  1245. {
  1246. int ch, nlines, blockType, i;
  1248. if( conceal_flag ) {
  1249.     for(ch=0;ch<nchan;ch++) {
  1251. #if defined (MP3_CONCEAL_LOSS)        
  1252.         conceal[ch]->insert();
  1253.         nlines = conceal[ch]->retrieve(&sample[ch][igr][0].x, blockType);
  1254. #endif //MP3_CONCEAL_LOSS
  1255.         
  1256.         side_info.gr[igr][ch].mixed_block_flag      = 0;
  1257.         side_info.gr[igr][ch].block_type            = blockType;
  1258.         side_info.gr[igr][ch].window_switching_flag = (blockType != 0) ? 1 : 0;
  1259.         nsamp[igr][ch] = nlines;
  1260.         for(i=nlines;i<576;i++) sample[ch][igr][i].x = 0.0f;
  1261.     }
  1262. }
  1263. else {       // mute
  1264.     for(ch=0;ch<nchan;ch++) {
  1265.         side_info.gr[igr][ch].mixed_block_flag      = 0;
  1266.         side_info.gr[igr][ch].block_type            = 0;
  1267.         side_info.gr[igr][ch].window_switching_flag = 0;
  1268.         for(i=0;i<576;i++) sample[ch][igr][i].x = 0.0f;
  1269.     }
  1271. }
  1273. }
  1274. /*====================================================================*/