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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
l3bitstream.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：24k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual 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.  **********************************************************************/
  6. /*
  7.   Revision History:
  9.   Date        Programmer                Comment
  10.   ==========  ========================= ===============================
  11.   1995/08/06  mc@fivebats.com           created
  12.   1995/09/06  mc@fivebats.com           modified to use formatBitstream
  13. */
  15. #include <stdlib.h>
  16. #include "lame.h"
  17. #include "l3bitstream.h" /* the public interface */
  18. #include "encoder.h"
  19. #include "quantize.h"
  20. #include "quantize-pvt.h"
  21. #include "formatBitstream.h"
  22. #include "tables.h"
  23. #include <assert.h>
  24. #include "l3bitstream-pvt.h"
  26. static Bit_stream_struc *bs = NULL;
  28. BF_FrameData    *frameData    = NULL;
  29. BF_FrameResults *frameResults = NULL;
  31. int PartHoldersInitialized = 0;
  33. BF_PartHolder *headerPH;
  34. BF_PartHolder *frameSIPH;
  35. BF_PartHolder *channelSIPH[ MAX_CHANNELS ];
  36. BF_PartHolder *spectrumSIPH[ MAX_GRANULES ][ MAX_CHANNELS ];
  37. BF_PartHolder *scaleFactorsPH[ MAX_GRANULES ][ MAX_CHANNELS ];
  38. BF_PartHolder *codedDataPH[ MAX_GRANULES ][ MAX_CHANNELS ];
  39. BF_PartHolder *userSpectrumPH[ MAX_GRANULES ][ MAX_CHANNELS ];
  40. BF_PartHolder *userFrameDataPH;
  43. void putMyBits( u_int val, u_int len )
  44. {
  45.     putbits( bs, val, len );
  46. }
  48. /*
  49.   III_format_bitstream()
  50.   
  51.   This is called after a frame of audio has been quantized and coded.
  52.   It will write the encoded audio to the bitstream. Note that
  53.   from a layer3 encoder's perspective the bit stream is primarily
  54.   a series of main_data() blocks, with header and side information
  55.   inserted at the proper locations to maintain framing. (See Figure A.7
  56.   in the IS).
  57.   */
  59. void
  60. III_format_bitstream( lame_global_flags *gfp,
  61.                       int              bitsPerFrame,
  62.       int              l3_enc[2][2][576],
  63.       III_side_info_t  *l3_side,
  64.       III_scalefac_t   scalefac[2][2],
  65.       Bit_stream_struc *in_bs)
  66. {
  67.     int gr, ch;
  68.     bs = in_bs;
  70.     if ( frameData == NULL )
  71.     {
  72. frameData = calloc( 1,sizeof *frameData);
  73. assert( frameData );
  74.     }
  75.     if ( frameResults == NULL )
  76.     {
  77. frameResults = calloc( 1,sizeof *frameResults);
  78. assert( frameResults );
  79.     }
  81.     if ( !PartHoldersInitialized )
  82.     {
  83. headerPH = BF_newPartHolder( 14 ); 
  84. frameSIPH = BF_newPartHolder( 12 );
  86. for ( ch = 0; ch < MAX_CHANNELS; ch++ )
  87.     channelSIPH[ch] = BF_newPartHolder( 8 );
  89. for ( gr = 0; gr < MAX_GRANULES; gr++ )
  90.     for ( ch = 0; ch < MAX_CHANNELS; ch++ )
  91.     {
  92. spectrumSIPH[gr][ch]   = BF_newPartHolder( 32 );
  93. scaleFactorsPH[gr][ch] = BF_newPartHolder( 64 );
  94. codedDataPH[gr][ch]    = BF_newPartHolder( 576 );
  95. userSpectrumPH[gr][ch] = BF_newPartHolder( 4 );
  96.     }
  97. userFrameDataPH = BF_newPartHolder( 8 );
  98. PartHoldersInitialized = 1;
  99.     }
  101.     encodeSideInfo( gfp,l3_side );
  102.     encodeMainData( gfp,l3_enc, l3_side, scalefac );
  106.     drain_into_ancillary_data( l3_side->resvDrain );
  107.     /*
  108.       Put frameData together for the call
  109.       to BitstreamFrame()
  110.     */
  111.     frameData->frameLength = bitsPerFrame;
  112.     frameData->nGranules   = gfp->mode_gr;
  113.     frameData->nChannels   = gfp->stereo;
  114.     frameData->header      = headerPH->part;
  115.     frameData->frameSI     = frameSIPH->part;
  117.     for ( ch = 0; ch < gfp->stereo; ch++ )
  118. frameData->channelSI[ch] = channelSIPH[ch]->part;
  120.     for ( gr = 0; gr < gfp->mode_gr; gr++ )
  121. for ( ch = 0; ch < gfp->stereo; ch++ )
  122. {
  123.     frameData->spectrumSI[gr][ch]   = spectrumSIPH[gr][ch]->part;
  124.     frameData->scaleFactors[gr][ch] = scaleFactorsPH[gr][ch]->part;
  125.     frameData->codedData[gr][ch]    = codedDataPH[gr][ch]->part;
  126.     frameData->userSpectrum[gr][ch] = userSpectrumPH[gr][ch]->part;
  127. }
  128.     frameData->userFrameData = userFrameDataPH->part;
  130.     BF_BitstreamFrame( frameData, frameResults );
  132.     /* we set this here -- it will be tested in the next loops iteration */
  133.     l3_side->main_data_begin = frameResults->nextBackPtr;
  135. }
  137. void
  138. III_FlushBitstream(void)
  139. {
  140.     if (PartHoldersInitialized!=0)
  141. BF_FlushBitstream( frameData, frameResults );
  142. }
  144. static unsigned slen1_tab[16] = { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 };
  145. static unsigned slen2_tab[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 };
  147. static void
  148. encodeMainData( lame_global_flags *gfp,
  149. int              l3_enc[2][2][576],
  150. III_side_info_t  *si,
  151. III_scalefac_t   scalefac[2][2] )
  152. {
  153.     int i, gr, ch, sfb, window;
  156.     for ( gr = 0; gr < gfp->mode_gr; gr++ )
  157. for ( ch = 0; ch < gfp->stereo; ch++ )
  158.     scaleFactorsPH[gr][ch]->part->nrEntries = 0;
  160.     for ( gr = 0; gr < gfp->mode_gr; gr++ )
  161. for ( ch = 0; ch < gfp->stereo; ch++ )
  162.     codedDataPH[gr][ch]->part->nrEntries = 0;
  164.     if ( gfp->version == 1 )
  165.     {  /* MPEG 1 */
  166. for ( gr = 0; gr < 2; gr++ )
  167. {
  168.     for ( ch = 0; ch < gfp->stereo; ch++ )
  169.     {
  170. BF_PartHolder **pph = &scaleFactorsPH[gr][ch];
  171. gr_info *gi = &(si->gr[gr].ch[ch].tt);
  172. unsigned slen1 = slen1_tab[ gi->scalefac_compress ];
  173. unsigned slen2 = slen2_tab[ gi->scalefac_compress ];
  174. int *ix = &l3_enc[gr][ch][0];
  176. if (gi->block_type == SHORT_TYPE)
  177. {
  178. #ifdef ALLOW_MIXED
  179.     if ( gi->mixed_block_flag )
  180.     {
  181. for ( sfb = 0; sfb < 8; sfb++ )
  182.     *pph = BF_addEntry( *pph,  scalefac[gr][ch].l[sfb], slen1 );
  184. for ( sfb = 3; sfb < 6; sfb++ )
  185.     for ( window = 0; window < 3; window++ )
  186. *pph = BF_addEntry( *pph,  scalefac[gr][ch].s[sfb][window], slen1 );
  188. for ( sfb = 6; sfb < 12; sfb++ )
  189.     for ( window = 0; window < 3; window++ )
  190. *pph = BF_addEntry( *pph,  scalefac[gr][ch].s[sfb][window], slen2 );
  192.     }
  193.     else
  194. #endif
  195.     {
  196. for ( sfb = 0; sfb < 6; sfb++ )
  197.     for ( window = 0; window < 3; window++ )
  198. *pph = BF_addEntry( *pph,  scalefac[gr][ch].s[sfb][window], slen1 );
  200. for ( sfb = 6; sfb < 12; sfb++ )
  201.     for ( window = 0; window < 3; window++ )
  202. *pph = BF_addEntry( *pph,  scalefac[gr][ch].s[sfb][window], slen2 );
  203.     }
  204. }
  205. else
  206. {
  207.     if ( (gr == 0) || (si->scfsi[ch][0] == 0) )
  208. for ( sfb = 0; sfb < 6; sfb++ )
  209.     *pph = BF_addEntry( *pph,  scalefac[gr][ch].l[sfb], slen1 );
  211.     if ( (gr == 0) || (si->scfsi[ch][1] == 0) )
  212. for ( sfb = 6; sfb < 11; sfb++ )
  213.     *pph = BF_addEntry( *pph,  scalefac[gr][ch].l[sfb], slen1 );
  215.     if ( (gr == 0) || (si->scfsi[ch][2] == 0) )
  216. for ( sfb = 11; sfb < 16; sfb++ )
  217.     *pph = BF_addEntry( *pph,  scalefac[gr][ch].l[sfb], slen2 );
  219.     if ( (gr == 0) || (si->scfsi[ch][3] == 0) )
  220. for ( sfb = 16; sfb < 21; sfb++ )
  221.     *pph = BF_addEntry( *pph,  scalefac[gr][ch].l[sfb], slen2 );
  222. }
  223. Huffmancodebits( &codedDataPH[gr][ch], ix, gi );
  224.     } /* for ch */
  225. } /* for gr */
  226.     }
  227.     else
  228.     {  /* MPEG 2 */
  229. gr = 0;
  230. for ( ch = 0; ch < gfp->stereo; ch++ )
  231. {
  232.     BF_PartHolder **pph = &scaleFactorsPH[gr][ch];
  233.     gr_info *gi = &(si->gr[gr].ch[ch].tt);
  234.     int *ix = &l3_enc[gr][ch][0];
  235.     int sfb_partition;
  236.     assert( gi->sfb_partition_table );
  238.     if (gi->block_type == SHORT_TYPE)
  239.     {
  240. #ifdef ALLOW_MIXED
  241. if ( gi->mixed_block_flag )
  242. {
  243.     sfb_partition = 0;
  244.     for ( sfb = 0; sfb < 8; sfb++ )
  245. *pph = BF_addEntry( *pph,  scalefac[gr][ch].l[sfb], gi->slen[sfb_partition] );
  247.     for ( sfb = 3, sfb_partition = 1; sfb_partition < 4; sfb_partition++ )
  248.     {
  249. int sfbs = gi->sfb_partition_table[ sfb_partition ] / 3;
  250. int slen = gi->slen[ sfb_partition ];
  251. for ( i = 0; i < sfbs; i++, sfb++ )
  252.     for ( window = 0; window < 3; window++ )
  253. *pph = BF_addEntry( *pph,  scalefac[gr][ch].s[sfb][window], slen );
  254.     }
  255. }
  256. else
  257. #endif
  258. {
  259.     for ( sfb = 0, sfb_partition = 0; sfb_partition < 4; sfb_partition++ )
  260.     {
  261. int sfbs = gi->sfb_partition_table[ sfb_partition ] / 3;
  262. int slen = gi->slen[ sfb_partition ];
  263. for ( i = 0; i < sfbs; i++, sfb++ )
  264.     for ( window = 0; window < 3; window++ )
  265. *pph = BF_addEntry( *pph,  scalefac[gr][ch].s[sfb][window], slen );
  266.     }
  267. }
  268.     }
  269.     else
  270.     {
  271. for ( sfb = 0, sfb_partition = 0; sfb_partition < 4; sfb_partition++ )
  272. {
  273.     int sfbs = gi->sfb_partition_table[ sfb_partition ];
  274.     int slen = gi->slen[ sfb_partition ];
  275.     for ( i = 0; i < sfbs; i++, sfb++ )
  276. *pph = BF_addEntry( *pph,  scalefac[gr][ch].l[sfb], slen );
  277. }
  278.     }
  282.     Huffmancodebits( &codedDataPH[gr][ch], ix, gi );
  283. } /* for ch */
  284.     }
  285. } /* main_data */
  287. static unsigned int crc = 0; /* (jo) current crc */
  289. /* (jo) this wrapper function for BF_addEntry() updates also the crc */
  290. static BF_PartHolder *CRC_BF_addEntry( BF_PartHolder *thePH, u_int value, u_int length )
  291. {
  292.    u_int bit = 1 << length;
  293.    
  294.    while((bit >>= 1)){
  295.       crc <<= 1;
  296.       if (!(crc & 0x10000) ^ !(value & bit))
  297. crc ^= CRC16_POLYNOMIAL;
  298.    }
  299.    crc &= 0xffff;   
  300.    return BF_addEntry(thePH, value, length);
  301. }
  306. static int encodeSideInfo( lame_global_flags *gfp,III_side_info_t  *si )
  307. {
  308.     int gr, ch, scfsi_band, region, window, bits_sent;
  309.     
  310.     crc = 0xffff; /* (jo) init crc16 for error_protection */
  312.     headerPH->part->nrEntries = 0;
  313.     headerPH = BF_addEntry( headerPH, 0xfff,                    12 );
  314.     headerPH = BF_addEntry( headerPH, gfp->version,            1 );
  315.     headerPH = BF_addEntry( headerPH, 1,                        2 );
  316.     headerPH = BF_addEntry( headerPH, !gfp->error_protection,     1 );
  317.     /* (jo) from now on call the CRC_BF_addEntry() wrapper to update crc */
  318.     headerPH = CRC_BF_addEntry( headerPH, gfp->bitrate_index,      4 );
  319.     headerPH = CRC_BF_addEntry( headerPH, gfp->samplerate_index,   2 );
  320.     headerPH = CRC_BF_addEntry( headerPH, gfp->padding,            1 );
  321.     headerPH = CRC_BF_addEntry( headerPH, gfp->extension,          1 );
  322.     headerPH = CRC_BF_addEntry( headerPH, gfp->mode,               2 );
  323.     headerPH = CRC_BF_addEntry( headerPH, gfp->mode_ext,           2 );
  324.     headerPH = CRC_BF_addEntry( headerPH, gfp->copyright,          1 );
  325.     headerPH = CRC_BF_addEntry( headerPH, gfp->original,           1 );
  326.     headerPH = CRC_BF_addEntry( headerPH, gfp->emphasis,           2 );
  327.     
  328.     bits_sent = 32;
  329.    
  330.     /* (jo) see below for BF_addEntry( headerPH, crc, 16 ); */
  332.     frameSIPH->part->nrEntries = 0;
  334.     for (ch = 0; ch < gfp->stereo; ch++ )
  335. channelSIPH[ch]->part->nrEntries = 0;
  337.     for ( gr = 0; gr < gfp->mode_gr; gr++ )
  338. for ( ch = 0; ch < gfp->stereo; ch++ )
  339.     spectrumSIPH[gr][ch]->part->nrEntries = 0;
  341.     if ( gfp->version == 1 )
  342.     {  /* MPEG1 */
  343. frameSIPH = CRC_BF_addEntry( frameSIPH, si->main_data_begin, 9 );
  345. if ( gfp->stereo == 2 )
  346.     frameSIPH = CRC_BF_addEntry( frameSIPH, si->private_bits, 3 );
  347. else
  348.     frameSIPH = CRC_BF_addEntry( frameSIPH, si->private_bits, 5 );
  350. for ( ch = 0; ch < gfp->stereo; ch++ )
  351.     for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
  352.     {
  353. BF_PartHolder **pph = &channelSIPH[ch];
  354. *pph = CRC_BF_addEntry( *pph, si->scfsi[ch][scfsi_band], 1 );
  355.     }
  357. for ( gr = 0; gr < 2; gr++ )
  358.     for ( ch = 0; ch < gfp->stereo; ch++ )
  359.     {
  360. BF_PartHolder **pph = &spectrumSIPH[gr][ch];
  361. gr_info *gi = &(si->gr[gr].ch[ch].tt);
  362. *pph = CRC_BF_addEntry( *pph, gi->part2_3_length,        12 );
  363. *pph = CRC_BF_addEntry( *pph, gi->big_values,            9 );
  364. *pph = CRC_BF_addEntry( *pph, gi->global_gain,           8 );
  365. *pph = CRC_BF_addEntry( *pph, gi->scalefac_compress,     4 );
  366. *pph = CRC_BF_addEntry( *pph, gi->window_switching_flag, 1 );
  368. if ( gi->window_switching_flag )
  369. {   
  370.     *pph = CRC_BF_addEntry( *pph, gi->block_type,       2 );
  371.     *pph = CRC_BF_addEntry( *pph, gi->mixed_block_flag, 1 );
  373.     for ( region = 0; region < 2; region++ )
  374. *pph = CRC_BF_addEntry( *pph, gi->table_select[region],  5 );
  375.     for ( window = 0; window < 3; window++ )
  376. *pph = CRC_BF_addEntry( *pph, gi->subblock_gain[window], 3 );
  377. }
  378. else
  379. {
  380.     assert( gi->block_type == NORM_TYPE );
  381.     for ( region = 0; region < 3; region++ )
  382. *pph = CRC_BF_addEntry( *pph, gi->table_select[region], 5 );
  384.     *pph = CRC_BF_addEntry( *pph, gi->region0_count, 4 );
  385.     *pph = CRC_BF_addEntry( *pph, gi->region1_count, 3 );
  386. }
  388. *pph = CRC_BF_addEntry( *pph, gi->preflag,            1 );
  389. *pph = CRC_BF_addEntry( *pph, gi->scalefac_scale,     1 );
  390. *pph = CRC_BF_addEntry( *pph, gi->count1table_select, 1 );
  391.     }
  393. if ( gfp->stereo == 2 )
  394.     bits_sent += 256;
  395. else
  396.     bits_sent += 136;
  397.     }
  398.     else
  399.     {  /* MPEG2 */
  400. frameSIPH = CRC_BF_addEntry( frameSIPH, si->main_data_begin, 8 );
  402. if ( gfp->stereo == 2 )
  403.     frameSIPH = CRC_BF_addEntry( frameSIPH, si->private_bits, 2 );
  404. else
  405.     frameSIPH = CRC_BF_addEntry( frameSIPH, si->private_bits, 1 );
  407. gr = 0;
  408. for ( ch = 0; ch < gfp->stereo; ch++ )
  409. {
  410.     BF_PartHolder **pph = &spectrumSIPH[gr][ch];
  411.     gr_info *gi = &(si->gr[gr].ch[ch].tt);
  412.     *pph = CRC_BF_addEntry( *pph, gi->part2_3_length,        12 );
  413.     *pph = CRC_BF_addEntry( *pph, gi->big_values,            9 );
  414.     *pph = CRC_BF_addEntry( *pph, gi->global_gain,           8 );
  415.     *pph = CRC_BF_addEntry( *pph, gi->scalefac_compress,     9 );
  416.     *pph = CRC_BF_addEntry( *pph, gi->window_switching_flag, 1 );
  418.     if ( gi->window_switching_flag )
  419.     {   
  420. *pph = CRC_BF_addEntry( *pph, gi->block_type,       2 );
  421. *pph = CRC_BF_addEntry( *pph, gi->mixed_block_flag, 1 );
  423. for ( region = 0; region < 2; region++ )
  424.     *pph = CRC_BF_addEntry( *pph, gi->table_select[region],  5 );
  425. for ( window = 0; window < 3; window++ )
  426.     *pph = CRC_BF_addEntry( *pph, gi->subblock_gain[window], 3 );
  427.     }
  428.     else
  429.     {
  430. for ( region = 0; region < 3; region++ )
  431.     *pph = CRC_BF_addEntry( *pph, gi->table_select[region], 5 );
  433. *pph = CRC_BF_addEntry( *pph, gi->region0_count, 4 );
  434. *pph = CRC_BF_addEntry( *pph, gi->region1_count, 3 );
  435.     }
  437.     *pph = CRC_BF_addEntry( *pph, gi->scalefac_scale,     1 );
  438.     *pph = CRC_BF_addEntry( *pph, gi->count1table_select, 1 );
  439. }
  440. if ( gfp->stereo == 2 )
  441.     bits_sent += 136;
  442. else
  443.     bits_sent += 72;
  444.     }
  446.     if ( gfp->error_protection )
  447.     {   /* (jo) error_protection: add crc16 information to header */
  448. headerPH = BF_addEntry( headerPH, crc, 16 );
  449. bits_sent += 16;
  450.     }
  452.     return bits_sent;
  453. }
  455. /*
  456.   Some combinations of bitrate, Fs, and stereo make it impossible to stuff
  457.   out a frame using just main_data, due to the limited number of bits to
  458.   indicate main_data_length. In these situations, we put stuffing bits into
  459.   the ancillary data...
  460. */
  461. static void
  462. drain_into_ancillary_data( int lengthInBits )
  463. {
  464.     /*
  465.      */
  466.     int wordsToSend   = lengthInBits / 32;
  467.     int remainingBits = lengthInBits % 32;
  468.     int i;
  470.     /*
  471.       userFrameDataPH->part->nrEntries set by call to write_ancillary_data()
  472.     */
  473.     
  474.     userFrameDataPH->part->nrEntries = 0;
  475.     for ( i = 0; i < wordsToSend; i++ )
  476. userFrameDataPH = BF_addEntry( userFrameDataPH, 0, 32 );
  477.     if ( remainingBits )
  478. userFrameDataPH = BF_addEntry( userFrameDataPH, 0, remainingBits );
  479. }
  481. /*
  482.   Note the discussion of huffmancodebits() on pages 28
  483.   and 29 of the IS, as well as the definitions of the side
  484.   information on pages 26 and 27.
  485.   */
  486. static void
  487. Huffmancodebits( BF_PartHolder **pph, int *ix, gr_info *gi )
  488. {
  489.     int L3_huffman_coder_count1( BF_PartHolder **pph, struct huffcodetab *h, int v, int w, int x, int y );
  491.     int region1Start;
  492.     int region2Start;
  493.     int i, bigvalues, count1End;
  494.     int v, w, x, y, bits, cbits, xbits, stuffingBits;
  495.     unsigned int code, ext;
  496. #ifdef DEBUG
  497.     int bvbits, c1bits;
  498. #endif
  499.     int bitsWritten = 0;
  501.     
  502.     /* 1: Write the bigvalues */
  503.     bigvalues = gi->big_values * 2;
  504.     if ( bigvalues )
  505.     {
  506. if ( !(gi->mixed_block_flag) && (gi->block_type == SHORT_TYPE) )
  507. { /* Three short blocks */
  508.     /*
  509.       Within each scalefactor band, data is given for successive
  510.       time windows, beginning with window 0 and ending with window 2.
  511.       Within each window, the quantized values are then arranged in
  512.       order of increasing frequency...
  513.       */
  514.     int sfb, window, line, start, end;
  516.     I192_3 *ix_s;
  517.     
  518.     ix_s = (I192_3 *) ix;
  519.     region1Start = 12;
  520.     region2Start = 576;
  522.     for ( sfb = 0; sfb < 13; sfb++ )
  523.     {
  524. unsigned tableindex = 100;
  525. start = scalefac_band.s[ sfb ];
  526. end   = scalefac_band.s[ sfb+1 ];
  528. if ( start < region1Start )
  529.     tableindex = gi->table_select[ 0 ];
  530. else
  531.     tableindex = gi->table_select[ 1 ];
  532. assert( tableindex < 32 );
  534. for ( window = 0; window < 3; window++ )
  535.     for ( line = start; line < end; line += 2 )
  536.     {
  537. x = (*ix_s)[line][window];
  538. y = (*ix_s)[line + 1][window];
  539. bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  540. *pph = BF_addEntry( *pph,  code, cbits );
  541. *pph = BF_addEntry( *pph,  ext, xbits );
  542. bitsWritten += bits;
  543.     }
  545.     }
  546. }
  547. else
  548. #ifdef ALLOW_MIXED
  549.     if ( gi->mixed_block_flag && gi->block_type == SHORT_TYPE )
  550.     {  /* Mixed blocks long, short */
  551. int sfb, window, line, start, end;
  552. unsigned tableindex;
  553. I192_3 *ix_s;
  555. ix_s = (I192_3 *) ix;
  557. /* Write the long block region */
  558. tableindex = gi->table_select[0];
  559. if ( tableindex )
  560.     for ( i = 0; i < 36; i += 2 )
  561.     {
  562. x = ix[i];
  563. y = ix[i + 1];
  564. bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  565. *pph = BF_addEntry( *pph,  code, cbits );
  566. *pph = BF_addEntry( *pph,  ext, xbits );
  567. bitsWritten += bits;
  569.     }
  570. /* Write the short block region */
  571. tableindex = gi->table_select[ 1 ];
  572. assert( tableindex < 32 );
  574. for ( sfb = 3; sfb < 13; sfb++ )
  575. {
  576.     start = scalefac_band.s[ sfb ];
  577.     end   = scalefac_band.s[ sfb+1 ];           
  578.     
  579.     for ( window = 0; window < 3; window++ )
  580. for ( line = start; line < end; line += 2 )
  581. {
  582.     x = (*ix_s)[line][window];
  583.     y = (*ix_s)[line + 1][window];
  584.     bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  585.     *pph = BF_addEntry( *pph,  code, cbits );
  586.     *pph = BF_addEntry( *pph,  ext, xbits );
  587.     bitsWritten += bits;
  588. }
  589. }
  591.     }
  592.     else
  593. #endif
  594.     { /* Long blocks */
  595. unsigned scalefac_index = 100;
  597. if ( gi->mixed_block_flag )
  598. {
  599.     region1Start = 36;
  600.     region2Start = 576;
  601. }
  602. else
  603. {
  604.     scalefac_index = gi->region0_count + 1;
  605.     assert( scalefac_index < 23 );
  606.     region1Start = scalefac_band.l[ scalefac_index ];
  607.     scalefac_index += gi->region1_count + 1;
  608.     assert( scalefac_index < 23 );    
  609.     region2Start = scalefac_band.l[ scalefac_index ];
  610. }
  612. for ( i = 0; i < bigvalues; i += 2 )
  613. {
  614.     unsigned tableindex = 100;
  615.     /* get table pointer */
  616.     if ( i < region1Start )
  617.     {
  618. tableindex = gi->table_select[0];
  619.     }
  620.     else
  621. if ( i < region2Start )
  622. {
  623.     tableindex = gi->table_select[1];
  624. }
  625. else
  626. {
  627.     tableindex = gi->table_select[2];
  628. }
  629.     assert( tableindex < 32 );
  630.     /* get huffman code */
  631.     x = ix[i];
  632.     y = ix[i + 1];
  634.     if ( tableindex )
  635.     {
  636. bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  637. *pph = BF_addEntry( *pph,  code, cbits );
  638. *pph = BF_addEntry( *pph,  ext, xbits );
  639. bitsWritten += bits;
  640.     }
  641. }
  642.     }
  643.     }
  644. #ifdef DEBUG
  645.     bvbits = bitsWritten; 
  646. #endif
  648.     /* 2: Write count1 area */
  649.     assert( (gi->count1table_select < 2) );
  650.     count1End = bigvalues + (gi->count1 * 4);
  652.     assert( count1End <= 576 );
  654.     for ( i = bigvalues; i < count1End; i += 4 )
  655.     {
  656. v = ix[i];
  657. w = ix[i+1];
  658. x = ix[i+2];
  659. y = ix[i+3];
  660. bitsWritten += L3_huffman_coder_count1( pph, &ht[gi->count1table_select + 32], v, w, x, y );
  661.     }
  662. #ifdef DEBUG
  663.     c1bits = bitsWritten - bvbits;
  664. #endif
  665.     if ( (stuffingBits = gi->part2_3_length - gi->part2_length - bitsWritten) )
  666.     {
  667. int stuffingWords = stuffingBits / 32;
  668. int remainingBits = stuffingBits % 32;
  670.         fprintf(stderr,"opps - adding stuffing bits = %i.n",stuffingBits);
  671.         fprintf(stderr,"this should not happen...n");
  673. /*
  674.   Due to the nature of the Huffman code
  675.   tables, we will pad with ones
  676. */
  677. while ( stuffingWords-- )
  678.     *pph = BF_addEntry( *pph, ~(u_int)0, 32 );
  679. if ( remainingBits )
  680.     *pph = BF_addEntry( *pph, ~(u_int)0, remainingBits );
  681. bitsWritten += stuffingBits;
  682.     }
  683.     assert( bitsWritten == (int)(gi->part2_3_length - gi->part2_length) );
  684. #ifdef DEBUG
  685.     fprintf(stderr, "## %d Huffman bits written (%02d + %02d), part2_length = %d, part2_3_length = %d, %d stuffing ##n",
  686.     bitsWritten, bvbits, c1bits, gi->part2_length, gi->part2_3_length, stuffingBits );
  687. #endif
  688. }
  690. int
  691. abs_and_sign( int *x )
  692. {
  693.     if ( *x > 0 )
  694. return 0;
  695.     *x *= -1;
  696.     return 1;
  697. }
  699. int
  700. L3_huffman_coder_count1( BF_PartHolder **pph, struct huffcodetab *h, int v, int w, int x, int y )
  701. {
  702.     HUFFBITS huffbits;
  703.     unsigned int signv, signw, signx, signy, p;
  704.     int len;
  705.     int totalBits = 0;
  706.     
  707.     signv = abs_and_sign( &v );
  708.     signw = abs_and_sign( &w );
  709.     signx = abs_and_sign( &x );
  710.     signy = abs_and_sign( &y );
  711.     
  712.     /* bug fix from Leonid A. Kulakov 9/1999:*/
  713.     p = (v << 3) + (w << 2) + (x << 1) + y;  
  715.     huffbits = h->table[p];
  716.     len = h->hlen[ p ];
  717.     *pph = BF_addEntry(*pph, huffbits, len);
  718.     totalBits= 0;
  719. #if 0
  720.     if ( v )
  721.     {
  722. *pph = BF_addEntry( *pph,  signv, 1 );
  723. totalBits += 1;
  724.     }
  725.     if ( w )
  726.     {
  727. *pph = BF_addEntry( *pph,  signw, 1 );
  728. totalBits += 1;
  729.     }
  731.     if ( x )
  732.     {
  733. *pph = BF_addEntry( *pph,  signx, 1 );
  734. totalBits += 1;
  735.     }
  736.     if ( y )
  737.     {
  738. *pph = BF_addEntry( *pph,  signy, 1 );
  739. totalBits += 1;
  740.     }
  741. #endif   
  743.     p=0;
  744.     if ( v ) {
  745. p = signv;
  746. ++totalBits;
  747.     }
  749.     if ( w ){
  750. p = 2*p + signw;
  751. ++totalBits;
  752.     }
  754.     if ( x ) {
  755. p = 2*p + signx;
  756. ++totalBits;
  757.     }
  759.     if ( y ) {
  760. p = 2*p + signy;
  761. ++totalBits;
  762.     }
  764.     *pph = BF_addEntry(*pph, p, totalBits);
  766.     return totalBits+len;  
  767. }
  769. /*
  770.   Implements the pseudocode of page 98 of the IS
  771.   */
  772. int
  773. HuffmanCode( int table_select, int x, int y, unsigned int *code, unsigned int *ext, int *cbits, int *xbits )
  774. {
  775.     unsigned signx, signy, linbitsx, linbitsy, linbits, idx;
  776.     struct huffcodetab *h;
  778.     *cbits = 0;
  779.     *xbits = 0;
  780.     *code  = 0;
  781.     *ext   = 0;
  782.     
  783.     if ( table_select == 0 )
  784. return 0;
  785.     
  786.     signx = abs_and_sign( &x );
  787.     signy = abs_and_sign( &y );
  788.     h = &(ht[table_select]);
  790.     if ( table_select > 15 )
  791.     { /* ESC-table is used */
  792.       linbits = h->xlen;
  793.       linbitsx = linbitsy = 0;
  794. if ( x > 14 )
  795. {
  796.     linbitsx = x - 15;
  797.     assert( linbitsx <= h->linmax );
  798.     x = 15;
  799. }
  800. if ( y > 14 )
  801. {
  802.     linbitsy = y - 15;
  803.     assert( linbitsy <= h->linmax );
  804.     y = 15;
  805. }
  806. idx = x * 16 + y;
  807. *code = h->table[idx];
  808.         *cbits = h->hlen[ idx ];
  809. if ( x > 14 )
  810. {
  811.     *ext |= linbitsx;
  812.     *xbits += linbits;
  813. }
  814. if ( x != 0 )
  815. {
  816.     *ext <<= 1;
  817.     *ext |= signx;
  818.     *xbits += 1;
  819. }
  820. if ( y > 14 )
  821. {
  822.     *ext <<= linbits;
  823.     *ext |= linbitsy;
  824.     *xbits += linbits;
  825. }
  826. if ( y != 0 )
  827. {
  828.     *ext <<= 1;
  829.     *ext |= signy;
  830.     *xbits += 1;
  831. }
  832.     }
  833.     else
  834.     { /* No ESC-words */
  835. idx = x * 16 + y;
  836. *code = h->table[idx];
  837. *cbits += h->hlen[ idx ];
  838. if ( x != 0 )
  839. {
  840.     *code <<= 1;
  841.     *code |= signx;
  842.     *cbits += 1;
  843. }
  844. if ( y != 0 )
  845. {
  846.     *code <<= 1;
  847.     *code |= signy;
  848.             *cbits += 1;
  849. }
  850.     }
  851.     assert( *cbits <= 32 );
  852.     assert( *xbits <= 32 );
  853.     return *cbits + *xbits;
  854. }