| 1 |
/* |
| 2 |
The function to compute the layer III tables at runtime or for pregeneration. |
| 3 |
|
| 4 |
copyright ?-2021 by the mpg123 project - free software under the terms of the LGPL 2.1 |
| 5 |
see COPYING and AUTHORS files in distribution or http://mpg123.org |
| 6 |
initially written by Michael Hipp (in layer3.c). |
| 7 |
|
| 8 |
The type clreal is either double or float. |
| 9 |
*/ |
| 10 |
|
| 11 |
// init tables for layer-3 ... specific with the downsampling... |
| 12 |
void INT123_init_layer3(void) |
| 13 |
{ |
| 14 |
int i,j,k,l; |
| 15 |
|
| 16 |
for(i=0;i<8207;i++) |
| 17 |
ispow[i] = POW((clreal)i,(clreal)4.0/3.0); |
| 18 |
|
| 19 |
for(i=0;i<8;i++) |
| 20 |
{ |
| 21 |
const clreal Ci[8] = {-0.6,-0.535,-0.33,-0.185,-0.095,-0.041,-0.0142,-0.0037}; |
| 22 |
clreal sq = sqrt(1.0+Ci[i]*Ci[i]); |
| 23 |
aa_cs[i] = 1.0/sq; |
| 24 |
aa_ca[i] = Ci[i]/sq; |
| 25 |
} |
| 26 |
|
| 27 |
for(i=0;i<18;i++) |
| 28 |
{ |
| 29 |
win[0][i] = win[1][i] = |
| 30 |
0.5*SIN(M_PI/72.0 * (clreal)(2*(i+0) +1)) / COS(M_PI * (clreal)(2*(i+0) +19) / 72.0); |
| 31 |
win[0][i+18] = win[3][i+18] = |
| 32 |
0.5*SIN(M_PI/72.0 * (clreal)(2*(i+18)+1)) / COS(M_PI * (clreal)(2*(i+18)+19) / 72.0); |
| 33 |
} |
| 34 |
for(i=0;i<6;i++) |
| 35 |
{ |
| 36 |
win[1][i+18] = 0.5 / COS( M_PI * (clreal) (2*(i+18)+19) / 72.0 ); |
| 37 |
win[3][i+12] = 0.5 / COS( M_PI * (clreal) (2*(i+12)+19) / 72.0 ); |
| 38 |
win[1][i+24] = 0.5 * SIN( M_PI / 24.0 * (clreal) (2*i+13) ) / COS( M_PI * (clreal) (2*(i+24)+19) / 72.0 ); |
| 39 |
win[1][i+30] = win[3][i] = 0.0; |
| 40 |
win[3][i+6 ] = 0.5 * SIN( M_PI / 24.0 * (clreal) (2*i+1 ) ) / COS( M_PI * (clreal) (2*(i+6 )+19) / 72.0 ); |
| 41 |
} |
| 42 |
|
| 43 |
for(i=0;i<9;i++) |
| 44 |
INT123_COS9[i] = COS( M_PI / 18.0 * (clreal) i); |
| 45 |
|
| 46 |
for(i=0;i<9;i++) |
| 47 |
INT123_tfcos36[i] = 0.5 / COS( M_PI * (clreal) (i*2+1) / 36.0 ); |
| 48 |
|
| 49 |
for(i=0;i<3;i++) |
| 50 |
tfcos12[i] = 0.5 / COS( M_PI * (clreal) (i*2+1) / 12.0 ); |
| 51 |
|
| 52 |
COS6_1 = COS( M_PI / 6.0 * (clreal) 1); |
| 53 |
COS6_2 = COS( M_PI / 6.0 * (clreal) 2); |
| 54 |
|
| 55 |
cos9[0] = COS(1.0*M_PI/9.0); |
| 56 |
cos9[1] = COS(5.0*M_PI/9.0); |
| 57 |
cos9[2] = COS(7.0*M_PI/9.0); |
| 58 |
cos18[0] = COS(1.0*M_PI/18.0); |
| 59 |
cos18[1] = COS(11.0*M_PI/18.0); |
| 60 |
cos18[2] = COS(13.0*M_PI/18.0); |
| 61 |
|
| 62 |
for(i=0;i<12;i++) |
| 63 |
{ |
| 64 |
win[2][i] = 0.5 * SIN( M_PI / 24.0 * (clreal) (2*i+1) ) / COS( M_PI * (clreal) (2*i+7) / 24.0 ); |
| 65 |
} |
| 66 |
|
| 67 |
for(i=0;i<16;i++) |
| 68 |
{ |
| 69 |
// Special-casing possibly troublesome values where t=inf or |
| 70 |
// t=-1 in theory. In practice, this never caused issues, but there might |
| 71 |
// be a system with enough precision in M_PI to raise an exception. |
| 72 |
// Actually, the special values are not excluded from use in the code, but |
| 73 |
// in practice, they even have no effect in the compliance tests. |
| 74 |
if(i > 11) // It's periodic! |
| 75 |
{ |
| 76 |
tan1_1[i] = tan1_1[i-12]; |
| 77 |
tan2_1[i] = tan2_1[i-12]; |
| 78 |
tan1_2[i] = tan1_2[i-12]; |
| 79 |
tan2_2[i] = tan2_2[i-12]; |
| 80 |
} else if(i == 6) // t=inf |
| 81 |
{ |
| 82 |
tan1_1[i] = 1.0; |
| 83 |
tan2_1[i] = 0.0; |
| 84 |
tan1_2[i] = M_SQRT2; |
| 85 |
tan2_2[i] = 0.0; |
| 86 |
} else if(i == 9) // t=-1 |
| 87 |
{ |
| 88 |
tan1_1[i] = -HUGE_VAL; |
| 89 |
tan2_1[i] = HUGE_VAL; |
| 90 |
tan1_2[i] = -HUGE_VAL; |
| 91 |
tan2_2[i] = HUGE_VAL; |
| 92 |
} else |
| 93 |
{ |
| 94 |
clreal t = TAN( (clreal) i * M_PI / 12.0 ); |
| 95 |
tan1_1[i] = t / (1.0+t); |
| 96 |
tan2_1[i] = 1.0 / (1.0 + t); |
| 97 |
tan1_2[i] = M_SQRT2 * t / (1.0+t); |
| 98 |
tan2_2[i] = M_SQRT2 / (1.0 + t); |
| 99 |
} |
| 100 |
} |
| 101 |
|
| 102 |
for(i=0;i<32;i++) |
| 103 |
{ |
| 104 |
for(j=0;j<2;j++) |
| 105 |
{ |
| 106 |
clreal base = POW(2.0,-0.25*(j+1.0)); |
| 107 |
clreal p1=1.0,p2=1.0; |
| 108 |
if(i > 0) |
| 109 |
{ |
| 110 |
if( i & 1 ) p1 = POW(base,(i+1.0)*0.5); |
| 111 |
else p2 = POW(base,i*0.5); |
| 112 |
} |
| 113 |
pow1_1[j][i] = p1; |
| 114 |
pow2_1[j][i] = p2; |
| 115 |
pow1_2[j][i] = M_SQRT2 * p1; |
| 116 |
pow2_2[j][i] = M_SQRT2 * p2; |
| 117 |
} |
| 118 |
} |
| 119 |
|
| 120 |
for(j=0;j<4;j++) |
| 121 |
{ |
| 122 |
const int len[4] = { 36,36,12,36 }; |
| 123 |
for(i=0;i<len[j];i+=2) win1[j][i] = + win[j][i]; |
| 124 |
|
| 125 |
for(i=1;i<len[j];i+=2) win1[j][i] = - win[j][i]; |
| 126 |
} |
| 127 |
|
| 128 |
for(j=0;j<9;j++) |
| 129 |
{ |
| 130 |
const struct bandInfoStruct *bi = &bandInfo[j]; |
| 131 |
short *mp; |
| 132 |
short cb,lwin; |
| 133 |
const unsigned char *bdf; |
| 134 |
int switch_idx; |
| 135 |
|
| 136 |
mp = map[j][0] = mapbuf0[j]; |
| 137 |
bdf = bi->longDiff; |
| 138 |
switch_idx = (j < 3) ? 8 : 6; |
| 139 |
for(i=0,cb = 0; cb < switch_idx ; cb++,i+=*bdf++) |
| 140 |
{ |
| 141 |
*mp++ = (*bdf) >> 1; |
| 142 |
*mp++ = i; |
| 143 |
*mp++ = 3; |
| 144 |
*mp++ = cb; |
| 145 |
} |
| 146 |
bdf = bi->shortDiff+3; |
| 147 |
for(cb=3;cb<13;cb++) |
| 148 |
{ |
| 149 |
int l = (*bdf++) >> 1; |
| 150 |
for(lwin=0;lwin<3;lwin++) |
| 151 |
{ |
| 152 |
*mp++ = l; |
| 153 |
*mp++ = i + lwin; |
| 154 |
*mp++ = lwin; |
| 155 |
*mp++ = cb; |
| 156 |
} |
| 157 |
i += 6*l; |
| 158 |
} |
| 159 |
mapend[j][0] = mp; |
| 160 |
|
| 161 |
mp = map[j][1] = mapbuf1[j]; |
| 162 |
bdf = bi->shortDiff+0; |
| 163 |
for(i=0,cb=0;cb<13;cb++) |
| 164 |
{ |
| 165 |
int l = (*bdf++) >> 1; |
| 166 |
for(lwin=0;lwin<3;lwin++) |
| 167 |
{ |
| 168 |
*mp++ = l; |
| 169 |
*mp++ = i + lwin; |
| 170 |
*mp++ = lwin; |
| 171 |
*mp++ = cb; |
| 172 |
} |
| 173 |
i += 6*l; |
| 174 |
} |
| 175 |
mapend[j][1] = mp; |
| 176 |
|
| 177 |
mp = map[j][2] = mapbuf2[j]; |
| 178 |
bdf = bi->longDiff; |
| 179 |
for(cb = 0; cb < 22 ; cb++) |
| 180 |
{ |
| 181 |
*mp++ = (*bdf++) >> 1; |
| 182 |
*mp++ = cb; |
| 183 |
} |
| 184 |
mapend[j][2] = mp; |
| 185 |
} |
| 186 |
|
| 187 |
/* Now for some serious loopings! */ |
| 188 |
for(i=0;i<5;i++) |
| 189 |
for(j=0;j<6;j++) |
| 190 |
for(k=0;k<6;k++) |
| 191 |
{ |
| 192 |
int n = k + j * 6 + i * 36; |
| 193 |
i_slen2[n] = i|(j<<3)|(k<<6)|(3<<12); |
| 194 |
} |
| 195 |
for(i=0;i<4;i++) |
| 196 |
for(j=0;j<4;j++) |
| 197 |
for(k=0;k<4;k++) |
| 198 |
{ |
| 199 |
int n = k + j * 4 + i * 16; |
| 200 |
i_slen2[n+180] = i|(j<<3)|(k<<6)|(4<<12); |
| 201 |
} |
| 202 |
for(i=0;i<4;i++) |
| 203 |
for(j=0;j<3;j++) |
| 204 |
{ |
| 205 |
int n = j + i * 3; |
| 206 |
i_slen2[n+244] = i|(j<<3) | (5<<12); |
| 207 |
n_slen2[n+500] = i|(j<<3) | (2<<12) | (1<<15); |
| 208 |
} |
| 209 |
for(i=0;i<5;i++) |
| 210 |
for(j=0;j<5;j++) |
| 211 |
for(k=0;k<4;k++) |
| 212 |
for(l=0;l<4;l++) |
| 213 |
{ |
| 214 |
int n = l + k * 4 + j * 16 + i * 80; |
| 215 |
n_slen2[n] = i|(j<<3)|(k<<6)|(l<<9)|(0<<12); |
| 216 |
} |
| 217 |
for(i=0;i<5;i++) |
| 218 |
for(j=0;j<5;j++) |
| 219 |
for(k=0;k<4;k++) |
| 220 |
{ |
| 221 |
int n = k + j * 4 + i * 20; |
| 222 |
n_slen2[n+400] = i|(j<<3)|(k<<6)|(1<<12); |
| 223 |
} |
| 224 |
|
| 225 |
#ifdef CALCTABLES |
| 226 |
// Only needed for fixed point. |
| 227 |
for(int i=-256;i<118+4;i++) |
| 228 |
gainpow2[i+256] = |
| 229 |
DOUBLE_TO_REAL_SCALE_LAYER3(POW((clreal)2.0,-0.25 * (clreal) (i+210)),i+256); |
| 230 |
#endif |
| 231 |
} |