XenevaOS
Loading...
Searching...
No Matches
minimp3.h
Go to the documentation of this file.
1#ifndef MINIMP3_H
2#define MINIMP3_H
3/*
4 https://github.com/lieff/minimp3
5 To the extent possible under law, the author(s) have dedicated all copyright and related and neighboring rights to this software to the public domain worldwide.
6 This software is distributed without any warranty.
7 See <http://creativecommons.org/publicdomain/zero/1.0/>.
8*/
9#include <stdint.h>
10#include <string.h>
11
12#define MINIMP3_MAX_SAMPLES_PER_FRAME (1152 * 2)
13
14typedef struct {
15 int frame_bytes, frame_offset, channels, hz, layer, bitrate_kbps;
16} mp3dec_frame_info_t;
17
18typedef struct {
19 float mdct_overlap[2][9 * 32], qmf_state[15 * 2 * 32];
20 int reserv, free_format_bytes;
21 unsigned char header[4], reserv_buf[511];
22} mp3dec_t;
23
24#ifdef __cplusplus
25extern "C" {
26#endif /* __cplusplus */
27
28void mp3dec_init(mp3dec_t* dec);
29#ifndef MINIMP3_FLOAT_OUTPUT
30typedef int16_t mp3d_sample_t;
31#else /* MINIMP3_FLOAT_OUTPUT */
32typedef float mp3d_sample_t;
33void mp3dec_f32_to_s16(const float* in, int16_t* out, int num_samples);
34#endif /* MINIMP3_FLOAT_OUTPUT */
35int mp3dec_decode_frame(mp3dec_t* dec,
36 const uint8_t* mp3,
37 int mp3_bytes,
38 mp3d_sample_t* pcm,
39 mp3dec_frame_info_t* info);
40
41#ifdef __cplusplus
42}
43#endif /* __cplusplus */
44
45#endif /* MINIMP3_H */
46#if defined(MINIMP3_IMPLEMENTATION) && !defined(_MINIMP3_IMPLEMENTATION_GUARD)
47#define _MINIMP3_IMPLEMENTATION_GUARD
48
49#include <stdlib.h>
50#include <string.h>
51
52#define MAX_FREE_FORMAT_FRAME_SIZE 2304 /* more than ISO spec's */
53#ifndef MAX_FRAME_SYNC_MATCHES
54#define MAX_FRAME_SYNC_MATCHES 10
55#endif /* MAX_FRAME_SYNC_MATCHES */
56
57#define MAX_L3_FRAME_PAYLOAD_BYTES \
58 MAX_FREE_FORMAT_FRAME_SIZE /* MUST be >= 320000/8/32000*1152 = 1440 */
59
60#define MAX_BITRESERVOIR_BYTES 511
61#define SHORT_BLOCK_TYPE 2
62#define STOP_BLOCK_TYPE 3
63#define MODE_MONO 3
64#define MODE_JOINT_STEREO 1
65#define HDR_SIZE 4
66#define HDR_IS_MONO(h) (((h[3]) & 0xC0) == 0xC0)
67#define HDR_IS_MS_STEREO(h) (((h[3]) & 0xE0) == 0x60)
68#define HDR_IS_FREE_FORMAT(h) (((h[2]) & 0xF0) == 0)
69#define HDR_IS_CRC(h) (!((h[1]) & 1))
70#define HDR_TEST_PADDING(h) ((h[2]) & 0x2)
71#define HDR_TEST_MPEG1(h) ((h[1]) & 0x8)
72#define HDR_TEST_NOT_MPEG25(h) ((h[1]) & 0x10)
73#define HDR_TEST_I_STEREO(h) ((h[3]) & 0x10)
74#define HDR_TEST_MS_STEREO(h) ((h[3]) & 0x20)
75#define HDR_GET_STEREO_MODE(h) (((h[3]) >> 6) & 3)
76#define HDR_GET_STEREO_MODE_EXT(h) (((h[3]) >> 4) & 3)
77#define HDR_GET_LAYER(h) (((h[1]) >> 1) & 3)
78#define HDR_GET_BITRATE(h) ((h[2]) >> 4)
79#define HDR_GET_SAMPLE_RATE(h) (((h[2]) >> 2) & 3)
80#define HDR_GET_MY_SAMPLE_RATE(h) \
81 (HDR_GET_SAMPLE_RATE(h) + (((h[1] >> 3) & 1) + ((h[1] >> 4) & 1)) * 3)
82#define HDR_IS_FRAME_576(h) ((h[1] & 14) == 2)
83#define HDR_IS_LAYER_1(h) ((h[1] & 6) == 6)
84
85#define BITS_DEQUANTIZER_OUT -1
86#define MAX_SCF (255 + BITS_DEQUANTIZER_OUT * 4 - 210)
87#define MAX_SCFI ((MAX_SCF + 3) & ~3)
88
89#define MINIMP3_MIN(a, b) ((a) > (b) ? (b) : (a))
90#define MINIMP3_MAX(a, b) ((a) < (b) ? (b) : (a))
91
92#if !defined(MINIMP3_NO_SIMD)
93
94#if !defined(MINIMP3_ONLY_SIMD) && \
95 (defined(_M_X64) || defined(__x86_64__) || defined(__aarch64__) || defined(_M_ARM64))
96/* x64 always have SSE2, arm64 always have neon, no need for generic code */
97#define MINIMP3_ONLY_SIMD
98#endif /* SIMD checks... */
99
100#if (defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))) || \
101 ((defined(__i386__) || defined(__x86_64__)) && defined(__SSE2__))
102#if defined(_MSC_VER)
103#include <intrin.h>
104#endif /* defined(_MSC_VER) */
105#include <immintrin.h>
106#define HAVE_SSE 1
107#define HAVE_SIMD 1
108#define VSTORE _mm_storeu_ps
109#define VLD _mm_loadu_ps
110#define VSET _mm_set1_ps
111#define VADD _mm_add_ps
112#define VSUB _mm_sub_ps
113#define VMUL _mm_mul_ps
114#define VMAC(a, x, y) _mm_add_ps(a, _mm_mul_ps(x, y))
115#define VMSB(a, x, y) _mm_sub_ps(a, _mm_mul_ps(x, y))
116#define VMUL_S(x, s) _mm_mul_ps(x, _mm_set1_ps(s))
117#define VREV(x) _mm_shuffle_ps(x, x, _MM_SHUFFLE(0, 1, 2, 3))
118typedef __m128 f4;
119#if defined(_MSC_VER) || defined(MINIMP3_ONLY_SIMD)
120#define minimp3_cpuid __cpuid
121#else /* defined(_MSC_VER) || defined(MINIMP3_ONLY_SIMD) */
122static __inline__
123 __attribute__((always_inline)) void minimp3_cpuid(int CPUInfo[], const int InfoType) {
124#if defined(__PIC__)
125 __asm__ __volatile__(
126#if defined(__x86_64__)
127 "push %%rbx\n"
128 "cpuid\n"
129 "xchgl %%ebx, %1\n"
130 "pop %%rbx\n"
131#else /* defined(__x86_64__) */
132 "xchgl %%ebx, %1\n"
133 "cpuid\n"
134 "xchgl %%ebx, %1\n"
135#endif /* defined(__x86_64__) */
136 : "=a"(CPUInfo[0]), "=r"(CPUInfo[1]), "=c"(CPUInfo[2]), "=d"(CPUInfo[3])
137 : "a"(InfoType));
138#else /* defined(__PIC__) */
139 __asm__ __volatile__("cpuid"
140 : "=a"(CPUInfo[0]), "=b"(CPUInfo[1]), "=c"(CPUInfo[2]), "=d"(CPUInfo[3])
141 : "a"(InfoType));
142#endif /* defined(__PIC__)*/
143}
144#endif /* defined(_MSC_VER) || defined(MINIMP3_ONLY_SIMD) */
145static int have_simd(void) {
146#ifdef MINIMP3_ONLY_SIMD
147 return 1;
148#else /* MINIMP3_ONLY_SIMD */
149 static int g_have_simd;
150 int CPUInfo[4];
151#ifdef MINIMP3_TEST
152 static int g_counter;
153 if (g_counter++ > 100)
154 return 0;
155#endif /* MINIMP3_TEST */
156 if (g_have_simd)
157 goto end;
158 minimp3_cpuid(CPUInfo, 0);
159 g_have_simd = 1;
160 if (CPUInfo[0] > 0) {
161 minimp3_cpuid(CPUInfo, 1);
162 g_have_simd = (CPUInfo[3] & (1 << 26)) + 1; /* SSE2 */
163 }
164end:
165 return g_have_simd - 1;
166#endif /* MINIMP3_ONLY_SIMD */
167}
168#elif defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64)
169#include <arm_neon.h>
170#define HAVE_SSE 0
171#define HAVE_SIMD 1
172#define VSTORE vst1q_f32
173#define VLD vld1q_f32
174#define VSET vmovq_n_f32
175#define VADD vaddq_f32
176#define VSUB vsubq_f32
177#define VMUL vmulq_f32
178#define VMAC(a, x, y) vmlaq_f32(a, x, y)
179#define VMSB(a, x, y) vmlsq_f32(a, x, y)
180#define VMUL_S(x, s) vmulq_f32(x, vmovq_n_f32(s))
181#define VREV(x) vcombine_f32(vget_high_f32(vrev64q_f32(x)), vget_low_f32(vrev64q_f32(x)))
182typedef float32x4_t f4;
183static int have_simd() { /* TODO: detect neon for !MINIMP3_ONLY_SIMD */
184 return 1;
185}
186#else /* SIMD checks... */
187#define HAVE_SSE 0
188#define HAVE_SIMD 0
189#ifdef MINIMP3_ONLY_SIMD
190#error MINIMP3_ONLY_SIMD used, but SSE/NEON not enabled
191#endif /* MINIMP3_ONLY_SIMD */
192#endif /* SIMD checks... */
193#else /* !defined(MINIMP3_NO_SIMD) */
194#define HAVE_SIMD 0
195#endif /* !defined(MINIMP3_NO_SIMD) */
196
197#if defined(__ARM_ARCH) && (__ARM_ARCH >= 6) && !defined(__aarch64__) && !defined(_M_ARM64)
198#define HAVE_ARMV6 1
199static __inline__ __attribute__((always_inline)) int32_t minimp3_clip_int16_arm(int32_t a) {
200 int32_t x = 0;
201 __asm__("ssat %0, #16, %1" : "=r"(x) : "r"(a));
202 return x;
203}
204#else
205#define HAVE_ARMV6 0
206#endif
207
208typedef struct {
209 const uint8_t* buf;
210 int pos, limit;
211} bs_t;
212
213typedef struct {
214 float scf[3 * 64];
215 uint8_t total_bands, stereo_bands, bitalloc[64], scfcod[64];
216} L12_scale_info;
217
218typedef struct {
219 uint8_t tab_offset, code_tab_width, band_count;
220} L12_subband_alloc_t;
221
222typedef struct {
223 const uint8_t* sfbtab;
224 uint16_t part_23_length, big_values, scalefac_compress;
225 uint8_t global_gain, block_type, mixed_block_flag, n_long_sfb, n_short_sfb;
226 uint8_t table_select[3], region_count[3], subblock_gain[3];
227 uint8_t preflag, scalefac_scale, count1_table, scfsi;
228} L3_gr_info_t;
229
230typedef struct {
231 bs_t bs;
232 uint8_t maindata[MAX_BITRESERVOIR_BYTES + MAX_L3_FRAME_PAYLOAD_BYTES];
233 L3_gr_info_t gr_info[4];
234 float grbuf[2][576], scf[40], syn[18 + 15][2 * 32];
235 uint8_t ist_pos[2][39];
236} mp3dec_scratch_t;
237
238static void bs_init(bs_t* bs, const uint8_t* data, int bytes) {
239 bs->buf = data;
240 bs->pos = 0;
241 bs->limit = bytes * 8;
242}
243
244static uint32_t get_bits(bs_t* bs, int n) {
245 uint32_t next, cache = 0, s = bs->pos & 7;
246 int shl = n + s;
247 const uint8_t* p = bs->buf + (bs->pos >> 3);
248 if ((bs->pos += n) > bs->limit)
249 return 0;
250 next = *p++ & (255 >> s);
251 while ((shl -= 8) > 0) {
252 cache |= next << shl;
253 next = *p++;
254 }
255 return cache | (next >> -shl);
256}
257
258static int hdr_valid(const uint8_t* h) {
259 return h[0] == 0xff && ((h[1] & 0xF0) == 0xf0 || (h[1] & 0xFE) == 0xe2) &&
260 (HDR_GET_LAYER(h) != 0) && (HDR_GET_BITRATE(h) != 15) && (HDR_GET_SAMPLE_RATE(h) != 3);
261}
262
263static int hdr_compare(const uint8_t* h1, const uint8_t* h2) {
264 return hdr_valid(h2) && ((h1[1] ^ h2[1]) & 0xFE) == 0 && ((h1[2] ^ h2[2]) & 0x0C) == 0 &&
265 !(HDR_IS_FREE_FORMAT(h1) ^ HDR_IS_FREE_FORMAT(h2));
266}
267
268static unsigned hdr_bitrate_kbps(const uint8_t* h) {
269 static const uint8_t halfrate[2][3][15] = {
270 {{0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 72, 80},
271 {0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 72, 80},
272 {0, 16, 24, 28, 32, 40, 48, 56, 64, 72, 80, 88, 96, 112, 128}},
273 {{0, 16, 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160},
274 {0, 16, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192},
275 {0, 16, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224}},
276 };
277 return 2 * halfrate[!!HDR_TEST_MPEG1(h)][HDR_GET_LAYER(h) - 1][HDR_GET_BITRATE(h)];
278}
279
280static unsigned hdr_sample_rate_hz(const uint8_t* h) {
281 static const unsigned g_hz[3] = {44100, 48000, 32000};
282 return g_hz[HDR_GET_SAMPLE_RATE(h)] >> (int)!HDR_TEST_MPEG1(h) >> (int)!HDR_TEST_NOT_MPEG25(h);
283}
284
285static unsigned hdr_frame_samples(const uint8_t* h) {
286 return HDR_IS_LAYER_1(h) ? 384 : (1152 >> (int)HDR_IS_FRAME_576(h));
287}
288
289static int hdr_frame_bytes(const uint8_t* h, int free_format_size) {
290 int frame_bytes = hdr_frame_samples(h) * hdr_bitrate_kbps(h) * 125 / hdr_sample_rate_hz(h);
291 if (HDR_IS_LAYER_1(h)) {
292 frame_bytes &= ~3; /* slot align */
293 }
294 return frame_bytes ? frame_bytes : free_format_size;
295}
296
297static int hdr_padding(const uint8_t* h) {
298 return HDR_TEST_PADDING(h) ? (HDR_IS_LAYER_1(h) ? 4 : 1) : 0;
299}
300
301#ifndef MINIMP3_ONLY_MP3
302static const L12_subband_alloc_t* L12_subband_alloc_table(const uint8_t* hdr, L12_scale_info* sci) {
303 const L12_subband_alloc_t* alloc;
304 int mode = HDR_GET_STEREO_MODE(hdr);
305 int nbands, stereo_bands = (mode == MODE_MONO) ? 0
306 : (mode == MODE_JOINT_STEREO)
307 ? (HDR_GET_STEREO_MODE_EXT(hdr) << 2) + 4
308 : 32;
309
310 if (HDR_IS_LAYER_1(hdr)) {
311 static const L12_subband_alloc_t g_alloc_L1[] = {{76, 4, 32}};
312 alloc = g_alloc_L1;
313 nbands = 32;
314 } else if (!HDR_TEST_MPEG1(hdr)) {
315 static const L12_subband_alloc_t g_alloc_L2M2[] = {{60, 4, 4}, {44, 3, 7}, {44, 2, 19}};
316 alloc = g_alloc_L2M2;
317 nbands = 30;
318 } else {
319 static const L12_subband_alloc_t g_alloc_L2M1[] = {
320 {0, 4, 3}, {16, 4, 8}, {32, 3, 12}, {40, 2, 7}};
321 int sample_rate_idx = HDR_GET_SAMPLE_RATE(hdr);
322 unsigned kbps = hdr_bitrate_kbps(hdr) >> (int)(mode != MODE_MONO);
323 if (!kbps) /* free-format */
324 {
325 kbps = 192;
326 }
327
328 alloc = g_alloc_L2M1;
329 nbands = 27;
330 if (kbps < 56) {
331 static const L12_subband_alloc_t g_alloc_L2M1_lowrate[] = {{44, 4, 2}, {44, 3, 10}};
332 alloc = g_alloc_L2M1_lowrate;
333 nbands = sample_rate_idx == 2 ? 12 : 8;
334 } else if (kbps >= 96 && sample_rate_idx != 1) {
335 nbands = 30;
336 }
337 }
338
339 sci->total_bands = (uint8_t)nbands;
340 sci->stereo_bands = (uint8_t)MINIMP3_MIN(stereo_bands, nbands);
341
342 return alloc;
343}
344
345static void L12_read_scalefactors(bs_t* bs, uint8_t* pba, uint8_t* scfcod, int bands, float* scf) {
346 static const float g_deq_L12[18 * 3] = {
347#define DQ(x) 9.53674316e-07f / x, 7.56931807e-07f / x, 6.00777173e-07f / x
348 DQ(3),
349 DQ(7),
350 DQ(15),
351 DQ(31),
352 DQ(63),
353 DQ(127),
354 DQ(255),
355 DQ(511),
356 DQ(1023),
357 DQ(2047),
358 DQ(4095),
359 DQ(8191),
360 DQ(16383),
361 DQ(32767),
362 DQ(65535),
363 DQ(3),
364 DQ(5),
365 DQ(9)};
366 int i, m;
367 for (i = 0; i < bands; i++) {
368 float s = 0;
369 int ba = *pba++;
370 int mask = ba ? 4 + ((19 >> scfcod[i]) & 3) : 0;
371 for (m = 4; m; m >>= 1) {
372 if (mask & m) {
373 int b = get_bits(bs, 6);
374 s = g_deq_L12[ba * 3 - 6 + b % 3] * (1 << 21 >> b / 3);
375 }
376 *scf++ = s;
377 }
378 }
379}
380
381static void L12_read_scale_info(const uint8_t* hdr, bs_t* bs, L12_scale_info* sci) {
382 static const uint8_t g_bitalloc_code_tab[] = {
383 0, 17, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0, 17, 18, 3, 19, 4, 5,
384 6, 7, 8, 9, 10, 11, 12, 13, 16, 0, 17, 18, 3, 19, 4, 5, 16, 0, 17, 18, 16, 0, 17,
385 18, 19, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 17, 18, 3, 19, 4, 5, 6, 7,
386 8, 9, 10, 11, 12, 13, 14, 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
387 const L12_subband_alloc_t* subband_alloc = L12_subband_alloc_table(hdr, sci);
388
389 int i, k = 0, ba_bits = 0;
390 const uint8_t* ba_code_tab = g_bitalloc_code_tab;
391
392 for (i = 0; i < sci->total_bands; i++) {
393 uint8_t ba;
394 if (i == k) {
395 k += subband_alloc->band_count;
396 ba_bits = subband_alloc->code_tab_width;
397 ba_code_tab = g_bitalloc_code_tab + subband_alloc->tab_offset;
398 subband_alloc++;
399 }
400 ba = ba_code_tab[get_bits(bs, ba_bits)];
401 sci->bitalloc[2 * i] = ba;
402 if (i < sci->stereo_bands) {
403 ba = ba_code_tab[get_bits(bs, ba_bits)];
404 }
405 sci->bitalloc[2 * i + 1] = sci->stereo_bands ? ba : 0;
406 }
407
408 for (i = 0; i < 2 * sci->total_bands; i++) {
409 sci->scfcod[i] = sci->bitalloc[i] ? HDR_IS_LAYER_1(hdr) ? 2 : get_bits(bs, 2) : 6;
410 }
411
412 L12_read_scalefactors(bs, sci->bitalloc, sci->scfcod, sci->total_bands * 2, sci->scf);
413
414 for (i = sci->stereo_bands; i < sci->total_bands; i++) {
415 sci->bitalloc[2 * i + 1] = 0;
416 }
417}
418
419static int L12_dequantize_granule(float* grbuf, bs_t* bs, L12_scale_info* sci, int group_size) {
420 int i, j, k, choff = 576;
421 for (j = 0; j < 4; j++) {
422 float* dst = grbuf + group_size * j;
423 for (i = 0; i < 2 * sci->total_bands; i++) {
424 int ba = sci->bitalloc[i];
425 if (ba != 0) {
426 if (ba < 17) {
427 int half = (1 << (ba - 1)) - 1;
428 for (k = 0; k < group_size; k++) {
429 dst[k] = (float)((int)get_bits(bs, ba) - half);
430 }
431 } else {
432 unsigned mod = (2 << (ba - 17)) + 1; /* 3, 5, 9 */
433 unsigned code = get_bits(bs, mod + 2 - (mod >> 3)); /* 5, 7, 10 */
434 for (k = 0; k < group_size; k++, code /= mod) {
435 dst[k] = (float)((int)(code % mod - mod / 2));
436 }
437 }
438 }
439 dst += choff;
440 choff = 18 - choff;
441 }
442 }
443 return group_size * 4;
444}
445
446static void L12_apply_scf_384(L12_scale_info* sci, const float* scf, float* dst) {
447 int i, k;
448 memcpy(dst + 576 + sci->stereo_bands * 18,
449 dst + sci->stereo_bands * 18,
450 (sci->total_bands - sci->stereo_bands) * 18 * sizeof(float));
451 for (i = 0; i < sci->total_bands; i++, dst += 18, scf += 6) {
452 for (k = 0; k < 12; k++) {
453 dst[k + 0] *= scf[0];
454 dst[k + 576] *= scf[3];
455 }
456 }
457}
458#endif /* MINIMP3_ONLY_MP3 */
459
460static int L3_read_side_info(bs_t* bs, L3_gr_info_t* gr, const uint8_t* hdr) {
461 static const uint8_t g_scf_long[8][23] = {
462 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54, 0},
463 {12, 12, 12, 12, 12, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 76, 90, 2, 2, 2, 2, 2, 0},
464 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54, 0},
465 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 18, 22, 26, 32, 38, 46, 54, 62, 70, 76, 36, 0},
466 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54, 0},
467 {4, 4, 4, 4, 4, 4, 6, 6, 8, 8, 10, 12, 16, 20, 24, 28, 34, 42, 50, 54, 76, 158, 0},
468 {4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 10, 12, 16, 18, 22, 28, 34, 40, 46, 54, 54, 192, 0},
469 {4, 4, 4, 4, 4, 4, 6, 6, 8, 10, 12, 16, 20, 24, 30, 38, 46, 56, 68, 84, 102, 26, 0}};
470 static const uint8_t g_scf_short[8][40] = {
471 {4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 12,
472 12, 14, 14, 14, 18, 18, 18, 24, 24, 24, 30, 30, 30, 40, 40, 40, 18, 18, 18, 0},
473 {8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12, 16, 16, 16, 20, 20, 20, 24, 24,
474 24, 28, 28, 28, 36, 36, 36, 2, 2, 2, 2, 2, 2, 2, 2, 2, 26, 26, 26, 0},
475 {4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 6, 6, 6, 8, 8, 8, 10, 10,
476 10, 14, 14, 14, 18, 18, 18, 26, 26, 26, 32, 32, 32, 42, 42, 42, 18, 18, 18, 0},
477 {4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 12,
478 12, 14, 14, 14, 18, 18, 18, 24, 24, 24, 32, 32, 32, 44, 44, 44, 12, 12, 12, 0},
479 {4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 12,
480 12, 14, 14, 14, 18, 18, 18, 24, 24, 24, 30, 30, 30, 40, 40, 40, 18, 18, 18, 0},
481 {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 8, 8, 10, 10,
482 10, 12, 12, 12, 14, 14, 14, 18, 18, 18, 22, 22, 22, 30, 30, 30, 56, 56, 56, 0},
483 {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 6, 6, 6, 10, 10,
484 10, 12, 12, 12, 14, 14, 14, 16, 16, 16, 20, 20, 20, 26, 26, 26, 66, 66, 66, 0},
485 {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 8, 8, 12, 12,
486 12, 16, 16, 16, 20, 20, 20, 26, 26, 26, 34, 34, 34, 42, 42, 42, 12, 12, 12, 0}};
487 static const uint8_t g_scf_mixed[8][40] = {
488 {6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 12, 12, 14,
489 14, 14, 18, 18, 18, 24, 24, 24, 30, 30, 30, 40, 40, 40, 18, 18, 18, 0},
490 {12, 12, 12, 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 16, 20, 20, 20, 24, 24,
491 24, 28, 28, 28, 36, 36, 36, 2, 2, 2, 2, 2, 2, 2, 2, 2, 26, 26, 26, 0},
492 {6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 10, 10, 10, 14,
493 14, 14, 18, 18, 18, 26, 26, 26, 32, 32, 32, 42, 42, 42, 18, 18, 18, 0},
494 {6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 12, 12, 14,
495 14, 14, 18, 18, 18, 24, 24, 24, 32, 32, 32, 44, 44, 44, 12, 12, 12, 0},
496 {6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 12, 12, 14,
497 14, 14, 18, 18, 18, 24, 24, 24, 30, 30, 30, 40, 40, 40, 18, 18, 18, 0},
498 {4, 4, 4, 4, 4, 4, 6, 6, 4, 4, 4, 6, 6, 6, 8, 8, 8, 10, 10, 10,
499 12, 12, 12, 14, 14, 14, 18, 18, 18, 22, 22, 22, 30, 30, 30, 56, 56, 56, 0},
500 {4, 4, 4, 4, 4, 4, 6, 6, 4, 4, 4, 6, 6, 6, 6, 6, 6, 10, 10, 10,
501 12, 12, 12, 14, 14, 14, 16, 16, 16, 20, 20, 20, 26, 26, 26, 66, 66, 66, 0},
502 {4, 4, 4, 4, 4, 4, 6, 6, 4, 4, 4, 6, 6, 6, 8, 8, 8, 12, 12, 12,
503 16, 16, 16, 20, 20, 20, 26, 26, 26, 34, 34, 34, 42, 42, 42, 12, 12, 12, 0}};
504
505 unsigned tables, scfsi = 0;
506 int main_data_begin, part_23_sum = 0;
507 int sr_idx = HDR_GET_MY_SAMPLE_RATE(hdr);
508 sr_idx -= (sr_idx != 0);
509 int gr_count = HDR_IS_MONO(hdr) ? 1 : 2;
510
511 if (HDR_TEST_MPEG1(hdr)) {
512 gr_count *= 2;
513 main_data_begin = get_bits(bs, 9);
514 scfsi = get_bits(bs, 7 + gr_count);
515 } else {
516 main_data_begin = get_bits(bs, 8 + gr_count) >> gr_count;
517 }
518
519 do {
520 if (HDR_IS_MONO(hdr)) {
521 scfsi <<= 4;
522 }
523 gr->part_23_length = (uint16_t)get_bits(bs, 12);
524 part_23_sum += gr->part_23_length;
525 gr->big_values = (uint16_t)get_bits(bs, 9);
526 if (gr->big_values > 288) {
527 return -1;
528 }
529 gr->global_gain = (uint8_t)get_bits(bs, 8);
530 gr->scalefac_compress = (uint16_t)get_bits(bs, HDR_TEST_MPEG1(hdr) ? 4 : 9);
531 gr->sfbtab = g_scf_long[sr_idx];
532 gr->n_long_sfb = 22;
533 gr->n_short_sfb = 0;
534 if (get_bits(bs, 1)) {
535 gr->block_type = (uint8_t)get_bits(bs, 2);
536 if (!gr->block_type) {
537 return -1;
538 }
539 gr->mixed_block_flag = (uint8_t)get_bits(bs, 1);
540 gr->region_count[0] = 7;
541 gr->region_count[1] = 255;
542 if (gr->block_type == SHORT_BLOCK_TYPE) {
543 scfsi &= 0x0F0F;
544 if (!gr->mixed_block_flag) {
545 gr->region_count[0] = 8;
546 gr->sfbtab = g_scf_short[sr_idx];
547 gr->n_long_sfb = 0;
548 gr->n_short_sfb = 39;
549 } else {
550 gr->sfbtab = g_scf_mixed[sr_idx];
551 gr->n_long_sfb = HDR_TEST_MPEG1(hdr) ? 8 : 6;
552 gr->n_short_sfb = 30;
553 }
554 }
555 tables = get_bits(bs, 10);
556 tables <<= 5;
557 gr->subblock_gain[0] = (uint8_t)get_bits(bs, 3);
558 gr->subblock_gain[1] = (uint8_t)get_bits(bs, 3);
559 gr->subblock_gain[2] = (uint8_t)get_bits(bs, 3);
560 } else {
561 gr->block_type = 0;
562 gr->mixed_block_flag = 0;
563 tables = get_bits(bs, 15);
564 gr->region_count[0] = (uint8_t)get_bits(bs, 4);
565 gr->region_count[1] = (uint8_t)get_bits(bs, 3);
566 gr->region_count[2] = 255;
567 }
568 gr->table_select[0] = (uint8_t)(tables >> 10);
569 gr->table_select[1] = (uint8_t)((tables >> 5) & 31);
570 gr->table_select[2] = (uint8_t)((tables) & 31);
571 gr->preflag = HDR_TEST_MPEG1(hdr) ? get_bits(bs, 1) : (gr->scalefac_compress >= 500);
572 gr->scalefac_scale = (uint8_t)get_bits(bs, 1);
573 gr->count1_table = (uint8_t)get_bits(bs, 1);
574 gr->scfsi = (uint8_t)((scfsi >> 12) & 15);
575 scfsi <<= 4;
576 gr++;
577 } while (--gr_count);
578
579 if (part_23_sum + bs->pos > bs->limit + main_data_begin * 8) {
580 return -1;
581 }
582
583 return main_data_begin;
584}
585
586static void L3_read_scalefactors(uint8_t* scf,
587 uint8_t* ist_pos,
588 const uint8_t* scf_size,
589 const uint8_t* scf_count,
590 bs_t* bitbuf,
591 int scfsi) {
592 int i, k;
593 for (i = 0; i < 4 && scf_count[i]; i++, scfsi *= 2) {
594 int cnt = scf_count[i];
595 if (scfsi & 8) {
596 memcpy(scf, ist_pos, cnt);
597 } else {
598 int bits = scf_size[i];
599 if (!bits) {
600 memset(scf, 0, cnt);
601 memset(ist_pos, 0, cnt);
602 } else {
603 int max_scf = (scfsi < 0) ? (1 << bits) - 1 : -1;
604 for (k = 0; k < cnt; k++) {
605 int s = get_bits(bitbuf, bits);
606 ist_pos[k] = (s == max_scf ? -1 : s);
607 scf[k] = s;
608 }
609 }
610 }
611 ist_pos += cnt;
612 scf += cnt;
613 }
614 scf[0] = scf[1] = scf[2] = 0;
615}
616
617static float L3_ldexp_q2(float y, int exp_q2) {
618 static const float g_expfrac[4] = {
619 9.31322575e-10f, 7.83145814e-10f, 6.58544508e-10f, 5.53767716e-10f};
620 int e;
621 do {
622 e = MINIMP3_MIN(30 * 4, exp_q2);
623 y *= g_expfrac[e & 3] * (1 << 30 >> (e >> 2));
624 } while ((exp_q2 -= e) > 0);
625 return y;
626}
627
628static void L3_decode_scalefactors(
629 const uint8_t* hdr, uint8_t* ist_pos, bs_t* bs, const L3_gr_info_t* gr, float* scf, int ch) {
630 static const uint8_t g_scf_partitions[3][28] = {
631 {6, 5, 5, 5, 6, 5, 5, 5, 6, 5, 7, 3, 11, 10, 0, 0, 7, 7, 7, 0, 6, 6, 6, 3, 8, 8, 5, 0},
632 {8, 9, 6, 12, 6, 9, 9, 9, 6, 9, 12, 6, 15, 18,
633 0, 0, 6, 15, 12, 0, 6, 12, 9, 6, 6, 18, 9, 0},
634 {9, 9, 6, 12, 9, 9, 9, 9, 9, 9, 12, 6, 18, 18,
635 0, 0, 12, 12, 12, 0, 12, 9, 9, 6, 15, 12, 9, 0}};
636 const uint8_t* scf_partition = g_scf_partitions[!!gr->n_short_sfb + !gr->n_long_sfb];
637 uint8_t scf_size[4], iscf[40];
638 int i, scf_shift = gr->scalefac_scale + 1, gain_exp, scfsi = gr->scfsi;
639 float gain;
640
641 if (HDR_TEST_MPEG1(hdr)) {
642 static const uint8_t g_scfc_decode[16] = {
643 0, 1, 2, 3, 12, 5, 6, 7, 9, 10, 11, 13, 14, 15, 18, 19};
644 int part = g_scfc_decode[gr->scalefac_compress];
645 scf_size[1] = scf_size[0] = (uint8_t)(part >> 2);
646 scf_size[3] = scf_size[2] = (uint8_t)(part & 3);
647 } else {
648 static const uint8_t g_mod[6 * 4] = {5, 5, 4, 4, 5, 5, 4, 1, 4, 3, 1, 1,
649 5, 6, 6, 1, 4, 4, 4, 1, 4, 3, 1, 1};
650 int k, modprod, sfc, ist = HDR_TEST_I_STEREO(hdr) && ch;
651 sfc = gr->scalefac_compress >> ist;
652 for (k = ist * 3 * 4; sfc >= 0; sfc -= modprod, k += 4) {
653 for (modprod = 1, i = 3; i >= 0; i--) {
654 scf_size[i] = (uint8_t)(sfc / modprod % g_mod[k + i]);
655 modprod *= g_mod[k + i];
656 }
657 }
658 scf_partition += k;
659 scfsi = -16;
660 }
661 L3_read_scalefactors(iscf, ist_pos, scf_size, scf_partition, bs, scfsi);
662
663 if (gr->n_short_sfb) {
664 int sh = 3 - scf_shift;
665 for (i = 0; i < gr->n_short_sfb; i += 3) {
666 iscf[gr->n_long_sfb + i + 0] += gr->subblock_gain[0] << sh;
667 iscf[gr->n_long_sfb + i + 1] += gr->subblock_gain[1] << sh;
668 iscf[gr->n_long_sfb + i + 2] += gr->subblock_gain[2] << sh;
669 }
670 } else if (gr->preflag) {
671 static const uint8_t g_preamp[10] = {1, 1, 1, 1, 2, 2, 3, 3, 3, 2};
672 for (i = 0; i < 10; i++) {
673 iscf[11 + i] += g_preamp[i];
674 }
675 }
676
677 gain_exp = gr->global_gain + BITS_DEQUANTIZER_OUT * 4 - 210 - (HDR_IS_MS_STEREO(hdr) ? 2 : 0);
678 gain = L3_ldexp_q2(1 << (MAX_SCFI / 4), MAX_SCFI - gain_exp);
679 for (i = 0; i < (int)(gr->n_long_sfb + gr->n_short_sfb); i++) {
680 scf[i] = L3_ldexp_q2(gain, iscf[i] << scf_shift);
681 }
682}
683
684static const float g_pow43[129 + 16] = {
685 0, -1, -2.519842f, -4.326749f, -6.349604f, -8.549880f, -10.902724f,
686 -13.390518f, -16.000000f, -18.720754f, -21.544347f, -24.463781f, -27.473142f, -30.567351f,
687 -33.741992f, -36.993181f, 0, 1, 2.519842f, 4.326749f, 6.349604f,
688 8.549880f, 10.902724f, 13.390518f, 16.000000f, 18.720754f, 21.544347f, 24.463781f,
689 27.473142f, 30.567351f, 33.741992f, 36.993181f, 40.317474f, 43.711787f, 47.173345f,
690 50.699631f, 54.288352f, 57.937408f, 61.644865f, 65.408941f, 69.227979f, 73.100443f,
691 77.024898f, 81.000000f, 85.024491f, 89.097188f, 93.216975f, 97.382800f, 101.593667f,
692 105.848633f, 110.146801f, 114.487321f, 118.869381f, 123.292209f, 127.755065f, 132.257246f,
693 136.798076f, 141.376907f, 145.993119f, 150.646117f, 155.335327f, 160.060199f, 164.820202f,
694 169.614826f, 174.443577f, 179.305980f, 184.201575f, 189.129918f, 194.090580f, 199.083145f,
695 204.107210f, 209.162385f, 214.248292f, 219.364564f, 224.510845f, 229.686789f, 234.892058f,
696 240.126328f, 245.389280f, 250.680604f, 256.000000f, 261.347174f, 266.721841f, 272.123723f,
697 277.552547f, 283.008049f, 288.489971f, 293.998060f, 299.532071f, 305.091761f, 310.676898f,
698 316.287249f, 321.922592f, 327.582707f, 333.267377f, 338.976394f, 344.709550f, 350.466646f,
699 356.247482f, 362.051866f, 367.879608f, 373.730522f, 379.604427f, 385.501143f, 391.420496f,
700 397.362314f, 403.326427f, 409.312672f, 415.320884f, 421.350905f, 427.402579f, 433.475750f,
701 439.570269f, 445.685987f, 451.822757f, 457.980436f, 464.158883f, 470.357960f, 476.577530f,
702 482.817459f, 489.077615f, 495.357868f, 501.658090f, 507.978156f, 514.317941f, 520.677324f,
703 527.056184f, 533.454404f, 539.871867f, 546.308458f, 552.764065f, 559.238575f, 565.731879f,
704 572.243870f, 578.774440f, 585.323483f, 591.890898f, 598.476581f, 605.080431f, 611.702349f,
705 618.342238f, 625.000000f, 631.675540f, 638.368763f, 645.079578f};
706
707static float L3_pow_43(int x) {
708 float frac;
709 int sign, mult = 256;
710
711 if (x < 129) {
712 return g_pow43[16 + x];
713 }
714
715 if (x < 1024) {
716 mult = 16;
717 x <<= 3;
718 }
719
720 sign = 2 * x & 64;
721 frac = (float)((x & 63) - sign) / ((x & ~63) + sign);
722 return g_pow43[16 + ((x + sign) >> 6)] * (1.f + frac * ((4.f / 3) + frac * (2.f / 9))) * mult;
723}
724
725static void L3_huffman(
726 float* dst, bs_t* bs, const L3_gr_info_t* gr_info, const float* scf, int layer3gr_limit) {
727 static const int16_t tabs[] = {
728 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
729 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
730 0, 0, 0, 0, 0, 0, 785, 785, 785, 785, 784, 784, 784,
731 784, 513, 513, 513, 513, 513, 513, 513, 513, 256, 256, 256, 256,
732 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, -255,
733 1313, 1298, 1282, 785, 785, 785, 785, 784, 784, 784, 784, 769, 769,
734 769, 769, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
735 256, 256, 256, 256, 256, 290, 288, -255, 1313, 1298, 1282, 769, 769,
736 769, 769, 529, 529, 529, 529, 529, 529, 529, 529, 528, 528, 528,
737 528, 528, 528, 528, 528, 512, 512, 512, 512, 512, 512, 512, 512,
738 290, 288, -253, -318, -351, -367, 785, 785, 785, 785, 784, 784, 784,
739 784, 769, 769, 769, 769, 256, 256, 256, 256, 256, 256, 256, 256,
740 256, 256, 256, 256, 256, 256, 256, 256, 819, 818, 547, 547, 275,
741 275, 275, 275, 561, 560, 515, 546, 289, 274, 288, 258, -254, -287,
742 1329, 1299, 1314, 1312, 1057, 1057, 1042, 1042, 1026, 1026, 784, 784, 784,
743 784, 529, 529, 529, 529, 529, 529, 529, 529, 769, 769, 769, 769,
744 768, 768, 768, 768, 563, 560, 306, 306, 291, 259, -252, -413, -477,
745 -542, 1298, -575, 1041, 1041, 784, 784, 784, 784, 769, 769, 769, 769,
746 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
747 256, 256, 256, -383, -399, 1107, 1092, 1106, 1061, 849, 849, 789, 789,
748 1104, 1091, 773, 773, 1076, 1075, 341, 340, 325, 309, 834, 804, 577,
749 577, 532, 532, 516, 516, 832, 818, 803, 816, 561, 561, 531, 531,
750 515, 546, 289, 289, 288, 258, -252, -429, -493, -559, 1057, 1057, 1042,
751 1042, 529, 529, 529, 529, 529, 529, 529, 529, 784, 784, 784, 784,
752 769, 769, 769, 769, 512, 512, 512, 512, 512, 512, 512, 512, -382,
753 1077, -415, 1106, 1061, 1104, 849, 849, 789, 789, 1091, 1076, 1029, 1075,
754 834, 834, 597, 581, 340, 340, 339, 324, 804, 833, 532, 532, 832,
755 772, 818, 803, 817, 787, 816, 771, 290, 290, 290, 290, 288, 258,
756 -253, -349, -414, -447, -463, 1329, 1299, -479, 1314, 1312, 1057, 1057, 1042,
757 1042, 1026, 1026, 785, 785, 785, 785, 784, 784, 784, 784, 769, 769,
758 769, 769, 768, 768, 768, 768, -319, 851, 821, -335, 836, 850, 805,
759 849, 341, 340, 325, 336, 533, 533, 579, 579, 564, 564, 773, 832,
760 578, 548, 563, 516, 321, 276, 306, 291, 304, 259, -251, -572, -733,
761 -830, -863, -879, 1041, 1041, 784, 784, 784, 784, 769, 769, 769, 769,
762 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
763 256, 256, 256, -511, -527, -543, 1396, 1351, 1381, 1366, 1395, 1335, 1380,
764 -559, 1334, 1138, 1138, 1063, 1063, 1350, 1392, 1031, 1031, 1062, 1062, 1364,
765 1363, 1120, 1120, 1333, 1348, 881, 881, 881, 881, 375, 374, 359, 373,
766 343, 358, 341, 325, 791, 791, 1123, 1122, -703, 1105, 1045, -719, 865,
767 865, 790, 790, 774, 774, 1104, 1029, 338, 293, 323, 308, -799, -815,
768 833, 788, 772, 818, 803, 816, 322, 292, 307, 320, 561, 531, 515,
769 546, 289, 274, 288, 258, -251, -525, -605, -685, -765, -831, -846, 1298,
770 1057, 1057, 1312, 1282, 785, 785, 785, 785, 784, 784, 784, 784, 769,
771 769, 769, 769, 512, 512, 512, 512, 512, 512, 512, 512, 1399, 1398,
772 1383, 1367, 1382, 1396, 1351, -511, 1381, 1366, 1139, 1139, 1079, 1079, 1124,
773 1124, 1364, 1349, 1363, 1333, 882, 882, 882, 882, 807, 807, 807, 807,
774 1094, 1094, 1136, 1136, 373, 341, 535, 535, 881, 775, 867, 822, 774,
775 -591, 324, 338, -671, 849, 550, 550, 866, 864, 609, 609, 293, 336,
776 534, 534, 789, 835, 773, -751, 834, 804, 308, 307, 833, 788, 832,
777 772, 562, 562, 547, 547, 305, 275, 560, 515, 290, 290, -252, -397,
778 -477, -557, -622, -653, -719, -735, -750, 1329, 1299, 1314, 1057, 1057, 1042,
779 1042, 1312, 1282, 1024, 1024, 785, 785, 785, 785, 784, 784, 784, 784,
780 769, 769, 769, 769, -383, 1127, 1141, 1111, 1126, 1140, 1095, 1110, 869,
781 869, 883, 883, 1079, 1109, 882, 882, 375, 374, 807, 868, 838, 881,
782 791, -463, 867, 822, 368, 263, 852, 837, 836, -543, 610, 610, 550,
783 550, 352, 336, 534, 534, 865, 774, 851, 821, 850, 805, 593, 533,
784 579, 564, 773, 832, 578, 578, 548, 548, 577, 577, 307, 276, 306,
785 291, 516, 560, 259, 259, -250, -2107, -2507, -2764, -2909, -2974, -3007, -3023,
786 1041, 1041, 1040, 1040, 769, 769, 769, 769, 256, 256, 256, 256, 256,
787 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, -767, -1052,
788 -1213, -1277, -1358, -1405, -1469, -1535, -1550, -1582, -1614, -1647, -1662, -1694, -1726,
789 -1759, -1774, -1807, -1822, -1854, -1886, 1565, -1919, -1935, -1951, -1967, 1731, 1730,
790 1580, 1717, -1983, 1729, 1564, -1999, 1548, -2015, -2031, 1715, 1595, -2047, 1714,
791 -2063, 1610, -2079, 1609, -2095, 1323, 1323, 1457, 1457, 1307, 1307, 1712, 1547,
792 1641, 1700, 1699, 1594, 1685, 1625, 1442, 1442, 1322, 1322, -780, -973, -910,
793 1279, 1278, 1277, 1262, 1276, 1261, 1275, 1215, 1260, 1229, -959, 974, 974,
794 989, 989, -943, 735, 478, 478, 495, 463, 506, 414, -1039, 1003, 958,
795 1017, 927, 942, 987, 957, 431, 476, 1272, 1167, 1228, -1183, 1256, -1199,
796 895, 895, 941, 941, 1242, 1227, 1212, 1135, 1014, 1014, 490, 489, 503,
797 487, 910, 1013, 985, 925, 863, 894, 970, 955, 1012, 847, -1343, 831,
798 755, 755, 984, 909, 428, 366, 754, 559, -1391, 752, 486, 457, 924,
799 997, 698, 698, 983, 893, 740, 740, 908, 877, 739, 739, 667, 667,
800 953, 938, 497, 287, 271, 271, 683, 606, 590, 712, 726, 574, 302,
801 302, 738, 736, 481, 286, 526, 725, 605, 711, 636, 724, 696, 651,
802 589, 681, 666, 710, 364, 467, 573, 695, 466, 466, 301, 465, 379,
803 379, 709, 604, 665, 679, 316, 316, 634, 633, 436, 436, 464, 269,
804 424, 394, 452, 332, 438, 363, 347, 408, 393, 448, 331, 422, 362,
805 407, 392, 421, 346, 406, 391, 376, 375, 359, 1441, 1306, -2367, 1290,
806 -2383, 1337, -2399, -2415, 1426, 1321, -2431, 1411, 1336, -2447, -2463, -2479, 1169,
807 1169, 1049, 1049, 1424, 1289, 1412, 1352, 1319, -2495, 1154, 1154, 1064, 1064,
808 1153, 1153, 416, 390, 360, 404, 403, 389, 344, 374, 373, 343, 358,
809 372, 327, 357, 342, 311, 356, 326, 1395, 1394, 1137, 1137, 1047, 1047,
810 1365, 1392, 1287, 1379, 1334, 1364, 1349, 1378, 1318, 1363, 792, 792, 792,
811 792, 1152, 1152, 1032, 1032, 1121, 1121, 1046, 1046, 1120, 1120, 1030, 1030,
812 -2895, 1106, 1061, 1104, 849, 849, 789, 789, 1091, 1076, 1029, 1090, 1060,
813 1075, 833, 833, 309, 324, 532, 532, 832, 772, 818, 803, 561, 561,
814 531, 560, 515, 546, 289, 274, 288, 258, -250, -1179, -1579, -1836, -1996,
815 -2124, -2253, -2333, -2413, -2477, -2542, -2574, -2607, -2622, -2655, 1314, 1313, 1298,
816 1312, 1282, 785, 785, 785, 785, 1040, 1040, 1025, 1025, 768, 768, 768,
817 768, -766, -798, -830, -862, -895, -911, -927, -943, -959, -975, -991, -1007,
818 -1023, -1039, -1055, -1070, 1724, 1647, -1103, -1119, 1631, 1767, 1662, 1738, 1708,
819 1723, -1135, 1780, 1615, 1779, 1599, 1677, 1646, 1778, 1583, -1151, 1777, 1567,
820 1737, 1692, 1765, 1722, 1707, 1630, 1751, 1661, 1764, 1614, 1736, 1676, 1763,
821 1750, 1645, 1598, 1721, 1691, 1762, 1706, 1582, 1761, 1566, -1167, 1749, 1629,
822 767, 766, 751, 765, 494, 494, 735, 764, 719, 749, 734, 763, 447,
823 447, 748, 718, 477, 506, 431, 491, 446, 476, 461, 505, 415, 430,
824 475, 445, 504, 399, 460, 489, 414, 503, 383, 474, 429, 459, 502,
825 502, 746, 752, 488, 398, 501, 473, 413, 472, 486, 271, 480, 270,
826 -1439, -1455, 1357, -1471, -1487, -1503, 1341, 1325, -1519, 1489, 1463, 1403, 1309,
827 -1535, 1372, 1448, 1418, 1476, 1356, 1462, 1387, -1551, 1475, 1340, 1447, 1402,
828 1386, -1567, 1068, 1068, 1474, 1461, 455, 380, 468, 440, 395, 425, 410,
829 454, 364, 467, 466, 464, 453, 269, 409, 448, 268, 432, 1371, 1473,
830 1432, 1417, 1308, 1460, 1355, 1446, 1459, 1431, 1083, 1083, 1401, 1416, 1458,
831 1445, 1067, 1067, 1370, 1457, 1051, 1051, 1291, 1430, 1385, 1444, 1354, 1415,
832 1400, 1443, 1082, 1082, 1173, 1113, 1186, 1066, 1185, 1050, -1967, 1158, 1128,
833 1172, 1097, 1171, 1081, -1983, 1157, 1112, 416, 266, 375, 400, 1170, 1142,
834 1127, 1065, 793, 793, 1169, 1033, 1156, 1096, 1141, 1111, 1155, 1080, 1126,
835 1140, 898, 898, 808, 808, 897, 897, 792, 792, 1095, 1152, 1032, 1125,
836 1110, 1139, 1079, 1124, 882, 807, 838, 881, 853, 791, -2319, 867, 368,
837 263, 822, 852, 837, 866, 806, 865, -2399, 851, 352, 262, 534, 534,
838 821, 836, 594, 594, 549, 549, 593, 593, 533, 533, 848, 773, 579,
839 579, 564, 578, 548, 563, 276, 276, 577, 576, 306, 291, 516, 560,
840 305, 305, 275, 259, -251, -892, -2058, -2620, -2828, -2957, -3023, -3039, 1041,
841 1041, 1040, 1040, 769, 769, 769, 769, 256, 256, 256, 256, 256, 256,
842 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, -511, -527, -543,
843 -559, 1530, -575, -591, 1528, 1527, 1407, 1526, 1391, 1023, 1023, 1023, 1023,
844 1525, 1375, 1268, 1268, 1103, 1103, 1087, 1087, 1039, 1039, 1523, -604, 815,
845 815, 815, 815, 510, 495, 509, 479, 508, 463, 507, 447, 431, 505,
846 415, 399, -734, -782, 1262, -815, 1259, 1244, -831, 1258, 1228, -847, -863,
847 1196, -879, 1253, 987, 987, 748, -767, 493, 493, 462, 477, 414, 414,
848 686, 669, 478, 446, 461, 445, 474, 429, 487, 458, 412, 471, 1266,
849 1264, 1009, 1009, 799, 799, -1019, -1276, -1452, -1581, -1677, -1757, -1821, -1886,
850 -1933, -1997, 1257, 1257, 1483, 1468, 1512, 1422, 1497, 1406, 1467, 1496, 1421,
851 1510, 1134, 1134, 1225, 1225, 1466, 1451, 1374, 1405, 1252, 1252, 1358, 1480,
852 1164, 1164, 1251, 1251, 1238, 1238, 1389, 1465, -1407, 1054, 1101, -1423, 1207,
853 -1439, 830, 830, 1248, 1038, 1237, 1117, 1223, 1148, 1236, 1208, 411, 426,
854 395, 410, 379, 269, 1193, 1222, 1132, 1235, 1221, 1116, 976, 976, 1192,
855 1162, 1177, 1220, 1131, 1191, 963, 963, -1647, 961, 780, -1663, 558, 558,
856 994, 993, 437, 408, 393, 407, 829, 978, 813, 797, 947, -1743, 721,
857 721, 377, 392, 844, 950, 828, 890, 706, 706, 812, 859, 796, 960,
858 948, 843, 934, 874, 571, 571, -1919, 690, 555, 689, 421, 346, 539,
859 539, 944, 779, 918, 873, 932, 842, 903, 888, 570, 570, 931, 917,
860 674, 674, -2575, 1562, -2591, 1609, -2607, 1654, 1322, 1322, 1441, 1441, 1696,
861 1546, 1683, 1593, 1669, 1624, 1426, 1426, 1321, 1321, 1639, 1680, 1425, 1425,
862 1305, 1305, 1545, 1668, 1608, 1623, 1667, 1592, 1638, 1666, 1320, 1320, 1652,
863 1607, 1409, 1409, 1304, 1304, 1288, 1288, 1664, 1637, 1395, 1395, 1335, 1335,
864 1622, 1636, 1394, 1394, 1319, 1319, 1606, 1621, 1392, 1392, 1137, 1137, 1137,
865 1137, 345, 390, 360, 375, 404, 373, 1047, -2751, -2767, -2783, 1062, 1121,
866 1046, -2799, 1077, -2815, 1106, 1061, 789, 789, 1105, 1104, 263, 355, 310,
867 340, 325, 354, 352, 262, 339, 324, 1091, 1076, 1029, 1090, 1060, 1075,
868 833, 833, 788, 788, 1088, 1028, 818, 818, 803, 803, 561, 561, 531,
869 531, 816, 771, 546, 546, 289, 274, 288, 258, -253, -317, -381, -446,
870 -478, -509, 1279, 1279, -811, -1179, -1451, -1756, -1900, -2028, -2189, -2253, -2333,
871 -2414, -2445, -2511, -2526, 1313, 1298, -2559, 1041, 1041, 1040, 1040, 1025, 1025,
872 1024, 1024, 1022, 1007, 1021, 991, 1020, 975, 1019, 959, 687, 687, 1018,
873 1017, 671, 671, 655, 655, 1016, 1015, 639, 639, 758, 758, 623, 623,
874 757, 607, 756, 591, 755, 575, 754, 559, 543, 543, 1009, 783, -575,
875 -621, -685, -749, 496, -590, 750, 749, 734, 748, 974, 989, 1003, 958,
876 988, 973, 1002, 942, 987, 957, 972, 1001, 926, 986, 941, 971, 956,
877 1000, 910, 985, 925, 999, 894, 970, -1071, -1087, -1102, 1390, -1135, 1436,
878 1509, 1451, 1374, -1151, 1405, 1358, 1480, 1420, -1167, 1507, 1494, 1389, 1342,
879 1465, 1435, 1450, 1326, 1505, 1310, 1493, 1373, 1479, 1404, 1492, 1464, 1419,
880 428, 443, 472, 397, 736, 526, 464, 464, 486, 457, 442, 471, 484,
881 482, 1357, 1449, 1434, 1478, 1388, 1491, 1341, 1490, 1325, 1489, 1463, 1403,
882 1309, 1477, 1372, 1448, 1418, 1433, 1476, 1356, 1462, 1387, -1439, 1475, 1340,
883 1447, 1402, 1474, 1324, 1461, 1371, 1473, 269, 448, 1432, 1417, 1308, 1460,
884 -1711, 1459, -1727, 1441, 1099, 1099, 1446, 1386, 1431, 1401, -1743, 1289, 1083,
885 1083, 1160, 1160, 1458, 1445, 1067, 1067, 1370, 1457, 1307, 1430, 1129, 1129,
886 1098, 1098, 268, 432, 267, 416, 266, 400, -1887, 1144, 1187, 1082, 1173,
887 1113, 1186, 1066, 1050, 1158, 1128, 1143, 1172, 1097, 1171, 1081, 420, 391,
888 1157, 1112, 1170, 1142, 1127, 1065, 1169, 1049, 1156, 1096, 1141, 1111, 1155,
889 1080, 1126, 1154, 1064, 1153, 1140, 1095, 1048, -2159, 1125, 1110, 1137, -2175,
890 823, 823, 1139, 1138, 807, 807, 384, 264, 368, 263, 868, 838, 853,
891 791, 867, 822, 852, 837, 866, 806, 865, 790, -2319, 851, 821, 836,
892 352, 262, 850, 805, 849, -2399, 533, 533, 835, 820, 336, 261, 578,
893 548, 563, 577, 532, 532, 832, 772, 562, 562, 547, 547, 305, 275,
894 560, 515, 290, 290, 288, 258};
895 static const uint8_t tab32[] = {130, 162, 193, 209, 44, 28, 76, 140, 9, 9,
896 9, 9, 9, 9, 9, 9, 190, 254, 222, 238,
897 126, 94, 157, 157, 109, 61, 173, 205};
898 static const uint8_t tab33[] = {
899 252, 236, 220, 204, 188, 172, 156, 140, 124, 108, 92, 76, 60, 44, 28, 12};
900 static const int16_t tabindex[2 * 16] = {0, 32, 64, 98, 0, 132, 180, 218,
901 292, 364, 426, 538, 648, 746, 0, 1126,
902 1460, 1460, 1460, 1460, 1460, 1460, 1460, 1460,
903 1842, 1842, 1842, 1842, 1842, 1842, 1842, 1842};
904 static const uint8_t g_linbits[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
905 1, 2, 3, 4, 6, 8, 10, 13, 4, 5, 6, 7, 8, 9, 11, 13};
906
907#define PEEK_BITS(n) (bs_cache >> (32 - n))
908#define FLUSH_BITS(n) \
909 { \
910 bs_cache <<= (n); \
911 bs_sh += (n); \
912 }
913#define CHECK_BITS \
914 while (bs_sh >= 0) { \
915 bs_cache |= (uint32_t)*bs_next_ptr++ << bs_sh; \
916 bs_sh -= 8; \
917 }
918#define BSPOS ((bs_next_ptr - bs->buf) * 8 - 24 + bs_sh)
919
920 float one = 0.0f;
921 int ireg = 0, big_val_cnt = gr_info->big_values;
922 const uint8_t* sfb = gr_info->sfbtab;
923 const uint8_t* bs_next_ptr = bs->buf + bs->pos / 8;
924 uint32_t bs_cache =
925 (((bs_next_ptr[0] * 256u + bs_next_ptr[1]) * 256u + bs_next_ptr[2]) * 256u + bs_next_ptr[3])
926 << (bs->pos & 7);
927 int pairs_to_decode, np, bs_sh = (bs->pos & 7) - 8;
928 bs_next_ptr += 4;
929
930 while (big_val_cnt > 0) {
931 int tab_num = gr_info->table_select[ireg];
932 int sfb_cnt = gr_info->region_count[ireg++];
933 const int16_t* codebook = tabs + tabindex[tab_num];
934 int linbits = g_linbits[tab_num];
935 if (linbits) {
936 do {
937 np = *sfb++ / 2;
938 pairs_to_decode = MINIMP3_MIN(big_val_cnt, np);
939 one = *scf++;
940 do {
941 int j, w = 5;
942 int leaf = codebook[PEEK_BITS(w)];
943 while (leaf < 0) {
944 FLUSH_BITS(w);
945 w = leaf & 7;
946 leaf = codebook[PEEK_BITS(w) - (leaf >> 3)];
947 }
948 FLUSH_BITS(leaf >> 8);
949
950 for (j = 0; j < 2; j++, dst++, leaf >>= 4) {
951 int lsb = leaf & 0x0F;
952 if (lsb == 15) {
953 lsb += PEEK_BITS(linbits);
954 FLUSH_BITS(linbits);
955 CHECK_BITS;
956 *dst = one * L3_pow_43(lsb) * ((int32_t)bs_cache < 0 ? -1 : 1);
957 } else {
958 *dst = g_pow43[16 + lsb - 16 * (bs_cache >> 31)] * one;
959 }
960 FLUSH_BITS(lsb ? 1 : 0);
961 }
962 CHECK_BITS;
963 } while (--pairs_to_decode);
964 } while ((big_val_cnt -= np) > 0 && --sfb_cnt >= 0);
965 } else {
966 do {
967 np = *sfb++ / 2;
968 pairs_to_decode = MINIMP3_MIN(big_val_cnt, np);
969 one = *scf++;
970 do {
971 int j, w = 5;
972 int leaf = codebook[PEEK_BITS(w)];
973 while (leaf < 0) {
974 FLUSH_BITS(w);
975 w = leaf & 7;
976 leaf = codebook[PEEK_BITS(w) - (leaf >> 3)];
977 }
978 FLUSH_BITS(leaf >> 8);
979
980 for (j = 0; j < 2; j++, dst++, leaf >>= 4) {
981 int lsb = leaf & 0x0F;
982 *dst = g_pow43[16 + lsb - 16 * (bs_cache >> 31)] * one;
983 FLUSH_BITS(lsb ? 1 : 0);
984 }
985 CHECK_BITS;
986 } while (--pairs_to_decode);
987 } while ((big_val_cnt -= np) > 0 && --sfb_cnt >= 0);
988 }
989 }
990
991 for (np = 1 - big_val_cnt;; dst += 4) {
992 const uint8_t* codebook_count1 = (gr_info->count1_table) ? tab33 : tab32;
993 int leaf = codebook_count1[PEEK_BITS(4)];
994 if (!(leaf & 8)) {
995 leaf = codebook_count1[(leaf >> 3) + (bs_cache << 4 >> (32 - (leaf & 3)))];
996 }
997 FLUSH_BITS(leaf & 7);
998 if (BSPOS > layer3gr_limit) {
999 break;
1000 }
1001#define RELOAD_SCALEFACTOR \
1002 if (!--np) { \
1003 np = *sfb++ / 2; \
1004 if (!np) \
1005 break; \
1006 one = *scf++; \
1007 }
1008#define DEQ_COUNT1(s) \
1009 if (leaf & (128 >> s)) { \
1010 dst[s] = ((int32_t)bs_cache < 0) ? -one : one; \
1011 FLUSH_BITS(1) \
1012 }
1013 RELOAD_SCALEFACTOR;
1014 DEQ_COUNT1(0);
1015 DEQ_COUNT1(1);
1016 RELOAD_SCALEFACTOR;
1017 DEQ_COUNT1(2);
1018 DEQ_COUNT1(3);
1019 CHECK_BITS;
1020 }
1021
1022 bs->pos = layer3gr_limit;
1023}
1024
1025static void L3_midside_stereo(float* left, int n) {
1026 int i = 0;
1027 float* right = left + 576;
1028#if HAVE_SIMD
1029 if (have_simd()) {
1030 for (; i < n - 3; i += 4) {
1031 f4 vl = VLD(left + i);
1032 f4 vr = VLD(right + i);
1033 VSTORE(left + i, VADD(vl, vr));
1034 VSTORE(right + i, VSUB(vl, vr));
1035 }
1036#ifdef __GNUC__
1037 /* Workaround for spurious -Waggressive-loop-optimizations warning from gcc.
1038 * For more info see: https://github.com/lieff/minimp3/issues/88
1039 */
1040 if (__builtin_constant_p(n % 4 == 0) && n % 4 == 0)
1041 return;
1042#endif
1043 }
1044#endif /* HAVE_SIMD */
1045 for (; i < n; i++) {
1046 float a = left[i];
1047 float b = right[i];
1048 left[i] = a + b;
1049 right[i] = a - b;
1050 }
1051}
1052
1053static void L3_intensity_stereo_band(float* left, int n, float kl, float kr) {
1054 int i;
1055 for (i = 0; i < n; i++) {
1056 left[i + 576] = left[i] * kr;
1057 left[i] = left[i] * kl;
1058 }
1059}
1060
1061static void
1062L3_stereo_top_band(const float* right, const uint8_t* sfb, int nbands, int max_band[3]) {
1063 int i, k;
1064
1065 max_band[0] = max_band[1] = max_band[2] = -1;
1066
1067 for (i = 0; i < nbands; i++) {
1068 for (k = 0; k < sfb[i]; k += 2) {
1069 if (right[k] != 0 || right[k + 1] != 0) {
1070 max_band[i % 3] = i;
1071 break;
1072 }
1073 }
1074 right += sfb[i];
1075 }
1076}
1077
1078static void L3_stereo_process(float* left,
1079 const uint8_t* ist_pos,
1080 const uint8_t* sfb,
1081 const uint8_t* hdr,
1082 int max_band[3],
1083 int mpeg2_sh) {
1084 static const float g_pan[7 * 2] = {0,
1085 1,
1086 0.21132487f,
1087 0.78867513f,
1088 0.36602540f,
1089 0.63397460f,
1090 0.5f,
1091 0.5f,
1092 0.63397460f,
1093 0.36602540f,
1094 0.78867513f,
1095 0.21132487f,
1096 1,
1097 0};
1098 unsigned i, max_pos = HDR_TEST_MPEG1(hdr) ? 7 : 64;
1099
1100 for (i = 0; sfb[i]; i++) {
1101 unsigned ipos = ist_pos[i];
1102 if ((int)i > max_band[i % 3] && ipos < max_pos) {
1103 float kl, kr, s = HDR_TEST_MS_STEREO(hdr) ? 1.41421356f : 1;
1104 if (HDR_TEST_MPEG1(hdr)) {
1105 kl = g_pan[2 * ipos];
1106 kr = g_pan[2 * ipos + 1];
1107 } else {
1108 kl = 1;
1109 kr = L3_ldexp_q2(1, (ipos + 1) >> 1 << mpeg2_sh);
1110 if (ipos & 1) {
1111 kl = kr;
1112 kr = 1;
1113 }
1114 }
1115 L3_intensity_stereo_band(left, sfb[i], kl * s, kr * s);
1116 } else if (HDR_TEST_MS_STEREO(hdr)) {
1117 L3_midside_stereo(left, sfb[i]);
1118 }
1119 left += sfb[i];
1120 }
1121}
1122
1123static void
1124L3_intensity_stereo(float* left, uint8_t* ist_pos, const L3_gr_info_t* gr, const uint8_t* hdr) {
1125 int max_band[3], n_sfb = gr->n_long_sfb + gr->n_short_sfb;
1126 int i, max_blocks = gr->n_short_sfb ? 3 : 1;
1127
1128 L3_stereo_top_band(left + 576, gr->sfbtab, n_sfb, max_band);
1129 if (gr->n_long_sfb) {
1130 max_band[0] = max_band[1] = max_band[2] =
1131 MINIMP3_MAX(MINIMP3_MAX(max_band[0], max_band[1]), max_band[2]);
1132 }
1133 for (i = 0; i < max_blocks; i++) {
1134 int default_pos = HDR_TEST_MPEG1(hdr) ? 3 : 0;
1135 int itop = n_sfb - max_blocks + i;
1136 int prev = itop - max_blocks;
1137 ist_pos[itop] = max_band[i] >= prev ? default_pos : ist_pos[prev];
1138 }
1139 L3_stereo_process(left, ist_pos, gr->sfbtab, hdr, max_band, gr[1].scalefac_compress & 1);
1140}
1141
1142static void L3_reorder(float* grbuf, float* scratch, const uint8_t* sfb) {
1143 int i, len;
1144 float *src = grbuf, *dst = scratch;
1145
1146 for (; 0 != (len = *sfb); sfb += 3, src += 2 * len) {
1147 for (i = 0; i < len; i++, src++) {
1148 *dst++ = src[0 * len];
1149 *dst++ = src[1 * len];
1150 *dst++ = src[2 * len];
1151 }
1152 }
1153 memcpy(grbuf, scratch, (dst - scratch) * sizeof(float));
1154}
1155
1156static void L3_antialias(float* grbuf, int nbands) {
1157 static const float g_aa[2][8] = {{0.85749293f,
1158 0.88174200f,
1159 0.94962865f,
1160 0.98331459f,
1161 0.99551782f,
1162 0.99916056f,
1163 0.99989920f,
1164 0.99999316f},
1165 {0.51449576f,
1166 0.47173197f,
1167 0.31337745f,
1168 0.18191320f,
1169 0.09457419f,
1170 0.04096558f,
1171 0.01419856f,
1172 0.00369997f}};
1173
1174 for (; nbands > 0; nbands--, grbuf += 18) {
1175 int i = 0;
1176#if HAVE_SIMD
1177 if (have_simd())
1178 for (; i < 8; i += 4) {
1179 f4 vu = VLD(grbuf + 18 + i);
1180 f4 vd = VLD(grbuf + 14 - i);
1181 f4 vc0 = VLD(g_aa[0] + i);
1182 f4 vc1 = VLD(g_aa[1] + i);
1183 vd = VREV(vd);
1184 VSTORE(grbuf + 18 + i, VSUB(VMUL(vu, vc0), VMUL(vd, vc1)));
1185 vd = VADD(VMUL(vu, vc1), VMUL(vd, vc0));
1186 VSTORE(grbuf + 14 - i, VREV(vd));
1187 }
1188#endif /* HAVE_SIMD */
1189#ifndef MINIMP3_ONLY_SIMD
1190 for (; i < 8; i++) {
1191 float u = grbuf[18 + i];
1192 float d = grbuf[17 - i];
1193 grbuf[18 + i] = u * g_aa[0][i] - d * g_aa[1][i];
1194 grbuf[17 - i] = u * g_aa[1][i] + d * g_aa[0][i];
1195 }
1196#endif /* MINIMP3_ONLY_SIMD */
1197 }
1198}
1199
1200static void L3_dct3_9(float* y) {
1201 float s0, s1, s2, s3, s4, s5, s6, s7, s8, t0, t2, t4;
1202
1203 s0 = y[0];
1204 s2 = y[2];
1205 s4 = y[4];
1206 s6 = y[6];
1207 s8 = y[8];
1208 t0 = s0 + s6 * 0.5f;
1209 s0 -= s6;
1210 t4 = (s4 + s2) * 0.93969262f;
1211 t2 = (s8 + s2) * 0.76604444f;
1212 s6 = (s4 - s8) * 0.17364818f;
1213 s4 += s8 - s2;
1214
1215 s2 = s0 - s4 * 0.5f;
1216 y[4] = s4 + s0;
1217 s8 = t0 - t2 + s6;
1218 s0 = t0 - t4 + t2;
1219 s4 = t0 + t4 - s6;
1220
1221 s1 = y[1];
1222 s3 = y[3];
1223 s5 = y[5];
1224 s7 = y[7];
1225
1226 s3 *= 0.86602540f;
1227 t0 = (s5 + s1) * 0.98480775f;
1228 t4 = (s5 - s7) * 0.34202014f;
1229 t2 = (s1 + s7) * 0.64278761f;
1230 s1 = (s1 - s5 - s7) * 0.86602540f;
1231
1232 s5 = t0 - s3 - t2;
1233 s7 = t4 - s3 - t0;
1234 s3 = t4 + s3 - t2;
1235
1236 y[0] = s4 - s7;
1237 y[1] = s2 + s1;
1238 y[2] = s0 - s3;
1239 y[3] = s8 + s5;
1240 y[5] = s8 - s5;
1241 y[6] = s0 + s3;
1242 y[7] = s2 - s1;
1243 y[8] = s4 + s7;
1244}
1245
1246static void L3_imdct36(float* grbuf, float* overlap, const float* window, int nbands) {
1247 int i, j;
1248 static const float g_twid9[18] = {0.73727734f,
1249 0.79335334f,
1250 0.84339145f,
1251 0.88701083f,
1252 0.92387953f,
1253 0.95371695f,
1254 0.97629601f,
1255 0.99144486f,
1256 0.99904822f,
1257 0.67559021f,
1258 0.60876143f,
1259 0.53729961f,
1260 0.46174861f,
1261 0.38268343f,
1262 0.30070580f,
1263 0.21643961f,
1264 0.13052619f,
1265 0.04361938f};
1266
1267 for (j = 0; j < nbands; j++, grbuf += 18, overlap += 9) {
1268 float co[9], si[9];
1269 co[0] = -grbuf[0];
1270 si[0] = grbuf[17];
1271 for (i = 0; i < 4; i++) {
1272 si[8 - 2 * i] = grbuf[4 * i + 1] - grbuf[4 * i + 2];
1273 co[1 + 2 * i] = grbuf[4 * i + 1] + grbuf[4 * i + 2];
1274 si[7 - 2 * i] = grbuf[4 * i + 4] - grbuf[4 * i + 3];
1275 co[2 + 2 * i] = -(grbuf[4 * i + 3] + grbuf[4 * i + 4]);
1276 }
1277 L3_dct3_9(co);
1278 L3_dct3_9(si);
1279
1280 si[1] = -si[1];
1281 si[3] = -si[3];
1282 si[5] = -si[5];
1283 si[7] = -si[7];
1284
1285 i = 0;
1286
1287#if HAVE_SIMD
1288 if (have_simd())
1289 for (; i < 8; i += 4) {
1290 f4 vovl = VLD(overlap + i);
1291 f4 vc = VLD(co + i);
1292 f4 vs = VLD(si + i);
1293 f4 vr0 = VLD(g_twid9 + i);
1294 f4 vr1 = VLD(g_twid9 + 9 + i);
1295 f4 vw0 = VLD(window + i);
1296 f4 vw1 = VLD(window + 9 + i);
1297 f4 vsum = VADD(VMUL(vc, vr1), VMUL(vs, vr0));
1298 VSTORE(overlap + i, VSUB(VMUL(vc, vr0), VMUL(vs, vr1)));
1299 VSTORE(grbuf + i, VSUB(VMUL(vovl, vw0), VMUL(vsum, vw1)));
1300 vsum = VADD(VMUL(vovl, vw1), VMUL(vsum, vw0));
1301 VSTORE(grbuf + 14 - i, VREV(vsum));
1302 }
1303#endif /* HAVE_SIMD */
1304 for (; i < 9; i++) {
1305 float ovl = overlap[i];
1306 float sum = co[i] * g_twid9[9 + i] + si[i] * g_twid9[0 + i];
1307 overlap[i] = co[i] * g_twid9[0 + i] - si[i] * g_twid9[9 + i];
1308 grbuf[i] = ovl * window[0 + i] - sum * window[9 + i];
1309 grbuf[17 - i] = ovl * window[9 + i] + sum * window[0 + i];
1310 }
1311 }
1312}
1313
1314static void L3_idct3(float x0, float x1, float x2, float* dst) {
1315 float m1 = x1 * 0.86602540f;
1316 float a1 = x0 - x2 * 0.5f;
1317 dst[1] = x0 + x2;
1318 dst[0] = a1 + m1;
1319 dst[2] = a1 - m1;
1320}
1321
1322static void L3_imdct12(float* x, float* dst, float* overlap) {
1323 static const float g_twid3[6] = {
1324 0.79335334f, 0.92387953f, 0.99144486f, 0.60876143f, 0.38268343f, 0.13052619f};
1325 float co[3], si[3];
1326 int i;
1327
1328 L3_idct3(-x[0], x[6] + x[3], x[12] + x[9], co);
1329 L3_idct3(x[15], x[12] - x[9], x[6] - x[3], si);
1330 si[1] = -si[1];
1331
1332 for (i = 0; i < 3; i++) {
1333 float ovl = overlap[i];
1334 float sum = co[i] * g_twid3[3 + i] + si[i] * g_twid3[0 + i];
1335 overlap[i] = co[i] * g_twid3[0 + i] - si[i] * g_twid3[3 + i];
1336 dst[i] = ovl * g_twid3[2 - i] - sum * g_twid3[5 - i];
1337 dst[5 - i] = ovl * g_twid3[5 - i] + sum * g_twid3[2 - i];
1338 }
1339}
1340
1341static void L3_imdct_short(float* grbuf, float* overlap, int nbands) {
1342 for (; nbands > 0; nbands--, overlap += 9, grbuf += 18) {
1343 float tmp[18];
1344 memcpy(tmp, grbuf, sizeof(tmp));
1345 memcpy(grbuf, overlap, 6 * sizeof(float));
1346 L3_imdct12(tmp, grbuf + 6, overlap + 6);
1347 L3_imdct12(tmp + 1, grbuf + 12, overlap + 6);
1348 L3_imdct12(tmp + 2, overlap, overlap + 6);
1349 }
1350}
1351
1352static void L3_change_sign(float* grbuf) {
1353 int b, i;
1354 for (b = 0, grbuf += 18; b < 32; b += 2, grbuf += 36)
1355 for (i = 1; i < 18; i += 2)
1356 grbuf[i] = -grbuf[i];
1357}
1358
1359static void L3_imdct_gr(float* grbuf, float* overlap, unsigned block_type, unsigned n_long_bands) {
1360 static const float g_mdct_window[2][18] = {{0.99904822f,
1361 0.99144486f,
1362 0.97629601f,
1363 0.95371695f,
1364 0.92387953f,
1365 0.88701083f,
1366 0.84339145f,
1367 0.79335334f,
1368 0.73727734f,
1369 0.04361938f,
1370 0.13052619f,
1371 0.21643961f,
1372 0.30070580f,
1373 0.38268343f,
1374 0.46174861f,
1375 0.53729961f,
1376 0.60876143f,
1377 0.67559021f},
1378 {1,
1379 1,
1380 1,
1381 1,
1382 1,
1383 1,
1384 0.99144486f,
1385 0.92387953f,
1386 0.79335334f,
1387 0,
1388 0,
1389 0,
1390 0,
1391 0,
1392 0,
1393 0.13052619f,
1394 0.38268343f,
1395 0.60876143f}};
1396 if (n_long_bands) {
1397 L3_imdct36(grbuf, overlap, g_mdct_window[0], n_long_bands);
1398 grbuf += 18 * n_long_bands;
1399 overlap += 9 * n_long_bands;
1400 }
1401 if (block_type == SHORT_BLOCK_TYPE)
1402 L3_imdct_short(grbuf, overlap, 32 - n_long_bands);
1403 else
1404 L3_imdct36(grbuf, overlap, g_mdct_window[block_type == STOP_BLOCK_TYPE], 32 - n_long_bands);
1405}
1406
1407static void L3_save_reservoir(mp3dec_t* h, mp3dec_scratch_t* s) {
1408 int pos = (s->bs.pos + 7) / 8u;
1409 int remains = s->bs.limit / 8u - pos;
1410 if (remains > MAX_BITRESERVOIR_BYTES) {
1411 pos += remains - MAX_BITRESERVOIR_BYTES;
1412 remains = MAX_BITRESERVOIR_BYTES;
1413 }
1414 if (remains > 0) {
1415 memmove(h->reserv_buf, s->maindata + pos, remains);
1416 }
1417 h->reserv = remains;
1418}
1419
1420static int L3_restore_reservoir(mp3dec_t* h, bs_t* bs, mp3dec_scratch_t* s, int main_data_begin) {
1421 int frame_bytes = (bs->limit - bs->pos) / 8;
1422 int bytes_have = MINIMP3_MIN(h->reserv, main_data_begin);
1423 memcpy(s->maindata,
1424 h->reserv_buf + MINIMP3_MAX(0, h->reserv - main_data_begin),
1425 MINIMP3_MIN(h->reserv, main_data_begin));
1426 memcpy(s->maindata + bytes_have, (void*)(bs->buf + bs->pos / 8), frame_bytes);
1427 bs_init(&s->bs, s->maindata, bytes_have + frame_bytes);
1428 return h->reserv >= main_data_begin;
1429}
1430
1431static void L3_decode(mp3dec_t* h, mp3dec_scratch_t* s, L3_gr_info_t* gr_info, int nch) {
1432 int ch;
1433
1434 for (ch = 0; ch < nch; ch++) {
1435 int layer3gr_limit = s->bs.pos + gr_info[ch].part_23_length;
1436 L3_decode_scalefactors(h->header, s->ist_pos[ch], &s->bs, gr_info + ch, s->scf, ch);
1437 L3_huffman(s->grbuf[ch], &s->bs, gr_info + ch, s->scf, layer3gr_limit);
1438 }
1439
1440 if (HDR_TEST_I_STEREO(h->header)) {
1441 L3_intensity_stereo(s->grbuf[0], s->ist_pos[1], gr_info, h->header);
1442 } else if (HDR_IS_MS_STEREO(h->header)) {
1443 L3_midside_stereo(s->grbuf[0], 576);
1444 }
1445
1446 for (ch = 0; ch < nch; ch++, gr_info++) {
1447 int aa_bands = 31;
1448 int n_long_bands = (gr_info->mixed_block_flag ? 2 : 0)
1449 << (int)(HDR_GET_MY_SAMPLE_RATE(h->header) == 2);
1450
1451 if (gr_info->n_short_sfb) {
1452 aa_bands = n_long_bands - 1;
1453 L3_reorder(
1454 s->grbuf[ch] + n_long_bands * 18, s->syn[0], gr_info->sfbtab + gr_info->n_long_sfb);
1455 }
1456
1457 L3_antialias(s->grbuf[ch], aa_bands);
1458 L3_imdct_gr(s->grbuf[ch], h->mdct_overlap[ch], gr_info->block_type, n_long_bands);
1459 L3_change_sign(s->grbuf[ch]);
1460 }
1461}
1462
1463static void mp3d_DCT_II(float* grbuf, int n) {
1464 static const float g_sec[24] = {
1465 10.19000816f, 0.50060302f, 0.50241929f, 3.40760851f, 0.50547093f, 0.52249861f,
1466 2.05778098f, 0.51544732f, 0.56694406f, 1.48416460f, 0.53104258f, 0.64682180f,
1467 1.16943991f, 0.55310392f, 0.78815460f, 0.97256821f, 0.58293498f, 1.06067765f,
1468 0.83934963f, 0.62250412f, 1.72244716f, 0.74453628f, 0.67480832f, 5.10114861f};
1469 int i, k = 0;
1470#if HAVE_SIMD
1471 if (have_simd())
1472 for (; k < n; k += 4) {
1473 f4 t[4][8], *x;
1474 float* y = grbuf + k;
1475
1476 for (x = t[0], i = 0; i < 8; i++, x++) {
1477 f4 x0 = VLD(&y[i * 18]);
1478 f4 x1 = VLD(&y[(15 - i) * 18]);
1479 f4 x2 = VLD(&y[(16 + i) * 18]);
1480 f4 x3 = VLD(&y[(31 - i) * 18]);
1481 f4 t0 = VADD(x0, x3);
1482 f4 t1 = VADD(x1, x2);
1483 f4 t2 = VMUL_S(VSUB(x1, x2), g_sec[3 * i + 0]);
1484 f4 t3 = VMUL_S(VSUB(x0, x3), g_sec[3 * i + 1]);
1485 x[0] = VADD(t0, t1);
1486 x[8] = VMUL_S(VSUB(t0, t1), g_sec[3 * i + 2]);
1487 x[16] = VADD(t3, t2);
1488 x[24] = VMUL_S(VSUB(t3, t2), g_sec[3 * i + 2]);
1489 }
1490 for (x = t[0], i = 0; i < 4; i++, x += 8) {
1491 f4 x0 = x[0], x1 = x[1], x2 = x[2], x3 = x[3], x4 = x[4], x5 = x[5], x6 = x[6],
1492 x7 = x[7], xt;
1493 xt = VSUB(x0, x7);
1494 x0 = VADD(x0, x7);
1495 x7 = VSUB(x1, x6);
1496 x1 = VADD(x1, x6);
1497 x6 = VSUB(x2, x5);
1498 x2 = VADD(x2, x5);
1499 x5 = VSUB(x3, x4);
1500 x3 = VADD(x3, x4);
1501 x4 = VSUB(x0, x3);
1502 x0 = VADD(x0, x3);
1503 x3 = VSUB(x1, x2);
1504 x1 = VADD(x1, x2);
1505 x[0] = VADD(x0, x1);
1506 x[4] = VMUL_S(VSUB(x0, x1), 0.70710677f);
1507 x5 = VADD(x5, x6);
1508 x6 = VMUL_S(VADD(x6, x7), 0.70710677f);
1509 x7 = VADD(x7, xt);
1510 x3 = VMUL_S(VADD(x3, x4), 0.70710677f);
1511 x5 = VSUB(x5, VMUL_S(x7, 0.198912367f)); /* rotate by PI/8 */
1512 x7 = VADD(x7, VMUL_S(x5, 0.382683432f));
1513 x5 = VSUB(x5, VMUL_S(x7, 0.198912367f));
1514 x0 = VSUB(xt, x6);
1515 xt = VADD(xt, x6);
1516 x[1] = VMUL_S(VADD(xt, x7), 0.50979561f);
1517 x[2] = VMUL_S(VADD(x4, x3), 0.54119611f);
1518 x[3] = VMUL_S(VSUB(x0, x5), 0.60134488f);
1519 x[5] = VMUL_S(VADD(x0, x5), 0.89997619f);
1520 x[6] = VMUL_S(VSUB(x4, x3), 1.30656302f);
1521 x[7] = VMUL_S(VSUB(xt, x7), 2.56291556f);
1522 }
1523
1524 if (k > n - 3) {
1525#if HAVE_SSE
1526#define VSAVE2(i, v) _mm_storel_pi((__m64*)(void*)&y[i * 18], v)
1527#else /* HAVE_SSE */
1528#define VSAVE2(i, v) vst1_f32((float32_t*)&y[i * 18], vget_low_f32(v))
1529#endif /* HAVE_SSE */
1530 for (i = 0; i < 7; i++, y += 4 * 18) {
1531 f4 s = VADD(t[3][i], t[3][i + 1]);
1532 VSAVE2(0, t[0][i]);
1533 VSAVE2(1, VADD(t[2][i], s));
1534 VSAVE2(2, VADD(t[1][i], t[1][i + 1]));
1535 VSAVE2(3, VADD(t[2][1 + i], s));
1536 }
1537 VSAVE2(0, t[0][7]);
1538 VSAVE2(1, VADD(t[2][7], t[3][7]));
1539 VSAVE2(2, t[1][7]);
1540 VSAVE2(3, t[3][7]);
1541 } else {
1542#define VSAVE4(i, v) VSTORE(&y[i * 18], v)
1543 for (i = 0; i < 7; i++, y += 4 * 18) {
1544 f4 s = VADD(t[3][i], t[3][i + 1]);
1545 VSAVE4(0, t[0][i]);
1546 VSAVE4(1, VADD(t[2][i], s));
1547 VSAVE4(2, VADD(t[1][i], t[1][i + 1]));
1548 VSAVE4(3, VADD(t[2][1 + i], s));
1549 }
1550 VSAVE4(0, t[0][7]);
1551 VSAVE4(1, VADD(t[2][7], t[3][7]));
1552 VSAVE4(2, t[1][7]);
1553 VSAVE4(3, t[3][7]);
1554 }
1555 }
1556 else
1557#endif /* HAVE_SIMD */
1558#ifdef MINIMP3_ONLY_SIMD
1559 {
1560 } /* for HAVE_SIMD=1, MINIMP3_ONLY_SIMD=1 case we do not need non-intrinsic "else" branch */
1561#else /* MINIMP3_ONLY_SIMD */
1562 for (; k < n; k++) {
1563 float t[4][8], *x, *y = grbuf + k;
1564
1565 for (x = t[0], i = 0; i < 8; i++, x++) {
1566 float x0 = y[i * 18];
1567 float x1 = y[(15 - i) * 18];
1568 float x2 = y[(16 + i) * 18];
1569 float x3 = y[(31 - i) * 18];
1570 float t0 = x0 + x3;
1571 float t1 = x1 + x2;
1572 float t2 = (x1 - x2) * g_sec[3 * i + 0];
1573 float t3 = (x0 - x3) * g_sec[3 * i + 1];
1574 x[0] = t0 + t1;
1575 x[8] = (t0 - t1) * g_sec[3 * i + 2];
1576 x[16] = t3 + t2;
1577 x[24] = (t3 - t2) * g_sec[3 * i + 2];
1578 }
1579 for (x = t[0], i = 0; i < 4; i++, x += 8) {
1580 float x0 = x[0], x1 = x[1], x2 = x[2], x3 = x[3], x4 = x[4], x5 = x[5], x6 = x[6],
1581 x7 = x[7], xt;
1582 xt = x0 - x7;
1583 x0 += x7;
1584 x7 = x1 - x6;
1585 x1 += x6;
1586 x6 = x2 - x5;
1587 x2 += x5;
1588 x5 = x3 - x4;
1589 x3 += x4;
1590 x4 = x0 - x3;
1591 x0 += x3;
1592 x3 = x1 - x2;
1593 x1 += x2;
1594 x[0] = x0 + x1;
1595 x[4] = (x0 - x1) * 0.70710677f;
1596 x5 = x5 + x6;
1597 x6 = (x6 + x7) * 0.70710677f;
1598 x7 = x7 + xt;
1599 x3 = (x3 + x4) * 0.70710677f;
1600 x5 -= x7 * 0.198912367f; /* rotate by PI/8 */
1601 x7 += x5 * 0.382683432f;
1602 x5 -= x7 * 0.198912367f;
1603 x0 = xt - x6;
1604 xt += x6;
1605 x[1] = (xt + x7) * 0.50979561f;
1606 x[2] = (x4 + x3) * 0.54119611f;
1607 x[3] = (x0 - x5) * 0.60134488f;
1608 x[5] = (x0 + x5) * 0.89997619f;
1609 x[6] = (x4 - x3) * 1.30656302f;
1610 x[7] = (xt - x7) * 2.56291556f;
1611 }
1612 for (i = 0; i < 7; i++, y += 4 * 18) {
1613 y[0 * 18] = t[0][i];
1614 y[1 * 18] = t[2][i] + t[3][i] + t[3][i + 1];
1615 y[2 * 18] = t[1][i] + t[1][i + 1];
1616 y[3 * 18] = t[2][i + 1] + t[3][i] + t[3][i + 1];
1617 }
1618 y[0 * 18] = t[0][7];
1619 y[1 * 18] = t[2][7] + t[3][7];
1620 y[2 * 18] = t[1][7];
1621 y[3 * 18] = t[3][7];
1622 }
1623#endif /* MINIMP3_ONLY_SIMD */
1624}
1625
1626#ifndef MINIMP3_FLOAT_OUTPUT
1627static int16_t mp3d_scale_pcm(float sample) {
1628#if HAVE_ARMV6
1629 int32_t s32 = (int32_t)(sample + .5f);
1630 s32 -= (s32 < 0);
1631 int16_t s = (int16_t)minimp3_clip_int16_arm(s32);
1632#else
1633 if (sample >= 32766.5)
1634 return (int16_t)32767;
1635 if (sample <= -32767.5)
1636 return (int16_t)-32768;
1637 int16_t s = (int16_t)(sample + .5f);
1638 s -= (s < 0); /* away from zero, to be compliant */
1639#endif
1640 return s;
1641}
1642#else /* MINIMP3_FLOAT_OUTPUT */
1643static float mp3d_scale_pcm(float sample) {
1644 return sample * (1.f / 32768.f);
1645}
1646#endif /* MINIMP3_FLOAT_OUTPUT */
1647
1648static void mp3d_synth_pair(mp3d_sample_t* pcm, int nch, const float* z) {
1649 float a;
1650 a = (z[14 * 64] - z[0]) * 29;
1651 a += (z[1 * 64] + z[13 * 64]) * 213;
1652 a += (z[12 * 64] - z[2 * 64]) * 459;
1653 a += (z[3 * 64] + z[11 * 64]) * 2037;
1654 a += (z[10 * 64] - z[4 * 64]) * 5153;
1655 a += (z[5 * 64] + z[9 * 64]) * 6574;
1656 a += (z[8 * 64] - z[6 * 64]) * 37489;
1657 a += z[7 * 64] * 75038;
1658 pcm[0] = mp3d_scale_pcm(a);
1659
1660 z += 2;
1661 a = z[14 * 64] * 104;
1662 a += z[12 * 64] * 1567;
1663 a += z[10 * 64] * 9727;
1664 a += z[8 * 64] * 64019;
1665 a += z[6 * 64] * -9975;
1666 a += z[4 * 64] * -45;
1667 a += z[2 * 64] * 146;
1668 a += z[0 * 64] * -5;
1669 pcm[16 * nch] = mp3d_scale_pcm(a);
1670}
1671
1672static void mp3d_synth(float* xl, mp3d_sample_t* dstl, int nch, float* lins) {
1673 int i;
1674 float* xr = xl + 576 * (nch - 1);
1675 mp3d_sample_t* dstr = dstl + (nch - 1);
1676
1677 static const float g_win[] = {
1678 -1, 26, -31, 208, 218, 401, -519, 2063, 2000, 4788, -5517, 7134,
1679 5959, 35640, -39336, 74992, -1, 24, -35, 202, 222, 347, -581, 2080,
1680 1952, 4425, -5879, 7640, 5288, 33791, -41176, 74856, -1, 21, -38, 196,
1681 225, 294, -645, 2087, 1893, 4063, -6237, 8092, 4561, 31947, -43006, 74630,
1682 -1, 19, -41, 190, 227, 244, -711, 2085, 1822, 3705, -6589, 8492,
1683 3776, 30112, -44821, 74313, -1, 17, -45, 183, 228, 197, -779, 2075,
1684 1739, 3351, -6935, 8840, 2935, 28289, -46617, 73908, -1, 16, -49, 176,
1685 228, 153, -848, 2057, 1644, 3004, -7271, 9139, 2037, 26482, -48390, 73415,
1686 -2, 14, -53, 169, 227, 111, -919, 2032, 1535, 2663, -7597, 9389,
1687 1082, 24694, -50137, 72835, -2, 13, -58, 161, 224, 72, -991, 2001,
1688 1414, 2330, -7910, 9592, 70, 22929, -51853, 72169, -2, 11, -63, 154,
1689 221, 36, -1064, 1962, 1280, 2006, -8209, 9750, -998, 21189, -53534, 71420,
1690 -2, 10, -68, 147, 215, 2, -1137, 1919, 1131, 1692, -8491, 9863,
1691 -2122, 19478, -55178, 70590, -3, 9, -73, 139, 208, -29, -1210, 1870,
1692 970, 1388, -8755, 9935, -3300, 17799, -56778, 69679, -3, 8, -79, 132,
1693 200, -57, -1283, 1817, 794, 1095, -8998, 9966, -4533, 16155, -58333, 68692,
1694 -4, 7, -85, 125, 189, -83, -1356, 1759, 605, 814, -9219, 9959,
1695 -5818, 14548, -59838, 67629, -4, 7, -91, 117, 177, -106, -1428, 1698,
1696 402, 545, -9416, 9916, -7154, 12980, -61289, 66494, -5, 6, -97, 111,
1697 163, -127, -1498, 1634, 185, 288, -9585, 9838, -8540, 11455, -62684, 65290};
1698 float* zlin = lins + 15 * 64;
1699 const float* w = g_win;
1700
1701 zlin[4 * 15] = xl[18 * 16];
1702 zlin[4 * 15 + 1] = xr[18 * 16];
1703 zlin[4 * 15 + 2] = xl[0];
1704 zlin[4 * 15 + 3] = xr[0];
1705
1706 zlin[4 * 31] = xl[1 + 18 * 16];
1707 zlin[4 * 31 + 1] = xr[1 + 18 * 16];
1708 zlin[4 * 31 + 2] = xl[1];
1709 zlin[4 * 31 + 3] = xr[1];
1710
1711 mp3d_synth_pair(dstr, nch, lins + 4 * 15 + 1);
1712 mp3d_synth_pair(dstr + 32 * nch, nch, lins + 4 * 15 + 64 + 1);
1713 mp3d_synth_pair(dstl, nch, lins + 4 * 15);
1714 mp3d_synth_pair(dstl + 32 * nch, nch, lins + 4 * 15 + 64);
1715
1716#if HAVE_SIMD
1717 if (have_simd())
1718 for (i = 14; i >= 0; i--) {
1719#define VLOAD(k) \
1720 f4 w0 = VSET(*w++); \
1721 f4 w1 = VSET(*w++); \
1722 f4 vz = VLD(&zlin[4 * i - 64 * k]); \
1723 f4 vy = VLD(&zlin[4 * i - 64 * (15 - k)]);
1724#define V0(k) \
1725 { \
1726 VLOAD(k) b = VADD(VMUL(vz, w1), VMUL(vy, w0)); \
1727 a = VSUB(VMUL(vz, w0), VMUL(vy, w1)); \
1728 }
1729#define V1(k) \
1730 { \
1731 VLOAD(k) b = VADD(b, VADD(VMUL(vz, w1), VMUL(vy, w0))); \
1732 a = VADD(a, VSUB(VMUL(vz, w0), VMUL(vy, w1))); \
1733 }
1734#define V2(k) \
1735 { \
1736 VLOAD(k) b = VADD(b, VADD(VMUL(vz, w1), VMUL(vy, w0))); \
1737 a = VADD(a, VSUB(VMUL(vy, w1), VMUL(vz, w0))); \
1738 }
1739 f4 a, b;
1740 zlin[4 * i] = xl[18 * (31 - i)];
1741 zlin[4 * i + 1] = xr[18 * (31 - i)];
1742 zlin[4 * i + 2] = xl[1 + 18 * (31 - i)];
1743 zlin[4 * i + 3] = xr[1 + 18 * (31 - i)];
1744 zlin[4 * i + 64] = xl[1 + 18 * (1 + i)];
1745 zlin[4 * i + 64 + 1] = xr[1 + 18 * (1 + i)];
1746 zlin[4 * i - 64 + 2] = xl[18 * (1 + i)];
1747 zlin[4 * i - 64 + 3] = xr[18 * (1 + i)];
1748
1749 V0(0)
1750 V2(1)
1751 V1(2)
1752 V2(3) V1(4) V2(5) V1(6) V2(7)
1753
1754 {
1755#ifndef MINIMP3_FLOAT_OUTPUT
1756#if HAVE_SSE
1757 static const f4 g_max = {32767.0f, 32767.0f, 32767.0f, 32767.0f};
1758 static const f4 g_min = {-32768.0f, -32768.0f, -32768.0f, -32768.0f};
1759 __m128i pcm8 =
1760 _mm_packs_epi32(_mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(a, g_max), g_min)),
1761 _mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(b, g_max), g_min)));
1762 dstr[(15 - i) * nch] = _mm_extract_epi16(pcm8, 1);
1763 dstr[(17 + i) * nch] = _mm_extract_epi16(pcm8, 5);
1764 dstl[(15 - i) * nch] = _mm_extract_epi16(pcm8, 0);
1765 dstl[(17 + i) * nch] = _mm_extract_epi16(pcm8, 4);
1766 dstr[(47 - i) * nch] = _mm_extract_epi16(pcm8, 3);
1767 dstr[(49 + i) * nch] = _mm_extract_epi16(pcm8, 7);
1768 dstl[(47 - i) * nch] = _mm_extract_epi16(pcm8, 2);
1769 dstl[(49 + i) * nch] = _mm_extract_epi16(pcm8, 6);
1770#else /* HAVE_SSE */
1771 int16x4_t pcma, pcmb;
1772 a = VADD(a, VSET(0.5f));
1773 b = VADD(b, VSET(0.5f));
1774 pcma = vqmovn_s32(
1775 vqaddq_s32(vcvtq_s32_f32(a), vreinterpretq_s32_u32(vcltq_f32(a, VSET(0)))));
1776 pcmb = vqmovn_s32(
1777 vqaddq_s32(vcvtq_s32_f32(b), vreinterpretq_s32_u32(vcltq_f32(b, VSET(0)))));
1778 vst1_lane_s16(dstr + (15 - i) * nch, pcma, 1);
1779 vst1_lane_s16(dstr + (17 + i) * nch, pcmb, 1);
1780 vst1_lane_s16(dstl + (15 - i) * nch, pcma, 0);
1781 vst1_lane_s16(dstl + (17 + i) * nch, pcmb, 0);
1782 vst1_lane_s16(dstr + (47 - i) * nch, pcma, 3);
1783 vst1_lane_s16(dstr + (49 + i) * nch, pcmb, 3);
1784 vst1_lane_s16(dstl + (47 - i) * nch, pcma, 2);
1785 vst1_lane_s16(dstl + (49 + i) * nch, pcmb, 2);
1786#endif /* HAVE_SSE */
1787
1788#else /* MINIMP3_FLOAT_OUTPUT */
1789
1790 static const f4 g_scale = {
1791 1.0f / 32768.0f, 1.0f / 32768.0f, 1.0f / 32768.0f, 1.0f / 32768.0f};
1792 a = VMUL(a, g_scale);
1793 b = VMUL(b, g_scale);
1794#if HAVE_SSE
1795 _mm_store_ss(dstr + (15 - i) * nch, _mm_shuffle_ps(a, a, _MM_SHUFFLE(1, 1, 1, 1)));
1796 _mm_store_ss(dstr + (17 + i) * nch, _mm_shuffle_ps(b, b, _MM_SHUFFLE(1, 1, 1, 1)));
1797 _mm_store_ss(dstl + (15 - i) * nch, _mm_shuffle_ps(a, a, _MM_SHUFFLE(0, 0, 0, 0)));
1798 _mm_store_ss(dstl + (17 + i) * nch, _mm_shuffle_ps(b, b, _MM_SHUFFLE(0, 0, 0, 0)));
1799 _mm_store_ss(dstr + (47 - i) * nch, _mm_shuffle_ps(a, a, _MM_SHUFFLE(3, 3, 3, 3)));
1800 _mm_store_ss(dstr + (49 + i) * nch, _mm_shuffle_ps(b, b, _MM_SHUFFLE(3, 3, 3, 3)));
1801 _mm_store_ss(dstl + (47 - i) * nch, _mm_shuffle_ps(a, a, _MM_SHUFFLE(2, 2, 2, 2)));
1802 _mm_store_ss(dstl + (49 + i) * nch, _mm_shuffle_ps(b, b, _MM_SHUFFLE(2, 2, 2, 2)));
1803#else /* HAVE_SSE */
1804 vst1q_lane_f32(dstr + (15 - i) * nch, a, 1);
1805 vst1q_lane_f32(dstr + (17 + i) * nch, b, 1);
1806 vst1q_lane_f32(dstl + (15 - i) * nch, a, 0);
1807 vst1q_lane_f32(dstl + (17 + i) * nch, b, 0);
1808 vst1q_lane_f32(dstr + (47 - i) * nch, a, 3);
1809 vst1q_lane_f32(dstr + (49 + i) * nch, b, 3);
1810 vst1q_lane_f32(dstl + (47 - i) * nch, a, 2);
1811 vst1q_lane_f32(dstl + (49 + i) * nch, b, 2);
1812#endif /* HAVE_SSE */
1813#endif /* MINIMP3_FLOAT_OUTPUT */
1814 }
1815 }
1816 else
1817#endif /* HAVE_SIMD */
1818#ifdef MINIMP3_ONLY_SIMD
1819 {
1820 } /* for HAVE_SIMD=1, MINIMP3_ONLY_SIMD=1 case we do not need non-intrinsic "else" branch */
1821#else /* MINIMP3_ONLY_SIMD */
1822 for (i = 14; i >= 0; i--) {
1823#define LOAD(k) \
1824 float w0 = *w++; \
1825 float w1 = *w++; \
1826 float* vz = &zlin[4 * i - k * 64]; \
1827 float* vy = &zlin[4 * i - (15 - k) * 64];
1828#define S0(k) \
1829 { \
1830 int j; \
1831 LOAD(k); \
1832 for (j = 0; j < 4; j++) \
1833 b[j] = vz[j] * w1 + vy[j] * w0, a[j] = vz[j] * w0 - vy[j] * w1; \
1834 }
1835#define S1(k) \
1836 { \
1837 int j; \
1838 LOAD(k); \
1839 for (j = 0; j < 4; j++) \
1840 b[j] += vz[j] * w1 + vy[j] * w0, a[j] += vz[j] * w0 - vy[j] * w1; \
1841 }
1842#define S2(k) \
1843 { \
1844 int j; \
1845 LOAD(k); \
1846 for (j = 0; j < 4; j++) \
1847 b[j] += vz[j] * w1 + vy[j] * w0, a[j] += vy[j] * w1 - vz[j] * w0; \
1848 }
1849 float a[4], b[4];
1850
1851 zlin[4 * i] = xl[18 * (31 - i)];
1852 zlin[4 * i + 1] = xr[18 * (31 - i)];
1853 zlin[4 * i + 2] = xl[1 + 18 * (31 - i)];
1854 zlin[4 * i + 3] = xr[1 + 18 * (31 - i)];
1855 zlin[4 * (i + 16)] = xl[1 + 18 * (1 + i)];
1856 zlin[4 * (i + 16) + 1] = xr[1 + 18 * (1 + i)];
1857 zlin[4 * (i - 16) + 2] = xl[18 * (1 + i)];
1858 zlin[4 * (i - 16) + 3] = xr[18 * (1 + i)];
1859
1860 S0(0)
1861 S2(1)
1862 S1(2)
1863 S2(3) S1(4) S2(5) S1(6) S2(7)
1864
1865 dstr[(15 - i) * nch] = mp3d_scale_pcm(a[1]);
1866 dstr[(17 + i) * nch] = mp3d_scale_pcm(b[1]);
1867 dstl[(15 - i) * nch] = mp3d_scale_pcm(a[0]);
1868 dstl[(17 + i) * nch] = mp3d_scale_pcm(b[0]);
1869 dstr[(47 - i) * nch] = mp3d_scale_pcm(a[3]);
1870 dstr[(49 + i) * nch] = mp3d_scale_pcm(b[3]);
1871 dstl[(47 - i) * nch] = mp3d_scale_pcm(a[2]);
1872 dstl[(49 + i) * nch] = mp3d_scale_pcm(b[2]);
1873 }
1874#endif /* MINIMP3_ONLY_SIMD */
1875}
1876
1877static void mp3d_synth_granule(
1878 float* qmf_state, float* grbuf, int nbands, int nch, mp3d_sample_t* pcm, float* lins) {
1879 int i;
1880 for (i = 0; i < nch; i++) {
1881 mp3d_DCT_II(grbuf + 576 * i, nbands);
1882 }
1883
1884 memcpy(lins, qmf_state, sizeof(float) * 15 * 64);
1885
1886 for (i = 0; i < nbands; i += 2) {
1887 mp3d_synth(grbuf + i, pcm + 32 * nch * i, nch, lins + i * 64);
1888 }
1889#ifndef MINIMP3_NONSTANDARD_BUT_LOGICAL
1890 if (nch == 1) {
1891 for (i = 0; i < 15 * 64; i += 2) {
1892 qmf_state[i] = lins[nbands * 64 + i];
1893 }
1894 } else
1895#endif /* MINIMP3_NONSTANDARD_BUT_LOGICAL */
1896 {
1897 memcpy(qmf_state, lins + nbands * 64, sizeof(float) * 15 * 64);
1898 }
1899}
1900
1901static int mp3d_match_frame(const uint8_t* hdr, int mp3_bytes, int frame_bytes) {
1902 int i, nmatch;
1903 for (i = 0, nmatch = 0; nmatch < MAX_FRAME_SYNC_MATCHES; nmatch++) {
1904 i += hdr_frame_bytes(hdr + i, frame_bytes) + hdr_padding(hdr + i);
1905 if (i + HDR_SIZE > mp3_bytes)
1906 return nmatch > 0;
1907 if (!hdr_compare(hdr, hdr + i))
1908 return 0;
1909 }
1910 return 1;
1911}
1912
1913static int
1914mp3d_find_frame(const uint8_t* mp3, int mp3_bytes, int* free_format_bytes, int* ptr_frame_bytes) {
1915 int i, k;
1916 for (i = 0; i < mp3_bytes - HDR_SIZE; i++, mp3++) {
1917 if (hdr_valid(mp3)) {
1918 int frame_bytes = hdr_frame_bytes(mp3, *free_format_bytes);
1919 int frame_and_padding = frame_bytes + hdr_padding(mp3);
1920
1921 for (k = HDR_SIZE;
1922 !frame_bytes && k < MAX_FREE_FORMAT_FRAME_SIZE && i + 2 * k < mp3_bytes - HDR_SIZE;
1923 k++) {
1924 if (hdr_compare(mp3, mp3 + k)) {
1925 int fb = k - hdr_padding(mp3);
1926 int nextfb = fb + hdr_padding(mp3 + k);
1927 if (i + k + nextfb + HDR_SIZE > mp3_bytes ||
1928 !hdr_compare(mp3, mp3 + k + nextfb))
1929 continue;
1930 frame_and_padding = k;
1931 frame_bytes = fb;
1932 *free_format_bytes = fb;
1933 }
1934 }
1935 if ((frame_bytes && i + frame_and_padding <= mp3_bytes &&
1936 mp3d_match_frame(mp3, mp3_bytes - i, frame_bytes)) ||
1937 (!i && frame_and_padding == mp3_bytes)) {
1938 *ptr_frame_bytes = frame_and_padding;
1939 return i;
1940 }
1941 *free_format_bytes = 0;
1942 }
1943 }
1944 *ptr_frame_bytes = 0;
1945 return mp3_bytes;
1946}
1947
1948void mp3dec_init(mp3dec_t* dec) {
1949 dec->header[0] = 0;
1950}
1951
1952int mp3dec_decode_frame(mp3dec_t* dec,
1953 const uint8_t* mp3,
1954 int mp3_bytes,
1955 mp3d_sample_t* pcm,
1956 mp3dec_frame_info_t* info) {
1957 int i = 0, igr, frame_size = 0, success = 1;
1958 const uint8_t* hdr;
1959 bs_t bs_frame[1];
1960 mp3dec_scratch_t scratch;
1961
1962 if (mp3_bytes > 4 && dec->header[0] == 0xff && hdr_compare(dec->header, mp3)) {
1963 frame_size = hdr_frame_bytes(mp3, dec->free_format_bytes) + hdr_padding(mp3);
1964 if (frame_size != mp3_bytes &&
1965 (frame_size + HDR_SIZE > mp3_bytes || !hdr_compare(mp3, mp3 + frame_size))) {
1966 frame_size = 0;
1967 }
1968 }
1969 if (!frame_size) {
1970 memset(dec, 0, sizeof(mp3dec_t));
1971 i = mp3d_find_frame(mp3, mp3_bytes, &dec->free_format_bytes, &frame_size);
1972 if (!frame_size || i + frame_size > mp3_bytes) {
1973 info->frame_bytes = i;
1974 return 0;
1975 }
1976 }
1977
1978 hdr = mp3 + i;
1979 memcpy(dec->header, (void*)hdr, HDR_SIZE);
1980 info->frame_bytes = i + frame_size;
1981 info->frame_offset = i;
1982 info->channels = HDR_IS_MONO(hdr) ? 1 : 2;
1983 info->hz = hdr_sample_rate_hz(hdr);
1984 info->layer = 4 - HDR_GET_LAYER(hdr);
1985 info->bitrate_kbps = hdr_bitrate_kbps(hdr);
1986
1987 if (!pcm) {
1988 return hdr_frame_samples(hdr);
1989 }
1990
1991 bs_init(bs_frame, hdr + HDR_SIZE, frame_size - HDR_SIZE);
1992 if (HDR_IS_CRC(hdr)) {
1993 get_bits(bs_frame, 16);
1994 }
1995
1996 if (info->layer == 3) {
1997 int main_data_begin = L3_read_side_info(bs_frame, scratch.gr_info, hdr);
1998 if (main_data_begin < 0 || bs_frame->pos > bs_frame->limit) {
1999 mp3dec_init(dec);
2000 return 0;
2001 }
2002 success = L3_restore_reservoir(dec, bs_frame, &scratch, main_data_begin);
2003 if (success) {
2004 for (igr = 0; igr < (HDR_TEST_MPEG1(hdr) ? 2 : 1); igr++, pcm += 576 * info->channels) {
2005 memset(scratch.grbuf[0], 0, 576 * 2 * sizeof(float));
2006 L3_decode(dec, &scratch, scratch.gr_info + igr * info->channels, info->channels);
2007 mp3d_synth_granule(
2008 dec->qmf_state, scratch.grbuf[0], 18, info->channels, pcm, scratch.syn[0]);
2009 }
2010 }
2011 L3_save_reservoir(dec, &scratch);
2012 } else {
2013#ifdef MINIMP3_ONLY_MP3
2014 return 0;
2015#else /* MINIMP3_ONLY_MP3 */
2016 L12_scale_info sci[1];
2017 L12_read_scale_info(hdr, bs_frame, sci);
2018
2019 memset(scratch.grbuf[0], 0, 576 * 2 * sizeof(float));
2020 for (i = 0, igr = 0; igr < 3; igr++) {
2021 if (12 == (i += L12_dequantize_granule(
2022 scratch.grbuf[0] + i, bs_frame, sci, info->layer | 1))) {
2023 i = 0;
2024 L12_apply_scf_384(sci, sci->scf + igr, scratch.grbuf[0]);
2025 mp3d_synth_granule(
2026 dec->qmf_state, scratch.grbuf[0], 12, info->channels, pcm, scratch.syn[0]);
2027 memset(scratch.grbuf[0], 0, 576 * 2 * sizeof(float));
2028 pcm += 384 * info->channels;
2029 }
2030 if (bs_frame->pos > bs_frame->limit) {
2031 mp3dec_init(dec);
2032 return 0;
2033 }
2034 }
2035#endif /* MINIMP3_ONLY_MP3 */
2036 }
2037 return success * hdr_frame_samples(dec->header);
2038}
2039
2040#ifdef MINIMP3_FLOAT_OUTPUT
2041void mp3dec_f32_to_s16(const float* in, int16_t* out, int num_samples) {
2042 int i = 0;
2043#if HAVE_SIMD
2044 int aligned_count = num_samples & ~7;
2045 for (; i < aligned_count; i += 8) {
2046 static const f4 g_scale = {32768.0f, 32768.0f, 32768.0f, 32768.0f};
2047 f4 a = VMUL(VLD(&in[i]), g_scale);
2048 f4 b = VMUL(VLD(&in[i + 4]), g_scale);
2049#if HAVE_SSE
2050 static const f4 g_max = {32767.0f, 32767.0f, 32767.0f, 32767.0f};
2051 static const f4 g_min = {-32768.0f, -32768.0f, -32768.0f, -32768.0f};
2052 __m128i pcm8 = _mm_packs_epi32(_mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(a, g_max), g_min)),
2053 _mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(b, g_max), g_min)));
2054 out[i] = _mm_extract_epi16(pcm8, 0);
2055 out[i + 1] = _mm_extract_epi16(pcm8, 1);
2056 out[i + 2] = _mm_extract_epi16(pcm8, 2);
2057 out[i + 3] = _mm_extract_epi16(pcm8, 3);
2058 out[i + 4] = _mm_extract_epi16(pcm8, 4);
2059 out[i + 5] = _mm_extract_epi16(pcm8, 5);
2060 out[i + 6] = _mm_extract_epi16(pcm8, 6);
2061 out[i + 7] = _mm_extract_epi16(pcm8, 7);
2062#else /* HAVE_SSE */
2063 int16x4_t pcma, pcmb;
2064 a = VADD(a, VSET(0.5f));
2065 b = VADD(b, VSET(0.5f));
2066 pcma =
2067 vqmovn_s32(vqaddq_s32(vcvtq_s32_f32(a), vreinterpretq_s32_u32(vcltq_f32(a, VSET(0)))));
2068 pcmb =
2069 vqmovn_s32(vqaddq_s32(vcvtq_s32_f32(b), vreinterpretq_s32_u32(vcltq_f32(b, VSET(0)))));
2070 vst1_lane_s16(out + i, pcma, 0);
2071 vst1_lane_s16(out + i + 1, pcma, 1);
2072 vst1_lane_s16(out + i + 2, pcma, 2);
2073 vst1_lane_s16(out + i + 3, pcma, 3);
2074 vst1_lane_s16(out + i + 4, pcmb, 0);
2075 vst1_lane_s16(out + i + 5, pcmb, 1);
2076 vst1_lane_s16(out + i + 6, pcmb, 2);
2077 vst1_lane_s16(out + i + 7, pcmb, 3);
2078#endif /* HAVE_SSE */
2079 }
2080#endif /* HAVE_SIMD */
2081 for (; i < num_samples; i++) {
2082 float sample = in[i] * 32768.0f;
2083 if (sample >= 32766.5)
2084 out[i] = (int16_t)32767;
2085 else if (sample <= -32767.5)
2086 out[i] = (int16_t)-32768;
2087 else {
2088 int16_t s = (int16_t)(sample + .5f);
2089 s -= (s < 0); /* away from zero, to be compliant */
2090 out[i] = s;
2091 }
2092 }
2093}
2094#endif /* MINIMP3_FLOAT_OUTPUT */
2095#endif /* MINIMP3_IMPLEMENTATION && !_MINIMP3_IMPLEMENTATION_GUARD */
__attribute__
typedef __attribute__
Definition list_sort.h:12
t
XETime t
Definition main.cpp:53
a
size_t a
Definition main.cpp:156
b
size_t b
Definition main.cpp:156
out
#define out(...)
Definition main.cpp:65
memmove
void * memmove(void *Dest, const void *Src, ACPI_SIZE Count)
Definition utclib.c:255
int32_t
int int32_t
Definition acefiex.h:160
uint32_t
unsigned int uint32_t
Definition acefiex.h:163
int16_t
short int int16_t
Definition acefiex.h:159
uint8_t
unsigned char uint8_t
Definition acefiex.h:161
uint16_t
unsigned short int uint16_t
Definition acefiex.h:162
sign
#define sign(x)
Definition draw.cpp:36
sample
int sample
Definition h264bsd_deblocking.c:642
alloc
ALLOCATOR alloc
Definition helix_memory.cpp:6
success
ChIcon * success
Definition icon.cpp:199
len
size_t len
Definition initial.c:23
memset
void memset(void)
memcpy
void memcpy(void)
data
void * data
Definition kthread.h:30
y
int y
Definition layout.c:118
h
int h
Definition layout.c:118
x
int x
Definition layout.c:118
w
int w
Definition layout.c:118
d
#define d
Definition libunicode.c:1833
s8
int8_t s8
Definition kernel.h:18
s32
int32_t s32
Definition kernel.h:20
end
char end[]
mp3d_sample_t
int16_t mp3d_sample_t
Definition minimp3.h:30
mp3dec_init
void mp3dec_init(mp3dec_t *dec)
mp3dec_decode_frame
int mp3dec_decode_frame(mp3dec_t *dec, const uint8_t *mp3, int mp3_bytes, mp3d_sample_t *pcm, mp3dec_frame_info_t *info)
hdr
NetRingHdr * hdr
Definition netproxy.c:39
mp3dec_frame_info_t
Definition minimp3.h:14
mp3dec_frame_info_t::bitrate_kbps
int bitrate_kbps
Definition minimp3.h:15
mp3dec_frame_info_t::frame_offset
int frame_offset
Definition minimp3.h:15
mp3dec_frame_info_t::frame_bytes
int frame_bytes
Definition minimp3.h:15
mp3dec_frame_info_t::channels
int channels
Definition minimp3.h:15
mp3dec_frame_info_t::hz
int hz
Definition minimp3.h:15
mp3dec_frame_info_t::layer
int layer
Definition minimp3.h:15
mp3dec_t
Definition minimp3.h:18
mp3dec_t::qmf_state
float qmf_state[15 *2 *32]
Definition minimp3.h:19
mp3dec_t::header
unsigned char header[4]
Definition minimp3.h:21
mp3dec_t::free_format_bytes
int free_format_bytes
Definition minimp3.h:20
mode
#define mode(x)
Generated by doxygen 1.9.8