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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > mpeg/mp3 > 查看源码
l3bitstream.c
资源名称：mpeg.zip　[点击查看]
上传用户：njqiyou
上传日期：2007-01-08
资源大小：574k
文件大小：24k
源码类别：

mpeg/mp3

开发平台：

C/C++

l3bitstream.c：源码内容
  1. /**********************************************************************
  2.  * ISO MPEG Audio Subgroup Software Simulation Group (1996)
  3.  * ISO 13818-3 MPEG-2 Audio Encoder - Lower Sampling Frequency Extension
  4.  *
  5.  * $Id: l3bitstream.c,v 1.1 1996/02/14 04:04:23 rowlands Exp $
  6.  *
  7.  * $Log: l3bitstream.c,v $
  8.  * Revision 1.1  1996/02/14 04:04:23  rowlands
  9.  * Initial revision
  10.  *
  11.  * Received from Mike Coleman
  12.  **********************************************************************/
  13. /*
  14.   Revision History:
  16.   Date        Programmer                Comment
  17.   ==========  ========================= ===============================
  18.   1995/08/06  mc@fivebats.com           created
  19.   1995/09/06  mc@fivebats.com           modified to use formatBitstream
  20. */
  22. #include <stdlib.h>
  23. #include "l3bitstream.h" /* the public interface */
  24. #include "l3psy.h"
  25. #include "mdct.h"
  26. #include "loop.h"
  27. #include "formatBitstream.h"
  28. #include "huffman.h"
  29. #include <assert.h>
  30. #include "l3bitstream-pvt.h"
  32. static int stereo = 1;
  33. static frame_params *fr_ps  = NULL;
  34. static Bit_stream_struc *bs = NULL;
  36. BF_FrameData    *frameData    = NULL;
  37. BF_FrameResults *frameResults = NULL;
  39. int PartHoldersInitialized = 0;
  41. BF_PartHolder *headerPH;
  42. BF_PartHolder *frameSIPH;
  43. BF_PartHolder *channelSIPH[ MAX_CHANNELS ];
  44. BF_PartHolder *spectrumSIPH[ MAX_GRANULES ][ MAX_CHANNELS ];
  45. BF_PartHolder *scaleFactorsPH[ MAX_GRANULES ][ MAX_CHANNELS ];
  46. BF_PartHolder *codedDataPH[ MAX_GRANULES ][ MAX_CHANNELS ];
  47. BF_PartHolder *userSpectrumPH[ MAX_GRANULES ][ MAX_CHANNELS ];
  48. BF_PartHolder *userFrameDataPH;
  51. void putMyBits( uint32 val, uint16 len )
  52. {
  53.     putbits( bs, val, len );
  54. }
  56. /*
  57.   III_format_bitstream()
  58.   
  59.   This is called after a frame of audio has been quantized and coded.
  60.   It will write the encoded audio to the bitstream. Note that
  61.   from a layer3 encoder's perspective the bit stream is primarily
  62.   a series of main_data() blocks, with header and side information
  63.   inserted at the proper locations to maintain framing. (See Figure A.7
  64.   in the IS).
  65.   */
  67. void
  68. III_format_bitstream( int              bitsPerFrame,
  69.       frame_params     *in_fr_ps,
  70.       int              l3_enc[2][2][576],
  71.       III_side_info_t  *l3_side,
  72.       III_scalefac_t   *scalefac,
  73.       Bit_stream_struc *in_bs,
  74.       double           (*xr)[2][576],
  75.       char             *ancillary,
  76.       int              ancillary_bits )
  77. {
  78.     int gr, ch, i, mode_gr;
  79.     fr_ps = in_fr_ps;
  80.     bs = in_bs;
  81.     stereo = fr_ps->stereo;
  82.     mode_gr = (fr_ps->header->version == 1) ? 2 : 1;
  83.     
  84.     if ( frameData == NULL )
  85.     {
  86. frameData = calloc( 1, sizeof(*frameData) );
  87. assert( frameData );
  88.     }
  89.     if ( frameResults == NULL )
  90.     {
  91. frameResults = calloc( 1, sizeof(*frameData) );
  92. assert( frameData );
  93.     }
  94.     if ( !PartHoldersInitialized )
  95.     {
  96. headerPH = BF_newPartHolder( 12 );
  97. frameSIPH = BF_newPartHolder( 12 );
  99. for ( ch = 0; ch < MAX_CHANNELS; ch++ )
  100.     channelSIPH[ch] = BF_newPartHolder( 8 );
  102. for ( gr = 0; gr < MAX_GRANULES; gr++ )
  103.     for ( ch = 0; ch < MAX_CHANNELS; ch++ )
  104.     {
  105. spectrumSIPH[gr][ch]   = BF_newPartHolder( 32 );
  106. scaleFactorsPH[gr][ch] = BF_newPartHolder( 64 );
  107. codedDataPH[gr][ch]    = BF_newPartHolder( 576 );
  108. userSpectrumPH[gr][ch] = BF_newPartHolder( 4 );
  109.     }
  110. userFrameDataPH = BF_newPartHolder( 8 );
  111. PartHoldersInitialized = 1;
  112.     }
  114. #if 1
  115.     for ( gr = 0; gr < mode_gr; gr++ )
  116. for ( ch =  0; ch < stereo; ch++ )
  117. {
  118.     int *pi = &l3_enc[gr][ch][0];
  119.     double *pr = &xr[gr][ch][0];
  120.     for ( i = 0; i < 576; i++, pr++, pi++ )
  121.     {
  122. if ( (*pr < 0) && (*pi > 0) )
  123.     *pi *= -1;
  124.     }
  125. }
  126. #endif
  128.     encodeSideInfo( l3_side );
  129.     encodeMainData( l3_enc, l3_side, scalefac );
  130.     write_ancillary_data( ancillary, ancillary_bits );
  132.     if ( l3_side->resvDrain )
  133. drain_into_ancillary_data( l3_side->resvDrain );
  134.     /*
  135.       Put frameData together for the call
  136.       to BitstreamFrame()
  137.     */
  138.     frameData->putbits     = putMyBits;
  139.     frameData->frameLength = bitsPerFrame;
  140.     frameData->nGranules   = mode_gr;
  141.     frameData->nChannels   = stereo;
  142.     frameData->header      = headerPH->part;
  143.     frameData->frameSI     = frameSIPH->part;
  145.     for ( ch = 0; ch < stereo; ch++ )
  146. frameData->channelSI[ch] = channelSIPH[ch]->part;
  148.     for ( gr = 0; gr < mode_gr; gr++ )
  149. for ( ch = 0; ch < stereo; ch++ )
  150. {
  151.     frameData->spectrumSI[gr][ch]   = spectrumSIPH[gr][ch]->part;
  152.     frameData->scaleFactors[gr][ch] = scaleFactorsPH[gr][ch]->part;
  153.     frameData->codedData[gr][ch]    = codedDataPH[gr][ch]->part;
  154.     frameData->userSpectrum[gr][ch] = userSpectrumPH[gr][ch]->part;
  155. }
  156.     frameData->userFrameData = userFrameDataPH->part;
  158.     BF_BitstreamFrame( frameData, frameResults );
  160.     /* we set this here -- it will be tested in the next loops iteration */
  161.     l3_side->main_data_begin = frameResults->nextBackPtr;
  162. }
  164. void
  165. III_FlushBitstream()
  166. {
  167.     assert( PartHoldersInitialized );
  168.     BF_FlushBitstream( frameData, frameResults );
  169. }
  171. static unsigned slen1_tab[16] = { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 };
  172. static unsigned slen2_tab[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 };
  174. static void
  175. encodeMainData( int              l3_enc[2][2][576],
  176. III_side_info_t  *si,
  177. III_scalefac_t   *scalefac )
  178. {
  179.     int i, gr, ch, sfb, window, mode_gr;
  180.     layer *info = fr_ps->header;
  182.     if ( info->version == 1 )
  183. mode_gr = 2;
  184.     else
  185. mode_gr = 1;
  187.     for ( gr = 0; gr < mode_gr; gr++ )
  188. for ( ch = 0; ch < stereo; ch++ )
  189.     scaleFactorsPH[gr][ch]->part->nrEntries = 0;
  191.     for ( gr = 0; gr < mode_gr; gr++ )
  192. for ( ch = 0; ch < stereo; ch++ )
  193.     codedDataPH[gr][ch]->part->nrEntries = 0;
  195.     if ( info->version == 1 )
  196.     {  /* MPEG 1 */
  197. for ( gr = 0; gr < 2; gr++ )
  198. {
  199.     for ( ch = 0; ch < stereo; ch++ )
  200.     {
  201. BF_PartHolder **pph = &scaleFactorsPH[gr][ch];
  202. gr_info *gi = &(si->gr[gr].ch[ch].tt);
  203. unsigned slen1 = slen1_tab[ gi->scalefac_compress ];
  204. unsigned slen2 = slen2_tab[ gi->scalefac_compress ];
  205. int *ix = &l3_enc[gr][ch][0];
  207. if ( (gi->window_switching_flag == 1) && (gi->block_type == 2) )
  208. {
  209.     if ( gi->mixed_block_flag )
  210.     {
  211. for ( sfb = 0; sfb < 8; sfb++ )
  212.     *pph = BF_addEntry( *pph,  scalefac->l[gr][ch][sfb], slen1 );
  214. for ( sfb = 3; sfb < 6; sfb++ )
  215.     for ( window = 0; window < 3; window++ )
  216. *pph = BF_addEntry( *pph,  scalefac->s[gr][ch][sfb][window], slen1 );
  218. for ( sfb = 6; sfb < 12; sfb++ )
  219.     for ( window = 0; window < 3; window++ )
  220. *pph = BF_addEntry( *pph,  scalefac->s[gr][ch][sfb][window], slen2 );
  222.     }
  223.     else
  224.     {
  225. for ( sfb = 0; sfb < 6; sfb++ )
  226.     for ( window = 0; window < 3; window++ )
  227. *pph = BF_addEntry( *pph,  scalefac->s[gr][ch][sfb][window], slen1 );
  229. for ( sfb = 6; sfb < 12; sfb++ )
  230.     for ( window = 0; window < 3; window++ )
  231. *pph = BF_addEntry( *pph,  scalefac->s[gr][ch][sfb][window], slen2 );
  232.     }
  233. }
  234. else
  235. {
  236.     if ( (gr == 0) || (si->scfsi[ch][0] == 0) )
  237. for ( sfb = 0; sfb < 6; sfb++ )
  238.     *pph = BF_addEntry( *pph,  scalefac->l[gr][ch][sfb], slen1 );
  240.     if ( (gr == 0) || (si->scfsi[ch][1] == 0) )
  241. for ( sfb = 6; sfb < 11; sfb++ )
  242.     *pph = BF_addEntry( *pph,  scalefac->l[gr][ch][sfb], slen1 );
  244.     if ( (gr == 0) || (si->scfsi[ch][2] == 0) )
  245. for ( sfb = 11; sfb < 16; sfb++ )
  246.     *pph = BF_addEntry( *pph,  scalefac->l[gr][ch][sfb], slen2 );
  248.     if ( (gr == 0) || (si->scfsi[ch][3] == 0) )
  249. for ( sfb = 16; sfb < 21; sfb++ )
  250.     *pph = BF_addEntry( *pph,  scalefac->l[gr][ch][sfb], slen2 );
  251. }
  252. Huffmancodebits( &codedDataPH[gr][ch], ix, gi );
  253.     } /* for ch */
  254. } /* for gr */
  255.     }
  256.     else
  257.     {  /* MPEG 2 */
  258. gr = 0;
  259. for ( ch = 0; ch < stereo; ch++ )
  260. {
  261.     BF_PartHolder **pph = &scaleFactorsPH[gr][ch];
  262.     gr_info *gi = &(si->gr[gr].ch[ch].tt);
  263.     int *ix = &l3_enc[gr][ch][0];
  264.     int sfb_partition;
  266.     assert( gi->sfb_partition_table );
  268.     if ( (gi->window_switching_flag == 1) && (gi->block_type == 2) )
  269.     {
  270. if ( gi->mixed_block_flag )
  271. {
  272.     sfb_partition = 0;
  273.     for ( sfb = 0; sfb < 8; sfb++ )
  274. *pph = BF_addEntry( *pph,  scalefac->l[gr][ch][sfb], gi->slen[sfb_partition] );
  276.     for ( sfb = 3, sfb_partition = 1; sfb_partition < 4; sfb_partition++ )
  277.     {
  278. int sfbs = gi->sfb_partition_table[ sfb_partition ] / 3;
  279. int slen = gi->slen[ sfb_partition ];
  280. for ( i = 0; i < sfbs; i++, sfb++ )
  281.     for ( window = 0; window < 3; window++ )
  282. *pph = BF_addEntry( *pph,  scalefac->s[gr][ch][sfb][window], slen );
  283.     }
  284. }
  285. else
  286. {
  287.     for ( sfb = 0, sfb_partition = 0; sfb_partition < 4; sfb_partition++ )
  288.     {
  289. int sfbs = gi->sfb_partition_table[ sfb_partition ] / 3;
  290. int slen = gi->slen[ sfb_partition ];
  291. for ( i = 0; i < sfbs; i++, sfb++ )
  292.     for ( window = 0; window < 3; window++ )
  293. *pph = BF_addEntry( *pph,  scalefac->s[gr][ch][sfb][window], slen );
  294.     }
  295. }
  296.     }
  297.     else
  298.     {
  299. for ( sfb = 0, sfb_partition = 0; sfb_partition < 4; sfb_partition++ )
  300. {
  301.     int sfbs = gi->sfb_partition_table[ sfb_partition ];
  302.     int slen = gi->slen[ sfb_partition ];
  303.     for ( i = 0; i < sfbs; i++, sfb++ )
  304. *pph = BF_addEntry( *pph,  scalefac->l[gr][ch][sfb], slen );
  305. }
  306.     }
  307.     Huffmancodebits( &codedDataPH[gr][ch], ix, gi );
  308. } /* for ch */
  309.     }
  310. } /* main_data */
  312. static unsigned int crc = 0;
  314. static int encodeSideInfo( III_side_info_t  *si )
  315. {
  316.     int gr, ch, scfsi_band, region, window, bits_sent, mode_gr;
  317.     layer *info = fr_ps->header;
  318.     
  319.     mode_gr =  (info->version == 1) ? 2 : 1;
  321.     headerPH->part->nrEntries = 0;
  322.     headerPH = BF_addEntry( headerPH, 0xfff,                    12 );
  323.     headerPH = BF_addEntry( headerPH, info->version,            1 );
  324.     headerPH = BF_addEntry( headerPH, 4 - info->lay,            2 );
  325.     headerPH = BF_addEntry( headerPH, !info->error_protection,  1 );
  326.     headerPH = BF_addEntry( headerPH, info->bitrate_index,      4 );
  327.     headerPH = BF_addEntry( headerPH, info->sampling_frequency, 2 );
  328.     headerPH = BF_addEntry( headerPH, info->padding,            1 );
  329.     headerPH = BF_addEntry( headerPH, info->extension,          1 );
  330.     headerPH = BF_addEntry( headerPH, info->mode,               2 );
  331.     headerPH = BF_addEntry( headerPH, info->mode_ext,           2 );
  332.     headerPH = BF_addEntry( headerPH, info->copyright,          1 );
  333.     headerPH = BF_addEntry( headerPH, info->original,           1 );
  334.     headerPH = BF_addEntry( headerPH, info->emphasis,           2 );
  335.     
  336.     bits_sent = 32;
  338.     if ( fr_ps->header->error_protection )
  339.     {
  340. headerPH = BF_addEntry( headerPH, crc, 16 );
  341. bits_sent += 16;
  342.     }
  344.     frameSIPH->part->nrEntries = 0;
  346.     for (ch = 0; ch < stereo; ch++ )
  347. channelSIPH[ch]->part->nrEntries = 0;
  349.     for ( gr = 0; gr < mode_gr; gr++ )
  350. for ( ch = 0; ch < stereo; ch++ )
  351.     spectrumSIPH[gr][ch]->part->nrEntries = 0;
  353.     if ( info->version == 1 )
  354.     {  /* MPEG1 */
  355. frameSIPH = BF_addEntry( frameSIPH, si->main_data_begin, 9 );
  357. if ( stereo == 2 )
  358.     frameSIPH = BF_addEntry( frameSIPH, si->private_bits, 3 );
  359. else
  360.     frameSIPH = BF_addEntry( frameSIPH, si->private_bits, 5 );
  362. for ( ch = 0; ch < stereo; ch++ )
  363.     for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
  364.     {
  365. BF_PartHolder **pph = &channelSIPH[ch];
  366. *pph = BF_addEntry( *pph, si->scfsi[ch][scfsi_band], 1 );
  367.     }
  369. for ( gr = 0; gr < 2; gr++ )
  370.     for ( ch = 0; ch < stereo; ch++ )
  371.     {
  372. BF_PartHolder **pph = &spectrumSIPH[gr][ch];
  373. gr_info *gi = &(si->gr[gr].ch[ch].tt);
  374. *pph = BF_addEntry( *pph, gi->part2_3_length,        12 );
  375. *pph = BF_addEntry( *pph, gi->big_values,            9 );
  376. *pph = BF_addEntry( *pph, gi->global_gain,           8 );
  377. *pph = BF_addEntry( *pph, gi->scalefac_compress,     4 );
  378. *pph = BF_addEntry( *pph, gi->window_switching_flag, 1 );
  380. if ( gi->window_switching_flag )
  381. {   
  382.     *pph = BF_addEntry( *pph, gi->block_type,       2 );
  383.     *pph = BF_addEntry( *pph, gi->mixed_block_flag, 1 );
  385.     for ( region = 0; region < 2; region++ )
  386. *pph = BF_addEntry( *pph, gi->table_select[region],  5 );
  387.     for ( window = 0; window < 3; window++ )
  388. *pph = BF_addEntry( *pph, gi->subblock_gain[window], 3 );
  389. }
  390. else
  391. {
  392.     assert( gi->block_type == 0 );
  393.     for ( region = 0; region < 3; region++ )
  394. *pph = BF_addEntry( *pph, gi->table_select[region], 5 );
  396.     *pph = BF_addEntry( *pph, gi->region0_count, 4 );
  397.     *pph = BF_addEntry( *pph, gi->region1_count, 3 );
  398. }
  400. *pph = BF_addEntry( *pph, gi->preflag,            1 );
  401. *pph = BF_addEntry( *pph, gi->scalefac_scale,     1 );
  402. *pph = BF_addEntry( *pph, gi->count1table_select, 1 );
  403.     }
  405. if ( stereo == 2 )
  406.     bits_sent += 256;
  407. else
  408.     bits_sent += 136;
  409.     }
  410.     else
  411.     {  /* MPEG2 */
  412. frameSIPH = BF_addEntry( frameSIPH, si->main_data_begin, 8 );
  414. if ( stereo == 2 )
  415.     frameSIPH = BF_addEntry( frameSIPH, si->private_bits, 2 );
  416. else
  417.     frameSIPH = BF_addEntry( frameSIPH, si->private_bits, 1 );
  419. gr = 0;
  420. for ( ch = 0; ch < stereo; ch++ )
  421. {
  422.     BF_PartHolder **pph = &spectrumSIPH[gr][ch];
  423.     gr_info *gi = &(si->gr[gr].ch[ch].tt);
  424.     *pph = BF_addEntry( *pph, gi->part2_3_length,        12 );
  425.     *pph = BF_addEntry( *pph, gi->big_values,            9 );
  426.     *pph = BF_addEntry( *pph, gi->global_gain,           8 );
  427.     *pph = BF_addEntry( *pph, gi->scalefac_compress,     9 );
  428.     *pph = BF_addEntry( *pph, gi->window_switching_flag, 1 );
  430.     if ( gi->window_switching_flag )
  431.     {   
  432. *pph = BF_addEntry( *pph, gi->block_type,       2 );
  433. *pph = BF_addEntry( *pph, gi->mixed_block_flag, 1 );
  435. for ( region = 0; region < 2; region++ )
  436.     *pph = BF_addEntry( *pph, gi->table_select[region],  5 );
  437. for ( window = 0; window < 3; window++ )
  438.     *pph = BF_addEntry( *pph, gi->subblock_gain[window], 3 );
  439.     }
  440.     else
  441.     {
  442. for ( region = 0; region < 3; region++ )
  443.     *pph = BF_addEntry( *pph, gi->table_select[region], 5 );
  445. *pph = BF_addEntry( *pph, gi->region0_count, 4 );
  446. *pph = BF_addEntry( *pph, gi->region1_count, 3 );
  447.     }
  449.     *pph = BF_addEntry( *pph, gi->scalefac_scale,     1 );
  450.     *pph = BF_addEntry( *pph, gi->count1table_select, 1 );
  451. }
  452. if ( stereo == 2 )
  453.     bits_sent += 136;
  454. else
  455.     bits_sent += 72;
  456.     }
  457.     return bits_sent;
  458. }
  460. static void
  461. write_ancillary_data( char *theData, int lengthInBits )
  462. {
  463.     /*
  464.      */
  465.     int bytesToSend = lengthInBits / 8;
  466.     int remainingBits = lengthInBits % 8;
  467.     unsigned wrd;
  468.     int i;
  470.     userFrameDataPH->part->nrEntries = 0;
  472.     for ( i = 0; i < bytesToSend; i++ )
  473.     {
  474. wrd = theData[i];
  475. userFrameDataPH = BF_addEntry( userFrameDataPH, wrd, 8 );
  476.     }
  477.     if ( remainingBits )
  478.     {
  479. /* right-justify remaining bits */
  480. wrd = theData[bytesToSend] >> (8 - remainingBits);
  481. userFrameDataPH = BF_addEntry( userFrameDataPH, wrd, remainingBits );
  482.     }
  483.     
  484. }
  486. /*
  487.   Some combinations of bitrate, Fs, and stereo make it impossible to stuff
  488.   out a frame using just main_data, due to the limited number of bits to
  489.   indicate main_data_length. In these situations, we put stuffing bits into
  490.   the ancillary data...
  491. */
  492. static void
  493. drain_into_ancillary_data( int lengthInBits )
  494. {
  495.     /*
  496.      */
  497.     int wordsToSend   = lengthInBits / 32;
  498.     int remainingBits = lengthInBits % 32;
  499.     int i;
  501.     /*
  502.       userFrameDataPH->part->nrEntries set by call to write_ancillary_data()
  503.     */
  505.     for ( i = 0; i < wordsToSend; i++ )
  506. userFrameDataPH = BF_addEntry( userFrameDataPH, 0, 32 );
  507.     if ( remainingBits )
  508. userFrameDataPH = BF_addEntry( userFrameDataPH, 0, remainingBits );    
  509. }
  511. /*
  512.   Note the discussion of huffmancodebits() on pages 28
  513.   and 29 of the IS, as well as the definitions of the side
  514.   information on pages 26 and 27.
  515.   */
  516. static void
  517. Huffmancodebits( BF_PartHolder **pph, int *ix, gr_info *gi )
  518. {
  519.     int L3_huffman_coder_count1( BF_PartHolder **pph, struct huffcodetab *h, int v, int w, int x, int y );
  520.     int bigv_bitcount( int ix[576], gr_info *cod_info );
  522.     int region1Start;
  523.     int region2Start;
  524.     int i, bigvalues, count1End;
  525.     int v, w, x, y, bits, cbits, xbits, stuffingBits;
  526.     unsigned int code, ext;
  527.     struct huffcodetab *h;
  528.     int bvbits, c1bits, tablezeros, r0, r1, r2, rt, *pr;
  529.     int bitsWritten = 0;
  530.     int idx = 0;
  531.     tablezeros = 0;
  532.     r0 = r1 = r2 = 0;
  533.     
  534.     /* 1: Write the bigvalues */
  535.     bigvalues = gi->big_values * 2;
  536.     if ( bigvalues )
  537.     {
  538. if ( !(gi->mixed_block_flag) && gi->window_switching_flag && (gi->block_type == 2) )
  539. { /* Three short blocks */
  540.     /*
  541.       Within each scalefactor band, data is given for successive
  542.       time windows, beginning with window 0 and ending with window 2.
  543.       Within each window, the quantized values are then arranged in
  544.       order of increasing frequency...
  545.       */
  546.     int sfb, window, line, start, end;
  548.     I192_3 *ix_s;
  549.     int *scalefac = &sfBandIndex[fr_ps->header->sampling_frequency + (fr_ps->header->version * 3)].s[0];
  550.     
  551.     ix_s = (I192_3 *) ix;
  552.     region1Start = 12;
  553.     region2Start = 576;
  555.     for ( sfb = 0; sfb < 13; sfb++ )
  556.     {
  557. unsigned tableindex = 100;
  558. start = scalefac[ sfb ];
  559. end   = scalefac[ sfb+1 ];
  561. if ( start < region1Start )
  562.     tableindex = gi->table_select[ 0 ];
  563. else
  564.     tableindex = gi->table_select[ 1 ];
  565. assert( tableindex < 32 );
  567. for ( window = 0; window < 3; window++ )
  568.     for ( line = start; line < end; line += 2 )
  569.     {
  570. x = (*ix_s)[line][window];
  571. y = (*ix_s)[line + 1][window];
  572. assert( idx < 576 );
  573. assert( idx >= 0 );
  574. bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  575. *pph = BF_addEntry( *pph,  code, cbits );
  576. *pph = BF_addEntry( *pph,  ext, xbits );
  577. bitsWritten += bits;
  578.     }
  580.     }
  581. }
  582. else
  583.     if ( gi->mixed_block_flag && gi->block_type == 2 )
  584.     {  /* Mixed blocks long, short */
  585. int sfb, window, line, start, end;
  586. unsigned tableindex;
  587. I192_3 *ix_s;
  588. int *scalefac = &sfBandIndex[fr_ps->header->sampling_frequency + (fr_ps->header->version * 3)].s[0];
  590. ix_s = (I192_3 *) ix;
  592. /* Write the long block region */
  593. tableindex = gi->table_select[0];
  594. if ( tableindex )
  595.     for ( i = 0; i < 36; i += 2 )
  596.     {
  597. x = ix[i];
  598. y = ix[i + 1];
  599. bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  600. *pph = BF_addEntry( *pph,  code, cbits );
  601. *pph = BF_addEntry( *pph,  ext, xbits );
  602. bitsWritten += bits;
  604.     }
  605. /* Write the short block region */
  606. tableindex = gi->table_select[ 1 ];
  607. assert( tableindex < 32 );
  609. for ( sfb = 3; sfb < 13; sfb++ )
  610. {
  611.     start = scalefac[ sfb ];
  612.     end   = scalefac[ sfb+1 ];           
  613.     
  614.     for ( window = 0; window < 3; window++ )
  615. for ( line = start; line < end; line += 2 )
  616. {
  617.     x = (*ix_s)[line][window];
  618.     y = (*ix_s)[line + 1][window];
  619.     bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  620.     *pph = BF_addEntry( *pph,  code, cbits );
  621.     *pph = BF_addEntry( *pph,  ext, xbits );
  622.     bitsWritten += bits;
  623. }
  624. }
  626.     }
  627.     else
  628.     { /* Long blocks */
  629. int *scalefac = &sfBandIndex[fr_ps->header->sampling_frequency + (fr_ps->header->version * 3)].l[0];
  630. unsigned scalefac_index = 100;
  632. if ( gi->mixed_block_flag )
  633. {
  634.     region1Start = 36;
  635.     region2Start = 576;
  636. }
  637. else
  638. {
  639.     scalefac_index = gi->region0_count + 1;
  640.     assert( scalefac_index < 23 );
  641.     region1Start = scalefac[ scalefac_index ];
  642.     scalefac_index += gi->region1_count + 1;
  643.     assert( scalefac_index < 23 );    
  644.     region2Start = scalefac[ scalefac_index ];
  645.     assert( region1Start == gi->address1 );
  646. }
  647. for ( i = 0; i < bigvalues; i += 2 )
  648. {
  649.     unsigned tableindex = 100;
  650.     /* get table pointer */
  651.     if ( i < region1Start )
  652.     {
  653. tableindex = gi->table_select[0];
  654. pr = &r0;
  655.     }
  656.     else
  657. if ( i < region2Start )
  658. {
  659.     tableindex = gi->table_select[1];
  660.     pr = &r1;
  661. }
  662. else
  663. {
  664.     tableindex = gi->table_select[2];
  665.     pr = &r2;
  666. }
  667.     assert( tableindex < 32 );
  668.     h = &ht[ tableindex ];
  669.     /* get huffman code */
  670.     x = ix[i];
  671.     y = ix[i + 1];
  672.     if ( tableindex )
  673.     {
  674. bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  675. *pph = BF_addEntry( *pph,  code, cbits );
  676. *pph = BF_addEntry( *pph,  ext, xbits );
  677. bitsWritten += rt = bits;
  678. *pr += rt;
  679.     }
  680.     else
  681.     {
  682. tablezeros += 1;
  683. *pr = 0;
  684.     }
  685. }
  686.     }
  687.     }
  688.     bvbits = bitsWritten; 
  690.     /* 2: Write count1 area */
  691.     assert( (gi->count1table_select < 2) );
  692.     h = &ht[gi->count1table_select + 32];
  693.     count1End = bigvalues + (gi->count1 * 4);
  694.     assert( count1End <= 576 );
  695.     for ( i = bigvalues; i < count1End; i += 4 )
  696.     {
  697. v = ix[i];
  698. w = ix[i+1];
  699. x = ix[i+2];
  700. y = ix[i+3];
  701. bitsWritten += L3_huffman_coder_count1( pph, h, v, w, x, y );
  702.     }
  703.     c1bits = bitsWritten - bvbits;
  704.     if ( (stuffingBits = gi->part2_3_length - gi->part2_length - bitsWritten) )
  705.     {
  706. int stuffingWords = stuffingBits / 32;
  707. int remainingBits = stuffingBits % 32;
  708. assert( stuffingBits > 0 );
  710. /*
  711.   Due to the nature of the Huffman code
  712.   tables, we will pad with ones
  713. */
  714. while ( stuffingWords-- )
  715.     *pph = BF_addEntry( *pph, ~0, 32 );
  716. if ( remainingBits )
  717.     *pph = BF_addEntry( *pph, ~0, remainingBits );
  718. bitsWritten += stuffingBits;
  719.     }
  720.     assert( bitsWritten == gi->part2_3_length - gi->part2_length );
  721. #ifdef DEBUG
  722.     printf( "#### %d Huffman bits written (%02d + %02d), part2_length = %d, part2_3_length = %d, %d stuffing ####n",
  723.     bitsWritten, bvbits, c1bits, gi->part2_length, gi->part2_3_length, stuffingBits );
  724. #endif
  725. }
  727. int
  728. abs_and_sign( int *x )
  729. {
  730.     if ( *x > 0 )
  731. return 0;
  732.     *x *= -1;
  733.     return 1;
  734. }
  736. int
  737. L3_huffman_coder_count1( BF_PartHolder **pph, struct huffcodetab *h, int v, int w, int x, int y )
  738. {
  739.     HUFFBITS huffbits;
  740.     unsigned int signv, signw, signx, signy, p;
  741.     int len;
  742.     int totalBits = 0;
  743.     
  744.     signv = abs_and_sign( &v );
  745.     signw = abs_and_sign( &w );
  746.     signx = abs_and_sign( &x );
  747.     signy = abs_and_sign( &y );
  748.     
  749.     p = v + (w << 1) + (x << 2) + (y << 3);
  750.     huffbits = h->table[p];
  751.     len = h->hlen[ p ];
  752.     *pph = BF_addEntry( *pph,  huffbits, len );
  753.     totalBits += len;
  754.     if ( v )
  755.     {
  756. *pph = BF_addEntry( *pph,  signv, 1 );
  757. totalBits += 1;
  758.     }
  759.     if ( w )
  760.     {
  761. *pph = BF_addEntry( *pph,  signw, 1 );
  762. totalBits += 1;
  763.     }
  765.     if ( x )
  766.     {
  767. *pph = BF_addEntry( *pph,  signx, 1 );
  768. totalBits += 1;
  769.     }
  770.     if ( y )
  771.     {
  772. *pph = BF_addEntry( *pph,  signy, 1 );
  773. totalBits += 1;
  774.     }
  775.     return totalBits;
  776. }
  778. /*
  779.   Implements the pseudocode of page 98 of the IS
  780.   */
  781. int
  782. HuffmanCode( int table_select, int x, int y, unsigned int *code, unsigned int *ext, int *cbits, int *xbits )
  783. {
  784.     unsigned signx, signy, linbitsx, linbitsy, linbits, xlen, ylen, idx;
  785.     struct huffcodetab *h;
  787.     *cbits = 0;
  788.     *xbits = 0;
  789.     *code  = 0;
  790.     *ext   = 0;
  791.     
  792.     if ( table_select == 0 )
  793. return 0;
  794.     
  795.     signx = abs_and_sign( &x );
  796.     signy = abs_and_sign( &y );
  797.     h = &(ht[table_select]);
  798.     xlen = h->xlen;
  799.     ylen = h->ylen;
  800.     linbits = h->linbits;
  801.     linbitsx = linbitsy = 0;
  803.     if ( table_select > 15 )
  804.     { /* ESC-table is used */
  805. if ( x > 14 )
  806. {
  807.     linbitsx = x - 15;
  808.     assert( linbitsx <= h->linmax );
  809.     x = 15;
  810. }
  811. if ( y > 14 )
  812. {
  813.     linbitsy = y - 15;
  814.     assert( linbitsy <= h->linmax );
  815.     y = 15;
  816. }
  817. idx = (x * ylen) + y;
  818. *code = h->table[idx];
  819. *cbits = h->hlen[ idx ];
  820. if ( x > 14 )
  821. {
  822.     *ext |= linbitsx;
  823.     *xbits += linbits;
  824. }
  825. if ( x != 0 )
  826. {
  827.     *ext <<= 1;
  828.     *ext |= signx;
  829.     *xbits += 1;
  830. }
  831. if ( y > 14 )
  832. {
  833.     *ext <<= linbits;
  834.     *ext |= linbitsy;
  835.     *xbits += linbits;
  836. }
  837. if ( y != 0 )
  838. {
  839.     *ext <<= 1;
  840.     *ext |= signy;
  841.     *xbits += 1;
  842. }
  843.     }
  844.     else
  845.     { /* No ESC-words */
  846. idx = (x * ylen) + y;
  847. *code = h->table[idx];
  848. *cbits += h->hlen[ idx ];
  849. if ( x != 0 )
  850. {
  851.     *code <<= 1;
  852.     *code |= signx;
  853.     *cbits += 1;
  854. }
  855. if ( y != 0 )
  856. {
  857.     *code <<= 1;
  858.     *code |= signy;
  859.     *cbits += 1;
  860. }
  861.     }
  862.     assert( *cbits <= 32 );
  863.     assert( *xbits <= 32 );
  864.     return *cbits + *xbits;
  865. }