aboutsummaryrefslogtreecommitdiffstats
path: root/libtoolame-dab/encode.c
diff options
context:
space:
mode:
authorMatthias P. Braendli <matthias.braendli@mpb.li>2016-02-15 02:44:20 +0100
committerMatthias P. Braendli <matthias.braendli@mpb.li>2016-02-15 02:44:20 +0100
commit22f1fce330059ef8a383cf327a023d6a9da5ad3e (patch)
tree6893f158dcaaaa1b9f1317923c32a841ba31f768 /libtoolame-dab/encode.c
parent891bb2592944aa2be2d81e1583e73e632e70537f (diff)
downloadfdk-aac-dabplus-22f1fce330059ef8a383cf327a023d6a9da5ad3e.tar.gz
fdk-aac-dabplus-22f1fce330059ef8a383cf327a023d6a9da5ad3e.tar.bz2
fdk-aac-dabplus-22f1fce330059ef8a383cf327a023d6a9da5ad3e.zip
Include toolame-dab as library
Diffstat (limited to 'libtoolame-dab/encode.c')
-rw-r--r--libtoolame-dab/encode.c1224
1 files changed, 1224 insertions, 0 deletions
diff --git a/libtoolame-dab/encode.c b/libtoolame-dab/encode.c
new file mode 100644
index 0000000..fa9bd4a
--- /dev/null
+++ b/libtoolame-dab/encode.c
@@ -0,0 +1,1224 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include "common.h"
+#include "encoder.h"
+#include "bitstream.h"
+#include "availbits.h"
+#include "encode.h"
+
+int vbrstats[15] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+/* This segment contains all the core routines of the encoder,
+ except for the psychoacoustic models.
+
+ The user can select either one of the two psychoacoustic
+ models. Model I is a simple tonal and noise masking threshold
+ generator, and Model II is a more sophisticated cochlear masking
+ threshold generator. Model I is recommended for lower complexity
+ applications whereas Model II gives better subjective quality at low
+ bit rates. */
+
+/************************************************************************
+* encode_info()
+*
+* PURPOSE: Puts the syncword and header information on the output
+* bitstream.
+*
+************************************************************************/
+
+void encode_info (frame_info * frame, Bit_stream_struc * bs)
+{
+ frame_header *header = frame->header;
+
+ putbits (bs, 0xfff, 12); /* syncword 12 bits */
+ put1bit (bs, header->version); /* ID 1 bit */
+ putbits (bs, 4 - header->lay, 2); /* layer 2 bits */
+ put1bit (bs, !header->error_protection); /* bit set => no err prot */
+ putbits (bs, header->bitrate_index, 4);
+ putbits (bs, header->sampling_frequency, 2);
+ put1bit (bs, header->padding);
+ put1bit (bs, header->extension); /* private_bit */
+ putbits (bs, header->mode, 2);
+ putbits (bs, header->mode_ext, 2);
+ put1bit (bs, header->copyright);
+ put1bit (bs, header->original);
+ putbits (bs, header->emphasis, 2);
+}
+
+/************************************************************************
+*
+* combine_LR (Layer II)
+*
+* PURPOSE:Combines left and right channels into a mono channel
+*
+* SEMANTICS: The average of left and right subband samples is put into
+* #joint_sample#
+*
+*
+************************************************************************/
+
+void combine_LR (double sb_sample[2][3][SCALE_BLOCK][SBLIMIT],
+ double joint_sample[3][SCALE_BLOCK][SBLIMIT], int sblimit)
+{ /* make a filtered mono for joint stereo */
+ int sb, smp, sufr;
+
+ for (sb = 0; sb < sblimit; ++sb)
+ for (smp = 0; smp < SCALE_BLOCK; ++smp)
+ for (sufr = 0; sufr < 3; ++sufr)
+ joint_sample[sufr][smp][sb] =
+ .5 * (sb_sample[0][sufr][smp][sb] + sb_sample[1][sufr][smp][sb]);
+}
+
+/************************************************************************
+*
+* scale_factor_calc (Layer II)
+*
+* PURPOSE:For each subband, calculate the scale factor for each set
+* of the 12 subband samples
+*
+* SEMANTICS: Pick the scalefactor #multiple[]# just larger than the
+* absolute value of the peak subband sample of 12 samples,
+* and store the corresponding scalefactor index in #scalar#.
+*
+* Layer II has three sets of 12-subband samples for a given
+* subband.
+*
+************************************************************************/
+
+#define PDS1
+#ifdef PDS1
+void scale_factor_calc (double sb_sample[][3][SCALE_BLOCK][SBLIMIT],
+ unsigned int scalar[][3][SBLIMIT], int nch,
+ int sblimit)
+{
+ /* Optimized to use binary search instead of linear scan through the
+ scalefactor table; guarantees to find scalefactor in only 5
+ jumps/comparisons and not in {0 (lin. best) to 63 (lin. worst)}.
+ Scalefactors for subbands > sblimit are no longer computed.
+ Uses a single sblimit-loop.
+ Patrick De Smet Oct 1999.
+ */
+ int k, t;
+ /* Using '--' loops to avoid possible "cmp value + bne/beq" compiler */
+ /* inefficiencies. Below loops should compile to "bne/beq" only code */
+ for (k = nch; k--;)
+ for (t = 3; t--;) {
+ int i;
+ for (i = sblimit; i--;) {
+ int j;
+ unsigned int l;
+ register double temp;
+ unsigned int scale_fac;
+ /* Determination of max. over each set of 12 subband samples: */
+ /* PDS TODO: maybe this could/should ??!! be integrated into */
+ /* the subband filtering routines? */
+ register double cur_max = fabs (sb_sample[k][t][SCALE_BLOCK - 1][i]);
+ for (j = SCALE_BLOCK - 1; j--;) {
+ if ((temp = fabs (sb_sample[k][t][j][i])) > cur_max)
+ cur_max = temp;
+ }
+ /* PDS: binary search in the scalefactor table: */
+ /* This is the real speed up: */
+ for (l = 16, scale_fac = 32; l; l >>= 1) {
+ if (cur_max <= multiple[scale_fac])
+ scale_fac += l;
+ else
+ scale_fac -= l;
+ }
+ if (cur_max > multiple[scale_fac])
+ scale_fac--;
+ scalar[k][t][i] = scale_fac;
+ }
+ }
+}
+#else
+void scale_factor_calc (sb_sample, scalar, nch, sblimit)
+ double sb_sample[][3][SCALE_BLOCK][SBLIMIT];
+ unsigned int scalar[][3][SBLIMIT];
+ int nch, sblimit;
+{
+ int i, j, k, t;
+ double s[SBLIMIT];
+
+ for (k = 0; k < nch; k++)
+ for (t = 0; t < 3; t++) {
+ for (i = 0; i < sblimit; i++)
+ for (j = 1, s[i] = fabs (sb_sample[k][t][0][i]); j < SCALE_BLOCK; j++)
+ if (fabs (sb_sample[k][t][j][i]) > s[i])
+ s[i] = fabs (sb_sample[k][t][j][i]);
+
+ for (i = 0; i < sblimit; i++)
+ for (j = SCALE_RANGE - 2, scalar[k][t][i] = 0; j >= 0; j--) /* $A 6/16/92 */
+ if (s[i] <= multiple[j]) {
+ scalar[k][t][i] = j;
+ break;
+ }
+ for (i = sblimit; i < SBLIMIT; i++)
+ scalar[k][t][i] = SCALE_RANGE - 1;
+ }
+}
+
+#endif
+/************************************************************************
+*
+* pick_scale (Layer II)
+*
+* PURPOSE:For each subband, puts the smallest scalefactor of the 3
+* associated with a frame into #max_sc#. This is used
+* used by Psychoacoustic Model I.
+* (I would recommend changin max_sc to min_sc)
+*
+************************************************************************/
+
+void pick_scale (unsigned int scalar[2][3][SBLIMIT], frame_info * frame,
+ double max_sc[2][SBLIMIT])
+{
+ int i, j, k, max;
+ int nch = frame->nch;
+ int sblimit = frame->sblimit;
+
+ for (k = 0; k < nch; k++)
+ for (i = 0; i < sblimit; max_sc[k][i] = multiple[max], i++)
+ for (j = 1, max = scalar[k][0][i]; j < 3; j++)
+ if (max > scalar[k][j][i])
+ max = scalar[k][j][i];
+ for (i = sblimit; i < SBLIMIT; i++)
+ max_sc[0][i] = max_sc[1][i] = 1E-20;
+}
+
+/************************************************************************
+*
+* transmission_pattern (Layer II only)
+*
+* PURPOSE:For a given subband, determines whether to send 1, 2, or
+* all 3 of the scalefactors, and fills in the scalefactor
+* select information accordingly
+*
+* SEMANTICS: The subbands and channels are classified based on how much
+* the scalefactors changes over its three values (corresponding
+* to the 3 sets of 12 samples per subband). The classification
+* will send 1 or 2 scalefactors instead of three if the scalefactors
+* do not change much. The scalefactor select information,
+* #scfsi#, is filled in accordingly.
+*
+************************************************************************/
+
+void transmission_pattern (unsigned int scalar[2][3][SBLIMIT],
+ unsigned int scfsi[2][SBLIMIT],
+ frame_info * frame)
+{
+ int nch = frame->nch;
+ int sblimit = frame->sblimit;
+ int dscf[2];
+ int class[2], i, j, k;
+ static int pattern[5][5] = { {0x123, 0x122, 0x122, 0x133, 0x123},
+ {0x113, 0x111, 0x111, 0x444, 0x113},
+ {0x111, 0x111, 0x111, 0x333, 0x113},
+ {0x222, 0x222, 0x222, 0x333, 0x123},
+ {0x123, 0x122, 0x122, 0x133, 0x123}
+ };
+
+ for (k = 0; k < nch; k++)
+ for (i = 0; i < sblimit; i++) {
+ dscf[0] = (scalar[k][0][i] - scalar[k][1][i]);
+ dscf[1] = (scalar[k][1][i] - scalar[k][2][i]);
+ for (j = 0; j < 2; j++) {
+ if (dscf[j] <= -3)
+ class[j] = 0;
+ else if (dscf[j] > -3 && dscf[j] < 0)
+ class[j] = 1;
+ else if (dscf[j] == 0)
+ class[j] = 2;
+ else if (dscf[j] > 0 && dscf[j] < 3)
+ class[j] = 3;
+ else
+ class[j] = 4;
+ }
+ switch (pattern[class[0]][class[1]]) {
+ case 0x123:
+ scfsi[k][i] = 0;
+ break;
+ case 0x122:
+ scfsi[k][i] = 3;
+ scalar[k][2][i] = scalar[k][1][i];
+ break;
+ case 0x133:
+ scfsi[k][i] = 3;
+ scalar[k][1][i] = scalar[k][2][i];
+ break;
+ case 0x113:
+ scfsi[k][i] = 1;
+ scalar[k][1][i] = scalar[k][0][i];
+ break;
+ case 0x111:
+ scfsi[k][i] = 2;
+ scalar[k][1][i] = scalar[k][2][i] = scalar[k][0][i];
+ break;
+ case 0x222:
+ scfsi[k][i] = 2;
+ scalar[k][0][i] = scalar[k][2][i] = scalar[k][1][i];
+ break;
+ case 0x333:
+ scfsi[k][i] = 2;
+ scalar[k][0][i] = scalar[k][1][i] = scalar[k][2][i];
+ break;
+ case 0x444:
+ scfsi[k][i] = 2;
+ if (scalar[k][0][i] > scalar[k][2][i])
+ scalar[k][0][i] = scalar[k][2][i];
+ scalar[k][1][i] = scalar[k][2][i] = scalar[k][0][i];
+ }
+ }
+}
+
+/************************************************************************
+*
+* encode_scale (Layer II)
+*
+* PURPOSE:The encoded scalar factor information is arranged and
+* queued into the output fifo to be transmitted.
+*
+* For Layer II, the three scale factors associated with
+* a given subband and channel are transmitted in accordance
+* with the scfsi, which is transmitted first.
+*
+************************************************************************/
+
+void
+encode_scale (unsigned int bit_alloc[2][SBLIMIT],
+ unsigned int scfsi[2][SBLIMIT],
+ unsigned int scalar[2][3][SBLIMIT], frame_info * frame,
+ Bit_stream_struc * bs)
+{
+ int nch = frame->nch;
+ int sblimit = frame->sblimit;
+ int i, j, k;
+
+ for (i = 0; i < sblimit; i++)
+ for (k = 0; k < nch; k++)
+ if (bit_alloc[k][i])
+ putbits (bs, scfsi[k][i], 2);
+
+ for (i = 0; i < sblimit; i++)
+ for (k = 0; k < nch; k++)
+ if (bit_alloc[k][i]) /* above jsbound, bit_alloc[0][i] == ba[1][i] */
+ switch (scfsi[k][i]) {
+ case 0:
+ for (j = 0; j < 3; j++)
+ putbits (bs, scalar[k][j][i], 6);
+ break;
+ case 1:
+ case 3:
+ putbits (bs, scalar[k][0][i], 6);
+ putbits (bs, scalar[k][2][i], 6);
+ break;
+ case 2:
+ putbits (bs, scalar[k][0][i], 6);
+ }
+}
+
+/*=======================================================================\
+| |
+| The following routines are done after the masking threshold |
+| has been calculated by the fft analysis routines in the Psychoacoustic |
+| model. Using the MNR calculated, the actual number of bits allocated |
+| to each subband is found iteratively. |
+| |
+\=======================================================================*/
+
+/************************************************************************
+*
+* bits_for_nonoise (Layer II)
+*
+* PURPOSE:Returns the number of bits required to produce a
+* mask-to-noise ratio better or equal to the noise/no_noise threshold.
+*
+* SEMANTICS:
+* bbal = # bits needed for encoding bit allocation
+* bsel = # bits needed for encoding scalefactor select information
+* banc = # bits needed for ancillary data (header info included)
+*
+* For each subband and channel, will add bits until one of the
+* following occurs:
+* - Hit maximum number of bits we can allocate for that subband
+* - MNR is better than or equal to the minimum masking level
+* (NOISY_MIN_MNR)
+* Then the bits required for scalefactors, scfsi, bit allocation,
+* and the subband samples are tallied (#req_bits#) and returned.
+*
+* (NOISY_MIN_MNR) is the smallest MNR a subband can have before it is
+* counted as 'noisy' by the logic which chooses the number of JS
+* subbands.
+*
+* Joint stereo is supported.
+*
+************************************************************************/
+
+static double snr[18] = { 0.00, 7.00, 11.00, 16.00, 20.84,
+ 25.28, 31.59, 37.75, 43.84,
+ 49.89, 55.93, 61.96, 67.98, 74.01,
+ 80.03, 86.05, 92.01, 98.01
+};
+
+int bits_for_nonoise (double perm_smr[2][SBLIMIT],
+ unsigned int scfsi[2][SBLIMIT], frame_info * frame)
+{
+ int sb, ch, ba;
+ int nch = frame->nch;
+ int sblimit = frame->sblimit;
+ int jsbound = frame->jsbound;
+ al_table *alloc = frame->alloc;
+ int req_bits = 0, bbal = 0, berr = 0, banc = 32;
+ int maxAlloc, sel_bits, sc_bits, smp_bits;
+ static int sfsPerScfsi[] = { 3, 2, 1, 2 }; /* lookup # sfs per scfsi */
+
+ /* added 92-08-11 shn */
+ if (frame->header->error_protection)
+ berr = 16;
+ else
+ berr = 0;
+
+ for (sb = 0; sb < jsbound; ++sb)
+ bbal += nch * (*alloc)[sb][0].bits;
+ for (sb = jsbound; sb < sblimit; ++sb)
+ bbal += (*alloc)[sb][0].bits;
+ req_bits = banc + bbal + berr;
+
+ for (sb = 0; sb < sblimit; ++sb)
+ for (ch = 0; ch < ((sb < jsbound) ? nch : 1); ++ch) {
+ maxAlloc = (1 << (*alloc)[sb][0].bits) - 1;
+ sel_bits = sc_bits = smp_bits = 0;
+ for (ba = 0; ba < maxAlloc - 1; ++ba)
+ if ((-perm_smr[ch][sb] +
+ snr[(*alloc)[sb][ba].quant + ((ba > 0) ? 1 : 0)]) >=
+ NOISY_MIN_MNR)
+ break; /* we found enough bits */
+ if (nch == 2 && sb >= jsbound) /* check other JS channel */
+ for (; ba < maxAlloc - 1; ++ba)
+ if ((-perm_smr[1 - ch][sb] +
+ snr[(*alloc)[sb][ba].quant + ((ba > 0) ? 1 : 0)]) >=
+ NOISY_MIN_MNR)
+ break;
+ if (ba > 0) {
+ smp_bits =
+ SCALE_BLOCK * ((*alloc)[sb][ba].group * (*alloc)[sb][ba].bits);
+ /* scale factor bits required for subband */
+ sel_bits = 2;
+ sc_bits = 6 * sfsPerScfsi[scfsi[ch][sb]];
+ if (nch == 2 && sb >= jsbound) {
+ /* each new js sb has L+R scfsis */
+ sel_bits += 2;
+ sc_bits += 6 * sfsPerScfsi[scfsi[1 - ch][sb]];
+ }
+ req_bits += smp_bits + sel_bits + sc_bits;
+ }
+ }
+ return req_bits;
+}
+
+int VBR_bits_for_nonoise (double perm_smr[2][SBLIMIT],
+ unsigned int scfsi[2][SBLIMIT],
+ frame_info * frame, int vbrlevel)
+{
+ int sb, ch, ba;
+ int nch = frame->nch;
+ int sblimit = frame->sblimit;
+ int jsbound = frame->jsbound;
+ al_table *alloc = frame->alloc;
+ int req_bits = 0, bbal = 0, berr = 0, banc = 32;
+ int maxAlloc, sel_bits, sc_bits, smp_bits;
+ static int sfsPerScfsi[] = { 3, 2, 1, 2 }; /* lookup # sfs per scfsi */
+
+ /* added 92-08-11 shn */
+ if (frame->header->error_protection)
+ berr = 16;
+ else
+ berr = 0;
+
+ for (sb = 0; sb < jsbound; ++sb)
+ bbal += nch * (*alloc)[sb][0].bits;
+ for (sb = jsbound; sb < sblimit; ++sb)
+ bbal += (*alloc)[sb][0].bits;
+ req_bits = banc + bbal + berr;
+
+ for (sb = 0; sb < sblimit; ++sb)
+ for (ch = 0; ch < ((sb < jsbound) ? nch : 1); ++ch) {
+ maxAlloc = (1 << (*alloc)[sb][0].bits) - 1;
+ sel_bits = sc_bits = smp_bits = 0;
+ for (ba = 0; ba < maxAlloc - 1; ++ba)
+ /* The change between this function and the normal one is that the MIN_MNR is increased by the vbrlevel */
+ if ((-perm_smr[ch][sb] +
+ snr[(*alloc)[sb][ba].quant + ((ba > 0) ? 1 : 0)]) >=
+ NOISY_MIN_MNR + vbrlevel)
+ break; /* we found enough bits */
+ if (nch == 2 && sb >= jsbound) /* check other JS channel */
+ for (; ba < maxAlloc - 1; ++ba)
+ if ((-perm_smr[1 - ch][sb] +
+ snr[(*alloc)[sb][ba].quant + ((ba > 0) ? 1 : 0)]) >=
+ NOISY_MIN_MNR + vbrlevel)
+ break;
+ if (ba > 0) {
+ smp_bits =
+ SCALE_BLOCK * ((*alloc)[sb][ba].group * (*alloc)[sb][ba].bits);
+ /* scale factor bits required for subband */
+ sel_bits = 2;
+ sc_bits = 6 * sfsPerScfsi[scfsi[ch][sb]];
+ if (nch == 2 && sb >= jsbound) {
+ /* each new js sb has L+R scfsis */
+ sel_bits += 2;
+ sc_bits += 6 * sfsPerScfsi[scfsi[1 - ch][sb]];
+ }
+ req_bits += smp_bits + sel_bits + sc_bits;
+ }
+ }
+ return req_bits;
+}
+
+/************************************************************************
+*
+* main_bit_allocation (Layer II)
+*
+* PURPOSE:For joint stereo mode, determines which of the 4 joint
+* stereo modes is needed. Then calls *_a_bit_allocation(), which
+* allocates bits for each of the subbands until there are no more bits
+* left, or the MNR is at the noise/no_noise threshold.
+*
+* SEMANTICS:
+*
+* For joint stereo mode, joint stereo is changed to stereo if
+* there are enough bits to encode stereo at or better than the
+* no-noise threshold (NOISY_MIN_MNR). Otherwise, the system
+* iteratively allocates less bits by using joint stereo until one
+* of the following occurs:
+* - there are no more noisy subbands (MNR >= NOISY_MIN_MNR)
+* - mode_ext has been reduced to 0, which means that all but the
+* lowest 4 subbands have been converted from stereo to joint
+* stereo, and no more subbands may be converted
+*
+* This function calls *_bits_for_nonoise() and *_a_bit_allocation().
+*
+************************************************************************/
+void main_bit_allocation (double perm_smr[2][SBLIMIT],
+ unsigned int scfsi[2][SBLIMIT],
+ unsigned int bit_alloc[2][SBLIMIT], int *adb,
+ frame_info * frame, options * glopts)
+{
+ int noisy_sbs;
+ int mode, mode_ext, lay;
+ int rq_db; /* av_db = *adb; Not Used MFC Nov 99 */
+
+ /* these are the tables which specify the limits within which the VBR can vary
+ You can't vary outside these ranges, otherwise a new alloc table would have to
+ be loaded in the middle of encoding. This VBR hack is dodgy - the standard
+ says that LayerII decoders don't have to support a variable bitrate, but Layer3
+ decoders must do so. Hence, it is unlikely that a compliant layer2 decoder would be
+ written to dynmically change allocation tables. *BUT* a layer3 encoder might handle it
+ by default meaning we could switch tables mid-encode and enjoy a wider range of bitrates
+ for the VBR encoding.
+ None of this needs to be done for LSF, since there is only *one* possible alloc table in LSF
+ MFC Feb 2003 */
+ int vbrlimits[2][3][2] = {
+ /* MONO */
+ { /* 44 */ {6, 10},
+ /* 48 */ {3, 10},
+ /* 32 */ {6, 10}},
+ /* STEREO */
+ { /* 44 */ {10, 14},
+ /* 48 */ {7, 14},
+ /* 32 */ {10, 14}}
+ };
+
+ static int init = 0;
+ static int lower = 10, upper = 10;
+ static int bitrateindextobits[15] =
+ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+ int guessindex = 0;
+
+ if (init == 0) {
+ int nch = 1;
+ int sfreq;
+ frame_header *header = frame->header;
+ init++;
+ if (header->version == 0) {
+ /* LSF: so can use any bitrate index from 1->15 */
+ lower = 1;
+ upper = 14;
+ } else {
+ if (frame->actual_mode == MPG_MD_MONO)
+ nch = 0;
+ sfreq = header->sampling_frequency;
+ lower = vbrlimits[nch][sfreq][0];
+ upper = vbrlimits[nch][sfreq][1];
+ }
+ if (glopts->verbosity > 2)
+ fprintf (stdout, "VBR bitrate index limits [%i -> %i]\n", lower, upper);
+
+ {
+ /* set up a conversion table for bitrateindex->bits for this version/sampl freq
+ This will be used to find the best bitrate to cope with the number of bits that
+ are needed (as determined by VBR_bits_for_nonoise) */
+ int brindex;
+ frame_header *header = frame->header;
+ for (brindex = lower; brindex <= upper; brindex++) {
+ bitrateindextobits[brindex] =
+ (int) (1152.0 / s_freq[header->version][header->sampling_frequency]) *
+ ((double) bitrate[header->version][brindex]);
+ }
+ }
+
+ }
+
+ if ((mode = frame->actual_mode) == MPG_MD_JOINT_STEREO) {
+ frame->header->mode = MPG_MD_STEREO;
+ frame->header->mode_ext = 0;
+ frame->jsbound = frame->sblimit;
+ if ((rq_db = bits_for_nonoise (perm_smr, scfsi, frame)) > *adb) {
+ frame->header->mode = MPG_MD_JOINT_STEREO;
+ mode_ext = 4; /* 3 is least severe reduction */
+ lay = frame->header->lay;
+ do {
+ --mode_ext;
+ frame->jsbound = js_bound (mode_ext);
+ rq_db = bits_for_nonoise (perm_smr, scfsi, frame);
+ }
+ while ((rq_db > *adb) && (mode_ext > 0));
+ frame->header->mode_ext = mode_ext;
+ } /* well we either eliminated noisy sbs or mode_ext == 0 */
+ }
+
+ /* decide on which bit allocation method to use */
+ if (glopts->vbr == FALSE) {
+ /* Just do the old bit allocation method */
+ noisy_sbs = a_bit_allocation (perm_smr, scfsi, bit_alloc, adb, frame);
+ } else {
+ /* do the VBR bit allocation method */
+ frame->header->bitrate_index = lower;
+ *adb = available_bits (frame->header, glopts);
+ {
+ int brindex;
+ int found = FALSE;
+
+ /* Work out how many bits are needed for there to be no noise (ie all MNR > 0.0 + VBRLEVEL) */
+ int req =
+ VBR_bits_for_nonoise (perm_smr, scfsi, frame, glopts->vbrlevel);
+
+ /* Look up this value in the bitrateindextobits table to find what bitrate we should use for
+ this frame */
+ for (brindex = lower; brindex <= upper; brindex++) {
+ if (bitrateindextobits[brindex] > req) {
+ /* this method always *overestimates* the bits that are needed
+ i.e. it will usually guess right but
+ when it's wrong it'll guess a higher bitrate than actually required.
+ e.g. on "messages from earth" track 6, the guess was
+ wrong on 75/36341 frames. each time it guessed higher.
+ MFC Feb 2003 */
+ guessindex = brindex;
+ found = TRUE;
+ break;
+ }
+ }
+ /* Just for sanity */
+ if (found == FALSE)
+ guessindex = upper;
+ }
+
+ frame->header->bitrate_index = guessindex;
+ *adb = available_bits (frame->header, glopts);
+
+ /* update the statistics */
+ vbrstats[frame->header->bitrate_index]++;
+
+ if (glopts->verbosity > 2) {
+ /* print out the VBR stats every 1000th frame */
+ static int count = 0;
+ int i;
+ if ((count++ % 1000) == 0) {
+ for (i = 1; i < 15; i++)
+ fprintf (stdout, "%4i ", vbrstats[i]);
+ fprintf (stdout, "\n");
+ }
+
+ /* Print out *every* frames bitrateindex, bits required, and bits available at this bitrate */
+ if (glopts->verbosity > 5)
+ fprintf (stdout,
+ "> bitrate index %2i has %i bits available to encode the %i bits\n",
+ frame->header->bitrate_index, *adb,
+ VBR_bits_for_nonoise (perm_smr, scfsi, frame,
+ glopts->vbrlevel));
+
+ }
+
+ noisy_sbs =
+ VBR_bit_allocation (perm_smr, scfsi, bit_alloc, adb, frame, glopts);
+ }
+}
+
+void VBR_maxmnr (double mnr[2][SBLIMIT], char used[2][SBLIMIT], int sblimit,
+ int nch, int *min_sb, int *min_ch, options * glopts)
+{
+ int i, k;
+ double small;
+
+ small = 999999.0;
+ *min_sb = -1;
+ *min_ch = -1;
+ for (k = 0; k < nch; ++k)
+ for (i = 0; i < sblimit; i++)
+ if (used[k][i] != 2 && small > mnr[k][i]) {
+ small = mnr[k][i];
+ *min_sb = i;
+ *min_ch = k;
+ }
+}
+/********************
+MFC Feb 2003
+VBR_bit_allocation is different to the normal a_bit_allocation in that
+it is known beforehand that there are definitely enough bits to do what we
+have to - i.e. a bitrate was specificially chosen in main_bit_allocation so
+that we have enough bits to encode what we have to.
+This function should take that into account and just greedily assign
+the bits, rather than fussing over the minimum MNR subband - we know
+each subband gets its required bits, why quibble?
+This function doesn't chew much CPU, so I haven't made any attempt
+to do this yet.
+*********************/
+int
+VBR_bit_allocation (double perm_smr[2][SBLIMIT],
+ unsigned int scfsi[2][SBLIMIT],
+ unsigned int bit_alloc[2][SBLIMIT], int *adb,
+ frame_info * frame, options * glopts)
+{
+ int i, min_ch, min_sb, oth_ch, k, increment, scale, seli, ba;
+ int bspl, bscf, bsel, ad, bbal = 0;
+ double mnr[2][SBLIMIT];
+ char used[2][SBLIMIT];
+ int nch = frame->nch;
+ int sblimit = frame->sblimit;
+ int jsbound = frame->jsbound;
+ al_table *alloc = frame->alloc;
+ static char init = 0;
+ static int banc = 32, berr = 0;
+ static int sfsPerScfsi[] = { 3, 2, 1, 2 }; /* lookup # sfs per scfsi */
+
+ if (!init) {
+ init = 1;
+ if (frame->header->error_protection)
+ berr = 16; /* added 92-08-11 shn */
+ }
+
+ for (i = 0; i < jsbound; ++i)
+ bbal += nch * (*alloc)[i][0].bits;
+ for (i = jsbound; i < sblimit; ++i)
+ bbal += (*alloc)[i][0].bits;
+ *adb -= bbal + berr + banc;
+ ad = *adb;
+
+ for (i = 0; i < sblimit; i++)
+ for (k = 0; k < nch; k++) {
+ mnr[k][i] = snr[0] - perm_smr[k][i];
+ bit_alloc[k][i] = 0;
+ used[k][i] = 0;
+ }
+ bspl = bscf = bsel = 0;
+
+ do {
+ /* locate the subband with minimum SMR */
+ VBR_maxmnr (mnr, used, sblimit, nch, &min_sb, &min_ch, glopts);
+
+ if (min_sb > -1) { /* there was something to find */
+ /* find increase in bit allocation in subband [min] */
+ increment =
+ SCALE_BLOCK * ((*alloc)[min_sb][bit_alloc[min_ch][min_sb] + 1].group *
+ (*alloc)[min_sb][bit_alloc[min_ch][min_sb] + 1].bits);
+ if (used[min_ch][min_sb])
+ increment -=
+ SCALE_BLOCK * ((*alloc)[min_sb][bit_alloc[min_ch][min_sb]].group *
+ (*alloc)[min_sb][bit_alloc[min_ch][min_sb]].bits);
+
+ /* scale factor bits required for subband [min] */
+ oth_ch = 1 - min_ch; /* above js bound, need both chans */
+ if (used[min_ch][min_sb])
+ scale = seli = 0;
+ else { /* this channel had no bits or scfs before */
+ seli = 2;
+ scale = 6 * sfsPerScfsi[scfsi[min_ch][min_sb]];
+ if (nch == 2 && min_sb >= jsbound) {
+ /* each new js sb has L+R scfsis */
+ seli += 2;
+ scale += 6 * sfsPerScfsi[scfsi[oth_ch][min_sb]];
+ }
+ }
+
+ /* check to see enough bits were available for */
+ /* increasing resolution in the minimum band */
+ if (ad >= bspl + bscf + bsel + seli + scale + increment) {
+ ba = ++bit_alloc[min_ch][min_sb]; /* next up alloc */
+ bspl += increment; /* bits for subband sample */
+ bscf += scale; /* bits for scale factor */
+ bsel += seli; /* bits for scfsi code */
+ used[min_ch][min_sb] = 1; /* subband has bits */
+ mnr[min_ch][min_sb] =
+ -perm_smr[min_ch][min_sb] + snr[(*alloc)[min_sb][ba].quant + 1];
+ /* Check if subband has been fully allocated max bits */
+ if (ba >= (1 << (*alloc)[min_sb][0].bits) - 1)
+ used[min_ch][min_sb] = 2; /* don't let this sb get any more bits */
+ } else
+ used[min_ch][min_sb] = 2; /* can't increase this alloc */
+
+ if (min_sb >= jsbound && nch == 2) {
+ /* above jsbound, alloc applies L+R */
+ ba = bit_alloc[oth_ch][min_sb] = bit_alloc[min_ch][min_sb];
+ used[oth_ch][min_sb] = used[min_ch][min_sb];
+ mnr[oth_ch][min_sb] =
+ -perm_smr[oth_ch][min_sb] + snr[(*alloc)[min_sb][ba].quant + 1];
+ }
+
+ }
+ }
+ while (min_sb > -1); /* until could find no channel */
+
+ /* Calculate the number of bits left */
+ ad -= bspl + bscf + bsel;
+ *adb = ad;
+ for (k = 0; k < nch; k++)
+ for (i = sblimit; i < SBLIMIT; i++)
+ bit_alloc[k][i] = 0;
+
+ return 0;
+}
+
+/************************************************************************
+*
+* a_bit_allocation (Layer II)
+*
+* PURPOSE:Adds bits to the subbands with the lowest mask-to-noise
+* ratios, until the maximum number of bits for the subband has
+* been allocated.
+*
+* SEMANTICS:
+* 1. Find the subband and channel with the smallest MNR (#min_sb#,
+* and #min_ch#)
+* 2. Calculate the increase in bits needed if we increase the bit
+* allocation to the next higher level
+* 3. If there are enough bits available for increasing the resolution
+* in #min_sb#, #min_ch#, and the subband has not yet reached its
+* maximum allocation, update the bit allocation, MNR, and bits
+ available accordingly
+* 4. Repeat until there are no more bits left, or no more available
+* subbands. (A subband is still available until the maximum
+* number of bits for the subband has been allocated, or there
+* aren't enough bits to go to the next higher resolution in the
+ subband.)
+*
+************************************************************************/
+
+void maxmnr (double mnr[2][SBLIMIT], char used[2][SBLIMIT], int sblimit,
+ int nch, int *min_sb, int *min_ch)
+{
+ int i, k;
+ double small;
+
+ small = 999999.0;
+ *min_sb = -1;
+ *min_ch = -1;
+ for (k = 0; k < nch; ++k)
+ for (i = 0; i < sblimit; i++)
+ if (used[k][i] != 2 && small > mnr[k][i]) {
+ small = mnr[k][i];
+ *min_sb = i;
+ *min_ch = k;
+ }
+}
+
+int a_bit_allocation (double perm_smr[2][SBLIMIT],
+ unsigned int scfsi[2][SBLIMIT],
+ unsigned int bit_alloc[2][SBLIMIT], int *adb,
+ frame_info * frame)
+{
+ int i, min_ch, min_sb, oth_ch, k, increment, scale, seli, ba;
+ int bspl, bscf, bsel, ad, bbal = 0;
+ double mnr[2][SBLIMIT];
+ char used[2][SBLIMIT];
+ int nch = frame->nch;
+ int sblimit = frame->sblimit;
+ int jsbound = frame->jsbound;
+ al_table *alloc = frame->alloc;
+ static char init = 0;
+ static int banc = 32, berr = 0;
+ static int sfsPerScfsi[] = { 3, 2, 1, 2 }; /* lookup # sfs per scfsi */
+
+#define CHECKITERx
+#ifdef CHECKITER
+ int count=0;
+#endif
+
+ if (!init) {
+ init = 1;
+ if (frame->header->error_protection)
+ berr = 16; /* added 92-08-11 shn */
+ }
+
+ for (i = 0; i < jsbound; ++i)
+ bbal += nch * (*alloc)[i][0].bits;
+ for (i = jsbound; i < sblimit; ++i)
+ bbal += (*alloc)[i][0].bits;
+ *adb -= bbal + berr + banc;
+ ad = *adb;
+
+ for (i = 0; i < sblimit; i++)
+ for (k = 0; k < nch; k++) {
+ mnr[k][i] = snr[0] - perm_smr[k][i];
+ bit_alloc[k][i] = 0;
+ used[k][i] = 0;
+ }
+ bspl = bscf = bsel = 0;
+
+ do {
+#ifdef CHECKITER
+ count++;
+#endif
+ /* locate the subband with minimum SMR */
+ maxmnr (mnr, used, sblimit, nch, &min_sb, &min_ch);
+
+ if (min_sb > -1) { /* there was something to find */
+ /* find increase in bit allocation in subband [min] */
+ increment =
+ SCALE_BLOCK * ((*alloc)[min_sb][bit_alloc[min_ch][min_sb] + 1].group *
+ (*alloc)[min_sb][bit_alloc[min_ch][min_sb] + 1].bits);
+ if (used[min_ch][min_sb])
+ increment -=
+ SCALE_BLOCK * ((*alloc)[min_sb][bit_alloc[min_ch][min_sb]].group *
+ (*alloc)[min_sb][bit_alloc[min_ch][min_sb]].bits);
+
+ /* scale factor bits required for subband [min] */
+ oth_ch = 1 - min_ch; /* above js bound, need both chans */
+ if (used[min_ch][min_sb])
+ scale = seli = 0;
+ else { /* this channel had no bits or scfs before */
+ seli = 2;
+ scale = 6 * sfsPerScfsi[scfsi[min_ch][min_sb]];
+ if (nch == 2 && min_sb >= jsbound) {
+ /* each new js sb has L+R scfsis */
+ seli += 2;
+ scale += 6 * sfsPerScfsi[scfsi[oth_ch][min_sb]];
+ }
+ }
+
+ /* check to see enough bits were available for */
+ /* increasing resolution in the minimum band */
+ if (ad >= bspl + bscf + bsel + seli + scale + increment) {
+ ba = ++bit_alloc[min_ch][min_sb]; /* next up alloc */
+ bspl += increment; /* bits for subband sample */
+ bscf += scale; /* bits for scale factor */
+ bsel += seli; /* bits for scfsi code */
+ used[min_ch][min_sb] = 1; /* subband has bits */
+ mnr[min_ch][min_sb] =
+ -perm_smr[min_ch][min_sb] + snr[(*alloc)[min_sb][ba].quant + 1];
+ /* Check if subband has been fully allocated max bits */
+ if (ba >= (1 << (*alloc)[min_sb][0].bits) - 1)
+ used[min_ch][min_sb] = 2; /* don't let this sb get any more bits */
+ } else
+ used[min_ch][min_sb] = 2; /* can't increase this alloc */
+
+ if (min_sb >= jsbound && nch == 2) {
+ /* above jsbound, alloc applies L+R */
+ ba = bit_alloc[oth_ch][min_sb] = bit_alloc[min_ch][min_sb];
+ used[oth_ch][min_sb] = used[min_ch][min_sb];
+ mnr[oth_ch][min_sb] =
+ -perm_smr[oth_ch][min_sb] + snr[(*alloc)[min_sb][ba].quant + 1];
+ }
+
+ }
+ }
+ while (min_sb > -1); /* until could find no channel */
+
+ /* Calculate the number of bits left */
+ ad -= bspl + bscf + bsel;
+ *adb = ad;
+ for (k = 0; k < nch; k++)
+ for (i = sblimit; i < SBLIMIT; i++)
+ bit_alloc[k][i] = 0;
+
+#ifdef USELESSCODE
+ /* this function is declared to return an INT, which is meant to be a count
+ of the subbands which are still noisy. But, the return value is ignored,
+ so why bother? Is the count of noisy_sbs useful as any sort of
+ quality measure? Leave this in, until I'm sure that noisy_sbs couldn't
+ be used for something
+ MFC Feb 2003 */
+
+ noisy_sbs = 0; /* calc worst noise in case */
+ for (k = 0; k < nch; ++k) {
+ for (i = 0; i < sblimit; i++) {
+ if (mnr[k][i] < NOISY_MIN_MNR)
+ ++noisy_sbs; /* noise is not masked */
+ }
+ }
+ return noisy_sbs;
+#endif
+#ifdef CHECKITER
+ fprintf(stdout,"a bit alloc %i\n", count);
+#endif
+ return 0;
+}
+
+/************************************************************************
+*
+* subband_quantization (Layer II)
+*
+* PURPOSE:Quantizes subband samples to appropriate number of bits
+*
+* SEMANTICS: Subband samples are divided by their scalefactors, which
+ makes the quantization more efficient. The scaled samples are
+* quantized by the function a*x+b, where a and b are functions of
+* the number of quantization levels. The result is then truncated
+* to the appropriate number of bits and the MSB is inverted.
+*
+* Note that for fractional 2's complement, inverting the MSB for a
+ negative number x is equivalent to adding 1 to it.
+*
+************************************************************************/
+#define PDS3
+#ifdef PDS3
+static double a[17] = {
+ 0.750000000, 0.625000000, 0.875000000, 0.562500000, 0.937500000,
+ 0.968750000, 0.984375000, 0.992187500, 0.996093750, 0.998046875,
+ 0.999023438, 0.999511719, 0.999755859, 0.999877930, 0.999938965,
+ 0.999969482, 0.999984741
+};
+
+static double b[17] = {
+ -0.250000000, -0.375000000, -0.125000000, -0.437500000, -0.062500000,
+ -0.031250000, -0.015625000, -0.007812500, -0.003906250, -0.001953125,
+ -0.000976563, -0.000488281, -0.000244141, -0.000122070, -0.000061035,
+ -0.000030518, -0.000015259
+};
+
+static unsigned int pds_quant_bits[17] = {
+ /* for a number of quantization steps; */
+ /* 3, 5, 7, 9, 15,
+ 31, 63, 127, 255, 511,
+ 1023, 2047, 4095, 8191, 16383,
+ 32767, 65535
+ */
+ /* below we need : */
+ 2, 4, 4, 8, 8,
+ 16, 32, 64, 128, 256,
+ 512, 1024, 2048, 4096, 8192,
+ 16384, 32768
+};
+/* to retain succesfull quant */
+/* This is only a quick and dirty tric to speed up ISO code */
+/* In below quant routine : also rewrote loops to decrement */
+/* Added/changed by Patrick De Smet, Nov. 1999 */
+
+/* PDS TODO: maybe it is faster not to store pds_quant_bits */
+/* but rather store (char) n, and use (1L shift left n) ; */
+/* is a shift faster than loading unsigned int from array ? */
+
+void
+subband_quantization (unsigned int scalar[2][3][SBLIMIT],
+ double sb_samples[2][3][SCALE_BLOCK][SBLIMIT],
+ unsigned int j_scale[3][SBLIMIT],
+ double j_samps[3][SCALE_BLOCK][SBLIMIT],
+ unsigned int bit_alloc[2][SBLIMIT],
+ unsigned int sbband[2][3][SCALE_BLOCK][SBLIMIT],
+ frame_info * frame)
+{
+ int i, j, k, s, qnt, sig;
+ int nch = frame->nch;
+ int sblimit = frame->sblimit;
+ int jsbound = frame->jsbound;
+ double d;
+ al_table *alloc = frame->alloc;
+
+ for (s = 3; s--;)
+ for (j = SCALE_BLOCK; j--;)
+ for (i = sblimit; i--;)
+ for (k = ((i < jsbound) ? nch : 1); k--;)
+ if (bit_alloc[k][i]) {
+ /* scale and quantize FLOATing point sample */
+ if (nch == 2 && i >= jsbound) /* use j-stereo samples */
+ d = j_samps[s][j][i] / multiple[j_scale[s][i]];
+ else
+ d = sb_samples[k][s][j][i] / multiple[scalar[k][s][i]];
+ if (fabs(d) > 1.0)
+ fprintf (stderr, "Not scaled properly %d %d %d %d\n", k, s, j,
+ i);
+ qnt = (*alloc)[i][bit_alloc[k][i]].quant;
+ d = d * a[qnt] + b[qnt];
+ /* extract MSB N-1 bits from the FLOATing point sample */
+ if (d >= 0)
+ sig = 1;
+ else {
+ sig = 0;
+ d += 1.0;
+ }
+ sbband[k][s][j][i] =
+ (unsigned int) (d * (double) (pds_quant_bits[qnt]));
+ /* tag the inverted sign bit to sbband at position N */
+ /* The bit inversion is a must for grouping with 3,5,9 steps
+ so it is done for all subbands */
+ if (sig)
+ sbband[k][s][j][i] |= (pds_quant_bits[qnt]);
+ }
+ for (s = 3; s--;)
+ for (j = sblimit; j < SBLIMIT; j++)
+ for (i = SCALE_BLOCK; i--;)
+ for (k = nch; k--;)
+ sbband[k][s][i][j] = 0;
+}
+#else
+
+static double a[17] = {
+ 0.750000000, 0.625000000, 0.875000000, 0.562500000, 0.937500000,
+ 0.968750000, 0.984375000, 0.992187500, 0.996093750, 0.998046875,
+ 0.999023438, 0.999511719, 0.999755859, 0.999877930, 0.999938965,
+ 0.999969482, 0.999984741
+};
+
+static double b[17] = {
+ -0.250000000, -0.375000000, -0.125000000, -0.437500000, -0.062500000,
+ -0.031250000, -0.015625000, -0.007812500, -0.003906250, -0.001953125,
+ -0.000976563, -0.000488281, -0.000244141, -0.000122070, -0.000061035,
+ -0.000030518, -0.000015259
+};
+
+void
+subband_quantization (unsigned int scalar[2][3][SBLIMIT],
+ double sb_samples[2][3][SCALE_BLOCK][SBLIMIT],
+ unsigned int j_scale[3][SBLIMIT],
+ double j_samps[3][SCALE_BLOCK][SBLIMIT],
+ unsigned int bit_alloc[2][SBLIMIT],
+ unsigned int sbband[2][3][SCALE_BLOCK][SBLIMIT],
+ frame_info * frame)
+{
+ int i, j, k, s, n, qnt, sig;
+ int nch = frame->nch;
+ int sblimit = frame->sblimit;
+ int jsbound = frame->jsbound;
+ unsigned int stps;
+ double d;
+ al_table *alloc = frame->alloc;
+
+ for (s = 0; s < 3; s++)
+ for (j = 0; j < SCALE_BLOCK; j++)
+ for (i = 0; i < sblimit; i++)
+ for (k = 0; k < ((i < jsbound) ? nch : 1); k++)
+ if (bit_alloc[k][i]) {
+ /* scale and quantize FLOATing point sample */
+ if (nch == 2 && i >= jsbound) /* use j-stereo samples */
+ d = j_samps[s][j][i] / multiple[j_scale[s][i]];
+ else
+ d = sb_samples[k][s][j][i] / multiple[scalar[k][s][i]];
+ if (mod (d) > 1.0)
+ fprintf (stderr, "Not scaled properly %d %d %d %d\n", k, s, j,
+ i);
+ qnt = (*alloc)[i][bit_alloc[k][i]].quant;
+ d = d * a[qnt] + b[qnt];
+ /* extract MSB N-1 bits from the FLOATing point sample */
+ if (d >= 0)
+ sig = 1;
+ else {
+ sig = 0;
+ d += 1.0;
+ }
+ n = 0;
+ stps = (*alloc)[i][bit_alloc[k][i]].steps;
+ while ((1L << n) < stps)
+ n++;
+ n--;
+ sbband[k][s][j][i] = (unsigned int) (d * (double) (1L << n));
+ /* tag the inverted sign bit to sbband at position N */
+ /* The bit inversion is a must for grouping with 3,5,9 steps
+ so it is done for all subbands */
+ if (sig)
+ sbband[k][s][j][i] |= 1 << n;
+ }
+
+ for (k = 0; k < nch; k++)
+ for (s = 0; s < 3; s++)
+ for (i = 0; i < SCALE_BLOCK; i++)
+ for (j = sblimit; j < SBLIMIT; j++)
+ sbband[k][s][i][j] = 0;
+}
+#endif
+
+/*************************************************************************
+* encode_bit_alloc (Layer II)
+*
+* PURPOSE:Writes bit allocation information onto bitstream
+*
+* Layer II uses 4,3,2, or 0 bits depending on the
+* quantization table used.
+*
+************************************************************************/
+
+void encode_bit_alloc (unsigned int bit_alloc[2][SBLIMIT],
+ frame_info * frame, Bit_stream_struc * bs)
+{
+ int i, k;
+ int nch = frame->nch;
+ int sblimit = frame->sblimit;
+ int jsbound = frame->jsbound;
+ al_table *alloc = frame->alloc;
+
+ for (i = 0; i < sblimit; i++)
+ for (k = 0; k < ((i < jsbound) ? nch : 1); k++)
+ putbits (bs, bit_alloc[k][i], (*alloc)[i][0].bits);
+}
+
+/************************************************************************
+*
+* sample_encoding (Layer II)
+*
+* PURPOSE:Put one frame of subband samples on to the bitstream
+*
+* SEMANTICS: The number of bits allocated per sample is read from
+* the bit allocation information #bit_alloc#. Layer 2
+* supports writing grouped samples for quantization steps
+* that are not a power of 2.
+*
+************************************************************************/
+
+void sample_encoding (unsigned int sbband[2][3][SCALE_BLOCK][SBLIMIT],
+ unsigned int bit_alloc[2][SBLIMIT],
+ frame_info * frame, Bit_stream_struc * bs)
+{
+ unsigned int temp;
+ unsigned int i, j, k, s, x, y;
+ int nch = frame->nch;
+ int sblimit = frame->sblimit;
+ int jsbound = frame->jsbound;
+ al_table *alloc = frame->alloc;
+
+ for (s = 0; s < 3; s++)
+ for (j = 0; j < SCALE_BLOCK; j += 3)
+ for (i = 0; i < sblimit; i++)
+ for (k = 0; k < ((i < jsbound) ? nch : 1); k++)
+ if (bit_alloc[k][i]) {
+ if ((*alloc)[i][bit_alloc[k][i]].group == 3) {
+ for (x = 0; x < 3; x++)
+ putbits (bs, sbband[k][s][j + x][i],
+ (*alloc)[i][bit_alloc[k][i]].bits);
+ } else {
+ y = (*alloc)[i][bit_alloc[k][i]].steps;
+ temp =
+ sbband[k][s][j][i] + sbband[k][s][j + 1][i] * y +
+ sbband[k][s][j + 2][i] * y * y;
+ putbits (bs, temp, (*alloc)[i][bit_alloc[k][i]].bits);
+ }
+ }
+}
+
+/************************************************************************
+*
+* encode_CRC
+*
+************************************************************************/
+
+void encode_CRC (unsigned int crc, Bit_stream_struc * bs)
+{
+ putbits (bs, crc, 16);
+}