home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 4 / AACD04.ISO / AACD / Sound / LAME / Source / l3bitstream.c < prev    next >
C/C++ Source or Header  |  1999-05-31  |  24KB  |  877 lines
  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:
  15.  
  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. */
  21.  
  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"
  31.  
  32. static int stereo = 1;
  33. static frame_params *fr_ps  = NULL;
  34. static Bit_stream_struc *bs = NULL;
  35.  
  36. BF_FrameData    *frameData    = NULL;
  37. BF_FrameResults *frameResults = NULL;
  38.  
  39. int PartHoldersInitialized = 0;
  40.  
  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;
  49.  
  50.  
  51. void putMyBits( uint32 val, uint16 len )
  52. {
  53.     putbits( bs, val, len );
  54. }
  55.  
  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.   */
  66.  
  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,  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 );
  98.  
  99.     for ( ch = 0; ch < MAX_CHANNELS; ch++ )
  100.         channelSIPH[ch] = BF_newPartHolder( 8 );
  101.  
  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.     }
  113.  
  114. #if 0
  115.     /* this makes more sense in loop.c */
  116.     for ( gr = 0; gr < mode_gr; gr++ )
  117.     for ( ch =  0; ch < stereo; ch++ )
  118.     {
  119.         int *pi = &l3_enc[gr][ch][0];
  120.         int i;
  121.         for ( i = 0; i < 576; i++)         {
  122.           double pr = xr[gr][ch][i];
  123.               /* ms stereo fix.  if ms_stereo, l3_enc will be M/S values */
  124.           if (in_fr_ps->header->mode_ext == 2) {
  125.         pr = ch ? (xr[gr][0][i]-xr[gr][1][i]) : (xr[gr][0][i]+xr[gr][1][i]);
  126.         /* pr /= sqrt(2.0); */
  127.           }
  128.  
  129.           if ( (pr < 0) && (pi[i] > 0) )   pi[i] *= -1;
  130.         }
  131.     }
  132. #endif
  133.  
  134.  
  135.     encodeSideInfo( l3_side );
  136.     encodeMainData( l3_enc, l3_side, scalefac );
  137.     write_ancillary_data( ancillary, ancillary_bits );
  138.  
  139.     if ( l3_side->resvDrain )
  140.     drain_into_ancillary_data( l3_side->resvDrain );
  141.     /*
  142.       Put frameData together for the call
  143.       to BitstreamFrame()
  144.     */
  145.     frameData->putbits     = putMyBits;
  146.     frameData->frameLength = bitsPerFrame;
  147.     frameData->nGranules   = mode_gr;
  148.     frameData->nChannels   = stereo;
  149.     frameData->header      = headerPH->part;
  150.     frameData->frameSI     = frameSIPH->part;
  151.  
  152.     for ( ch = 0; ch < stereo; ch++ )
  153.     frameData->channelSI[ch] = channelSIPH[ch]->part;
  154.  
  155.     for ( gr = 0; gr < mode_gr; gr++ )
  156.     for ( ch = 0; ch < stereo; ch++ )
  157.     {
  158.         frameData->spectrumSI[gr][ch]   = spectrumSIPH[gr][ch]->part;
  159.         frameData->scaleFactors[gr][ch] = scaleFactorsPH[gr][ch]->part;
  160.         frameData->codedData[gr][ch]    = codedDataPH[gr][ch]->part;
  161.         frameData->userSpectrum[gr][ch] = userSpectrumPH[gr][ch]->part;
  162.     }
  163.     frameData->userFrameData = userFrameDataPH->part;
  164.  
  165.     BF_BitstreamFrame( frameData, frameResults );
  166.  
  167.     /* we set this here -- it will be tested in the next loops iteration */
  168.     l3_side->main_data_begin = frameResults->nextBackPtr;
  169.  
  170. }
  171.  
  172. void
  173. III_FlushBitstream()
  174. {
  175.     assert( PartHoldersInitialized );
  176.     BF_FlushBitstream( frameData, frameResults );
  177. }
  178.  
  179. static unsigned slen1_tab[16] = { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 };
  180. static unsigned slen2_tab[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 };
  181.  
  182. static void
  183. encodeMainData( int              l3_enc[2][2][576],
  184.         III_side_info_t  *si,
  185.         III_scalefac_t   *scalefac )
  186. {
  187.     int i, gr, ch, sfb, window, mode_gr;
  188.     layer *info = fr_ps->header;
  189.  
  190.     if ( info->version == 1 )
  191.     mode_gr = 2;
  192.     else
  193.     mode_gr = 1;
  194.  
  195.     for ( gr = 0; gr < mode_gr; gr++ )
  196.     for ( ch = 0; ch < stereo; ch++ )
  197.         scaleFactorsPH[gr][ch]->part->nrEntries = 0;
  198.  
  199.     for ( gr = 0; gr < mode_gr; gr++ )
  200.     for ( ch = 0; ch < stereo; ch++ )
  201.         codedDataPH[gr][ch]->part->nrEntries = 0;
  202.  
  203.     if ( info->version == 1 )
  204.     {  /* MPEG 1 */
  205.     for ( gr = 0; gr < 2; gr++ )
  206.     {
  207.         for ( ch = 0; ch < stereo; ch++ )
  208.         {
  209.         BF_PartHolder **pph = &scaleFactorsPH[gr][ch];        
  210.         gr_info *gi = &(si->gr[gr].ch[ch].tt);
  211.         unsigned slen1 = slen1_tab[ gi->scalefac_compress ];
  212.         unsigned slen2 = slen2_tab[ gi->scalefac_compress ];
  213.         int *ix = &l3_enc[gr][ch][0];
  214.  
  215.         if ( (gi->window_switching_flag == 1) && (gi->block_type == 2) )
  216.         {
  217. #ifdef ALLOW_MIXED
  218.             if ( gi->mixed_block_flag )
  219.             {
  220.             for ( sfb = 0; sfb < 8; sfb++ )
  221.                 *pph = BF_addEntry( *pph,  scalefac->l[gr][ch][sfb], slen1 );
  222.  
  223.             for ( sfb = 3; sfb < 6; sfb++ )
  224.                 for ( window = 0; window < 3; window++ )
  225.                 *pph = BF_addEntry( *pph,  scalefac->s[gr][ch][sfb][window], slen1 );
  226.  
  227.             for ( sfb = 6; sfb < 12; sfb++ )
  228.                 for ( window = 0; window < 3; window++ )
  229.                 *pph = BF_addEntry( *pph,  scalefac->s[gr][ch][sfb][window], slen2 );
  230.  
  231.             }
  232.             else
  233. #endif
  234.             {
  235.             for ( sfb = 0; sfb < 6; sfb++ )
  236.                 for ( window = 0; window < 3; window++ )
  237.                 *pph = BF_addEntry( *pph,  scalefac->s[gr][ch][sfb][window], slen1 );
  238.  
  239.             for ( sfb = 6; sfb < 12; sfb++ )
  240.                 for ( window = 0; window < 3; window++ )
  241.                 *pph = BF_addEntry( *pph,  scalefac->s[gr][ch][sfb][window], slen2 );
  242.             }
  243.         }
  244.         else
  245.         {
  246.             if ( (gr == 0) || (si->scfsi[ch][0] == 0) )
  247.             for ( sfb = 0; sfb < 6; sfb++ )
  248.                 *pph = BF_addEntry( *pph,  scalefac->l[gr][ch][sfb], slen1 );
  249.  
  250.             if ( (gr == 0) || (si->scfsi[ch][1] == 0) )
  251.             for ( sfb = 6; sfb < 11; sfb++ )
  252.                 *pph = BF_addEntry( *pph,  scalefac->l[gr][ch][sfb], slen1 );
  253.  
  254.             if ( (gr == 0) || (si->scfsi[ch][2] == 0) )
  255.             for ( sfb = 11; sfb < 16; sfb++ )
  256.                 *pph = BF_addEntry( *pph,  scalefac->l[gr][ch][sfb], slen2 );
  257.  
  258.             if ( (gr == 0) || (si->scfsi[ch][3] == 0) )
  259.             for ( sfb = 16; sfb < 21; sfb++ )
  260.                 *pph = BF_addEntry( *pph,  scalefac->l[gr][ch][sfb], slen2 );
  261.         }
  262.         Huffmancodebits( &codedDataPH[gr][ch], ix, gi );
  263.         } /* for ch */
  264.     } /* for gr */
  265.     }
  266.     else
  267.     {  /* MPEG 2 */
  268.     gr = 0;
  269.     for ( ch = 0; ch < stereo; ch++ )
  270.     {
  271.         BF_PartHolder **pph = &scaleFactorsPH[gr][ch];        
  272.         gr_info *gi = &(si->gr[gr].ch[ch].tt);
  273.         int *ix = &l3_enc[gr][ch][0];
  274.         int sfb_partition;
  275.  
  276.         assert( gi->sfb_partition_table );
  277.  
  278.         if ( (gi->window_switching_flag == 1) && (gi->block_type == 2) )
  279.         {
  280. #ifdef ALLOW_MIXED
  281.         if ( gi->mixed_block_flag )
  282.         {
  283.             sfb_partition = 0;
  284.             for ( sfb = 0; sfb < 8; sfb++ )
  285.             *pph = BF_addEntry( *pph,  scalefac->l[gr][ch][sfb], gi->slen[sfb_partition] );
  286.  
  287.             for ( sfb = 3, sfb_partition = 1; 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.         else
  297. #endif
  298.         {
  299.             for ( sfb = 0, sfb_partition = 0; sfb_partition < 4; sfb_partition++ )
  300.             {
  301.             int sfbs = gi->sfb_partition_table[ sfb_partition ] / 3;
  302.             int slen = gi->slen[ sfb_partition ];
  303.             for ( i = 0; i < sfbs; i++, sfb++ )
  304.                 for ( window = 0; window < 3; window++ )
  305.                 *pph = BF_addEntry( *pph,  scalefac->s[gr][ch][sfb][window], slen );
  306.             }
  307.         }
  308.         }
  309.         else
  310.         {
  311.         for ( sfb = 0, sfb_partition = 0; sfb_partition < 4; sfb_partition++ )
  312.         {
  313.             int sfbs = gi->sfb_partition_table[ sfb_partition ];
  314.             int slen = gi->slen[ sfb_partition ];
  315.             for ( i = 0; i < sfbs; i++, sfb++ )
  316.             *pph = BF_addEntry( *pph,  scalefac->l[gr][ch][sfb], slen );
  317.         }
  318.         }
  319.         Huffmancodebits( &codedDataPH[gr][ch], ix, gi );
  320.     } /* for ch */
  321.     }
  322. } /* main_data */
  323.  
  324. static unsigned int crc = 0;
  325.  
  326. static int encodeSideInfo( III_side_info_t  *si )
  327. {
  328.     int gr, ch, scfsi_band, region, window, bits_sent, mode_gr;
  329.     layer *info = fr_ps->header;
  330.     
  331.     mode_gr =  (info->version == 1) ? 2 : 1;
  332.  
  333.     headerPH->part->nrEntries = 0;
  334.     headerPH = BF_addEntry( headerPH, 0xfff,                    12 );
  335.     headerPH = BF_addEntry( headerPH, info->version,            1 );
  336.     headerPH = BF_addEntry( headerPH, 4 - info->lay,            2 );
  337.     headerPH = BF_addEntry( headerPH, !info->error_protection,  1 );
  338.     headerPH = BF_addEntry( headerPH, info->bitrate_index,      4 );
  339.     headerPH = BF_addEntry( headerPH, info->sampling_frequency, 2 );
  340.     headerPH = BF_addEntry( headerPH, info->padding,            1 );
  341.     headerPH = BF_addEntry( headerPH, info->extension,          1 );
  342.     headerPH = BF_addEntry( headerPH, info->mode,               2 );
  343.     headerPH = BF_addEntry( headerPH, info->mode_ext,           2 );
  344.     headerPH = BF_addEntry( headerPH, info->copyright,          1 );
  345.     headerPH = BF_addEntry( headerPH, info->original,           1 );
  346.     headerPH = BF_addEntry( headerPH, info->emphasis,           2 );
  347.     
  348.     bits_sent = 32;
  349.  
  350.     if ( fr_ps->header->error_protection )
  351.     {
  352.     headerPH = BF_addEntry( headerPH, crc, 16 );
  353.     bits_sent += 16;
  354.     }
  355.  
  356.     frameSIPH->part->nrEntries = 0;
  357.  
  358.     for (ch = 0; ch < stereo; ch++ )
  359.     channelSIPH[ch]->part->nrEntries = 0;
  360.  
  361.     for ( gr = 0; gr < mode_gr; gr++ )
  362.     for ( ch = 0; ch < stereo; ch++ )
  363.         spectrumSIPH[gr][ch]->part->nrEntries = 0;
  364.  
  365.     if ( info->version == 1 )
  366.     {  /* MPEG1 */
  367.     frameSIPH = BF_addEntry( frameSIPH, si->main_data_begin, 9 );
  368.  
  369.     if ( stereo == 2 )
  370.         frameSIPH = BF_addEntry( frameSIPH, si->private_bits, 3 );
  371.     else
  372.         frameSIPH = BF_addEntry( frameSIPH, si->private_bits, 5 );
  373.     
  374.     for ( ch = 0; ch < stereo; ch++ )
  375.         for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
  376.         {
  377.         BF_PartHolder **pph = &channelSIPH[ch];
  378.         *pph = BF_addEntry( *pph, si->scfsi[ch][scfsi_band], 1 );
  379.         }
  380.  
  381.     for ( gr = 0; gr < 2; gr++ )
  382.         for ( ch = 0; ch < stereo; ch++ )
  383.         {
  384.         BF_PartHolder **pph = &spectrumSIPH[gr][ch];
  385.         gr_info *gi = &(si->gr[gr].ch[ch].tt);
  386.         *pph = BF_addEntry( *pph, gi->part2_3_length,        12 );
  387.         *pph = BF_addEntry( *pph, gi->big_values,            9 );
  388.         *pph = BF_addEntry( *pph, gi->global_gain,           8 );
  389.         *pph = BF_addEntry( *pph, gi->scalefac_compress,     4 );
  390.         *pph = BF_addEntry( *pph, gi->window_switching_flag, 1 );
  391.  
  392.         if ( gi->window_switching_flag )
  393.         {   
  394.             *pph = BF_addEntry( *pph, gi->block_type,       2 );
  395.             *pph = BF_addEntry( *pph, gi->mixed_block_flag, 1 );
  396.  
  397.             for ( region = 0; region < 2; region++ )
  398.             *pph = BF_addEntry( *pph, gi->table_select[region],  5 );
  399.             for ( window = 0; window < 3; window++ )
  400.             *pph = BF_addEntry( *pph, gi->subblock_gain[window], 3 );
  401.         }
  402.         else
  403.         {
  404.             assert( gi->block_type == 0 );
  405.             for ( region = 0; region < 3; region++ )
  406.             *pph = BF_addEntry( *pph, gi->table_select[region], 5 );
  407.  
  408.             *pph = BF_addEntry( *pph, gi->region0_count, 4 );
  409.             *pph = BF_addEntry( *pph, gi->region1_count, 3 );
  410.         }
  411.  
  412.         *pph = BF_addEntry( *pph, gi->preflag,            1 );
  413.         *pph = BF_addEntry( *pph, gi->scalefac_scale,     1 );
  414.         *pph = BF_addEntry( *pph, gi->count1table_select, 1 );
  415.         }
  416.  
  417.     if ( stereo == 2 )
  418.         bits_sent += 256;
  419.     else
  420.         bits_sent += 136;
  421.     }
  422.     else
  423.     {  /* MPEG2 */
  424.     frameSIPH = BF_addEntry( frameSIPH, si->main_data_begin, 8 );
  425.  
  426.     if ( stereo == 2 )
  427.         frameSIPH = BF_addEntry( frameSIPH, si->private_bits, 2 );
  428.     else
  429.         frameSIPH = BF_addEntry( frameSIPH, si->private_bits, 1 );
  430.     
  431.     gr = 0;
  432.     for ( ch = 0; ch < stereo; ch++ )
  433.     {
  434.         BF_PartHolder **pph = &spectrumSIPH[gr][ch];
  435.         gr_info *gi = &(si->gr[gr].ch[ch].tt);
  436.         *pph = BF_addEntry( *pph, gi->part2_3_length,        12 );
  437.         *pph = BF_addEntry( *pph, gi->big_values,            9 );
  438.         *pph = BF_addEntry( *pph, gi->global_gain,           8 );
  439.         *pph = BF_addEntry( *pph, gi->scalefac_compress,     9 );
  440.         *pph = BF_addEntry( *pph, gi->window_switching_flag, 1 );
  441.  
  442.         if ( gi->window_switching_flag )
  443.         {   
  444.         *pph = BF_addEntry( *pph, gi->block_type,       2 );
  445.         *pph = BF_addEntry( *pph, gi->mixed_block_flag, 1 );
  446.  
  447.         for ( region = 0; region < 2; region++ )
  448.             *pph = BF_addEntry( *pph, gi->table_select[region],  5 );
  449.         for ( window = 0; window < 3; window++ )
  450.             *pph = BF_addEntry( *pph, gi->subblock_gain[window], 3 );
  451.         }
  452.         else
  453.         {
  454.         for ( region = 0; region < 3; region++ )
  455.             *pph = BF_addEntry( *pph, gi->table_select[region], 5 );
  456.  
  457.         *pph = BF_addEntry( *pph, gi->region0_count, 4 );
  458.         *pph = BF_addEntry( *pph, gi->region1_count, 3 );
  459.         }
  460.  
  461.         *pph = BF_addEntry( *pph, gi->scalefac_scale,     1 );
  462.         *pph = BF_addEntry( *pph, gi->count1table_select, 1 );
  463.     }
  464.     if ( stereo == 2 )
  465.         bits_sent += 136;
  466.     else
  467.         bits_sent += 72;
  468.     }
  469.     return bits_sent;
  470. }
  471.  
  472. static void
  473. write_ancillary_data( char *theData, int lengthInBits )
  474. {
  475.     /*
  476.      */
  477.     int bytesToSend = lengthInBits / 8;
  478.     int remainingBits = lengthInBits % 8;
  479.     unsigned wrd;
  480.     int i;
  481.  
  482.     userFrameDataPH->part->nrEntries = 0;
  483.  
  484.     for ( i = 0; i < bytesToSend; i++ )
  485.     {
  486.     wrd = theData[i];
  487.     userFrameDataPH = BF_addEntry( userFrameDataPH, wrd, 8 );
  488.     }
  489.     if ( remainingBits )
  490.     {
  491.     /* right-justify remaining bits */
  492.     wrd = theData[bytesToSend] >> (8 - remainingBits);
  493.     userFrameDataPH = BF_addEntry( userFrameDataPH, wrd, remainingBits );
  494.     }
  495.     
  496. }
  497.  
  498. /*
  499.   Some combinations of bitrate, Fs, and stereo make it impossible to stuff
  500.   out a frame using just main_data, due to the limited number of bits to
  501.   indicate main_data_length. In these situations, we put stuffing bits into
  502.   the ancillary data...
  503. */
  504. static void
  505. drain_into_ancillary_data( int lengthInBits )
  506. {
  507.     /*
  508.      */
  509.     int wordsToSend   = lengthInBits / 32;
  510.     int remainingBits = lengthInBits % 32;
  511.     int i;
  512.  
  513.     /*
  514.       userFrameDataPH->part->nrEntries set by call to write_ancillary_data()
  515.     */
  516.  
  517.     for ( i = 0; i < wordsToSend; i++ )
  518.     userFrameDataPH = BF_addEntry( userFrameDataPH, 0, 32 );
  519.     if ( remainingBits )
  520.     userFrameDataPH = BF_addEntry( userFrameDataPH, 0, remainingBits );    
  521. }
  522.  
  523. /*
  524.   Note the discussion of huffmancodebits() on pages 28
  525.   and 29 of the IS, as well as the definitions of the side
  526.   information on pages 26 and 27.
  527.   */
  528. static void
  529. Huffmancodebits( BF_PartHolder **pph, int *ix, gr_info *gi )
  530. {
  531.     int L3_huffman_coder_count1( BF_PartHolder **pph, struct huffcodetab *h, int v, int w, int x, int y );
  532.     int bigv_bitcount( int ix[576], gr_info *cod_info );
  533.  
  534.     int region1Start;
  535.     int region2Start;
  536.     int i, bigvalues, count1End;
  537.     int v, w, x, y, bits, cbits, xbits, stuffingBits;
  538.     unsigned int code, ext;
  539.     struct huffcodetab *h;
  540.     int bvbits, c1bits, tablezeros, r0, r1, r2, rt, *pr;
  541.     int bitsWritten = 0;
  542.     tablezeros = 0;
  543.     r0 = r1 = r2 = 0;
  544.     
  545.     /* 1: Write the bigvalues */
  546.     bigvalues = gi->big_values * 2;
  547.     if ( bigvalues )
  548.     {
  549.     if ( !(gi->mixed_block_flag) && gi->window_switching_flag && (gi->block_type == 2) )
  550.     { /* Three short blocks */
  551.         /*
  552.           Within each scalefactor band, data is given for successive
  553.           time windows, beginning with window 0 and ending with window 2.
  554.           Within each window, the quantized values are then arranged in
  555.           order of increasing frequency...
  556.           */
  557.         int sfb, window, line, start, end;
  558.  
  559.         I192_3 *ix_s;
  560.         int *scalefac = &sfBandIndex[fr_ps->header->sampling_frequency + (fr_ps->header->version * 3)].s[0];
  561.         
  562.         ix_s = (I192_3 *) ix;
  563.         region1Start = 12;
  564.         region2Start = 576;
  565.  
  566.         for ( sfb = 0; sfb < 13; sfb++ )
  567.         {
  568.         unsigned tableindex = 100;
  569.         start = scalefac[ sfb ];
  570.         end   = scalefac[ sfb+1 ];
  571.  
  572.         if ( start < region1Start )
  573.             tableindex = gi->table_select[ 0 ];
  574.         else
  575.             tableindex = gi->table_select[ 1 ];
  576.         assert( tableindex < 32 );
  577.  
  578.         for ( window = 0; window < 3; window++ )
  579.             for ( line = start; line < end; line += 2 )
  580.             {
  581.             x = (*ix_s)[line][window];
  582.             y = (*ix_s)[line + 1][window];
  583.             bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  584.             *pph = BF_addEntry( *pph,  code, cbits );
  585.             *pph = BF_addEntry( *pph,  ext, xbits );
  586.             bitsWritten += bits;
  587.             }
  588.         
  589.         }
  590.     }
  591.     else
  592. #ifdef ALLOW_MIXED
  593.         if ( gi->mixed_block_flag && gi->block_type == 2 )
  594.         {  /* Mixed blocks long, short */
  595.         int sfb, window, line, start, end;
  596.         unsigned tableindex;
  597.         I192_3 *ix_s;
  598.         int *scalefac = &sfBandIndex[fr_ps->header->sampling_frequency + (fr_ps->header->version * 3)].s[0];
  599.         
  600.         ix_s = (I192_3 *) ix;
  601.  
  602.         /* Write the long block region */
  603.         tableindex = gi->table_select[0];
  604.         if ( tableindex )
  605.             for ( i = 0; i < 36; i += 2 )
  606.             {
  607.             x = ix[i];
  608.             y = ix[i + 1];
  609.             bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  610.             *pph = BF_addEntry( *pph,  code, cbits );
  611.             *pph = BF_addEntry( *pph,  ext, xbits );
  612.             bitsWritten += bits;
  613.             
  614.             }
  615.         /* Write the short block region */
  616.         tableindex = gi->table_select[ 1 ];
  617.         assert( tableindex < 32 );
  618.  
  619.         for ( sfb = 3; sfb < 13; sfb++ )
  620.         {
  621.             start = scalefac[ sfb ];
  622.             end   = scalefac[ sfb+1 ];           
  623.             
  624.             for ( window = 0; window < 3; window++ )
  625.             for ( line = start; line < end; line += 2 )
  626.             {
  627.                 x = (*ix_s)[line][window];
  628.                 y = (*ix_s)[line + 1][window];
  629.                 bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  630.                 *pph = BF_addEntry( *pph,  code, cbits );
  631.                 *pph = BF_addEntry( *pph,  ext, xbits );
  632.                 bitsWritten += bits;
  633.             }
  634.         }
  635.  
  636.         }
  637.         else
  638. #endif
  639.         { /* Long blocks */
  640.         int *scalefac = &sfBandIndex[fr_ps->header->sampling_frequency + (fr_ps->header->version * 3)].l[0];
  641.         unsigned scalefac_index = 100;
  642.         
  643.         if ( gi->mixed_block_flag )
  644.         {
  645.             region1Start = 36;
  646.             region2Start = 576;
  647.         }
  648.         else
  649.         {
  650.             scalefac_index = gi->region0_count + 1;
  651.             assert( scalefac_index < 23 );
  652.             region1Start = scalefac[ scalefac_index ];
  653.             scalefac_index += gi->region1_count + 1;
  654.             assert( scalefac_index < 23 );    
  655.             region2Start = scalefac[ scalefac_index ];
  656.             assert( region1Start == gi->address1 );
  657.         }
  658.         for ( i = 0; i < bigvalues; i += 2 )
  659.         {
  660.             unsigned tableindex = 100;
  661.             /* get table pointer */
  662.             if ( i < region1Start )
  663.             {
  664.             tableindex = gi->table_select[0];
  665.             pr = &r0;
  666.             }
  667.             else
  668.             if ( i < region2Start )
  669.             {
  670.                 tableindex = gi->table_select[1];
  671.                 pr = &r1;
  672.             }
  673.             else
  674.             {
  675.                 tableindex = gi->table_select[2];
  676.                 pr = &r2;
  677.             }
  678.             assert( tableindex < 32 );
  679.             h = &ht[ tableindex ];
  680.             /* get huffman code */
  681.             x = ix[i];
  682.             y = ix[i + 1];
  683.             if ( tableindex )
  684.             {
  685.             bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  686.             *pph = BF_addEntry( *pph,  code, cbits );
  687.             *pph = BF_addEntry( *pph,  ext, xbits );
  688.             bitsWritten += rt = bits;
  689.             *pr += rt;
  690.             }
  691.             else
  692.             {
  693.             tablezeros += 1;
  694.             *pr = 0;
  695.             }
  696.         }
  697.         }
  698.     }
  699.     bvbits = bitsWritten; 
  700.  
  701.     /* 2: Write count1 area */
  702.     assert( (gi->count1table_select < 2) );
  703.     h = &ht[gi->count1table_select + 32];
  704.     count1End = bigvalues + (gi->count1 * 4);
  705.     assert( count1End <= 576 );
  706.     for ( i = bigvalues; i < count1End; i += 4 )
  707.     {
  708.     v = ix[i];
  709.     w = ix[i+1];
  710.     x = ix[i+2];
  711.     y = ix[i+3];
  712.     bitsWritten += L3_huffman_coder_count1( pph, h, v, w, x, y );
  713.     }
  714.     c1bits = bitsWritten - bvbits;
  715.     if ( (stuffingBits = gi->part2_3_length - gi->part2_length - bitsWritten) )
  716.     {
  717.     int stuffingWords = stuffingBits / 32;
  718.     int remainingBits = stuffingBits % 32;
  719.     assert( stuffingBits > 0 );
  720.  
  721.     /*
  722.       Due to the nature of the Huffman code
  723.       tables, we will pad with ones
  724.     */
  725.     while ( stuffingWords-- )
  726.         *pph = BF_addEntry( *pph, ~0, 32 );
  727.     if ( remainingBits )
  728.         *pph = BF_addEntry( *pph, ~0, remainingBits );
  729.     bitsWritten += stuffingBits;
  730.     }
  731.     assert( bitsWritten == gi->part2_3_length - gi->part2_length );
  732. #ifdef DEBUG
  733.     printf( "#### %d Huffman bits written (%02d + %02d), part2_length = %d, part2_3_length = %d, %d stuffing ####\n",
  734.         bitsWritten, bvbits, c1bits, gi->part2_length, gi->part2_3_length, stuffingBits );
  735. #endif
  736. }
  737.  
  738. int
  739. abs_and_sign( int *x )
  740. {
  741.     if ( *x > 0 )
  742.     return 0;
  743.     *x *= -1;
  744.     return 1;
  745. }
  746.  
  747. int
  748. L3_huffman_coder_count1( BF_PartHolder **pph, struct huffcodetab *h, int v, int w, int x, int y )
  749. {
  750.     HUFFBITS huffbits;
  751.     unsigned int signv, signw, signx, signy, p;
  752.     int len;
  753.     int totalBits = 0;
  754.     
  755.     signv = abs_and_sign( &v );
  756.     signw = abs_and_sign( &w );
  757.     signx = abs_and_sign( &x );
  758.     signy = abs_and_sign( &y );
  759.     
  760.     p = v + (w << 1) + (x << 2) + (y << 3);
  761.     huffbits = h->table[p];
  762.     len = h->hlen[ p ];
  763.     *pph = BF_addEntry( *pph,  huffbits, len );
  764.     totalBits += len;
  765.     if ( v )
  766.     {
  767.     *pph = BF_addEntry( *pph,  signv, 1 );
  768.     totalBits += 1;
  769.     }
  770.     if ( w )
  771.     {
  772.     *pph = BF_addEntry( *pph,  signw, 1 );
  773.     totalBits += 1;
  774.     }
  775.  
  776.     if ( x )
  777.     {
  778.     *pph = BF_addEntry( *pph,  signx, 1 );
  779.     totalBits += 1;
  780.     }
  781.     if ( y )
  782.     {
  783.     *pph = BF_addEntry( *pph,  signy, 1 );
  784.     totalBits += 1;
  785.     }
  786.     return totalBits;
  787. }
  788.  
  789. /*
  790.   Implements the pseudocode of page 98 of the IS
  791.   */
  792. int
  793. HuffmanCode( int table_select, int x, int y, unsigned int *code, unsigned int *ext, int *cbits, int *xbits )
  794. {
  795.     unsigned signx, signy, linbitsx, linbitsy, linbits, xlen, ylen, idx;
  796.     struct huffcodetab *h;
  797.  
  798.     *cbits = 0;
  799.     *xbits = 0;
  800.     *code  = 0;
  801.     *ext   = 0;
  802.     
  803.     if ( table_select == 0 )
  804.     return 0;
  805.     
  806.     signx = abs_and_sign( &x );
  807.     signy = abs_and_sign( &y );
  808.     h = &(ht[table_select]);
  809.     xlen = h->xlen;
  810.     ylen = h->ylen;
  811.     linbits = h->linbits;
  812.     linbitsx = linbitsy = 0;
  813.  
  814.     if ( table_select > 15 )
  815.     { /* ESC-table is used */
  816.     if ( x > 14 )
  817.     {
  818.         linbitsx = x - 15;
  819.         assert( linbitsx <= h->linmax );
  820.         x = 15;
  821.     }
  822.     if ( y > 14 )
  823.     {
  824.         linbitsy = y - 15;
  825.         assert( linbitsy <= h->linmax );
  826.         y = 15;
  827.     }
  828.     idx = (x * ylen) + y;
  829.     *code = h->table[idx];
  830.     *cbits = h->hlen[ idx ];
  831.     if ( x > 14 )
  832.     {
  833.         *ext |= linbitsx;
  834.         *xbits += linbits;
  835.     }
  836.     if ( x != 0 )
  837.     {
  838.         *ext <<= 1;
  839.         *ext |= signx;
  840.         *xbits += 1;
  841.     }
  842.     if ( y > 14 )
  843.     {
  844.         *ext <<= linbits;
  845.         *ext |= linbitsy;
  846.         *xbits += linbits;
  847.     }
  848.     if ( y != 0 )
  849.     {
  850.         *ext <<= 1;
  851.         *ext |= signy;
  852.         *xbits += 1;
  853.     }
  854.     }
  855.     else
  856.     { /* No ESC-words */
  857.     idx = (x * ylen) + y;
  858.     *code = h->table[idx];
  859.     *cbits += h->hlen[ idx ];
  860.     if ( x != 0 )
  861.     {
  862.         *code <<= 1;
  863.         *code |= signx;
  864.         *cbits += 1;
  865.     }
  866.     if ( y != 0 )
  867.     {
  868.         *code <<= 1;
  869.         *code |= signy;
  870.         *cbits += 1;
  871.     }
  872.     }
  873.     assert( *cbits <= 32 );
  874.     assert( *xbits <= 32 );
  875.     return *cbits + *xbits;
  876. }
  877.