From 22f1fce330059ef8a383cf327a023d6a9da5ad3e Mon Sep 17 00:00:00 2001 From: "Matthias P. Braendli" Date: Mon, 15 Feb 2016 02:44:20 +0100 Subject: Include toolame-dab as library --- libtoolame-dab/encode_new.c | 1188 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1188 insertions(+) create mode 100644 libtoolame-dab/encode_new.c (limited to 'libtoolame-dab/encode_new.c') diff --git a/libtoolame-dab/encode_new.c b/libtoolame-dab/encode_new.c new file mode 100644 index 0000000..2e797c9 --- /dev/null +++ b/libtoolame-dab/encode_new.c @@ -0,0 +1,1188 @@ +#include +#include +#include +#include "common.h" +#include "options.h" +#include "bitstream.h" +#include "availbits.h" +#include "encode_new.h" + +#define NUMTABLES 5 +int vbrstats_new[15] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + +/* There are really only 9 distinct lines in the allocation tables + each member of this table is an index into */ +/* step_index[linenumber][index] */ +static int step_index[9][16] = { + /*0*/ {0, 1, 3, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17}, + /*1*/ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,17}, + /*2*/ {0, 1, 2, 3, 4, 5, 6,17, 0, 0, 0, 0, 0, 0, 0, 0}, + /*3*/ {0, 1, 2, 17,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, + /*4*/ {0, 1, 2, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16}, + /*5*/ {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0}, + /* From ISO13818 Table B.1 */ + /*6*/ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15}, + /*7*/ {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0}, + /*8*/ {0, 1, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} +}; + +static int nbal[9] = {4, 4, 3, 2, 4, 3, 4, 3, 2}; + + +/* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 */ +/* The number of steps allowed */ +static int steps[18] = {0, 3, 5, 7, 9, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535}; +/* The power of 2 just under the steps value */ +static int steps2n[18]={0, 2, 4, 4, 8, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768}; +/* The bits per codeword from TableB.4 */ +static int bits[18] = {0, 5, 7, 3, 10, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; +/* Samples per codeword Table B.4 Page 53 */ +//static int group[18] = {0, 3, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; +static int group[18] = {0, 1, 1, 3, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3}; + +/* nbal */ + +/* The sblimits of the 5 allocation tables + 4 tables for MPEG-1 + 1 table for MPEG-2 LSF */ +static int table_sblimit[5] = {27, 30, 8, 12, 30}; + +/* Each table contains a list of allowable quantization steps. + There are only 9 distinct lists of steps. + This table gives the index of which of the 9 lists is being used + A "-1" entry means that it is above the sblimit for this table */ +static int line[5][SBLIMIT] = { + /*00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 */ + {0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3,-1,-1,-1,-1,-1}, + {0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3,-1,-1}, + {4, 4, 5, 5, 5, 5, 5, 5,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}, + {4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}, + /* LSF Table */ + {6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8} +}; + +/* This is ISO11172 Table B.1 */ +double scalefactor[64] = { /* Equation for nth element = 2 / (cuberoot(2) ^ n) */ + 2.00000000000000, 1.58740105196820, 1.25992104989487, + 1.00000000000000, 0.79370052598410, 0.62996052494744, 0.50000000000000, + 0.39685026299205, 0.31498026247372, 0.25000000000000, 0.19842513149602, + 0.15749013123686, 0.12500000000000, 0.09921256574801, 0.07874506561843, + 0.06250000000000, 0.04960628287401, 0.03937253280921, 0.03125000000000, + 0.02480314143700, 0.01968626640461, 0.01562500000000, 0.01240157071850, + 0.00984313320230, 0.00781250000000, 0.00620078535925, 0.00492156660115, + 0.00390625000000, 0.00310039267963, 0.00246078330058, 0.00195312500000, + 0.00155019633981, 0.00123039165029, 0.00097656250000, 0.00077509816991, + 0.00061519582514, 0.00048828125000, 0.00038754908495, 0.00030759791257, + 0.00024414062500, 0.00019377454248, 0.00015379895629, 0.00012207031250, + 0.00009688727124, 0.00007689947814, 0.00006103515625, 0.00004844363562, + 0.00003844973907, 0.00003051757813, 0.00002422181781, 0.00001922486954, + 0.00001525878906, 0.00001211090890, 0.00000961243477, 0.00000762939453, + 0.00000605545445, 0.00000480621738, 0.00000381469727, 0.00000302772723, + 0.00000240310869, 0.00000190734863, 0.00000151386361, 0.00000120155435, + 1E-20 +}; + +/* ISO11172 Table C.5 Layer II Signal to Noise Raios + MFC FIX find a reference for these in terms of bits->SNR value + Index into table is the steps index + index steps SNR + 0 0 0.00 + 1 3 7.00 + 2 5 11.00 + 3 7 16.00 + 4 9 20.84 + etc +*/ +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 tablenum=0; + +int encode_init(frame_info *frame) { + int ws, bsp, br_per_ch, sfrq; + + bsp = frame->header->bitrate_index; + br_per_ch = bitrate[frame->header->version][bsp] / frame->nch; + ws = frame->header->sampling_frequency; + sfrq = s_freq[frame->header->version][ws]; + /* decision rules refer to per-channel bitrates (kbits/sec/chan) */ + if (frame->header->version == MPEG_AUDIO_ID) { /* MPEG-1 */ + if ((sfrq == 48 && br_per_ch >= 56) + || (br_per_ch >= 56 && br_per_ch <= 80)) + tablenum = 0; + else if (sfrq != 48 && br_per_ch >= 96) + tablenum = 1; + else if (sfrq != 32 && br_per_ch <= 48) + tablenum = 2; + else + tablenum = 3; + } else { /* MPEG-2 LSF */ + tablenum = 4; + } + fprintf(stdout,"encode_init: using tablenum %i with sblimit %i\n",tablenum, table_sblimit[tablenum]); + +#define DUMPTABLESx +#ifdef DUMPTABLES + { + int tablenumber,j,sblimit, sb; + fprintf(stdout,"Tables B.21,b,c,d from ISO11172 and the LSF table from ISO13818\n"); + for (tablenumber=0;tablenumber sblimit are no longer computed. + Uses a single sblimit-loop. + Patrick De Smet Oct 1999. */ + int ch, gr; + /* Using '--' loops to avoid possible "cmp value + bne/beq" compiler */ + /* inefficiencies. Below loops should compile to "bne/beq" only code */ + for (ch = nch; ch--;) + for (gr = 3; gr--;) { + int sb; + for (sb = sblimit; sb--;) { + 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[ch][gr][SCALE_BLOCK - 1][sb]); + for (j = SCALE_BLOCK - 1; j--;) { + if ((temp = fabs (sb_sample[ch][gr][j][sb])) > 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 <= scalefactor[scale_fac]) + scale_fac += l; + else + scale_fac -= l; + } + if (cur_max > scalefactor[scale_fac]) + scale_fac--; + sf_index[ch][gr][sb] = scale_fac; + /* There is a direct way of working out the index, if the + maximum value is known but since + it involves a log it isn't really speedy. + Items in the scalefactor[] table are calculated by: + the n'th entry = 2 / (cuberoot(2) ^ n) + And so using a bit of maths you get: + index = (int)(log(2.0/cur_max) / LNCUBEROOTTWO); + fprintf(stdout,"cur_max %.14lf scalefactorindex %i multiple %.14lf\n",cur_max, scale_fac, scalefactor[scale_fac]); + */ + } + } +} +double mod (double a) +{ + return (a > 0) ? a : -a; +} + +/* Combine L&R channels into a mono joint stereo channel */ +void combine_LR_new (double sb_sample[2][3][SCALE_BLOCK][SBLIMIT], + double joint_sample[3][SCALE_BLOCK][SBLIMIT], int sblimit) { + int sb, sample, gr; + + for (sb = 0; sb < sblimit; ++sb) + for (sample = 0; sample < SCALE_BLOCK; ++sample) + for (gr = 0; gr < 3; ++gr) + joint_sample[gr][sample][sb] = + .5 * (sb_sample[0][gr][sample][sb] + sb_sample[1][gr][sample][sb]); +} + +/* 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. + Someone in dist10 source code's history, somebody wrote the following: + "(I would recommend changin max_sc to min_sc)" + + In psy model 1, the *maximum* out of the scale picked here and + the maximum SPL within each subband is selected. So I'd think that + a maximum here makes heaps of sense. + + MFC FIX: Feb 2003 - is this only needed for psy model 1? +*/ +void find_sf_max (unsigned int sf_index[2][3][SBLIMIT], frame_info * frame, + double sf_max[2][SBLIMIT]) +{ + int sb, gr, ch; + int lowest_sf_index; + int nch = frame->nch; + int sblimit = frame->sblimit; + + for (ch = 0; ch < nch; ch++) + for (sb = 0; sb < sblimit; sb++) { + for (gr = 1, lowest_sf_index = sf_index[ch][0][sb]; gr < 3; gr++) + if (lowest_sf_index > sf_index[ch][gr][sb]) + lowest_sf_index = sf_index[ch][gr][sb]; + sf_max[ch][sb] = multiple[lowest_sf_index]; + } + for (sb = sblimit; sb < SBLIMIT; sb++) + sf_max[0][sb] = sf_max[1][sb] = 1E-20; +} + +/* sf_transmission_pattern + 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 + + This is From ISO11172 Sect C.1.5.2.5 "coding of scalefactors" + and + Table C.4 "LayerII Scalefactors Transmission Pattern" +*/ +void sf_transmission_pattern (unsigned int sf_index[2][3][SBLIMIT], + unsigned int sf_selectinfo[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] = (sf_index[k][0][i] - sf_index[k][1][i]); + dscf[1] = (sf_index[k][1][i] - sf_index[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: + sf_selectinfo[k][i] = 0; + break; + case 0x122: + sf_selectinfo[k][i] = 3; + sf_index[k][2][i] = sf_index[k][1][i]; + break; + case 0x133: + sf_selectinfo[k][i] = 3; + sf_index[k][1][i] = sf_index[k][2][i]; + break; + case 0x113: + sf_selectinfo[k][i] = 1; + sf_index[k][1][i] = sf_index[k][0][i]; + break; + case 0x111: + sf_selectinfo[k][i] = 2; + sf_index[k][1][i] = sf_index[k][2][i] = sf_index[k][0][i]; + break; + case 0x222: + sf_selectinfo[k][i] = 2; + sf_index[k][0][i] = sf_index[k][2][i] = sf_index[k][1][i]; + break; + case 0x333: + sf_selectinfo[k][i] = 2; + sf_index[k][0][i] = sf_index[k][1][i] = sf_index[k][2][i]; + break; + case 0x444: + sf_selectinfo[k][i] = 2; + if (sf_index[k][0][i] > sf_index[k][2][i]) + sf_index[k][0][i] = sf_index[k][2][i]; + sf_index[k][1][i] = sf_index[k][2][i] = sf_index[k][0][i]; + } + } +} + +void write_header (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); +} + +/************************************************************************* + encode_bit_alloc (Layer II) + + PURPOSE:Writes bit allocation information onto bitstream + + 4,3,2, or 0 bits depending on the quantization table used. + +************************************************************************/ +void write_bit_alloc (unsigned int bit_alloc[2][SBLIMIT], + frame_info * frame, Bit_stream_struc * bs) +{ + int sb, ch; + int nch = frame->nch; + int sblimit = frame->sblimit; + int jsbound = frame->jsbound; + + for (sb = 0; sb < sblimit; sb++) { + if (sb < jsbound) { + for (ch = 0; ch < ((sb < jsbound) ? nch : 1); ch++) + putbits (bs, bit_alloc[ch][sb], nbal[ line[tablenum][sb] ]); // (*alloc)[sb][0].bits); + } + else + putbits (bs, bit_alloc[0][sb], nbal[ line[tablenum][sb] ]); //(*alloc)[sb][0].bits); + } +} + +/************************************************************************ + write_scalefactors + + PURPOSE:The encoded scalar factor information is arranged and + queued into the output fifo to be transmitted. + + The three scale factors associated with + a given subband and channel are transmitted in accordance + with the scfsi, which is transmitted first. + +************************************************************************/ + +void write_scalefactors (unsigned int bit_alloc[2][SBLIMIT], + unsigned int sf_selectinfo[2][SBLIMIT], + unsigned int sf_index[2][3][SBLIMIT], frame_info * frame, + Bit_stream_struc * bs) +{ + int nch = frame->nch; + int sblimit = frame->sblimit; + int sb, gr, ch; + + /* Write out the scalefactor selection information */ + for (sb = 0; sb < sblimit; sb++) + for (ch = 0; ch < nch; ch++) + if (bit_alloc[ch][sb]) + putbits (bs, sf_selectinfo[ch][sb], 2); + + for (sb = 0; sb < sblimit; sb++) + for (ch = 0; ch < nch; ch++) + if (bit_alloc[ch][sb]) /* above jsbound, bit_alloc[0][i] == ba[1][i] */ + switch (sf_selectinfo[ch][sb]) { + case 0: + for (gr = 0; gr < 3; gr++) + putbits (bs, sf_index[ch][gr][sb], 6); + break; + case 1: + case 3: + putbits (bs, sf_index[ch][0][sb], 6); + putbits (bs, sf_index[ch][2][sb], 6); + break; + case 2: + putbits (bs, sf_index[ch][0][sb], 6); + } +} + + +/* ISO11172 Table C.6 Layer II quantization co-efficients */ +static double a[18] = { + 0, + 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[18] = { + 0, + -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 +}; + +/************************************************************************ + 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. + +************************************************************************/ +void +subband_quantization_new (unsigned int sf_index[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 sb, j, ch, gr, qnt_coeff_index, sig; + int nch = frame->nch; + int sblimit = frame->sblimit; + int jsbound = frame->jsbound; + double d; + + for (gr = 0; gr < 3; gr++) + for (j = 0; j < SCALE_BLOCK; j++) + for (sb = 0; sb < sblimit; sb++) + for (ch = 0; ch < ((sb < jsbound) ? nch : 1); ch++) + + if (bit_alloc[ch][sb]) { + /* scale and quantize FLOATing point sample */ + if (nch == 2 && sb >= jsbound) /* use j-stereo samples */ + d = j_samps[gr][j][sb] / scalefactor[j_scale[gr][sb]]; + else + d = sb_samples[ch][gr][j][sb] / scalefactor[sf_index[ch][gr][sb]]; + + /* Check that the wrong scale factor hasn't been chosen - + which would result in a scaled sample being > 1.0 + This error shouldn't ever happen *unless* something went wrong in + scalefactor calc + + if (mod (d) > 1.0) + fprintf (stderr, "Not scaled properly %d %d %d %d\n", ch, gr, j, + sb); + */ + + { + /* 'index' indicates which "step line" we are using */ + int index = line[tablenum][sb]; + + /* Find the "step index" within that line */ + qnt_coeff_index = step_index[index][bit_alloc[ch][sb]]; + } + d = d * a[qnt_coeff_index] + b[qnt_coeff_index]; + + /* extract MSB N-1 bits from the FLOATing point sample */ + if (d >= 0) + sig = 1; + else { + sig = 0; + d += 1.0; + } + + sbband[ch][gr][j][sb] = (unsigned int) (d * (double)steps2n[qnt_coeff_index]); + /* 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[ch][gr][j][sb] |= steps2n[qnt_coeff_index]; + } + + /* Set everything above the sblimit to 0 */ + for (ch = 0; ch < nch; ch++) + for (gr = 0; gr < 3; gr++) + for (sb = 0; sb < SCALE_BLOCK; sb++) + for (j = sblimit; j < SBLIMIT; j++) + sbband[ch][gr][sb][j] = 0; +} + +/************************************************************************ + sample_encoding + + 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 write_samples_new (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 sb, j, ch, gr, x, y; + int nch = frame->nch; + int sblimit = frame->sblimit; + int jsbound = frame->jsbound; + + for (gr = 0; gr < 3; gr++) + for (j = 0; j < SCALE_BLOCK; j += 3) + for (sb = 0; sb < sblimit; sb++) + for (ch = 0; ch < ((sb < jsbound) ? nch : 1); ch++) + + if (bit_alloc[ch][sb]) { + int thisline = line[tablenum][sb]; + int thisstep_index = step_index[thisline][bit_alloc[ch][sb]]; + /* Check how many samples per codeword */ + if (group[thisstep_index] == 3) { + /* Going to send 1 sample per codeword -> 3 samples */ + for (x = 0; x < 3; x++) { + putbits (bs, sbband[ch][gr][j + x][sb], bits[thisstep_index]); + } + } else { + /* ISO11172 Sec C.1.5.2.8 + If steps=3, 5 or 9, then three consecutive samples are coded + as one codeword i.e. only one value (V) is transmitted for this + triplet. If the 3 subband samples are x,y,z then + V = (steps*steps)*z + steps*y +x + */ + y = steps[thisstep_index]; + temp = + sbband[ch][gr][j][sb] + sbband[ch][gr][j + 1][sb] * y + + sbband[ch][gr][j + 2][sb] * y * y; + putbits (bs, temp, bits[thisstep_index]); + } + } +} + + +//#include "bit_alloc_new.c" +/***************************************************************************************/ +/* Bit Allocation Routines */ + + +/************************************************************************ +* +* 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. +* +************************************************************************/ + +int bits_for_nonoise_new (double SMR[2][SBLIMIT], + unsigned int scfsi[2][SBLIMIT], frame_info * frame, float min_mnr, + unsigned int bit_alloc[2][SBLIMIT]) +{ + int sb, ch, ba; + int nch = frame->nch; + int sblimit = frame->sblimit; + int jsbound = frame->jsbound; + 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 */ + + /* MFC Feb 2003 + This works out the basic number of bits just to get a valid (but empty) + frame. + This needs to be done for every frame, since a joint_stereo frame + will change the number of basic bits (depending on the sblimit in + the particular js mode that's been selected */ + + /* Make sure there's room for the error protection bits */ + if (frame->header->error_protection) + berr = 16; + else + berr = 0; + + /* Count the number of bits required to encode the quantization index for both + channels in each subband. If we're above the jsbound, then pretend we only + have one channel */ + for (sb = 0; sb < jsbound; ++sb) + bbal += nch * nbal[ line[tablenum][sb] ]; //(*alloc)[sb][0].bits; + for (sb = jsbound; sb < sblimit; ++sb) + bbal += nbal[ line[tablenum][sb] ]; //(*alloc)[sb][0].bits; + req_bits = banc + bbal + berr; + + for (sb = 0; sb < sblimit; ++sb) + for (ch = 0; ch < ((sb < jsbound) ? nch : 1); ++ch) { + int thisline = line[tablenum][sb]; + + /* How many possible steps are there to choose from ? */ + maxAlloc = (1 << nbal[ line[tablenum][sb] ]) -1; //(*alloc)[sb][0].bits) - 1; + sel_bits = sc_bits = smp_bits = 0; + /* Keep choosing the next number of steps (and hence our SNR value) + until we have the required MNR value */ + for (ba = 0; ba < maxAlloc - 1; ++ba) { + int thisstep_index = step_index[thisline][ba]; + if ((SNR[thisstep_index] - SMR[ch][sb]) >= min_mnr) + break; /* we found enough bits */ + } + if (nch == 2 && sb >= jsbound) /* check other JS channel */ + for (; ba < maxAlloc - 1; ++ba) { + int thisstep_index = step_index[thisline][ba]; + if ((SNR[thisstep_index] - SMR[1-ch][sb]) >= min_mnr) + break; + } + if (ba > 0) { + //smp_bits = SCALE_BLOCK * ((*alloc)[sb][ba].group * (*alloc)[sb][ba].bits); + int thisstep_index = step_index[thisline][ba]; + smp_bits = SCALE_BLOCK * group[thisstep_index] * bits[thisstep_index]; + /* 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; + } + bit_alloc[ch][sb] = ba; + } + 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_new (double 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 = 2; + 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 = 1; + sfreq = header->sampling_frequency; + lower = vbrlimits[nch-1][sfreq][0]; + upper = vbrlimits[nch-1][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_new (SMR, scfsi, frame, 0, bit_alloc)) > *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_new (SMR, scfsi, frame, 0, bit_alloc); + } + 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_new (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 > VBRLEVEL) */ + int req = + bits_for_nonoise_new (SMR, scfsi, frame, glopts->vbrlevel, bit_alloc); + + /* 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_new[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_new[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, + bits_for_nonoise_new (SMR, scfsi, frame, + glopts->vbrlevel, bit_alloc)); + + } + + noisy_sbs = + VBR_bit_allocation_new (SMR, scfsi, bit_alloc, adb, frame, glopts); + } +} + +void VBR_maxmnr_new (double mnr[2][SBLIMIT], char used[2][SBLIMIT], int sblimit, + int nch, int *min_sb, int *min_ch, options * glopts) +{ + int sb, ch; + double small; + + small = 999999.0; + *min_sb = -1; + *min_ch = -1; + +#define NEWBITx +#ifdef NEWBIT + /* Keep going until all subbands have reached the MNR level that we specified */ + for (ch=0;chvbrlevel) { + *min_sb = sb; + *min_ch = ch; + //fprintf(stdout,"."); + //fflush(stdout); + return; + } +#endif + + /* Then start adding bits to whichever is the min MNR */ + for (ch = 0; ch < nch; ++ch) + for (sb = 0; sb < sblimit; sb++) + if (used[ch][sb] != 2 && small > mnr[ch][sb]) { + small = mnr[ch][sb]; + *min_sb = sb; + *min_ch = ch; + } + //fprintf(stdout,"Min sb: %i\n",*min_sb); +} +/******************** +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_new (double SMR[2][SBLIMIT], + unsigned int scfsi[2][SBLIMIT], + unsigned int bit_alloc[2][SBLIMIT], int *adb, + frame_info * frame, options *glopts) +{ + int sb, min_ch, min_sb, oth_ch, ch, 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 */ + + int thisstep_index; + + if (!init) { + init = 1; + if (frame->header->error_protection) + berr = 16; /* added 92-08-11 shn */ + } + + /* No need to worry about jsbound here as JS is disabled for VBR mode */ + for (sb = 0; sb < sblimit; sb++) + bbal += nch * nbal[ line[tablenum][sb] ]; + *adb -= bbal + berr + banc; + ad = *adb; + + for (sb = 0; sb < sblimit; sb++) + for (ch = 0; ch < nch; ch++) { + mnr[ch][sb] = SNR[0] - SMR[ch][sb]; + bit_alloc[ch][sb] = 0; + used[ch][sb] = 0; + } + bspl = bscf = bsel = 0; + + do { + /* locate the subband with minimum SMR */ + VBR_maxmnr_new (mnr, used, sblimit, nch, &min_sb, &min_ch, glopts); + + if (min_sb > -1) { /* there was something to find */ + int thisline = line[tablenum][min_sb]; { + /* find increase in bit allocation in subband [min] */ + int nextstep_index = step_index[thisline][bit_alloc[min_ch][min_sb]+1]; + increment = SCALE_BLOCK * group[nextstep_index] * bits[nextstep_index]; + } + if (used[min_ch][min_sb]) { + /* If we've already increased the limit on this ch/sb, then + subtract the last thing that we added */ + thisstep_index = step_index[thisline][bit_alloc[min_ch][min_sb]]; + increment -= SCALE_BLOCK * group[thisstep_index] * bits[thisstep_index]; + } + + /* 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) { + /* Then there are enough bits to have another go at allocating */ + 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 */ + thisstep_index = step_index[thisline][ba]; + mnr[min_ch][min_sb] = SNR[thisstep_index] - SMR[min_ch][min_sb]; + /* Check if this min_sb subband has been fully allocated max bits */ + if (ba >= (1 << nbal[ line[tablenum][min_sb] ]) -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 */ + } + } + while (min_sb > -1); /* until could find no channel */ + + /* Calculate the number of bits left */ + ad -= bspl + bscf + bsel; + *adb = ad; + for (ch = 0; ch < nch; ch++) + for (sb = sblimit; sb < SBLIMIT; sb++) + bit_alloc[ch][sb] = 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_new (double mnr[2][SBLIMIT], char used[2][SBLIMIT], int sblimit, + int nch, int *min_sb, int *min_ch) +{ + int sb, ch; + double small; + + small = 999999.0; + *min_sb = -1; + *min_ch = -1; + for (ch = 0; ch < nch; ++ch) + for (sb = 0; sb < sblimit; sb++) + if (used[ch][sb] != 2 && small > mnr[ch][sb]) { + small = mnr[ch][sb]; + *min_sb = sb; + *min_ch = ch; + } +} +int a_bit_allocation_new (double SMR[2][SBLIMIT], + unsigned int scfsi[2][SBLIMIT], + unsigned int bit_alloc[2][SBLIMIT], int *adb, + frame_info * frame) +{ + int sb, min_ch, min_sb, oth_ch, ch, 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 */ + + int thisstep_index; + + if (!init) { + init = 1; + if (frame->header->error_protection) + berr = 16; /* added 92-08-11 shn */ + } + + for (sb = 0; sb < jsbound; sb++) + bbal += nch * nbal[ line[tablenum][sb] ]; //(*alloc)[sb][0].bits; + for (sb = jsbound; sb < sblimit; sb++) + bbal += nbal[ line[tablenum][sb] ]; //(*alloc)[sb][0].bits; + *adb -= bbal + berr + banc; + ad = *adb; + + for (sb = 0; sb < sblimit; sb++) + for (ch = 0; ch < nch; ch++) { + mnr[ch][sb] = SNR[0] - SMR[ch][sb]; + bit_alloc[ch][sb] = 0; + used[ch][sb] = 0; + } + bspl = bscf = bsel = 0; + + do { + /* locate the subband with minimum SMR */ + maxmnr_new (mnr, used, sblimit, nch, &min_sb, &min_ch); + + if (min_sb > -1) { /* there was something to find */ + int thisline = line[tablenum][min_sb]; { + /* find increase in bit allocation in subband [min] */ + int nextstep_index = step_index[thisline][bit_alloc[min_ch][min_sb]+1]; + increment = SCALE_BLOCK * group[nextstep_index] * bits[nextstep_index]; + } + if (used[min_ch][min_sb]) { + /* If we've already increased the limit on this ch/sb, then + subtract the last thing that we added */ + thisstep_index = step_index[thisline][bit_alloc[min_ch][min_sb]]; + increment -= SCALE_BLOCK * group[thisstep_index] * bits[thisstep_index]; + } + + /* 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) { + /* Then there are enough bits to have another go at allocating */ + 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 */ + thisstep_index = step_index[thisline][ba]; + mnr[min_ch][min_sb] = SNR[thisstep_index] - SMR[min_ch][min_sb]; + /* Check if this min_sb subband has been fully allocated max bits */ + if (ba >= (1 << nbal[ line[tablenum][min_sb] ]) -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]; + thisstep_index = step_index[thisline][ba]; + mnr[oth_ch][min_sb] = SNR[thisstep_index] - SMR[oth_ch][min_sb]; + //mnr[oth_ch][min_sb] = SNR[(*alloc)[min_sb][ba].quant + 1] - SMR[oth_ch][min_sb]; + } + + } + } + while (min_sb > -1); /* until could find no channel */ + + /* Calculate the number of bits left */ + ad -= bspl + bscf + bsel; + *adb = ad; + for (ch = 0; ch < nch; ch++) + for (sb = sblimit; sb < SBLIMIT; sb++) + bit_alloc[ch][sb] = 0; + + return 0; +} + -- cgit v1.2.3