1 /*____________________________________________________________________________
2
3 FreeAmp - The Free MP3 Player
4
5 MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
6 Corp. http://www.xingtech.com
7
8 Portions Copyright (C) 1998-1999 EMusic.com
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23
24 $Id: upsf.c,v 1.3 1999/10/19 07:13:09 elrod Exp $
25 ____________________________________________________________________________*/
26
27 /**** upsf.c ***************************************************
28
29 Layer III
30 unpack scale factors
31
32
33
34 ******************************************************************/
35
36 #include <stdlib.h>
37 #include <stdio.h>
38 #include <float.h>
39 #include <math.h>
40 #include "l3.h"
41
42 unsigned int bitget(int n);
43
44 /*------------------------------------------------------------*/
45 static const int slen_table[16][2] =
46 {
47 {0, 0}, {0, 1},
48 {0, 2}, {0, 3},
49 {3, 0}, {1, 1},
50 {1, 2}, {1, 3},
51 {2, 1}, {2, 2},
52 {2, 3}, {3, 1},
53 {3, 2}, {3, 3},
54 {4, 2}, {4, 3},
55 };
56
57 /* nr_table[size+3*is_right][block type 0,1,3 2, 2+mixed][4] */
58 /* for bt=2 nr is count for group of 3 */
59 static const int nr_table[6][3][4] =
60 {
61 {{6, 5, 5, 5},
62 {3, 3, 3, 3},
63 {6, 3, 3, 3}},
64
65 {{6, 5, 7, 3},
66 {3, 3, 4, 2},
67 {6, 3, 4, 2}},
68
69 {{11, 10, 0, 0},
70 {6, 6, 0, 0},
71 {6, 3, 6, 0}}, /* adjusted *//* 15, 18, 0, 0, */
72 /*-intensity stereo right chan--*/
73 {{7, 7, 7, 0},
74 {4, 4, 4, 0},
75 {6, 5, 4, 0}},
76
77 {{6, 6, 6, 3},
78 {4, 3, 3, 2},
79 {6, 4, 3, 2}},
80
81 {{8, 8, 5, 0},
82 {5, 4, 3, 0},
83 {6, 6, 3, 0}},
84 };
85
86 /*=============================================================*/
unpack_sf_sub_MPEG1(SCALEFACT sf[],GR * grdat,int scfsi,int gr)87 void unpack_sf_sub_MPEG1(SCALEFACT sf[],
88 GR * grdat,
89 int scfsi, /* bit flag */
90 int gr)
91 {
92 int sfb;
93 int slen0, slen1;
94 int block_type, mixed_block_flag, scalefac_compress;
95
96
97 block_type = grdat->block_type;
98 mixed_block_flag = grdat->mixed_block_flag;
99 scalefac_compress = grdat->scalefac_compress;
100
101 slen0 = slen_table[scalefac_compress][0];
102 slen1 = slen_table[scalefac_compress][1];
103
104
105 if (block_type == 2)
106 {
107 if (mixed_block_flag)
108 { /* mixed */
109 for (sfb = 0; sfb < 8; sfb++)
110 sf[0].l[sfb] = bitget(slen0);
111 for (sfb = 3; sfb < 6; sfb++)
112 {
113 sf[0].s[0][sfb] = bitget(slen0);
114 sf[0].s[1][sfb] = bitget(slen0);
115 sf[0].s[2][sfb] = bitget(slen0);
116 }
117 for (sfb = 6; sfb < 12; sfb++)
118 {
119 sf[0].s[0][sfb] = bitget(slen1);
120 sf[0].s[1][sfb] = bitget(slen1);
121 sf[0].s[2][sfb] = bitget(slen1);
122 }
123 return;
124 }
125 for (sfb = 0; sfb < 6; sfb++)
126 {
127 sf[0].s[0][sfb] = bitget(slen0);
128 sf[0].s[1][sfb] = bitget(slen0);
129 sf[0].s[2][sfb] = bitget(slen0);
130 }
131 for (; sfb < 12; sfb++)
132 {
133 sf[0].s[0][sfb] = bitget(slen1);
134 sf[0].s[1][sfb] = bitget(slen1);
135 sf[0].s[2][sfb] = bitget(slen1);
136 }
137 return;
138 }
139
140 /* long blocks types 0 1 3, first granule */
141 if (gr == 0)
142 {
143 for (sfb = 0; sfb < 11; sfb++)
144 sf[0].l[sfb] = bitget(slen0);
145 for (; sfb < 21; sfb++)
146 sf[0].l[sfb] = bitget(slen1);
147 return;
148 }
149
150 /* long blocks 0, 1, 3, second granule */
151 sfb = 0;
152 if (scfsi & 8)
153 for (; sfb < 6; sfb++)
154 sf[0].l[sfb] = sf[-2].l[sfb];
155 else
156 for (; sfb < 6; sfb++)
157 sf[0].l[sfb] = bitget(slen0);
158 if (scfsi & 4)
159 for (; sfb < 11; sfb++)
160 sf[0].l[sfb] = sf[-2].l[sfb];
161 else
162 for (; sfb < 11; sfb++)
163 sf[0].l[sfb] = bitget(slen0);
164 if (scfsi & 2)
165 for (; sfb < 16; sfb++)
166 sf[0].l[sfb] = sf[-2].l[sfb];
167 else
168 for (; sfb < 16; sfb++)
169 sf[0].l[sfb] = bitget(slen1);
170 if (scfsi & 1)
171 for (; sfb < 21; sfb++)
172 sf[0].l[sfb] = sf[-2].l[sfb];
173 else
174 for (; sfb < 21; sfb++)
175 sf[0].l[sfb] = bitget(slen1);
176
177
178
179 return;
180 }
181 /*=============================================================*/
unpack_sf_sub_MPEG2(SCALEFACT sf[],GR * grdat,int is_and_ch,IS_SF_INFO * sf_info)182 void unpack_sf_sub_MPEG2(SCALEFACT sf[],
183 GR * grdat,
184 int is_and_ch, IS_SF_INFO * sf_info)
185 {
186 int sfb;
187 int slen1, slen2, slen3, slen4;
188 int nr1, nr2, nr3, nr4;
189 int i, k;
190 int preflag, intensity_scale;
191 int block_type, mixed_block_flag, scalefac_compress;
192
193
194 block_type = grdat->block_type;
195 mixed_block_flag = grdat->mixed_block_flag;
196 scalefac_compress = grdat->scalefac_compress;
197
198 preflag = 0;
199 intensity_scale = 0; /* to avoid compiler warning */
200 if (is_and_ch == 0)
201 {
202 if (scalefac_compress < 400)
203 {
204 slen2 = scalefac_compress >> 4;
205 slen1 = slen2 / 5;
206 slen2 = slen2 % 5;
207 slen4 = scalefac_compress & 15;
208 slen3 = slen4 >> 2;
209 slen4 = slen4 & 3;
210 k = 0;
211 }
212 else if (scalefac_compress < 500)
213 {
214 scalefac_compress -= 400;
215 slen2 = scalefac_compress >> 2;
216 slen1 = slen2 / 5;
217 slen2 = slen2 % 5;
218 slen3 = scalefac_compress & 3;
219 slen4 = 0;
220 k = 1;
221 }
222 else
223 {
224 scalefac_compress -= 500;
225 slen1 = scalefac_compress / 3;
226 slen2 = scalefac_compress % 3;
227 slen3 = slen4 = 0;
228 if (mixed_block_flag)
229 {
230 slen3 = slen2; /* adjust for long/short mix logic */
231 slen2 = slen1;
232 }
233 preflag = 1;
234 k = 2;
235 }
236 }
237 else
238 { /* intensity stereo ch = 1 (right) */
239 intensity_scale = scalefac_compress & 1;
240 scalefac_compress >>= 1;
241 if (scalefac_compress < 180)
242 {
243 slen1 = scalefac_compress / 36;
244 slen2 = scalefac_compress % 36;
245 slen3 = slen2 % 6;
246 slen2 = slen2 / 6;
247 slen4 = 0;
248 k = 3 + 0;
249 }
250 else if (scalefac_compress < 244)
251 {
252 scalefac_compress -= 180;
253 slen3 = scalefac_compress & 3;
254 scalefac_compress >>= 2;
255 slen2 = scalefac_compress & 3;
256 slen1 = scalefac_compress >> 2;
257 slen4 = 0;
258 k = 3 + 1;
259 }
260 else
261 {
262 scalefac_compress -= 244;
263 slen1 = scalefac_compress / 3;
264 slen2 = scalefac_compress % 3;
265 slen3 = slen4 = 0;
266 k = 3 + 2;
267 }
268 }
269
270 i = 0;
271 if (block_type == 2)
272 i = (mixed_block_flag & 1) + 1;
273 nr1 = nr_table[k][i][0];
274 nr2 = nr_table[k][i][1];
275 nr3 = nr_table[k][i][2];
276 nr4 = nr_table[k][i][3];
277
278
279 /* return is scale factor info (for right chan is mode) */
280 if (is_and_ch)
281 {
282 sf_info->nr[0] = nr1;
283 sf_info->nr[1] = nr2;
284 sf_info->nr[2] = nr3;
285 sf_info->slen[0] = slen1;
286 sf_info->slen[1] = slen2;
287 sf_info->slen[2] = slen3;
288 sf_info->intensity_scale = intensity_scale;
289 }
290 grdat->preflag = preflag; /* return preflag */
291
292 /*--------------------------------------*/
293 if (block_type == 2)
294 {
295 if (mixed_block_flag)
296 { /* mixed */
297 if (slen1 != 0) /* long block portion */
298 for (sfb = 0; sfb < 6; sfb++)
299 sf[0].l[sfb] = bitget(slen1);
300 else
301 for (sfb = 0; sfb < 6; sfb++)
302 sf[0].l[sfb] = 0;
303 sfb = 3; /* start sfb for short */
304 }
305 else
306 { /* all short, initial short blocks */
307 sfb = 0;
308 if (slen1 != 0)
309 for (i = 0; i < nr1; i++, sfb++)
310 {
311 sf[0].s[0][sfb] = bitget(slen1);
312 sf[0].s[1][sfb] = bitget(slen1);
313 sf[0].s[2][sfb] = bitget(slen1);
314 }
315 else
316 for (i = 0; i < nr1; i++, sfb++)
317 {
318 sf[0].s[0][sfb] = 0;
319 sf[0].s[1][sfb] = 0;
320 sf[0].s[2][sfb] = 0;
321 }
322 }
323 /* remaining short blocks */
324 if (slen2 != 0)
325 for (i = 0; i < nr2; i++, sfb++)
326 {
327 sf[0].s[0][sfb] = bitget(slen2);
328 sf[0].s[1][sfb] = bitget(slen2);
329 sf[0].s[2][sfb] = bitget(slen2);
330 }
331 else
332 for (i = 0; i < nr2; i++, sfb++)
333 {
334 sf[0].s[0][sfb] = 0;
335 sf[0].s[1][sfb] = 0;
336 sf[0].s[2][sfb] = 0;
337 }
338 if (slen3 != 0)
339 for (i = 0; i < nr3; i++, sfb++)
340 {
341 sf[0].s[0][sfb] = bitget(slen3);
342 sf[0].s[1][sfb] = bitget(slen3);
343 sf[0].s[2][sfb] = bitget(slen3);
344 }
345 else
346 for (i = 0; i < nr3; i++, sfb++)
347 {
348 sf[0].s[0][sfb] = 0;
349 sf[0].s[1][sfb] = 0;
350 sf[0].s[2][sfb] = 0;
351 }
352 if (slen4 != 0)
353 for (i = 0; i < nr4; i++, sfb++)
354 {
355 sf[0].s[0][sfb] = bitget(slen4);
356 sf[0].s[1][sfb] = bitget(slen4);
357 sf[0].s[2][sfb] = bitget(slen4);
358 }
359 else
360 for (i = 0; i < nr4; i++, sfb++)
361 {
362 sf[0].s[0][sfb] = 0;
363 sf[0].s[1][sfb] = 0;
364 sf[0].s[2][sfb] = 0;
365 }
366 return;
367 }
368
369
370 /* long blocks types 0 1 3 */
371 sfb = 0;
372 if (slen1 != 0)
373 for (i = 0; i < nr1; i++, sfb++)
374 sf[0].l[sfb] = bitget(slen1);
375 else
376 for (i = 0; i < nr1; i++, sfb++)
377 sf[0].l[sfb] = 0;
378
379 if (slen2 != 0)
380 for (i = 0; i < nr2; i++, sfb++)
381 sf[0].l[sfb] = bitget(slen2);
382 else
383 for (i = 0; i < nr2; i++, sfb++)
384 sf[0].l[sfb] = 0;
385
386 if (slen3 != 0)
387 for (i = 0; i < nr3; i++, sfb++)
388 sf[0].l[sfb] = bitget(slen3);
389 else
390 for (i = 0; i < nr3; i++, sfb++)
391 sf[0].l[sfb] = 0;
392
393 if (slen4 != 0)
394 for (i = 0; i < nr4; i++, sfb++)
395 sf[0].l[sfb] = bitget(slen4);
396 else
397 for (i = 0; i < nr4; i++, sfb++)
398 sf[0].l[sfb] = 0;
399
400
401 }
402 /*-------------------------------------------------*/
403