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

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

mpeg/mp3

开发平台：

Visual C++

l3bitstream.c：源码内容
  1. /*
  2. (c) Copyright 1998, 1999 - Tord Jansson
  3. =======================================
  5. This file is part of the BladeEnc MP3 Encoder, based on
  6. ISO's reference code for MPEG Layer 3 compression, and might
  7. contain smaller or larger sections that are directly taken
  8. from ISO's reference code.
  10. All changes to the ISO reference code herein are either
  11. copyrighted by Tord Jansson (tord.jansson@swipnet.se)
  12. or sublicensed to Tord Jansson by a third party.
  14. BladeEnc is free software; you can redistribute this file
  15. and/or modify it under the terms of the GNU Lesser General Public
  16. License as published by the Free Software Foundation; either
  17. version 2.1 of the License, or (at your option) any later version.
  19. */
  21. #include <stdlib.h>
  22. #include "system.h"
  24. #include "l3bitstream.h" /* the public interface */
  25. #include "l3psy.h"
  26. #include "mdct.h"
  27. #include "loop.h"
  28. #include "formatbitstream2.h"
  29. #include "huffman.h"
  30. #include <assert.h>
  31. #include "l3bitstream-pvt.h"
  33. static int stereo = 1;
  34. static frame_params *fr_ps  = NULL;
  37. int PartHoldersInitialized = 0;
  39. BitHolder *headerPH;
  40. BitHolder *frameSIPH;
  41. BitHolder *channelSIPH[ MAX_CHANNELS ];
  42. BitHolder *spectrumSIPH[ MAX_GRANULES ][ MAX_CHANNELS ];
  43. BitHolder *scaleFactorsPH[ MAX_GRANULES ][ MAX_CHANNELS ];
  44. BitHolder *codedDataPH[ MAX_GRANULES ][ MAX_CHANNELS ];
  45. BitHolder *userSpectrumPH[ MAX_GRANULES ][ MAX_CHANNELS ];
  46. BitHolder *userFrameDataPH;
  49. BF_FrameData sFrameData;
  50. BF_FrameResults sFrameResults;
  54. /*
  55.   III_format_bitstream()
  56.   
  57.   This is called after a frame of audio has been quantized and coded.
  58.   It will write the encoded audio to the bitstream. Note that
  59.   from a layer3 encoder's perspective the bit stream is primarily
  60.   a series of main_data() blocks, with header and side information
  61.   inserted at the proper locations to maintain framing. (See Figure A.7
  62.   in the IS).
  63.   */
  65. void III_format_bitstream( int              bitsPerFrame,
  66. frame_params     *in_fr_ps,
  67. int              l3_enc[2][2][576],
  68. III_side_info_t  *l3_side,
  69. III_scalefac_t   *scalefac,
  70. double           (*xr)[2][576],
  71. char             *ancillary,
  72. int              ancillary_bits )
  73. {
  74.   int gr, ch, i, mode_gr;
  75.   fr_ps = in_fr_ps;
  76.   stereo = fr_ps->stereo;
  77.   mode_gr = 2;
  78.   
  79.   if ( !PartHoldersInitialized )
  80.   {
  81. headerPH = initBitHolder( &sFrameData.header, 16*2 );
  82. frameSIPH = initBitHolder( &sFrameData.frameSI, 4*2 );
  84. for ( ch = 0; ch < MAX_CHANNELS; ch++ )
  85.     channelSIPH[ch] = initBitHolder( &sFrameData.channelSI[ch], 8*2 );
  87. for ( gr = 0; gr < MAX_GRANULES; gr++ )
  88.     for ( ch = 0; ch < MAX_CHANNELS; ch++ )
  89.     {
  90. spectrumSIPH[gr][ch]   = initBitHolder( &sFrameData.spectrumSI[gr][ch], 32*2 );
  91. scaleFactorsPH[gr][ch] = initBitHolder( &sFrameData.scaleFactors[gr][ch], 64*2 );
  92. codedDataPH[gr][ch]    = initBitHolder( &sFrameData.codedData[gr][ch], 576*2 );
  93. userSpectrumPH[gr][ch] = initBitHolder( &sFrameData.userSpectrum[gr][ch], 4*2 );
  94.     }
  95. userFrameDataPH = initBitHolder( &sFrameData.userFrameData, 8*2 );
  98. PartHoldersInitialized = 1;
  99.   }
  101. #if 1
  102.   for ( gr = 0; gr < mode_gr; gr++ )
  103. for ( ch =  0; ch < stereo; ch++ )
  104. {
  105.     int *pi = &l3_enc[gr][ch][0];
  106.     double *pr = &xr[gr][ch][0];
  107.     for ( i = 0; i < 576; i++, pr++, pi++ )
  108.   {
  109. if ( (*pr < 0) && (*pi > 0) )
  110.   *pi *= -1;
  111.     }
  112. }
  113. #endif
  115.   encodeSideInfo( l3_side );
  116.   encodeMainData( l3_enc, l3_side, scalefac );
  117.   write_ancillary_data( ancillary, ancillary_bits );
  119.   if ( l3_side->resvDrain )
  120. drain_into_ancillary_data( l3_side->resvDrain );
  122.   sFrameData.frameLength = bitsPerFrame;
  123.   sFrameData.nGranules   = mode_gr;
  124.   sFrameData.nChannels   = stereo;
  126.   writeFrame( &sFrameData, &sFrameResults );
  128.   /* we set this here -- it will be tested in the next loops iteration */
  129.   l3_side->main_data_begin = sFrameResults.nextBackPtr;
  130. }
  132. void III_FlushBitstream()
  133. {
  134. int ch, gr;
  136.   if ( PartHoldersInitialized )
  137.   {
  139. exitBitHolder( &sFrameData.header );
  140. exitBitHolder( &sFrameData.frameSI );
  142. for ( ch = 0; ch < MAX_CHANNELS; ch++ )
  143.     exitBitHolder( &sFrameData.channelSI[ch] );
  146. for ( gr = 0; gr < MAX_GRANULES; gr++ )
  147.     for ( ch = 0; ch < MAX_CHANNELS; ch++ )
  148.     {
  149. exitBitHolder( &sFrameData.spectrumSI[gr][ch] );
  150. exitBitHolder( &sFrameData.scaleFactors[gr][ch] );
  151. exitBitHolder( &sFrameData.codedData[gr][ch] );
  152. exitBitHolder( &sFrameData.userSpectrum[gr][ch] );
  153.     }
  154. exitBitHolder( &sFrameData.userFrameData );
  156. PartHoldersInitialized = 0;
  157.   }
  160.  /* BF_FlushBitstream( frameData, frameResults ); */
  161. }
  163. static unsigned slen1_tab[16] = { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 };
  164. static unsigned slen2_tab[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 };
  166. static void encodeMainData( int l3_enc[2][2][576],
  167. III_side_info_t  *si,
  168. III_scalefac_t   *scalefac )
  169. {
  170.   int gr, ch, sfb, window, mode_gr;
  172. mode_gr = 2;
  174.   for ( gr = 0; gr < mode_gr; gr++ )
  175. for ( ch = 0; ch < stereo; ch++ )
  176.     scaleFactorsPH[gr][ch]->nrEntries = 0;
  178.   for ( gr = 0; gr < mode_gr; gr++ )
  179. for ( ch = 0; ch < stereo; ch++ )
  180.     codedDataPH[gr][ch]->nrEntries = 0;
  182. for ( gr = 0; gr < 2; gr++ )
  183. {
  184.   for ( ch = 0; ch < stereo; ch++ )
  185.   {
  186. BitHolder **pph = &scaleFactorsPH[gr][ch];
  187. gr_info *gi = &(si->gr[gr].ch[ch].tt);
  188. unsigned slen1 = slen1_tab[ gi->scalefac_compress ];
  189. unsigned slen2 = slen2_tab[ gi->scalefac_compress ];
  190. int *ix = &l3_enc[gr][ch][0];
  192. if ( (gi->window_switching_flag == 1) && (gi->block_type == 2) )
  193. {
  194. if ( gi->mixed_block_flag )
  195. {
  196. for ( sfb = 0; sfb < 8; sfb++ )
  197. addBits( *pph,  scalefac->l[gr][ch][sfb], slen1 );
  199. for ( sfb = 3; sfb < 6; sfb++ )
  200. for ( window = 0; window < 3; window++ )
  201. addBits( *pph,  scalefac->s[gr][ch][sfb][window], slen1 );
  203. for ( sfb = 6; sfb < 12; sfb++ )
  204. for ( window = 0; window < 3; window++ )
  205. addBits( *pph,  scalefac->s[gr][ch][sfb][window], slen2 );
  207. }
  208. else
  209. {
  210. for ( sfb = 0; sfb < 6; sfb++ )
  211. for ( window = 0; window < 3; window++ )
  212. addBits( *pph,  scalefac->s[gr][ch][sfb][window], slen1 );
  214. for ( sfb = 6; sfb < 12; sfb++ )
  215. for ( window = 0; window < 3; window++ )
  216. addBits( *pph,  scalefac->s[gr][ch][sfb][window], slen2 );
  217. }
  218. }
  219. else
  220. {
  221. if ( (gr == 0) || (si->scfsi[ch][0] == 0) )
  222. for ( sfb = 0; sfb < 6; sfb++ )
  223. addBits( *pph,  scalefac->l[gr][ch][sfb], slen1 );
  225. if ( (gr == 0) || (si->scfsi[ch][1] == 0) )
  226. for ( sfb = 6; sfb < 11; sfb++ )
  227. addBits( *pph,  scalefac->l[gr][ch][sfb], slen1 );
  229. if ( (gr == 0) || (si->scfsi[ch][2] == 0) )
  230. for ( sfb = 11; sfb < 16; sfb++ )
  231. addBits( *pph,  scalefac->l[gr][ch][sfb], slen2 );
  233. if ( (gr == 0) || (si->scfsi[ch][3] == 0) )
  234. for ( sfb = 16; sfb < 21; sfb++ )
  235. addBits( *pph,  scalefac->l[gr][ch][sfb], slen2 );
  236. }
  237. Huffmancodebits( &codedDataPH[gr][ch], ix, gi );
  238.   } /* for ch */
  239. } /* for gr */
  240. } /* main_data */
  242. /*____ encodeSideInfo() _____________________________________________________*/
  244. static int encodeSideInfo( III_side_info_t  *si )
  245. {
  246.   int gr, ch, scfsi_band, region, window, bits_sent, mode_gr;
  247.   layer *info = fr_ps->header;
  249.   mode_gr =  2;
  251.   headerPH->nrEntries = 0;
  252.   addBits( headerPH, 0xfff,                   12 );
  253.   addBits( headerPH, 1,    1 );
  254.   addBits( headerPH, 4 - 3,                2 );  /* 4 - Layer */
  255.   addBits( headerPH, !info->error_protection,  1 );
  256.   addBits( headerPH, info->bitrate_index,      4 );
  257.   addBits( headerPH, info->sampling_frequency, 2 );
  258.   addBits( headerPH, info->padding,            1 );
  259.   addBits( headerPH, info->extension,          1 );
  260.   addBits( headerPH, info->mode,               2 );
  261.   addBits( headerPH, info->mode_ext,           2 );
  262.   addBits( headerPH, info->copyright,          1 );
  263.   addBits( headerPH, info->original,           1 );
  264.   addBits( headerPH, info->emphasis,           2 );
  265.     
  266.   bits_sent = 32;
  268.   if ( info->error_protection )
  269.   {
  270. addBits( headerPH, 0, 16 ); /* Just a dummy add. Real CRC calculated & inserted in writeSideInfo() */
  271. bits_sent += 16;
  272.   }
  275.   frameSIPH->nrEntries = 0;
  277.   for (ch = 0; ch < stereo; ch++ )
  278. channelSIPH[ch]->nrEntries = 0;
  280.   for ( gr = 0; gr < 2; gr++ )
  281. for ( ch = 0; ch < stereo; ch++ )
  282.     spectrumSIPH[gr][ch]->nrEntries = 0;
  284. addBits( frameSIPH, si->main_data_begin, 9 );
  286. if ( stereo == 2 )
  287.   addBits( frameSIPH, si->private_bits, 3 );
  288. else
  289.   addBits( frameSIPH, si->private_bits, 5 );
  291. for ( ch = 0; ch < stereo; ch++ )
  292.   for ( scfsi_band = 0; scfsi_band < 4; scfsi_band++ )
  293.   {
  294. BitHolder **pph = &channelSIPH[ch];
  295. addBits( *pph, si->scfsi[ch][scfsi_band], 1 );
  296.   }
  298. for ( gr = 0; gr < 2; gr++ )
  299.   for ( ch = 0; ch < stereo; ch++ )
  300.   {
  301. BitHolder **pph = &spectrumSIPH[gr][ch];
  302. gr_info *gi = &(si->gr[gr].ch[ch].tt);
  303. addBits( *pph, gi->part2_3_length,        12 );
  304. addBits( *pph, gi->big_values,            9 );
  305. addBits( *pph, gi->global_gain,           8 );
  306. addBits( *pph, gi->scalefac_compress,     4 );
  307. addBits( *pph, gi->window_switching_flag, 1 );
  309. if ( gi->window_switching_flag )
  310. {   
  311. addBits( *pph, gi->block_type,       2 );
  312. addBits( *pph, gi->mixed_block_flag, 1 );
  314. for ( region = 0; region < 2; region++ )
  315. addBits( *pph, gi->table_select[region],  5 );
  316. for ( window = 0; window < 3; window++ )
  317. addBits( *pph, gi->subblock_gain[window], 3 );
  318. }
  319. else
  320. {
  321. /* assert( gi->block_type == 0 ); */
  322. for ( region = 0; region < 3; region++ )
  323. addBits( *pph, gi->table_select[region], 5 );
  325. addBits( *pph, gi->region0_count, 4 );
  326. addBits( *pph, gi->region1_count, 3 );
  327. }
  329. addBits( *pph, gi->preflag,            1 );
  330. addBits( *pph, gi->scalefac_scale,     1 );
  331. addBits( *pph, gi->count1table_select, 1 );
  332. }
  335. if ( stereo == 2 )
  336. bits_sent += 256;
  337. else
  338. bits_sent += 136;
  339.   return bits_sent;
  340. }
  344. /*____ write_ancillary_data() _______________________________________________*/
  346. static void write_ancillary_data( char *theData, int lengthInBits )
  347. {
  348.     /*
  349.      */
  350.   int bytesToSend = lengthInBits / 8;
  351.   int remainingBits = lengthInBits % 8;
  352.   unsigned wrd;
  353.   int i;
  355.   userFrameDataPH->nrEntries = 0;
  357.   for ( i = 0; i < bytesToSend; i++ )
  358.   {
  359. wrd = theData[i];
  360. addBits( userFrameDataPH, wrd, 8 );
  361.   }
  362.   if ( remainingBits )
  363.   {
  364. /* right-justify remaining bits */
  365. wrd = theData[bytesToSend] >> (8 - remainingBits);
  366. addBits( userFrameDataPH, wrd, remainingBits );
  367.   }
  368.     
  369. }
  371. /*
  372.   Some combinations of bitrate, Fs, and stereo make it impossible to stuff
  373.   out a frame using just main_data, due to the limited number of bits to
  374.   indicate main_data_length. In these situations, we put stuffing bits into
  375.   the ancillary data...
  376. */
  377. static void drain_into_ancillary_data( int lengthInBits )
  378. {
  379.   /*
  380.    */
  381.   int wordsToSend   = lengthInBits / 32;
  382.   int remainingBits = lengthInBits % 32;
  383.   int i;
  385.   /*
  386.     userFrameDataPH->part->nrEntries set by call to write_ancillary_data()
  387.   */
  389.   for ( i = 0; i < wordsToSend; i++ )
  390. addBits( userFrameDataPH, 0, 32 );
  391.   if ( remainingBits )
  392. addBits( userFrameDataPH, 0, remainingBits );    
  393. }
  395. /*
  396.   Note the discussion of huffmancodebits() on pages 28
  397.   and 29 of the IS, as well as the definitions of the side
  398.   information on pages 26 and 27.
  399.   */
  400. static void Huffmancodebits( BitHolder **pph, int *ix, gr_info *gi )
  401. {
  402.   int L3_huffman_coder_count1( BitHolder **pph, struct huffcodetab *h, int v, int w, int x, int y );
  403.   int bigv_bitcount( int ix[576], gr_info *cod_info );
  405.   int region1Start;
  406.   int region2Start;
  407.   int i, bigvalues, count1End;
  408.   int v, w, x, y, bits, cbits, xbits, stuffingBits;
  409.   unsigned int code, ext;
  410.   struct huffcodetab *h;
  411.   int bvbits, c1bits, tablezeros, r0, r1, r2, rt, *pr;
  412.   int bitsWritten = 0;
  413.   tablezeros = 0;
  414.   r0 = r1 = r2 = 0;
  415.   
  416.   /* 1: Write the bigvalues */
  417.   bigvalues = gi->big_values * 2;
  418.   if ( bigvalues )
  419.   {
  420. if ( !(gi->mixed_block_flag) && gi->window_switching_flag && (gi->block_type == 2) )
  421. { /* Three short blocks */
  422.     /*
  423.       Within each scalefactor band, data is given for successive
  424.       time windows, beginning with window 0 and ending with window 2.
  425.       Within each window, the quantized values are then arranged in
  426.       order of increasing frequency...
  427.       */
  428.     int sfb, window, line, start, end;
  430.     I192_3 *ix_s;
  431.     int *scalefac = &sfBandIndex[fr_ps->header->sampling_frequency].s[0];
  432.     
  433.     ix_s = (I192_3 *) ix;
  434.     region1Start = 12;
  435.     region2Start = 576;
  437.     for ( sfb = 0; sfb < 13; sfb++ )
  438.     {
  439. unsigned tableindex = 100;
  440. start = scalefac[ sfb ];
  441. end   = scalefac[ sfb+1 ];
  443. if ( start < region1Start )
  444.     tableindex = gi->table_select[ 0 ];
  445. else
  446.     tableindex = gi->table_select[ 1 ];
  447. /* assert( tableindex < 32 ); */
  449. for ( window = 0; window < 3; window++ )
  450.     for ( line = start; line < end; line += 2 )
  451.     {
  452. x = (*ix_s)[line][window];
  453. y = (*ix_s)[line + 1][window];
  454. /* assert( idx < 576 );
  455. assert( idx >= 0 ); */
  456. bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  457. addBits( *pph,  code, cbits );
  458. addBits( *pph,  ext, xbits );
  459. bitsWritten += bits;
  460.     }
  462.     }
  463. }
  464. else if ( gi->mixed_block_flag && gi->block_type == 2 )
  465.   {  /* Mixed blocks long, short */
  466. int sfb, window, line, start, end;
  467. unsigned tableindex;
  468. I192_3 *ix_s;
  469. int *scalefac = &sfBandIndex[fr_ps->header->sampling_frequency].s[0];
  471. ix_s = (I192_3 *) ix;
  473. /* Write the long block region */
  474. tableindex = gi->table_select[0];
  475. if ( tableindex )
  476.     for ( i = 0; i < 36; i += 2 )
  477.     {
  478. x = ix[i];
  479. y = ix[i + 1];
  480. bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  481. addBits( *pph,  code, cbits );
  482. addBits( *pph,  ext, xbits );
  483. bitsWritten += bits;
  484.     }
  485. /* Write the short block region */
  486. tableindex = gi->table_select[ 1 ];
  487. /* assert( tableindex < 32 ); */
  489. for ( sfb = 3; sfb < 13; sfb++ )
  490. {
  491.     start = scalefac[ sfb ];
  492.     end   = scalefac[ sfb+1 ];           
  493.     
  494.     for ( window = 0; window < 3; window++ )
  495. for ( line = start; line < end; line += 2 )
  496. {
  497. x = (*ix_s)[line][window];
  498. y = (*ix_s)[line + 1][window];
  499. bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  500. addBits( *pph,  code, cbits );
  501. addBits( *pph,  ext, xbits );
  502. bitsWritten += bits;
  503. }
  504. }
  506.     }
  507.     else
  508.     { /* Long blocks */
  509. int *scalefac = &sfBandIndex[fr_ps->header->sampling_frequency].l[0];
  510. unsigned scalefac_index = 100;
  512. if ( gi->mixed_block_flag )
  513. {
  514.     region1Start = 36;
  515.     region2Start = 576;
  516. }
  517. else
  518. {
  519.     scalefac_index = gi->region0_count + 1;
  520.     region1Start = scalefac[ scalefac_index ];
  521.     scalefac_index += gi->region1_count + 1;
  522.     region2Start = scalefac[ scalefac_index ];
  523. }
  524. for ( i = 0; i < bigvalues; i += 2 )
  525. {
  526.     unsigned tableindex = 100;
  527.     /* get table pointer */
  528.     if ( i < region1Start )
  529.     {
  530. tableindex = gi->table_select[0];
  531. pr = &r0;
  532.     }
  533.     else if ( i < region2Start )
  534. {
  535.     tableindex = gi->table_select[1];
  536.     pr = &r1;
  537. }
  538. else
  539. {
  540.     tableindex = gi->table_select[2];
  541.     pr = &r2;
  542. }
  543. /*     assert( tableindex < 32 ); */
  544.     h = &ht[ tableindex ];
  545.     /* get huffman code */
  546.     x = ix[i];
  547.     y = ix[i + 1];
  548.     if ( tableindex )
  549.     {
  550. bits = HuffmanCode( tableindex, x, y, &code, &ext, &cbits, &xbits );
  551. addBits( *pph,  code, cbits );
  552. addBits( *pph,  ext, xbits );
  553. bitsWritten += rt = bits;
  554. *pr += rt;
  555.     }
  556.     else
  557.     {
  558. tablezeros += 1;
  559. *pr = 0;
  560.     }
  561. }
  562.     }
  563.   }
  564.   bvbits = bitsWritten; 
  566.   /* 2: Write count1 area */
  567.   h = &ht[gi->count1table_select + 32];
  568.   count1End = bigvalues + (gi->count1 * 4);
  569.   for ( i = bigvalues; i < count1End; i += 4 )
  570.   {
  571. v = ix[i];
  572. w = ix[i+1];
  573. x = ix[i+2];
  574. y = ix[i+3];
  575. bitsWritten += L3_huffman_coder_count1( pph, h, v, w, x, y );
  576.   }
  577.   c1bits = bitsWritten - bvbits;
  578.   if ( (stuffingBits = gi->part2_3_length - gi->part2_length - bitsWritten) )
  579.   {
  580. int stuffingWords = stuffingBits / 32;
  581. int remainingBits = stuffingBits % 32;
  582. /* assert( stuffingBits > 0 ); */
  584. /*
  585.   Due to the nature of the Huffman code
  586.   tables, we will pad with ones
  587. */
  588. while ( stuffingWords-- )
  589.     addBits( *pph, ~0, 32 );
  590. if ( remainingBits )
  591.     addBits( *pph, ~0, remainingBits );
  592. bitsWritten += stuffingBits;
  593.   }
  594. }
  596. int __inline abs_and_sign( int *x )
  597. {
  598.   if ( *x > 0 )
  599. return 0;
  600.   *x *= -1;
  601.     return 1;
  602. }
  604. int L3_huffman_coder_count1( BitHolder **pph, struct huffcodetab *h, int v, int w, int x, int y )
  605. {
  606.   HUFFBITS huffbits;
  607.   unsigned int signv, signw, signx, signy, p;
  608.   int len;
  609.   int totalBits = 0;
  610.   
  611.   signv = abs_and_sign( &v );
  612.   signw = abs_and_sign( &w );
  613.   signx = abs_and_sign( &x );
  614.   signy = abs_and_sign( &y );
  615.   
  616.   p = v + (w << 1) + (x << 2) + (y << 3);
  617.   huffbits = h->table[p];
  618.   len = h->hlen[ p ];
  619.   addBits( *pph,  huffbits, len );
  620.   totalBits += len;
  621.   if ( v )
  622.   {
  623. addBits( *pph,  signv, 1 );
  624. totalBits += 1;
  625.   }
  626.   if ( w )
  627.   {
  628. addBits( *pph,  signw, 1 );
  629. totalBits += 1;
  630.   }
  632.   if ( x )
  633.   {
  634. addBits( *pph,  signx, 1 );
  635. totalBits += 1;
  636.   }
  637.   if ( y )
  638.   {
  639. addBits( *pph,  signy, 1 );
  640. totalBits += 1;
  641.   }
  642.   return totalBits;
  643. }
  645. /*
  646.   Implements the pseudocode of page 98 of the IS
  647.   */
  648. int HuffmanCode( int table_select, int x, int y, unsigned int *code, unsigned int *ext, int *cbits, int *xbits )
  649. {
  650.   unsigned signx, signy, linbitsx, linbitsy, linbits, xlen, ylen, idx;
  651.   struct huffcodetab *h;
  653.   *cbits = 0;
  654.   *xbits = 0;
  655.   *code  = 0;
  656.   *ext   = 0;
  657.   
  658.   if ( table_select == 0 )
  659. return 0;
  660.     
  661.   signx = abs_and_sign( &x );
  662.   signy = abs_and_sign( &y );
  663.   h = &(ht[table_select]);
  664.   xlen = h->xlen;
  665.   ylen = h->ylen;
  666.   linbits = h->linbits;
  667.   linbitsx = linbitsy = 0;
  669.   if ( table_select > 15 )
  670.   { /* ESC-table is used */
  671. if ( x > 14 )
  672. {
  673.     linbitsx = x - 15;
  674. /*     assert( linbitsx <= h->linmax ); */
  675.     x = 15;
  676. }
  677. if ( y > 14 )
  678. {
  679.     linbitsy = y - 15;
  680. /*     assert( linbitsy <= h->linmax ); */
  681.     y = 15;
  682. }
  683. idx = (x * ylen) + y;
  684. *code = h->table[idx];
  685. *cbits = h->hlen[ idx ];
  686. if ( x > 14 )
  687. {
  688.     *ext |= linbitsx;
  689.     *xbits += linbits;
  690. }
  691. if ( x != 0 )
  692. {
  693.     *ext <<= 1;
  694.     *ext |= signx;
  695.     *xbits += 1;
  696. }
  697. if ( y > 14 )
  698. {
  699.     *ext <<= linbits;
  700.     *ext |= linbitsy;
  701.     *xbits += linbits;
  702. }
  703. if ( y != 0 )
  704. {
  705.     *ext <<= 1;
  706.     *ext |= signy;
  707.     *xbits += 1;
  708. }
  709.   }
  710.   else
  711.   { /* No ESC-words */
  712. idx = (x * ylen) + y;
  713. *code = h->table[idx];
  714. *cbits += h->hlen[ idx ];
  715. if ( x != 0 )
  716. {
  717.     *code <<= 1;
  718.     *code |= signx;
  719.     *cbits += 1;
  720. }
  721. if ( y != 0 )
  722. {
  723.     *code <<= 1;
  724.     *code |= signy;
  725.     *cbits += 1;
  726. }
  727.   }
  728. /*assert( *cbits <= 32 );
  729.   assert( *xbits <= 32 ); */
  730.   return *cbits + *xbits;
  731. }