| 1 |
/* |
| 2 |
* TwoLAME: an optimized MPEG Audio Layer Two encoder |
| 3 |
* |
| 4 |
* Copyright (C) 2001-2004 Michael Cheng |
| 5 |
* Copyright (C) 2004-2018 The TwoLAME Project |
| 6 |
* |
| 7 |
* This library is free software; you can redistribute it and/or |
| 8 |
* modify it under the terms of the GNU Lesser General Public |
| 9 |
* License as published by the Free Software Foundation; either |
| 10 |
* version 2.1 of the License, or (at your option) any later version. |
| 11 |
* |
| 12 |
* This library is distributed in the hope that it will be useful, |
| 13 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 15 |
* Lesser General Public License for more details. |
| 16 |
* |
| 17 |
* You should have received a copy of the GNU Lesser General Public |
| 18 |
* License along with this library; if not, write to the Free Software |
| 19 |
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 20 |
* |
| 21 |
*/ |
| 22 |
|
| 23 |
|
| 24 |
#include <stdio.h> |
| 25 |
#include <stdlib.h> |
| 26 |
#include <math.h> |
| 27 |
|
| 28 |
#include "twolame.h" |
| 29 |
#include "common.h" |
| 30 |
#include "bitbuffer.h" |
| 31 |
#include "availbits.h" |
| 32 |
#include "encode.h" |
| 33 |
#include "util.h" |
| 34 |
|
| 35 |
#include "bitbuffer_inline.h" |
| 36 |
|
| 37 |
|
| 38 |
static const FLOAT multiple[64] = { |
| 39 |
2.00000000000000, 1.58740105196820, 1.25992104989487, |
| 40 |
1.00000000000000, 0.79370052598410, 0.62996052494744, 0.50000000000000, |
| 41 |
0.39685026299205, 0.31498026247372, 0.25000000000000, 0.19842513149602, |
| 42 |
0.15749013123686, 0.12500000000000, 0.09921256574801, 0.07874506561843, |
| 43 |
0.06250000000000, 0.04960628287401, 0.03937253280921, 0.03125000000000, |
| 44 |
0.02480314143700, 0.01968626640461, 0.01562500000000, 0.01240157071850, |
| 45 |
0.00984313320230, 0.00781250000000, 0.00620078535925, 0.00492156660115, |
| 46 |
0.00390625000000, 0.00310039267963, 0.00246078330058, 0.00195312500000, |
| 47 |
0.00155019633981, 0.00123039165029, 0.00097656250000, 0.00077509816991, |
| 48 |
0.00061519582514, 0.00048828125000, 0.00038754908495, 0.00030759791257, |
| 49 |
0.00024414062500, 0.00019377454248, 0.00015379895629, 0.00012207031250, |
| 50 |
0.00009688727124, 0.00007689947814, 0.00006103515625, 0.00004844363562, |
| 51 |
0.00003844973907, 0.00003051757813, 0.00002422181781, 0.00001922486954, |
| 52 |
0.00001525878906, 0.00001211090890, 0.00000961243477, 0.00000762939453, |
| 53 |
0.00000605545445, 0.00000480621738, 0.00000381469727, 0.00000302772723, |
| 54 |
0.00000240310869, 0.00000190734863, 0.00000151386361, 0.00000120155435, |
| 55 |
1E-20 |
| 56 |
}; |
| 57 |
|
| 58 |
/* MFC May03 |
| 59 |
Gosh. I should really document this mess. |
| 60 |
This is a compact data format for all the info that is |
| 61 |
in the bit allocation tables in the mpeg standards. |
| 62 |
|
| 63 |
All the allocation tables are here. There is just multiple |
| 64 |
redirections to find the number that you want. |
| 65 |
|
| 66 |
I might have to reduce the number of index tables to make the code |
| 67 |
more readable. |
| 68 |
*/ |
| 69 |
|
| 70 |
|
| 71 |
#define NUMTABLES 5 |
| 72 |
|
| 73 |
/* There are really only 9 distinct lines in the allocation tables |
| 74 |
each member of this table is an index into */ |
| 75 |
/* step_index[linenumber][index] */ |
| 76 |
static const int step_index[9][16] = { |
| 77 |
/* 0 */ {0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17}, |
| 78 |
/* 1 */ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17}, |
| 79 |
/* 2 */ {0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0}, |
| 80 |
/* 3 */ {0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, |
| 81 |
/* 4 */ {0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}, |
| 82 |
/* 5 */ {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0}, |
| 83 |
/* From ISO13818 Table B.1 */ |
| 84 |
/* 6 */ {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, |
| 85 |
/* 7 */ {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0}, |
| 86 |
/* 8 */ {0, 1, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} |
| 87 |
}; |
| 88 |
|
| 89 |
static const int nbal[9] = { 4, 4, 3, 2, 4, 3, 4, 3, 2 }; |
| 90 |
|
| 91 |
|
| 92 |
/* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 */ |
| 93 |
/* The number of steps allowed */ |
| 94 |
static const int steps[18] = |
| 95 |
{ 0, 3, 5, 7, 9, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535 }; |
| 96 |
/* The power of 2 just under the steps value */ |
| 97 |
static const int steps2n[18] = |
| 98 |
{ 0, 2, 4, 4, 8, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768 }; |
| 99 |
/* The bits per codeword from TableB.4 */ |
| 100 |
static const int bits[18] = { 0, 5, 7, 3, 10, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; |
| 101 |
|
| 102 |
/* Samples per codeword Table B.4 Page 53 */ |
| 103 |
//static int group[18] = {0, 3, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; |
| 104 |
static const int group[18] = { 0, 1, 1, 3, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 }; |
| 105 |
|
| 106 |
/* nbal */ |
| 107 |
|
| 108 |
/* The sblimits of the 5 allocation tables |
| 109 |
4 tables for MPEG-1 |
| 110 |
1 table for MPEG-2 LSF */ |
| 111 |
static const int table_sblimit[5] = { 27, 30, 8, 12, 30 }; |
| 112 |
|
| 113 |
/* Each table contains a list of allowable quantization steps. |
| 114 |
There are only 9 distinct lists of steps. |
| 115 |
This table gives the index of which of the 9 lists is being used |
| 116 |
A "-1" entry means that it is above the sblimit for this table */ |
| 117 |
static const int line[5][SBLIMIT] = { |
| 118 |
/* 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 |
| 119 |
31 */ |
| 120 |
{ 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, |
| 121 |
-1, -1 |
| 122 |
}, |
| 123 |
{ 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, |
| 124 |
-1 |
| 125 |
}, |
| 126 |
{ 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, |
| 127 |
-1, -1, -1, -1, -1, -1 |
| 128 |
}, |
| 129 |
{ 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, |
| 130 |
-1, -1, -1, -1, -1 |
| 131 |
}, |
| 132 |
/* LSF Table */ |
| 133 |
{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} |
| 134 |
}; |
| 135 |
|
| 136 |
/* This is ISO11172 Table B.1 */ |
| 137 |
static const FLOAT scalefactor[64] = { /* Equation for nth element = 2 / (cuberoot(2) ^ n) */ |
| 138 |
2.00000000000000, 1.58740105196820, 1.25992104989487, |
| 139 |
1.00000000000000, 0.79370052598410, 0.62996052494744, 0.50000000000000, |
| 140 |
0.39685026299205, 0.31498026247372, 0.25000000000000, 0.19842513149602, |
| 141 |
0.15749013123686, 0.12500000000000, 0.09921256574801, 0.07874506561843, |
| 142 |
0.06250000000000, 0.04960628287401, 0.03937253280921, 0.03125000000000, |
| 143 |
0.02480314143700, 0.01968626640461, 0.01562500000000, 0.01240157071850, |
| 144 |
0.00984313320230, 0.00781250000000, 0.00620078535925, 0.00492156660115, |
| 145 |
0.00390625000000, 0.00310039267963, 0.00246078330058, 0.00195312500000, |
| 146 |
0.00155019633981, 0.00123039165029, 0.00097656250000, 0.00077509816991, |
| 147 |
0.00061519582514, 0.00048828125000, 0.00038754908495, 0.00030759791257, |
| 148 |
0.00024414062500, 0.00019377454248, 0.00015379895629, 0.00012207031250, |
| 149 |
0.00009688727124, 0.00007689947814, 0.00006103515625, 0.00004844363562, |
| 150 |
0.00003844973907, 0.00003051757813, 0.00002422181781, 0.00001922486954, |
| 151 |
0.00001525878906, 0.00001211090890, 0.00000961243477, 0.00000762939453, |
| 152 |
0.00000605545445, 0.00000480621738, 0.00000381469727, 0.00000302772723, |
| 153 |
0.00000240310869, 0.00000190734863, 0.00000151386361, 0.00000120155435, |
| 154 |
1E-20 |
| 155 |
}; |
| 156 |
|
| 157 |
/* ISO11172 Table C.5 Layer II Signal to Noise Raios |
| 158 |
MFC FIX find a reference for these in terms of bits->SNR value |
| 159 |
Index into table is the steps index |
| 160 |
index steps SNR |
| 161 |
0 0 0.00 |
| 162 |
1 3 7.00 |
| 163 |
2 5 11.00 |
| 164 |
3 7 16.00 |
| 165 |
4 9 20.84 |
| 166 |
etc |
| 167 |
*/ |
| 168 |
static const FLOAT SNR[18] = { |
| 169 |
0.00, 7.00, 11.00, 16.00, 20.84, 25.28, 31.59, 37.75, 43.84, |
| 170 |
49.89, 55.93, 61.96, 67.98, 74.01, 80.03, 86.05, 92.01, 98.01 |
| 171 |
}; |
| 172 |
|
| 173 |
|
| 174 |
|
| 175 |
static int get_js_bound(int m_ext) |
| 176 |
{ |
| 177 |
static const int jsb_table[4] = { 4, 8, 12, 16 }; |
| 178 |
|
| 179 |
if (m_ext < 0 || m_ext > 3) { |
| 180 |
fprintf(stderr, "get_js_bound() bad modext (%d)\n", m_ext); |
| 181 |
return -1; |
| 182 |
} |
| 183 |
return (jsb_table[m_ext]); |
| 184 |
} |
| 185 |
|
| 186 |
|
| 187 |
int twolame_encode_init(twolame_options * glopts) |
| 188 |
{ |
| 189 |
frame_header *header = &glopts->header; |
| 190 |
int br_per_ch, sfrq; |
| 191 |
|
| 192 |
br_per_ch = glopts->bitrate / glopts->num_channels_out; |
| 193 |
sfrq = (int) (glopts->samplerate_out / 1000.0); |
| 194 |
|
| 195 |
/* decision rules refer to per-channel bitrates (kbits/sec/chan) */ |
| 196 |
if (header->version == TWOLAME_MPEG1) { /* MPEG-1 */ |
| 197 |
if (glopts->freeformat) { |
| 198 |
glopts->tablenum = (sfrq == 48) ? 0 : 1; |
| 199 |
} else { |
| 200 |
if ((sfrq == 48 && br_per_ch >= 56) |
| 201 |
|| (br_per_ch >= 56 && br_per_ch <= 80)) |
| 202 |
glopts->tablenum = 0; |
| 203 |
else if (sfrq != 48 && br_per_ch >= 96) |
| 204 |
glopts->tablenum = 1; |
| 205 |
else if (sfrq != 32 && br_per_ch <= 48) |
| 206 |
glopts->tablenum = 2; |
| 207 |
else |
| 208 |
glopts->tablenum = 3; |
| 209 |
} |
| 210 |
} else { /* MPEG-2 LSF */ |
| 211 |
glopts->tablenum = 4; |
| 212 |
} |
| 213 |
|
| 214 |
// glopts->sblimit = pick_table ( glopts ); |
| 215 |
/* MFC FIX this up */ |
| 216 |
glopts->sblimit = table_sblimit[glopts->tablenum]; |
| 217 |
// fprintf(stderr,"twolame_encode_init: using tablenum %i with sblimit %i\n",glopts->tablenum, |
| 218 |
// glopts->sblimit); |
| 219 |
|
| 220 |
if (glopts->mode == TWOLAME_JOINT_STEREO) |
| 221 |
glopts->jsbound = get_js_bound(header->mode_ext); |
| 222 |
else |
| 223 |
glopts->jsbound = glopts->sblimit; |
| 224 |
/* alloc, tab_num set in pick_table */ |
| 225 |
|
| 226 |
|
| 227 |
#define DUMPTABLESx |
| 228 |
#ifdef DUMPTABLES |
| 229 |
{ |
| 230 |
int tablenumber, j, sblimit, sb; |
| 231 |
fprintf(stderr, "Tables B.21,b,c,d from ISO11172 and the LSF table from ISO13818\n"); |
| 232 |
for (tablenumber = 0; tablenumber < NUMTABLES; tablenumber++) { |
| 233 |
/* Print Table Header */ |
| 234 |
fprintf(stderr, "Tablenum %i\n", tablenumber); |
| 235 |
fprintf(stderr, "sb nbal "); |
| 236 |
for (j = 0; j < 16; j++) |
| 237 |
fprintf(stderr, "%6i ", j); |
| 238 |
fprintf(stderr, "\n"); |
| 239 |
fprintf(stderr, |
| 240 |
"-----------------------------------------------------------------------------------------------------------------------\n"); |
| 241 |
|
| 242 |
sblimit = table_sblimit[tablenumber]; |
| 243 |
for (sb = 0; sb < SBLIMIT; sb++) { |
| 244 |
int thisline = line[tablenumber][sb]; |
| 245 |
fprintf(stderr, "%2i %4i ", sb, nbal[thisline]); |
| 246 |
if (nbal[thisline] != 0) { |
| 247 |
for (j = 0; j < (1 << nbal[thisline]); j++) |
| 248 |
fprintf(stderr, "%6i ", steps[step_index[thisline][j]]); |
| 249 |
} |
| 250 |
fprintf(stderr, "\n"); |
| 251 |
} |
| 252 |
fprintf(stderr, "\n"); |
| 253 |
} |
| 254 |
} |
| 255 |
#endif |
| 256 |
|
| 257 |
// Success |
| 258 |
return 0; |
| 259 |
} |
| 260 |
|
| 261 |
|
| 262 |
|
| 263 |
/* |
| 264 |
scale_factor_calc |
| 265 |
pick_scale |
| 266 |
if JOINTSTEREO |
| 267 |
combine_LR |
| 268 |
scale_factor_calc |
| 269 |
use psy model to determine SMR |
| 270 |
transmission pattern |
| 271 |
main_bit_allocation |
| 272 |
if (error protection) |
| 273 |
calc CRC |
| 274 |
encode_info |
| 275 |
if (error_protection) |
| 276 |
encode_CRC |
| 277 |
encode_bit_alloc |
| 278 |
encode_scale |
| 279 |
subband_quantization |
| 280 |
sample_encoding |
| 281 |
*/ |
| 282 |
|
| 283 |
void twolame_scalefactor_calc(FLOAT sb_sample[][3][SCALE_BLOCK][SBLIMIT], |
| 284 |
unsigned int sf_index[][3][SBLIMIT], int nch, int sblimit) |
| 285 |
{ |
| 286 |
/* Optimized to use binary search instead of linear scan through the scalefactor table; |
| 287 |
guarantees to find scalefactor in only 5 jumps/comparisons and not in {0 (lin. best) to 63 |
| 288 |
(lin. worst)}. Scalefactors for subbands > sblimit are no longer computed. Uses a single |
| 289 |
sblimit-loop. Patrick De Smet Oct 1999. */ |
| 290 |
int ch, gr; |
| 291 |
/* Using '--' loops to avoid possible "cmp value + bne/beq" compiler */ |
| 292 |
/* inefficiencies. Below loops should compile to "bne/beq" only code */ |
| 293 |
for (ch = nch; ch--;) |
| 294 |
for (gr = 3; gr--;) { |
| 295 |
int sb; |
| 296 |
for (sb = sblimit; sb--;) { |
| 297 |
int j; |
| 298 |
unsigned int l; |
| 299 |
register FLOAT temp; |
| 300 |
unsigned int scale_fac; |
| 301 |
/* Determination of max. over each set of 12 subband samples: */ |
| 302 |
/* PDS TODO: maybe this could/should ??!! be integrated into */ |
| 303 |
/* the subband filtering routines? */ |
| 304 |
register FLOAT cur_max = fabs(sb_sample[ch][gr][SCALE_BLOCK - 1][sb]); |
| 305 |
for (j = SCALE_BLOCK - 1; j--;) { |
| 306 |
if ((temp = fabs(sb_sample[ch][gr][j][sb])) > cur_max) |
| 307 |
cur_max = temp; |
| 308 |
} |
| 309 |
/* PDS: binary search in the scalefactor table: */ |
| 310 |
/* This is the real speed up: */ |
| 311 |
for (l = 16, scale_fac = 32; l; l >>= 1) { |
| 312 |
if (cur_max <= scalefactor[scale_fac]) |
| 313 |
scale_fac += l; |
| 314 |
else |
| 315 |
scale_fac -= l; |
| 316 |
} |
| 317 |
if (cur_max > scalefactor[scale_fac]) |
| 318 |
scale_fac--; |
| 319 |
sf_index[ch][gr][sb] = scale_fac; |
| 320 |
/* There is a direct way of working out the index, if the maximum value is known |
| 321 |
but since it involves a log it isn't really speedy. Items in the scalefactor[] |
| 322 |
table are calculated by: the n'th entry = 2 / (cuberoot(2) ^ n) And so using a |
| 323 |
bit of maths you get: index = (int)(log(2.0/cur_max) / LNCUBEROOTTWO); |
| 324 |
fprintf(stderr,"cur_max %.14lf scalefactorindex %i multiple %.14lf\n",cur_max, |
| 325 |
scale_fac, scalefactor[scale_fac]); */ |
| 326 |
} |
| 327 |
} |
| 328 |
} |
| 329 |
|
| 330 |
|
| 331 |
/* Combine L&R channels into a mono joint stereo channel */ |
| 332 |
void twolame_combine_lr(FLOAT sb_sample[2][3][SCALE_BLOCK][SBLIMIT], |
| 333 |
FLOAT joint_sample[3][SCALE_BLOCK][SBLIMIT], int sblimit) |
| 334 |
{ |
| 335 |
int sb, sample, gr; |
| 336 |
|
| 337 |
for (sb = 0; sb < sblimit; ++sb) |
| 338 |
for (sample = 0; sample < SCALE_BLOCK; ++sample) |
| 339 |
for (gr = 0; gr < 3; ++gr) |
| 340 |
joint_sample[gr][sample][sb] = |
| 341 |
.5 * (sb_sample[0][gr][sample][sb] + sb_sample[1][gr][sample][sb]); |
| 342 |
} |
| 343 |
|
| 344 |
/* PURPOSE:For each subband, puts the smallest scalefactor of the 3 |
| 345 |
associated with a frame into #max_sc#. This is used |
| 346 |
used by Psychoacoustic Model I. |
| 347 |
Someone in dist10 source code's history, somebody wrote the following: |
| 348 |
"(I would recommend changin max_sc to min_sc)" |
| 349 |
|
| 350 |
In psy model 1, the *maximum* out of the scale picked here and |
| 351 |
the maximum SPL within each subband is selected. So I'd think that |
| 352 |
a maximum here makes heaps of sense. |
| 353 |
|
| 354 |
MFC FIX: Feb 2003 - is this only needed for psy model 1? |
| 355 |
*/ |
| 356 |
void twolame_find_sf_max(twolame_options * glopts, |
| 357 |
unsigned int sf_index[2][3][SBLIMIT], FLOAT sf_max[2][SBLIMIT]) |
| 358 |
{ |
| 359 |
unsigned int sb, gr, ch; |
| 360 |
unsigned int lowest_sf_index; |
| 361 |
unsigned int nch = glopts->num_channels_out; |
| 362 |
unsigned int sblimit = glopts->sblimit; |
| 363 |
|
| 364 |
for (ch = 0; ch < nch; ch++) |
| 365 |
for (sb = 0; sb < sblimit; sb++) { |
| 366 |
for (gr = 1, lowest_sf_index = sf_index[ch][0][sb]; gr < 3; gr++) |
| 367 |
if (lowest_sf_index > sf_index[ch][gr][sb]) |
| 368 |
lowest_sf_index = sf_index[ch][gr][sb]; |
| 369 |
sf_max[ch][sb] = multiple[lowest_sf_index]; |
| 370 |
} |
| 371 |
for (sb = sblimit; sb < SBLIMIT; sb++) |
| 372 |
sf_max[0][sb] = sf_max[1][sb] = 1E-20; |
| 373 |
} |
| 374 |
|
| 375 |
/* sf_transmission_pattern |
| 376 |
PURPOSE:For a given subband, determines whether to send 1, 2, or |
| 377 |
all 3 of the scalefactors, and fills in the scalefactor |
| 378 |
select information accordingly |
| 379 |
|
| 380 |
This is From ISO11172 Sect C.1.5.2.5 "coding of scalefactors" |
| 381 |
and |
| 382 |
Table C.4 "LayerII Scalefactors Transmission Pattern" |
| 383 |
*/ |
| 384 |
void twolame_sf_transmission_pattern(twolame_options * glopts, |
| 385 |
unsigned int sf_index[2][3][SBLIMIT], |
| 386 |
unsigned int sf_selectinfo[2][SBLIMIT]) |
| 387 |
{ |
| 388 |
int nch = glopts->num_channels_out; |
| 389 |
int sblimit = glopts->sblimit; |
| 390 |
int dscf[2]; |
| 391 |
int class[2], i, j, k; |
| 392 |
static const int pattern[5][5] = { |
| 393 |
{0x123, 0x122, 0x122, 0x133, 0x123}, |
| 394 |
{0x113, 0x111, 0x111, 0x444, 0x113}, |
| 395 |
{0x111, 0x111, 0x111, 0x333, 0x113}, |
| 396 |
{0x222, 0x222, 0x222, 0x333, 0x123}, |
| 397 |
{0x123, 0x122, 0x122, 0x133, 0x123} |
| 398 |
}; |
| 399 |
|
| 400 |
for (k = 0; k < nch; k++) |
| 401 |
for (i = 0; i < sblimit; i++) { |
| 402 |
dscf[0] = (sf_index[k][0][i] - sf_index[k][1][i]); |
| 403 |
dscf[1] = (sf_index[k][1][i] - sf_index[k][2][i]); |
| 404 |
for (j = 0; j < 2; j++) { |
| 405 |
if (dscf[j] <= -3) |
| 406 |
class[j] = 0; |
| 407 |
else if (dscf[j] > -3 && dscf[j] < 0) |
| 408 |
class[j] = 1; |
| 409 |
else if (dscf[j] == 0) |
| 410 |
class[j] = 2; |
| 411 |
else if (dscf[j] > 0 && dscf[j] < 3) |
| 412 |
class[j] = 3; |
| 413 |
else |
| 414 |
class[j] = 4; |
| 415 |
} |
| 416 |
switch (pattern[class[0]][class[1]]) { |
| 417 |
case 0x123: |
| 418 |
sf_selectinfo[k][i] = 0; |
| 419 |
break; |
| 420 |
case 0x122: |
| 421 |
sf_selectinfo[k][i] = 3; |
| 422 |
sf_index[k][2][i] = sf_index[k][1][i]; |
| 423 |
break; |
| 424 |
case 0x133: |
| 425 |
sf_selectinfo[k][i] = 3; |
| 426 |
sf_index[k][1][i] = sf_index[k][2][i]; |
| 427 |
break; |
| 428 |
case 0x113: |
| 429 |
sf_selectinfo[k][i] = 1; |
| 430 |
sf_index[k][1][i] = sf_index[k][0][i]; |
| 431 |
break; |
| 432 |
case 0x111: |
| 433 |
sf_selectinfo[k][i] = 2; |
| 434 |
sf_index[k][1][i] = sf_index[k][2][i] = sf_index[k][0][i]; |
| 435 |
break; |
| 436 |
case 0x222: |
| 437 |
sf_selectinfo[k][i] = 2; |
| 438 |
sf_index[k][0][i] = sf_index[k][2][i] = sf_index[k][1][i]; |
| 439 |
break; |
| 440 |
case 0x333: |
| 441 |
sf_selectinfo[k][i] = 2; |
| 442 |
sf_index[k][0][i] = sf_index[k][1][i] = sf_index[k][2][i]; |
| 443 |
break; |
| 444 |
case 0x444: |
| 445 |
sf_selectinfo[k][i] = 2; |
| 446 |
if (sf_index[k][0][i] > sf_index[k][2][i]) |
| 447 |
sf_index[k][0][i] = sf_index[k][2][i]; |
| 448 |
sf_index[k][1][i] = sf_index[k][2][i] = sf_index[k][0][i]; |
| 449 |
break; |
| 450 |
} |
| 451 |
} |
| 452 |
} |
| 453 |
|
| 454 |
void twolame_write_header(twolame_options * glopts, bit_stream * bs) |
| 455 |
{ |
| 456 |
frame_header *header = &glopts->header; |
| 457 |
|
| 458 |
buffer_putbits(bs, 0xfff, 12); /* syncword 12 bits */ |
| 459 |
buffer_put1bit(bs, header->version); /* ID 1 bit */ |
| 460 |
buffer_putbits(bs, 4 - header->lay, 2); /* layer 2 bits */ |
| 461 |
buffer_put1bit(bs, !header->error_protection); /* bit set => no err prot */ |
| 462 |
buffer_putbits(bs, header->bitrate_index, 4); |
| 463 |
buffer_putbits(bs, header->samplerate_idx, 2); |
| 464 |
buffer_put1bit(bs, header->padding); |
| 465 |
buffer_put1bit(bs, header->private_extension); /* private extension bit */ |
| 466 |
buffer_putbits(bs, header->mode, 2); |
| 467 |
buffer_putbits(bs, header->mode_ext, 2); |
| 468 |
buffer_put1bit(bs, header->copyright); |
| 469 |
buffer_put1bit(bs, header->original); |
| 470 |
buffer_putbits(bs, header->emphasis, 2); |
| 471 |
} |
| 472 |
|
| 473 |
/************************************************************************* |
| 474 |
encode_bit_alloc (Layer II) |
| 475 |
|
| 476 |
PURPOSE: Writes bit allocation information onto bitstream |
| 477 |
|
| 478 |
4,3,2, or 0 bits depending on the quantization table used. |
| 479 |
|
| 480 |
************************************************************************/ |
| 481 |
void twolame_write_bit_alloc(twolame_options * glopts, unsigned int bit_alloc[2][SBLIMIT], bit_stream * bs) |
| 482 |
{ |
| 483 |
int nch = glopts->num_channels_out; |
| 484 |
int sblimit = glopts->sblimit; |
| 485 |
int jsbound = glopts->jsbound; |
| 486 |
int sb, ch; |
| 487 |
|
| 488 |
for (sb = 0; sb < sblimit; sb++) { |
| 489 |
for (ch = 0; ch < ((sb < jsbound) ? nch : 1); ch++) { |
| 490 |
buffer_putbits(bs, bit_alloc[ch][sb], nbal[line[glopts->tablenum][sb]]); |
| 491 |
glopts->num_crc_bits += nbal[line[glopts->tablenum][sb]]; |
| 492 |
} |
| 493 |
} |
| 494 |
} |
| 495 |
|
| 496 |
/************************************************************************ |
| 497 |
write_scalefactors |
| 498 |
|
| 499 |
PURPOSE:The encoded scalar factor information is arranged and |
| 500 |
queued into the output fifo to be transmitted. |
| 501 |
|
| 502 |
The three scale factors associated with |
| 503 |
a given subband and channel are transmitted in accordance |
| 504 |
with the scfsi, which is transmitted first. |
| 505 |
|
| 506 |
************************************************************************/ |
| 507 |
|
| 508 |
void twolame_write_scalefactors(twolame_options * glopts, |
| 509 |
unsigned int bit_alloc[2][SBLIMIT], |
| 510 |
unsigned int sf_selectinfo[2][SBLIMIT], |
| 511 |
unsigned int sf_index[2][3][SBLIMIT], bit_stream * bs) |
| 512 |
{ |
| 513 |
int nch = glopts->num_channels_out; |
| 514 |
int sblimit = glopts->sblimit; |
| 515 |
int sb, gr, ch; |
| 516 |
|
| 517 |
/* Write out the scalefactor selection information */ |
| 518 |
for (sb = 0; sb < sblimit; sb++) |
| 519 |
for (ch = 0; ch < nch; ch++) |
| 520 |
if (bit_alloc[ch][sb]) { |
| 521 |
buffer_putbits(bs, sf_selectinfo[ch][sb], 2); |
| 522 |
glopts->num_crc_bits += 2; |
| 523 |
} |
| 524 |
|
| 525 |
/* Write out the scalefactors */ |
| 526 |
for (sb = 0; sb < sblimit; sb++) |
| 527 |
for (ch = 0; ch < nch; ch++) |
| 528 |
if (bit_alloc[ch][sb]) // above jsbound, bit_alloc[0][i] == ba[1][i] |
| 529 |
{ |
| 530 |
switch (sf_selectinfo[ch][sb]) { |
| 531 |
case 0: |
| 532 |
for (gr = 0; gr < 3; gr++) |
| 533 |
buffer_putbits(bs, sf_index[ch][gr][sb], 6); |
| 534 |
break; |
| 535 |
case 1: |
| 536 |
case 3: |
| 537 |
buffer_putbits(bs, sf_index[ch][0][sb], 6); |
| 538 |
buffer_putbits(bs, sf_index[ch][2][sb], 6); |
| 539 |
break; |
| 540 |
case 2: |
| 541 |
buffer_putbits(bs, sf_index[ch][0][sb], 6); |
| 542 |
break; |
| 543 |
} |
| 544 |
} |
| 545 |
} |
| 546 |
|
| 547 |
|
| 548 |
/* ISO11172 Table C.6 Layer II quantization co-efficients */ |
| 549 |
static const FLOAT a[18] = { |
| 550 |
0, |
| 551 |
0.750000000, 0.625000000, 0.875000000, 0.562500000, 0.937500000, |
| 552 |
0.968750000, 0.984375000, 0.992187500, 0.996093750, 0.998046875, |
| 553 |
0.999023438, 0.999511719, 0.999755859, 0.999877930, 0.999938965, |
| 554 |
0.999969482, 0.999984741 |
| 555 |
}; |
| 556 |
|
| 557 |
static const FLOAT b[18] = { |
| 558 |
0, |
| 559 |
-0.250000000, -0.375000000, -0.125000000, -0.437500000, -0.062500000, |
| 560 |
-0.031250000, -0.015625000, -0.007812500, -0.003906250, -0.001953125, |
| 561 |
-0.000976563, -0.000488281, -0.000244141, -0.000122070, -0.000061035, |
| 562 |
-0.000030518, -0.000015259 |
| 563 |
}; |
| 564 |
|
| 565 |
/************************************************************************ |
| 566 |
subband_quantization (Layer II) |
| 567 |
|
| 568 |
PURPOSE:Quantizes subband samples to appropriate number of bits |
| 569 |
|
| 570 |
SEMANTICS: Subband samples are divided by their scalefactors, which |
| 571 |
makes the quantization more efficient. The scaled samples are |
| 572 |
quantized by the function a*x+b, where a and b are functions of |
| 573 |
the number of quantization levels. The result is then truncated |
| 574 |
to the appropriate number of bits and the MSB is inverted. |
| 575 |
|
| 576 |
Note that for fractional 2's complement, inverting the MSB for a |
| 577 |
negative number x is equivalent to adding 1 to it. |
| 578 |
|
| 579 |
************************************************************************/ |
| 580 |
void twolame_subband_quantization(twolame_options * glopts, |
| 581 |
unsigned int sf_index[2][3][SBLIMIT], |
| 582 |
FLOAT sb_samples[2][3][SCALE_BLOCK][SBLIMIT], |
| 583 |
unsigned int j_scale[3][SBLIMIT], |
| 584 |
FLOAT j_samps[3][SCALE_BLOCK][SBLIMIT], |
| 585 |
unsigned int bit_alloc[2][SBLIMIT], |
| 586 |
unsigned int sbband[2][3][SCALE_BLOCK][SBLIMIT]) |
| 587 |
{ |
| 588 |
int sb, j, ch, gr, qnt_coeff_index, sig; |
| 589 |
int nch = glopts->num_channels_out; |
| 590 |
int sblimit = glopts->sblimit; |
| 591 |
int jsbound = glopts->jsbound; |
| 592 |
FLOAT d; |
| 593 |
|
| 594 |
for (gr = 0; gr < 3; gr++) |
| 595 |
for (j = 0; j < SCALE_BLOCK; j++) |
| 596 |
for (sb = 0; sb < sblimit; sb++) |
| 597 |
for (ch = 0; ch < ((sb < jsbound) ? nch : 1); ch++) |
| 598 |
|
| 599 |
if (bit_alloc[ch][sb]) { |
| 600 |
/* scale and quantize FLOATing point sample */ |
| 601 |
if (nch == 2 && sb >= jsbound) /* use j-stereo samples */ |
| 602 |
d = j_samps[gr][j][sb] / scalefactor[j_scale[gr][sb]]; |
| 603 |
else |
| 604 |
d = sb_samples[ch][gr][j][sb] / scalefactor[sf_index[ch][gr][sb]]; |
| 605 |
|
| 606 |
/* Check that the wrong scale factor hasn't been chosen - which would |
| 607 |
result in a scaled sample being > 1.0 This error shouldn't ever happen |
| 608 |
*unless* something went wrong in scalefactor calc |
| 609 |
|
| 610 |
if (mod (d) > 1.0) fprintf (stderr, "Not scaled properly %d %d %d %d\n", |
| 611 |
ch, gr, j, sb); */ |
| 612 |
|
| 613 |
{ |
| 614 |
/* 'index' indicates which "step line" we are using */ |
| 615 |
int index = line[glopts->tablenum][sb]; |
| 616 |
|
| 617 |
/* Find the "step index" within that line */ |
| 618 |
qnt_coeff_index = step_index[index][bit_alloc[ch][sb]]; |
| 619 |
} |
| 620 |
d = d * a[qnt_coeff_index] + b[qnt_coeff_index]; |
| 621 |
|
| 622 |
/* extract MSB N-1 bits from the FLOATing point sample */ |
| 623 |
if (d >= 0) |
| 624 |
sig = 1; |
| 625 |
else { |
| 626 |
sig = 0; |
| 627 |
d += 1.0; |
| 628 |
} |
| 629 |
|
| 630 |
sbband[ch][gr][j][sb] = |
| 631 |
(unsigned int) (d * (FLOAT) steps2n[qnt_coeff_index]); |
| 632 |
/* tag the inverted sign bit to sbband at position N */ |
| 633 |
/* The bit inversion is a must for grouping with 3,5,9 steps so it is done |
| 634 |
for all subbands */ |
| 635 |
if (sig) |
| 636 |
sbband[ch][gr][j][sb] |= steps2n[qnt_coeff_index]; |
| 637 |
} |
| 638 |
|
| 639 |
/* Set everything above the sblimit to 0 */ |
| 640 |
for (ch = 0; ch < nch; ch++) |
| 641 |
for (gr = 0; gr < 3; gr++) |
| 642 |
for (sb = 0; sb < SCALE_BLOCK; sb++) |
| 643 |
for (j = sblimit; j < SBLIMIT; j++) |
| 644 |
sbband[ch][gr][sb][j] = 0; |
| 645 |
} |
| 646 |
|
| 647 |
/************************************************************************ |
| 648 |
sample_encoding |
| 649 |
|
| 650 |
PURPOSE:Put one frame of subband samples on to the bitstream |
| 651 |
|
| 652 |
SEMANTICS: The number of bits allocated per sample is read from |
| 653 |
the bit allocation information #bit_alloc#. Layer 2 |
| 654 |
supports writing grouped samples for quantization steps |
| 655 |
that are not a power of 2. |
| 656 |
|
| 657 |
***********************************************************************/ |
| 658 |
void twolame_write_samples(twolame_options * glopts, |
| 659 |
unsigned int sbband[2][3][SCALE_BLOCK][SBLIMIT], |
| 660 |
unsigned int bit_alloc[2][SBLIMIT], bit_stream * bs) |
| 661 |
{ |
| 662 |
unsigned int nch = glopts->num_channels_out; |
| 663 |
unsigned int sblimit = glopts->sblimit; |
| 664 |
unsigned int jsbound = glopts->jsbound; |
| 665 |
unsigned int sb, j, ch, gr, x, y; |
| 666 |
unsigned int temp; |
| 667 |
|
| 668 |
for (gr = 0; gr < 3; gr++) |
| 669 |
for (j = 0; j < SCALE_BLOCK; j += 3) |
| 670 |
for (sb = 0; sb < sblimit; sb++) |
| 671 |
for (ch = 0; ch < ((sb < jsbound) ? nch : 1); ch++) { |
| 672 |
if (bit_alloc[ch][sb]) { |
| 673 |
int thisline = line[glopts->tablenum][sb]; |
| 674 |
int thisstep_index = step_index[thisline][bit_alloc[ch][sb]]; |
| 675 |
|
| 676 |
/* Check how many samples per codeword */ |
| 677 |
if (group[thisstep_index] == 3) { |
| 678 |
/* Going to send 1 sample per codeword -> 3 samples */ |
| 679 |
for (x = 0; x < 3; x++) { |
| 680 |
buffer_putbits(bs, sbband[ch][gr][j + x][sb], bits[thisstep_index]); |
| 681 |
} |
| 682 |
|
| 683 |
} else { |
| 684 |
/* ISO11172 Sec C.1.5.2.8 If steps=3, 5 or 9, then three consecutive |
| 685 |
samples are coded as one codeword i.e. only one value (V) is |
| 686 |
transmitted for this triplet. If the 3 subband samples are x,y,z |
| 687 |
then V = (steps*steps)*z + steps*y +x */ |
| 688 |
y = steps[thisstep_index]; |
| 689 |
temp = |
| 690 |
sbband[ch][gr][j][sb] + sbband[ch][gr][j + 1][sb] * y + |
| 691 |
sbband[ch][gr][j + 2][sb] * y * y; |
| 692 |
buffer_putbits(bs, temp, bits[thisstep_index]); |
| 693 |
} |
| 694 |
} |
| 695 |
} |
| 696 |
} |
| 697 |
|
| 698 |
|
| 699 |
/************************************************************************ |
| 700 |
* |
| 701 |
* bits_for_nonoise (Layer II) |
| 702 |
* |
| 703 |
* PURPOSE:Returns the number of bits required to produce a |
| 704 |
* mask-to-noise ratio better or equal to the noise/no_noise threshold. |
| 705 |
* |
| 706 |
* SEMANTICS: |
| 707 |
* bbal = # bits needed for encoding bit allocation |
| 708 |
* bsel = # bits needed for encoding scalefactor select information |
| 709 |
* banc = # bits needed for ancillary data (header info included) |
| 710 |
* |
| 711 |
* For each subband and channel, will add bits until one of the |
| 712 |
* following occurs: |
| 713 |
* - Hit maximum number of bits we can allocate for that subband |
| 714 |
* - MNR is better than or equal to the minimum masking level |
| 715 |
* (NOISY_MIN_MNR) |
| 716 |
* Then the bits required for scalefactors, scfsi, bit allocation, |
| 717 |
* and the subband samples are tallied (#req_bits#) and returned. |
| 718 |
* |
| 719 |
* (NOISY_MIN_MNR) is the smallest MNR a subband can have before it is |
| 720 |
* counted as 'noisy' by the logic which chooses the number of JS |
| 721 |
* subbands. |
| 722 |
* |
| 723 |
* Joint stereo is supported. |
| 724 |
* |
| 725 |
************************************************************************/ |
| 726 |
|
| 727 |
int twolame_bits_for_nonoise(twolame_options * glopts, |
| 728 |
FLOAT SMR[2][SBLIMIT], |
| 729 |
unsigned int scfsi[2][SBLIMIT], FLOAT min_mnr, |
| 730 |
unsigned int bit_alloc[2][SBLIMIT]) |
| 731 |
{ |
| 732 |
frame_header *header = &glopts->header; |
| 733 |
int sb, ch, ba; |
| 734 |
int nch = glopts->num_channels_out; |
| 735 |
int sblimit = glopts->sblimit; |
| 736 |
int jsbound = glopts->jsbound; |
| 737 |
int req_bits = 0, bbal = 0, berr = 0, banc = 32; |
| 738 |
int maxAlloc, sel_bits, sc_bits, smp_bits; |
| 739 |
static const int sfsPerScfsi[] = { 3, 2, 1, 2 }; /* lookup # sfs per scfsi */ |
| 740 |
|
| 741 |
/* MFC Feb 2003 This works out the basic number of bits just to get a valid (but empty) frame. |
| 742 |
This needs to be done for every frame, since a joint_stereo frame will change the number of |
| 743 |
basic bits (depending on the sblimit in the particular js mode that's been selected */ |
| 744 |
|
| 745 |
/* Make sure there's room for the error protection bits */ |
| 746 |
if (header->error_protection) |
| 747 |
berr = 16; |
| 748 |
else |
| 749 |
berr = 0; |
| 750 |
|
| 751 |
/* Count the number of bits required to encode the quantization index for both channels in each |
| 752 |
subband. If we're above the jsbound, then pretend we only have one channel */ |
| 753 |
for (sb = 0; sb < jsbound; ++sb) |
| 754 |
bbal += nch * nbal[line[glopts->tablenum][sb]]; // (*alloc)[sb][0].bits; |
| 755 |
|
| 756 |
for (sb = jsbound; sb < sblimit; ++sb) |
| 757 |
bbal += nbal[line[glopts->tablenum][sb]]; // (*alloc)[sb][0].bits; |
| 758 |
req_bits = banc + bbal + berr; |
| 759 |
|
| 760 |
for (sb = 0; sb < sblimit; ++sb) |
| 761 |
for (ch = 0; ch < ((sb < jsbound) ? nch : 1); ++ch) { |
| 762 |
int thisline = line[glopts->tablenum][sb]; |
| 763 |
|
| 764 |
/* How many possible steps are there to choose from ? */ |
| 765 |
maxAlloc = (1 << nbal[line[glopts->tablenum][sb]]) - 1; // (*alloc)[sb][0].bits) - 1; |
| 766 |
sel_bits = sc_bits = smp_bits = 0; |
| 767 |
/* Keep choosing the next number of steps (and hence our SNR value) until we have the |
| 768 |
required MNR value */ |
| 769 |
for (ba = 0; ba < maxAlloc - 1; ++ba) { |
| 770 |
int thisstep_index = step_index[thisline][ba]; |
| 771 |
if ((SNR[thisstep_index] - SMR[ch][sb]) >= min_mnr) |
| 772 |
break; /* we found enough bits */ |
| 773 |
} |
| 774 |
if (nch == 2 && sb >= jsbound) /* check other JS channel */ |
| 775 |
for (; ba < maxAlloc - 1; ++ba) { |
| 776 |
int thisstep_index = step_index[thisline][ba]; |
| 777 |
if ((SNR[thisstep_index] - SMR[1 - ch][sb]) >= min_mnr) |
| 778 |
break; |
| 779 |
} |
| 780 |
if (ba > 0) { |
| 781 |
// smp_bits = SCALE_BLOCK * ((*alloc)[sb][ba].group * (*alloc)[sb][ba].bits); |
| 782 |
int thisstep_index = step_index[thisline][ba]; |
| 783 |
smp_bits = SCALE_BLOCK * group[thisstep_index] * bits[thisstep_index]; |
| 784 |
/* scale factor bits required for subband */ |
| 785 |
sel_bits = 2; |
| 786 |
sc_bits = 6 * sfsPerScfsi[scfsi[ch][sb]]; |
| 787 |
if (nch == 2 && sb >= jsbound) { |
| 788 |
/* each new js sb has L+R scfsis */ |
| 789 |
sel_bits += 2; |
| 790 |
sc_bits += 6 * sfsPerScfsi[scfsi[1 - ch][sb]]; |
| 791 |
} |
| 792 |
req_bits += smp_bits + sel_bits + sc_bits; |
| 793 |
} |
| 794 |
bit_alloc[ch][sb] = ba; |
| 795 |
} |
| 796 |
return req_bits; |
| 797 |
} |
| 798 |
|
| 799 |
|
| 800 |
/* must be called before calling main_bit_allocation */ |
| 801 |
int twolame_init_bit_allocation(twolame_options * glopts) |
| 802 |
{ |
| 803 |
frame_header *header = &glopts->header; |
| 804 |
int nch = glopts->num_channels_out; |
| 805 |
int brindex; |
| 806 |
|
| 807 |
|
| 808 |
/* these are the tables which specify the limits within which the VBR can vary You can't vary |
| 809 |
outside these ranges, otherwise a new alloc table would have to be loaded in the middle of |
| 810 |
encoding. This VBR hack is dodgy - the standard says that LayerII decoders don't have to |
| 811 |
support a variable bitrate, but Layer3 decoders must do so. Hence, it is unlikely that a |
| 812 |
compliant layer2 decoder would be written to dynmically change allocation tables. *BUT* a |
| 813 |
layer3 encoder might handle it by default, meaning we could switch tables mid-encode and |
| 814 |
enjoy a wider range of bitrates for the VBR encoding. None of this needs to be done for LSF, |
| 815 |
since there is only *one* possible alloc table in LSF MFC Feb 2003 */ |
| 816 |
|
| 817 |
static const int vbrlimits[2][3][2] = { |
| 818 |
/* MONO */ |
| 819 |
{ /* 44 */ {6, 10}, |
| 820 |
/* 48 */ {3, 10}, |
| 821 |
/* 32 */ {6, 10} |
| 822 |
}, |
| 823 |
/* STEREO */ |
| 824 |
{ /* 44 */ {10, 14}, |
| 825 |
/* 48 */ {7, 14}, |
| 826 |
/* 32 */ {10, 14} |
| 827 |
} |
| 828 |
}; |
| 829 |
|
| 830 |
|
| 831 |
for (brindex = 0; brindex < 15; brindex++) |
| 832 |
glopts->bitrateindextobits[brindex] = 0; |
| 833 |
|
| 834 |
if (header->version == TWOLAME_MPEG2) { |
| 835 |
/* LSF: so can use any bitrate index from 1->15 */ |
| 836 |
glopts->lower_index = 1; |
| 837 |
glopts->upper_index = 14; |
| 838 |
} else { |
| 839 |
int sfreq = header->samplerate_idx; |
| 840 |
glopts->lower_index = vbrlimits[nch - 1][sfreq][0]; |
| 841 |
glopts->upper_index = vbrlimits[nch - 1][sfreq][1]; |
| 842 |
} |
| 843 |
|
| 844 |
if (glopts->vbr_upper_index > 0) { |
| 845 |
/* User is requesting a specific upperbitrate */ |
| 846 |
if ((glopts->vbr_upper_index < glopts->lower_index) || |
| 847 |
(glopts->vbr_upper_index > glopts->upper_index)) { |
| 848 |
fprintf(stderr, "Can't satisfy upper bitrate index constraint. out of bounds. %i\n", |
| 849 |
glopts->vbr_upper_index); |
| 850 |
return -2; |
| 851 |
} else |
| 852 |
glopts->upper_index = glopts->vbr_upper_index; |
| 853 |
} |
| 854 |
/* when vbr is requested, check glopts->bitrate and fix it eventually */ |
| 855 |
if (glopts->vbr) { |
| 856 |
/* the specified bitrate will be used as a lower bound when valid */ |
| 857 |
if (glopts->bitrate < twolame_index_bitrate((int)glopts->version, glopts->lower_index)) |
| 858 |
glopts->bitrate = twolame_index_bitrate((int)glopts->version, glopts->lower_index); |
| 859 |
else |
| 860 |
glopts->lower_index = twolame_get_bitrate_index(glopts->bitrate, glopts->version); |
| 861 |
} |
| 862 |
|
| 863 |
|
| 864 |
/* set up a conversion table for bitrateindex->bits for this version/sampl freq This will be |
| 865 |
used to find the best bitrate to cope with the number of bits that are needed (as determined |
| 866 |
by vbr_bits_for_nonoise) */ |
| 867 |
for (brindex = glopts->lower_index; brindex <= glopts->upper_index; brindex++) { |
| 868 |
glopts->bitrateindextobits[brindex] = |
| 869 |
(int) (1152.0 / (glopts->samplerate_out / 1000.0) * (FLOAT) twolame_index_bitrate((int)glopts->version, brindex)); |
| 870 |
} |
| 871 |
|
| 872 |
return 0; |
| 873 |
} |
| 874 |
|
| 875 |
|
| 876 |
/************************************************************************ |
| 877 |
* |
| 878 |
* main_bit_allocation (Layer II) |
| 879 |
* |
| 880 |
* PURPOSE:For joint stereo mode, determines which of the 4 joint |
| 881 |
* stereo modes is needed. Then calls *_a_bit_allocation(), which |
| 882 |
* allocates bits for each of the subbands until there are no more bits |
| 883 |
* left, or the MNR is at the noise/no_noise threshold. |
| 884 |
* |
| 885 |
* SEMANTICS: |
| 886 |
* |
| 887 |
* For joint stereo mode, joint stereo is changed to stereo if |
| 888 |
* there are enough bits to encode stereo at or better than the |
| 889 |
* no-noise threshold (NOISY_MIN_MNR). Otherwise, the system |
| 890 |
* iteratively allocates less bits by using joint stereo until one |
| 891 |
* of the following occurs: |
| 892 |
* - there are no more noisy subbands (MNR >= NOISY_MIN_MNR) |
| 893 |
* - mode_ext has been reduced to 0, which means that all but the |
| 894 |
* lowest 4 subbands have been converted from stereo to joint |
| 895 |
* stereo, and no more subbands may be converted |
| 896 |
* |
| 897 |
* This function calls *_bits_for_nonoise() and *_a_bit_allocation(). |
| 898 |
* |
| 899 |
************************************************************************/ |
| 900 |
void twolame_main_bit_allocation(twolame_options * glopts, |
| 901 |
FLOAT SMR[2][SBLIMIT], |
| 902 |
unsigned int scfsi[2][SBLIMIT], |
| 903 |
unsigned int bit_alloc[2][SBLIMIT], int *adb) |
| 904 |
{ |
| 905 |
frame_header *header = &glopts->header; |
| 906 |
int mode = glopts->mode; |
| 907 |
int mode_ext; |
| 908 |
int rq_db; /* av_db = *adb; Not Used MFC Nov 99 */ |
| 909 |
int guessindex = 0; |
| 910 |
|
| 911 |
|
| 912 |
if (mode == TWOLAME_JOINT_STEREO) { |
| 913 |
header->mode = TWOLAME_STEREO; |
| 914 |
header->mode_ext = 0; |
| 915 |
glopts->jsbound = glopts->sblimit; |
| 916 |
if ((rq_db = twolame_bits_for_nonoise(glopts, SMR, scfsi, 0, bit_alloc)) > *adb) { |
| 917 |
header->mode = TWOLAME_JOINT_STEREO; |
| 918 |
mode_ext = 4; /* 3 is least severe reduction */ |
| 919 |
do { |
| 920 |
--mode_ext; |
| 921 |
glopts->jsbound = get_js_bound(mode_ext); |
| 922 |
rq_db = twolame_bits_for_nonoise(glopts, SMR, scfsi, 0, bit_alloc); |
| 923 |
} |
| 924 |
while ((rq_db > *adb) && (mode_ext > 0)); |
| 925 |
header->mode_ext = mode_ext; |
| 926 |
} /* well we either eliminated noisy sbs or mode_ext == 0 */ |
| 927 |
} |
| 928 |
|
| 929 |
/* decide on which bit allocation method to use */ |
| 930 |
if (glopts->vbr == FALSE) { |
| 931 |
/* Just do the old bit allocation method */ |
| 932 |
twolame_a_bit_allocation(glopts, SMR, scfsi, bit_alloc, adb); |
| 933 |
} else { |
| 934 |
/* do the VBR bit allocation method */ |
| 935 |
{ |
| 936 |
int brindex; |
| 937 |
|
| 938 |
/* Work out how many bits are needed for there to be no noise (ie all MNR > VBRLEVEL) */ |
| 939 |
int req = twolame_bits_for_nonoise(glopts, SMR, scfsi, glopts->vbrlevel, bit_alloc); |
| 940 |
|
| 941 |
/* Look up this value in the bitrateindextobits table to find what bitrate we should |
| 942 |
use for this frame */ |
| 943 |
for (brindex = glopts->lower_index; brindex <= glopts->upper_index; brindex++) { |
| 944 |
if (glopts->bitrateindextobits[brindex] > req) { |
| 945 |
/* this method always *overestimates* the bits that are needed i.e. it will |
| 946 |
usually guess right but when it's wrong it'll guess a higher bitrate than |
| 947 |
actually required. e.g. on "messages from earth" track 6, the guess was |
| 948 |
wrong on 75/36341 frames. each time it guessed higher. MFC Feb 2003 */ |
| 949 |
guessindex = brindex; |
| 950 |
break; |
| 951 |
} |
| 952 |
} |
| 953 |
/* Just for sanity */ |
| 954 |
if (brindex == glopts->upper_index+1) |
| 955 |
guessindex = glopts->upper_index; |
| 956 |
} |
| 957 |
|
| 958 |
header->bitrate_index = guessindex; |
| 959 |
glopts->bitrate = twolame_index_bitrate((int)glopts->version, guessindex); |
| 960 |
*adb = twolame_available_bits(glopts); |
| 961 |
|
| 962 |
/* update the statistics */ |
| 963 |
glopts->vbrstats[header->bitrate_index]++; |
| 964 |
|
| 965 |
if (glopts->verbosity > 3) { |
| 966 |
/* print out the VBR stats every 1000th frame */ |
| 967 |
int i; |
| 968 |
if ((glopts->vbr_frame_count++ % 1000) == 0) { |
| 969 |
for (i = 1; i < 15; i++) |
| 970 |
fprintf(stderr, "%4i ", glopts->vbrstats[i]); |
| 971 |
fprintf(stderr, "\n"); |
| 972 |
} |
| 973 |
|
| 974 |
/* Print out *every* frames bitrateindex, bits required, and bits available at this |
| 975 |
bitrate */ |
| 976 |
if (glopts->verbosity > 5) |
| 977 |
fprintf(stderr, |
| 978 |
"> bitrate index %2i has %i bits available to encode the %i bits\n", |
| 979 |
header->bitrate_index, *adb, |
| 980 |
twolame_bits_for_nonoise(glopts, SMR, scfsi, glopts->vbrlevel, bit_alloc)); |
| 981 |
|
| 982 |
} |
| 983 |
|
| 984 |
twolame_vbr_bit_allocation(glopts, SMR, scfsi, bit_alloc, adb); |
| 985 |
} |
| 986 |
} |
| 987 |
|
| 988 |
static void vbr_maxmnr(FLOAT mnr[2][SBLIMIT], char used[2][SBLIMIT], int sblimit, |
| 989 |
int nch, int *min_sb, int *min_ch, FLOAT vbrlevel) |
| 990 |
{ |
| 991 |
int sb, ch; |
| 992 |
FLOAT small; |
| 993 |
|
| 994 |
small = 999999.0; |
| 995 |
*min_sb = -1; |
| 996 |
*min_ch = -1; |
| 997 |
|
| 998 |
#define NEWBITx |
| 999 |
#ifdef NEWBIT |
| 1000 |
/* Keep going until all subbands have reached the MNR level that we specified */ |
| 1001 |
for (ch = 0; ch < nch; ch++) |
| 1002 |
for (sb = 0; sb < sblimit; sb++) |
| 1003 |
if (mnr[ch][sb] < vbrlevel) { |
| 1004 |
*min_sb = sb; |
| 1005 |
*min_ch = ch; |
| 1006 |
// fprintf(stderr,"."); |
| 1007 |
// fflush(stderr); |
| 1008 |
return; |
| 1009 |
} |
| 1010 |
#endif |
| 1011 |
|
| 1012 |
/* Then start adding bits to whichever is the min MNR */ |
| 1013 |
for (ch = 0; ch < nch; ++ch) |
| 1014 |
for (sb = 0; sb < sblimit; sb++) |
| 1015 |
if (used[ch][sb] != 2 && small > mnr[ch][sb]) { |
| 1016 |
small = mnr[ch][sb]; |
| 1017 |
*min_sb = sb; |
| 1018 |
*min_ch = ch; |
| 1019 |
} |
| 1020 |
// fprintf(stderr,"Min sb: %i\n",*min_sb); |
| 1021 |
} |
| 1022 |
|
| 1023 |
|
| 1024 |
|
| 1025 |
|
| 1026 |
/******************** |
| 1027 |
MFC Feb 2003 |
| 1028 |
vbr_bit_allocation is different to the normal a_bit_allocation in that |
| 1029 |
it is known beforehand that there are definitely enough bits to do what we |
| 1030 |
have to - i.e. a bitrate was specificially chosen in main_bit_allocation so |
| 1031 |
that we have enough bits to encode what we have to. |
| 1032 |
This function should take that into account and just greedily assign |
| 1033 |
the bits, rather than fussing over the minimum MNR subband - we know |
| 1034 |
each subband gets its required bits, why quibble? |
| 1035 |
This function doesn't chew much CPU, so I haven't made any attempt |
| 1036 |
to do this yet. |
| 1037 |
*********************/ |
| 1038 |
int twolame_vbr_bit_allocation(twolame_options * glopts, |
| 1039 |
FLOAT SMR[2][SBLIMIT], |
| 1040 |
unsigned int scfsi[2][SBLIMIT], unsigned int bit_alloc[2][SBLIMIT], int *adb) |
| 1041 |
{ |
| 1042 |
int sb, min_ch, min_sb, oth_ch, ch, increment, scale, seli, ba; |
| 1043 |
int bspl, bscf, bsel, ad, bbal = 0; |
| 1044 |
frame_header *header = &glopts->header; |
| 1045 |
FLOAT mnr[2][SBLIMIT]; |
| 1046 |
char used[2][SBLIMIT]; |
| 1047 |
int nch = glopts->num_channels_out; |
| 1048 |
int sblimit = glopts->sblimit; |
| 1049 |
int jsbound = glopts->jsbound; |
| 1050 |
int banc, berr; |
| 1051 |
static const int sfsPerScfsi[] = { 3, 2, 1, 2 }; /* lookup # sfs per scfsi */ |
| 1052 |
int thisstep_index; |
| 1053 |
|
| 1054 |
if (header->error_protection) { |
| 1055 |
berr = 16; /* added 92-08-11 shn */ |
| 1056 |
banc = 32; |
| 1057 |
} else { |
| 1058 |
berr = 0; |
| 1059 |
banc = 32; |
| 1060 |
} |
| 1061 |
|
| 1062 |
|
| 1063 |
/* No need to worry about jsbound here as JS is disabled for VBR mode */ |
| 1064 |
for (sb = 0; sb < sblimit; sb++) |
| 1065 |
bbal += nch * nbal[line[glopts->tablenum][sb]]; |
| 1066 |
*adb -= bbal + berr + banc; |
| 1067 |
ad = *adb; |
| 1068 |
|
| 1069 |
for (sb = 0; sb < sblimit; sb++) |
| 1070 |
for (ch = 0; ch < nch; ch++) { |
| 1071 |
mnr[ch][sb] = SNR[0] - SMR[ch][sb]; |
| 1072 |
bit_alloc[ch][sb] = 0; |
| 1073 |
used[ch][sb] = 0; |
| 1074 |
} |
| 1075 |
bspl = bscf = bsel = 0; |
| 1076 |
|
| 1077 |
do { |
| 1078 |
/* locate the subband with minimum SMR */ |
| 1079 |
vbr_maxmnr(mnr, used, sblimit, nch, &min_sb, &min_ch, glopts->vbrlevel); |
| 1080 |
|
| 1081 |
if (min_sb > -1) { /* there was something to find */ |
| 1082 |
int thisline = line[glopts->tablenum][min_sb]; |
| 1083 |
{ |
| 1084 |
/* find increase in bit allocation in subband [min] */ |
| 1085 |
int nextstep_index = step_index[thisline][bit_alloc[min_ch][min_sb] + 1]; |
| 1086 |
increment = SCALE_BLOCK * group[nextstep_index] * bits[nextstep_index]; |
| 1087 |
} |
| 1088 |
if (used[min_ch][min_sb]) { |
| 1089 |
/* If we've already increased the limit on this ch/sb, then subtract the last thing |
| 1090 |
that we added */ |
| 1091 |
thisstep_index = step_index[thisline][bit_alloc[min_ch][min_sb]]; |
| 1092 |
increment -= SCALE_BLOCK * group[thisstep_index] * bits[thisstep_index]; |
| 1093 |
} |
| 1094 |
|
| 1095 |
/* scale factor bits required for subband [min] */ |
| 1096 |
oth_ch = 1 - min_ch; /* above js bound, need both chans */ |
| 1097 |
if (used[min_ch][min_sb]) { |
| 1098 |
scale = seli = 0; |
| 1099 |
} else { /* this channel had no bits or scfs before */ |
| 1100 |
seli = 2; |
| 1101 |
scale = 6 * sfsPerScfsi[scfsi[min_ch][min_sb]]; |
| 1102 |
if (nch == 2 && min_sb >= jsbound) { |
| 1103 |
/* each new js sb has L+R scfsis */ |
| 1104 |
seli += 2; |
| 1105 |
scale += 6 * sfsPerScfsi[scfsi[oth_ch][min_sb]]; |
| 1106 |
} |
| 1107 |
} |
| 1108 |
|
| 1109 |
/* check to see enough bits were available for */ |
| 1110 |
/* increasing resolution in the minimum band */ |
| 1111 |
if (ad >= bspl + bscf + bsel + seli + scale + increment) { |
| 1112 |
/* Then there are enough bits to have another go at allocating */ |
| 1113 |
ba = ++bit_alloc[min_ch][min_sb]; /* next up alloc */ |
| 1114 |
bspl += increment; /* bits for subband sample */ |
| 1115 |
bscf += scale; /* bits for scale factor */ |
| 1116 |
bsel += seli; /* bits for scfsi code */ |
| 1117 |
used[min_ch][min_sb] = 1; /* subband has bits */ |
| 1118 |
thisstep_index = step_index[thisline][ba]; |
| 1119 |
mnr[min_ch][min_sb] = SNR[thisstep_index] - SMR[min_ch][min_sb]; |
| 1120 |
/* Check if this min_sb subband has been fully allocated max bits */ |
| 1121 |
if (ba >= (1 << nbal[line[glopts->tablenum][min_sb]]) - 1) // (*alloc)[min_sb][0].bits) |
| 1122 |
// |
| 1123 |
// - 1) |
| 1124 |
used[min_ch][min_sb] = 2; /* don't let this sb get any more bits */ |
| 1125 |
} else { |
| 1126 |
used[min_ch][min_sb] = 2; /* can't increase this alloc */ |
| 1127 |
} |
| 1128 |
} |
| 1129 |
} |
| 1130 |
while (min_sb > -1); /* until could find no channel */ |
| 1131 |
|
| 1132 |
/* Calculate the number of bits left */ |
| 1133 |
ad -= bspl + bscf + bsel; |
| 1134 |
*adb = ad; |
| 1135 |
for (ch = 0; ch < nch; ch++) |
| 1136 |
for (sb = sblimit; sb < SBLIMIT; sb++) |
| 1137 |
bit_alloc[ch][sb] = 0; |
| 1138 |
|
| 1139 |
return 0; |
| 1140 |
} |
| 1141 |
|
| 1142 |
|
| 1143 |
|
| 1144 |
static void maxmnr(FLOAT mnr[2][SBLIMIT], char used[2][SBLIMIT], int sblimit, |
| 1145 |
int nch, int *min_sb, int *min_ch) |
| 1146 |
{ |
| 1147 |
int sb, ch; |
| 1148 |
FLOAT small; |
| 1149 |
|
| 1150 |
small = 999999.0; |
| 1151 |
*min_sb = -1; |
| 1152 |
*min_ch = -1; |
| 1153 |
for (ch = 0; ch < nch; ++ch) |
| 1154 |
for (sb = 0; sb < sblimit; sb++) |
| 1155 |
if (used[ch][sb] != 2 && small > mnr[ch][sb]) { |
| 1156 |
small = mnr[ch][sb]; |
| 1157 |
*min_sb = sb; |
| 1158 |
*min_ch = ch; |
| 1159 |
} |
| 1160 |
} |
| 1161 |
|
| 1162 |
|
| 1163 |
|
| 1164 |
|
| 1165 |
|
| 1166 |
/************************************************************************ |
| 1167 |
* |
| 1168 |
* a_bit_allocation (Layer II) |
| 1169 |
* |
| 1170 |
* PURPOSE:Adds bits to the subbands with the lowest mask-to-noise |
| 1171 |
* ratios, until the maximum number of bits for the subband has |
| 1172 |
* been allocated. |
| 1173 |
* |
| 1174 |
* SEMANTICS: |
| 1175 |
* 1. Find the subband and channel with the smallest MNR (#min_sb#, |
| 1176 |
* and #min_ch#) |
| 1177 |
* 2. Calculate the increase in bits needed if we increase the bit |
| 1178 |
* allocation to the next higher level |
| 1179 |
* 3. If there are enough bits available for increasing the resolution |
| 1180 |
* in #min_sb#, #min_ch#, and the subband has not yet reached its |
| 1181 |
* maximum allocation, update the bit allocation, MNR, and bits |
| 1182 |
* available accordingly |
| 1183 |
* 4. Repeat until there are no more bits left, or no more available |
| 1184 |
* subbands. (A subband is still available until the maximum |
| 1185 |
* number of bits for the subband has been allocated, or there |
| 1186 |
* aren't enough bits to go to the next higher resolution in the |
| 1187 |
* subband.) |
| 1188 |
* |
| 1189 |
************************************************************************/ |
| 1190 |
|
| 1191 |
int twolame_a_bit_allocation(twolame_options * glopts, FLOAT SMR[2][SBLIMIT], |
| 1192 |
unsigned int scfsi[2][SBLIMIT], unsigned int bit_alloc[2][SBLIMIT], int *adb) |
| 1193 |
{ |
| 1194 |
int sb, min_ch, min_sb, oth_ch, ch, increment, scale, seli, ba; |
| 1195 |
int bspl, bscf, bsel, ad, bbal = 0; |
| 1196 |
FLOAT mnr[2][SBLIMIT]; |
| 1197 |
char used[2][SBLIMIT]; |
| 1198 |
frame_header *header = &glopts->header; |
| 1199 |
int nch = glopts->num_channels_out; |
| 1200 |
int sblimit = glopts->sblimit; |
| 1201 |
int jsbound = glopts->jsbound; |
| 1202 |
int banc, berr; |
| 1203 |
static const int sfsPerScfsi[] = { 3, 2, 1, 2 }; /* lookup # sfs per scfsi */ |
| 1204 |
|
| 1205 |
int thisstep_index; |
| 1206 |
|
| 1207 |
if (header->error_protection) { |
| 1208 |
berr = 16; /* added 92-08-11 shn */ |
| 1209 |
banc = 32; |
| 1210 |
} else { |
| 1211 |
berr = 0; |
| 1212 |
banc = 32; |
| 1213 |
} |
| 1214 |
|
| 1215 |
for (sb = 0; sb < jsbound; sb++) |
| 1216 |
bbal += nch * nbal[line[glopts->tablenum][sb]]; // (*alloc)[sb][0].bits; |
| 1217 |
for (sb = jsbound; sb < sblimit; sb++) |
| 1218 |
bbal += nbal[line[glopts->tablenum][sb]]; // (*alloc)[sb][0].bits; |
| 1219 |
*adb -= bbal + berr + banc; |
| 1220 |
ad = *adb; |
| 1221 |
|
| 1222 |
|
| 1223 |
for (sb = 0; sb < sblimit; sb++) { |
| 1224 |
for (ch = 0; ch < nch; ch++) { |
| 1225 |
mnr[ch][sb] = SNR[0] - SMR[ch][sb]; |
| 1226 |
bit_alloc[ch][sb] = 0; |
| 1227 |
used[ch][sb] = 0; |
| 1228 |
} |
| 1229 |
} |
| 1230 |
bspl = bscf = bsel = 0; |
| 1231 |
|
| 1232 |
do { |
| 1233 |
/* locate the subband with minimum SMR */ |
| 1234 |
maxmnr(mnr, used, sblimit, nch, &min_sb, &min_ch); |
| 1235 |
|
| 1236 |
if (min_sb > -1) { /* there was something to find */ |
| 1237 |
int thisline = line[glopts->tablenum][min_sb]; |
| 1238 |
{ |
| 1239 |
/* find increase in bit allocation in subband [min] */ |
| 1240 |
int nextstep_index = step_index[thisline][bit_alloc[min_ch][min_sb] + 1]; |
| 1241 |
increment = SCALE_BLOCK * group[nextstep_index] * bits[nextstep_index]; |
| 1242 |
} |
| 1243 |
if (used[min_ch][min_sb]) { |
| 1244 |
/* If we've already increased the limit on this ch/sb, then subtract the last thing |
| 1245 |
that we added */ |
| 1246 |
thisstep_index = step_index[thisline][bit_alloc[min_ch][min_sb]]; |
| 1247 |
increment -= SCALE_BLOCK * group[thisstep_index] * bits[thisstep_index]; |
| 1248 |
} |
| 1249 |
|
| 1250 |
/* scale factor bits required for subband [min] */ |
| 1251 |
oth_ch = 1 - min_ch; /* above js bound, need both chans */ |
| 1252 |
if (used[min_ch][min_sb]) { |
| 1253 |
scale = seli = 0; |
| 1254 |
} else { /* this channel had no bits or scfs before */ |
| 1255 |
seli = 2; |
| 1256 |
scale = 6 * sfsPerScfsi[scfsi[min_ch][min_sb]]; |
| 1257 |
if (nch == 2 && min_sb >= jsbound) { |
| 1258 |
/* each new js sb has L+R scfsis */ |
| 1259 |
seli += 2; |
| 1260 |
scale += 6 * sfsPerScfsi[scfsi[oth_ch][min_sb]]; |
| 1261 |
} |
| 1262 |
} |
| 1263 |
|
| 1264 |
/* check to see enough bits were available for */ |
| 1265 |
/* increasing resolution in the minimum band */ |
| 1266 |
if (ad >= bspl + bscf + bsel + seli + scale + increment) { |
| 1267 |
/* Then there are enough bits to have another go at allocating */ |
| 1268 |
ba = ++bit_alloc[min_ch][min_sb]; /* next up alloc */ |
| 1269 |
bspl += increment; /* bits for subband sample */ |
| 1270 |
bscf += scale; /* bits for scale factor */ |
| 1271 |
bsel += seli; /* bits for scfsi code */ |
| 1272 |
used[min_ch][min_sb] = 1; /* subband has bits */ |
| 1273 |
thisstep_index = step_index[thisline][ba]; |
| 1274 |
mnr[min_ch][min_sb] = SNR[thisstep_index] - SMR[min_ch][min_sb]; |
| 1275 |
/* Check if this min_sb subband has been fully allocated max bits */ |
| 1276 |
if (ba >= (1 << nbal[line[glopts->tablenum][min_sb]]) - 1) // (*alloc)[min_sb][0].bits) |
| 1277 |
// |
| 1278 |
// - 1) |
| 1279 |
used[min_ch][min_sb] = 2; /* don't let this sb get any more bits */ |
| 1280 |
} else { |
| 1281 |
used[min_ch][min_sb] = 2; /* can't increase this alloc */ |
| 1282 |
} |
| 1283 |
if (min_sb >= jsbound && nch == 2) { |
| 1284 |
/* above jsbound, alloc applies L+R */ |
| 1285 |
ba = bit_alloc[oth_ch][min_sb] = bit_alloc[min_ch][min_sb]; |
| 1286 |
used[oth_ch][min_sb] = used[min_ch][min_sb]; |
| 1287 |
thisstep_index = step_index[thisline][ba]; |
| 1288 |
mnr[oth_ch][min_sb] = SNR[thisstep_index] - SMR[oth_ch][min_sb]; |
| 1289 |
// mnr[oth_ch][min_sb] = SNR[(*alloc)[min_sb][ba].quant + 1] - SMR[oth_ch][min_sb]; |
| 1290 |
} |
| 1291 |
|
| 1292 |
} |
| 1293 |
} |
| 1294 |
while (min_sb > -1); /* until could find no channel */ |
| 1295 |
|
| 1296 |
/* Calculate the number of bits left */ |
| 1297 |
ad -= bspl + bscf + bsel; |
| 1298 |
*adb = ad; |
| 1299 |
for (ch = 0; ch < nch; ch++) |
| 1300 |
for (sb = sblimit; sb < SBLIMIT; sb++) |
| 1301 |
bit_alloc[ch][sb] = 0; |
| 1302 |
|
| 1303 |
return 0; |
| 1304 |
} |
| 1305 |
|
| 1306 |
|
| 1307 |
// vim:ts=4:sw=4:nowrap: |