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.5 2000/10/17 21:15:33 ijr 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 #include "mhead.h"
42
43 unsigned int bitget(MPEG *m, int n);
44
45 /*------------------------------------------------------------*/
46 static const int slen_table[16][2] =
47 {
48 {0, 0}, {0, 1},
49 {0, 2}, {0, 3},
50 {3, 0}, {1, 1},
51 {1, 2}, {1, 3},
52 {2, 1}, {2, 2},
53 {2, 3}, {3, 1},
54 {3, 2}, {3, 3},
55 {4, 2}, {4, 3},
56 };
57
58 /* nr_table[size+3*is_right][block type 0,1,3 2, 2+mixed][4] */
59 /* for bt=2 nr is count for group of 3 */
60 static const int nr_table[6][3][4] =
61 {
62 {{6, 5, 5, 5},
63 {3, 3, 3, 3},
64 {6, 3, 3, 3}},
65
66 {{6, 5, 7, 3},
67 {3, 3, 4, 2},
68 {6, 3, 4, 2}},
69
70 {{11, 10, 0, 0},
71 {6, 6, 0, 0},
72 {6, 3, 6, 0}}, /* adjusted *//* 15, 18, 0, 0, */
73 /*-intensity stereo right chan--*/
74 {{7, 7, 7, 0},
75 {4, 4, 4, 0},
76 {6, 5, 4, 0}},
77
78 {{6, 6, 6, 3},
79 {4, 3, 3, 2},
80 {6, 4, 3, 2}},
81
82 {{8, 8, 5, 0},
83 {5, 4, 3, 0},
84 {6, 6, 3, 0}},
85 };
86
87 /*=============================================================*/
unpack_sf_sub_MPEG1(MPEG * m,SCALEFACT sf[],GR * grdat,int scfsi,int gr)88 void unpack_sf_sub_MPEG1(MPEG *m, SCALEFACT sf[],
89 GR * grdat,
90 int scfsi, /* bit flag */
91 int gr)
92 {
93 int sfb;
94 int slen0, slen1;
95 int block_type, mixed_block_flag, scalefac_compress;
96
97
98 block_type = grdat->block_type;
99 mixed_block_flag = grdat->mixed_block_flag;
100 scalefac_compress = grdat->scalefac_compress;
101
102 slen0 = slen_table[scalefac_compress][0];
103 slen1 = slen_table[scalefac_compress][1];
104
105
106 if (block_type == 2)
107 {
108 if (mixed_block_flag)
109 { /* mixed */
110 for (sfb = 0; sfb < 8; sfb++)
111 sf[0].l[sfb] = bitget(m, slen0);
112 for (sfb = 3; sfb < 6; sfb++)
113 {
114 sf[0].s[0][sfb] = bitget(m, slen0);
115 sf[0].s[1][sfb] = bitget(m, slen0);
116 sf[0].s[2][sfb] = bitget(m, slen0);
117 }
118 for (sfb = 6; sfb < 12; sfb++)
119 {
120 sf[0].s[0][sfb] = bitget(m, slen1);
121 sf[0].s[1][sfb] = bitget(m, slen1);
122 sf[0].s[2][sfb] = bitget(m, slen1);
123 }
124 return;
125 }
126 for (sfb = 0; sfb < 6; sfb++)
127 {
128 sf[0].s[0][sfb] = bitget(m, slen0);
129 sf[0].s[1][sfb] = bitget(m, slen0);
130 sf[0].s[2][sfb] = bitget(m, slen0);
131 }
132 for (; sfb < 12; sfb++)
133 {
134 sf[0].s[0][sfb] = bitget(m, slen1);
135 sf[0].s[1][sfb] = bitget(m, slen1);
136 sf[0].s[2][sfb] = bitget(m, slen1);
137 }
138 return;
139 }
140
141 /* long blocks types 0 1 3, first granule */
142 if (gr == 0)
143 {
144 for (sfb = 0; sfb < 11; sfb++)
145 sf[0].l[sfb] = bitget(m, slen0);
146 for (; sfb < 21; sfb++)
147 sf[0].l[sfb] = bitget(m, slen1);
148 return;
149 }
150
151 /* long blocks 0, 1, 3, second granule */
152 sfb = 0;
153 if (scfsi & 8)
154 for (; sfb < 6; sfb++)
155 sf[0].l[sfb] = sf[-2].l[sfb];
156 else
157 for (; sfb < 6; sfb++)
158 sf[0].l[sfb] = bitget(m, slen0);
159 if (scfsi & 4)
160 for (; sfb < 11; sfb++)
161 sf[0].l[sfb] = sf[-2].l[sfb];
162 else
163 for (; sfb < 11; sfb++)
164 sf[0].l[sfb] = bitget(m, slen0);
165 if (scfsi & 2)
166 for (; sfb < 16; sfb++)
167 sf[0].l[sfb] = sf[-2].l[sfb];
168 else
169 for (; sfb < 16; sfb++)
170 sf[0].l[sfb] = bitget(m, slen1);
171 if (scfsi & 1)
172 for (; sfb < 21; sfb++)
173 sf[0].l[sfb] = sf[-2].l[sfb];
174 else
175 for (; sfb < 21; sfb++)
176 sf[0].l[sfb] = bitget(m, slen1);
177
178
179
180 return;
181 }
182 /*=============================================================*/
unpack_sf_sub_MPEG2(MPEG * m,SCALEFACT sf[],GR * grdat,int is_and_ch,IS_SF_INFO * sf_info)183 void unpack_sf_sub_MPEG2(MPEG *m, SCALEFACT sf[],
184 GR * grdat,
185 int is_and_ch, IS_SF_INFO * sf_info)
186 {
187 int sfb;
188 int slen1, slen2, slen3, slen4;
189 int nr1, nr2, nr3, nr4;
190 int i, k;
191 int preflag, intensity_scale;
192 int block_type, mixed_block_flag, scalefac_compress;
193
194
195 block_type = grdat->block_type;
196 mixed_block_flag = grdat->mixed_block_flag;
197 scalefac_compress = grdat->scalefac_compress;
198
199 preflag = 0;
200 intensity_scale = 0; /* to avoid compiler warning */
201 if (is_and_ch == 0)
202 {
203 if (scalefac_compress < 400)
204 {
205 slen2 = scalefac_compress >> 4;
206 slen1 = slen2 / 5;
207 slen2 = slen2 % 5;
208 slen4 = scalefac_compress & 15;
209 slen3 = slen4 >> 2;
210 slen4 = slen4 & 3;
211 k = 0;
212 }
213 else if (scalefac_compress < 500)
214 {
215 scalefac_compress -= 400;
216 slen2 = scalefac_compress >> 2;
217 slen1 = slen2 / 5;
218 slen2 = slen2 % 5;
219 slen3 = scalefac_compress & 3;
220 slen4 = 0;
221 k = 1;
222 }
223 else
224 {
225 scalefac_compress -= 500;
226 slen1 = scalefac_compress / 3;
227 slen2 = scalefac_compress % 3;
228 slen3 = slen4 = 0;
229 if (mixed_block_flag)
230 {
231 slen3 = slen2; /* adjust for long/short mix logic */
232 slen2 = slen1;
233 }
234 preflag = 1;
235 k = 2;
236 }
237 }
238 else
239 { /* intensity stereo ch = 1 (right) */
240 intensity_scale = scalefac_compress & 1;
241 scalefac_compress >>= 1;
242 if (scalefac_compress < 180)
243 {
244 slen1 = scalefac_compress / 36;
245 slen2 = scalefac_compress % 36;
246 slen3 = slen2 % 6;
247 slen2 = slen2 / 6;
248 slen4 = 0;
249 k = 3 + 0;
250 }
251 else if (scalefac_compress < 244)
252 {
253 scalefac_compress -= 180;
254 slen3 = scalefac_compress & 3;
255 scalefac_compress >>= 2;
256 slen2 = scalefac_compress & 3;
257 slen1 = scalefac_compress >> 2;
258 slen4 = 0;
259 k = 3 + 1;
260 }
261 else
262 {
263 scalefac_compress -= 244;
264 slen1 = scalefac_compress / 3;
265 slen2 = scalefac_compress % 3;
266 slen3 = slen4 = 0;
267 k = 3 + 2;
268 }
269 }
270
271 i = 0;
272 if (block_type == 2)
273 i = (mixed_block_flag & 1) + 1;
274 nr1 = nr_table[k][i][0];
275 nr2 = nr_table[k][i][1];
276 nr3 = nr_table[k][i][2];
277 nr4 = nr_table[k][i][3];
278
279
280 /* return is scale factor info (for right chan is mode) */
281 if (is_and_ch)
282 {
283 sf_info->nr[0] = nr1;
284 sf_info->nr[1] = nr2;
285 sf_info->nr[2] = nr3;
286 sf_info->slen[0] = slen1;
287 sf_info->slen[1] = slen2;
288 sf_info->slen[2] = slen3;
289 sf_info->intensity_scale = intensity_scale;
290 }
291 grdat->preflag = preflag; /* return preflag */
292
293 /*--------------------------------------*/
294 if (block_type == 2)
295 {
296 if (mixed_block_flag)
297 { /* mixed */
298 if (slen1 != 0) /* long block portion */
299 for (sfb = 0; sfb < 6; sfb++)
300 sf[0].l[sfb] = bitget(m, slen1);
301 else
302 for (sfb = 0; sfb < 6; sfb++)
303 sf[0].l[sfb] = 0;
304 sfb = 3; /* start sfb for short */
305 }
306 else
307 { /* all short, initial short blocks */
308 sfb = 0;
309 if (slen1 != 0)
310 for (i = 0; i < nr1; i++, sfb++)
311 {
312 sf[0].s[0][sfb] = bitget(m, slen1);
313 sf[0].s[1][sfb] = bitget(m, slen1);
314 sf[0].s[2][sfb] = bitget(m, slen1);
315 }
316 else
317 for (i = 0; i < nr1; i++, sfb++)
318 {
319 sf[0].s[0][sfb] = 0;
320 sf[0].s[1][sfb] = 0;
321 sf[0].s[2][sfb] = 0;
322 }
323 }
324 /* remaining short blocks */
325 if (slen2 != 0)
326 for (i = 0; i < nr2; i++, sfb++)
327 {
328 sf[0].s[0][sfb] = bitget(m, slen2);
329 sf[0].s[1][sfb] = bitget(m, slen2);
330 sf[0].s[2][sfb] = bitget(m, slen2);
331 }
332 else
333 for (i = 0; i < nr2; i++, sfb++)
334 {
335 sf[0].s[0][sfb] = 0;
336 sf[0].s[1][sfb] = 0;
337 sf[0].s[2][sfb] = 0;
338 }
339 if (slen3 != 0)
340 for (i = 0; i < nr3; i++, sfb++)
341 {
342 sf[0].s[0][sfb] = bitget(m, slen3);
343 sf[0].s[1][sfb] = bitget(m, slen3);
344 sf[0].s[2][sfb] = bitget(m, slen3);
345 }
346 else
347 for (i = 0; i < nr3; i++, sfb++)
348 {
349 sf[0].s[0][sfb] = 0;
350 sf[0].s[1][sfb] = 0;
351 sf[0].s[2][sfb] = 0;
352 }
353 if (slen4 != 0)
354 for (i = 0; i < nr4; i++, sfb++)
355 {
356 sf[0].s[0][sfb] = bitget(m, slen4);
357 sf[0].s[1][sfb] = bitget(m, slen4);
358 sf[0].s[2][sfb] = bitget(m, slen4);
359 }
360 else
361 for (i = 0; i < nr4; i++, sfb++)
362 {
363 sf[0].s[0][sfb] = 0;
364 sf[0].s[1][sfb] = 0;
365 sf[0].s[2][sfb] = 0;
366 }
367 return;
368 }
369
370
371 /* long blocks types 0 1 3 */
372 sfb = 0;
373 if (slen1 != 0)
374 for (i = 0; i < nr1; i++, sfb++)
375 sf[0].l[sfb] = bitget(m, slen1);
376 else
377 for (i = 0; i < nr1; i++, sfb++)
378 sf[0].l[sfb] = 0;
379
380 if (slen2 != 0)
381 for (i = 0; i < nr2; i++, sfb++)
382 sf[0].l[sfb] = bitget(m, slen2);
383 else
384 for (i = 0; i < nr2; i++, sfb++)
385 sf[0].l[sfb] = 0;
386
387 if (slen3 != 0)
388 for (i = 0; i < nr3; i++, sfb++)
389 sf[0].l[sfb] = bitget(m, slen3);
390 else
391 for (i = 0; i < nr3; i++, sfb++)
392 sf[0].l[sfb] = 0;
393
394 if (slen4 != 0)
395 for (i = 0; i < nr4; i++, sfb++)
396 sf[0].l[sfb] = bitget(m, slen4);
397 else
398 for (i = 0; i < nr4; i++, sfb++)
399 sf[0].l[sfb] = 0;
400
401
402 }
403 /*-------------------------------------------------*/
404