?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
VST3: fetch midi mappings all at once, use it for note/sound-off
[carla.git] / source / modules / juce_audio_formats / codecs / juce_MP3AudioFormat.cpp
blob7a287f9cc306fecf49225ae0d2dee4d8e6069667
1 /*
2 ==============================================================================
3
4 This file is part of the JUCE library.
5 Copyright (c) 2022 - Raw Material Software Limited
6
7 JUCE is an open source library subject to commercial or open-source
8 licensing.
9
10 By using JUCE, you agree to the terms of both the JUCE 7 End-User License
11 Agreement and JUCE Privacy Policy.
12
13 End User License Agreement: www.juce.com/juce-7-licence
14 Privacy Policy: www.juce.com/juce-privacy-policy
15
16 Or: You may also use this code under the terms of the GPL v3 (see
17 www.gnu.org/licenses).
18
19 JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
20 EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
21 DISCLAIMED.
22
23 ==============================================================================
24 */
25
26 namespace juce
27 {
28
29 /*
30 IMPORTANT DISCLAIMER: By choosing to enable the JUCE_USE_MP3AUDIOFORMAT flag and
31 to compile this MP3 code into your software, you do so AT YOUR OWN RISK! By doing so,
32 you are agreeing that Raw Material Software Limited is in no way responsible for any patent,
33 copyright, or other legal issues that you may suffer as a result.
34
35 The code in juce_MP3AudioFormat.cpp is NOT guaranteed to be free from infringements of 3rd-party
36 intellectual property. If you wish to use it, please seek your own independent advice about the
37 legality of doing so. If you are not willing to accept full responsibility for the consequences
38 of using this code, then do not enable the JUCE_USE_MP3AUDIOFORMAT setting.
39 */
40 #if JUCE_USE_MP3AUDIOFORMAT
41
42 namespace MP3Decoder
43 {
44
45 struct AllocationTable
46 {
47 int16 bits, d;
48 };
49
50 constexpr AllocationTable allocTable0[] =
51 {
52 {4, 0}, {5, 3}, {3, -3}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383}, {16, -32767},
53 {4, 0}, {5, 3}, {3, -3}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383}, {16, -32767},
54 {4, 0}, {5, 3}, {3, -3}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383}, {16, -32767},
55 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},
56 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},
57 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},
58 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},
59 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},
60 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},
61 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},
62 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},
63 {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},
64 {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},
65 {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},
66 {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},
67 {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},
68 {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},
69 {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}
70 };
71
72 constexpr AllocationTable allocTable1[] =
73 {
74 {4, 0}, {5, 3}, {3, -3}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383}, {16, -32767},
75 {4, 0}, {5, 3}, {3, -3}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383}, {16, -32767},
76 {4, 0}, {5, 3}, {3, -3}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383}, {16, -32767},
77 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},
78 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},
79 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},
80 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},
81 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},
82 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},
83 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},
84 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {16, -32767},
85 {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},
86 {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},
87 {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},
88 {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},
89 {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},
90 {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767}, {3, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {16, -32767},
91 {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767},
92 {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}
93 };
94
95 constexpr AllocationTable allocTable2[] =
96 {
97 {4, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383},
98 {4, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383},
99 {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},
100 {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},
101 {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}
102 };
103
104 constexpr AllocationTable allocTable3[] =
105 {
106 {4, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383},
107 {4, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191}, {15, -16383},
108 {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},
109 {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},
110 {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},
111 {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},
112 {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}
113 };
114
115 constexpr AllocationTable allocTable4[] =
116 {
117 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191},
118 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191},
119 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191},
120 {4, 0}, {5, 3}, {7, 5}, {3, -3}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {8, -127}, {9, -255}, {10, -511}, {11, -1023}, {12, -2047}, {13, -4095}, {14, -8191},
121 {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},
122 {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},
123 {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63},
124 {3, 0}, {5, 3}, {7, 5}, {10, 9}, {4, -7}, {5, -15}, {6, -31}, {7, -63}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9},
125 {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9},
126 {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9},
127 {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9},
128 {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9},
129 {2, 0}, {5, 3}, {7, 5}, {10, 9}
130 };
131
132 struct BandInfoStruct
133 {
134 int16 longIndex[23];
135 int16 longDiff[22];
136 int16 shortIndex[14];
137 int16 shortDiff[13];
138 };
139
140 constexpr BandInfoStruct bandInfo[9] =
141 {
142 { {0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162, 196, 238, 288, 342, 418, 576},
143 {4, 4, 4, 4, 4, 4, 6, 6, 8, 8, 10, 12, 16, 20, 24, 28, 34, 42, 50, 54, 76, 158},
144 {0, 4 * 3, 8 * 3, 12 * 3, 16 * 3, 22 * 3, 30 * 3, 40 * 3, 52 * 3, 66 * 3, 84 * 3, 106 * 3, 136 * 3, 192 * 3},
145 {4, 4, 4, 4, 6, 8, 10, 12, 14, 18, 22, 30, 56} },
146
147 { {0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156, 190, 230, 276, 330, 384, 576},
148 {4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 10, 12, 16, 18, 22, 28, 34, 40, 46, 54, 54, 192},
149 {0, 4 * 3, 8 * 3, 12 * 3, 16 * 3, 22 * 3, 28 * 3, 38 * 3, 50 * 3, 64 * 3, 80 * 3, 100 * 3, 126 * 3, 192 * 3},
150 {4, 4, 4, 4, 6, 6, 10, 12, 14, 16, 20, 26, 66} },
151
152 { {0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194, 240, 296, 364, 448, 550, 576},
153 {4, 4, 4, 4, 4, 4, 6, 6, 8, 10, 12, 16, 20, 24, 30, 38, 46, 56, 68, 84, 102, 26},
154 {0, 4 * 3, 8 * 3, 12 * 3, 16 * 3, 22 * 3, 30 * 3, 42 * 3, 58 * 3, 78 * 3, 104 * 3, 138 * 3, 180 * 3, 192 * 3},
155 {4, 4, 4, 4, 6, 8, 12, 16, 20, 26, 34, 42, 12} },
156
157 { {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
158 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54 },
159 {0, 4 * 3, 8 * 3, 12 * 3, 18 * 3, 24 * 3, 32 * 3, 42 * 3, 56 * 3, 74 * 3, 100 * 3, 132 * 3, 174 * 3, 192 * 3},
160 {4, 4, 4, 6, 6, 8, 10, 14, 18, 26, 32, 42, 18 } },
161
162 { {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194, 232, 278, 332, 394, 464, 540, 576},
163 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 18, 22, 26, 32, 38, 46, 54, 62, 70, 76, 36 },
164 {0, 4 * 3, 8 * 3, 12 * 3, 18 * 3, 26 * 3, 36 * 3, 48 * 3, 62 * 3, 80 * 3, 104 * 3, 136 * 3, 180 * 3, 192 * 3},
165 {4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 32, 44, 12 } },
166
167 { {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
168 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54 },
169 {0, 4 * 3, 8 * 3, 12 * 3, 18 * 3, 26 * 3, 36 * 3, 48 * 3, 62 * 3, 80 * 3, 104 * 3, 134 * 3, 174 * 3, 192 * 3},
170 {4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18 } },
171
172 { {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
173 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54},
174 {0, 12, 24, 36, 54, 78, 108, 144, 186, 240, 312, 402, 522, 576},
175 {4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18} },
176
177 { {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
178 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54},
179 {0, 12, 24, 36, 54, 78, 108, 144, 186, 240, 312, 402, 522, 576},
180 {4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18} },
181
182 { {0, 12, 24, 36, 48, 60, 72, 88, 108, 132, 160, 192, 232, 280, 336, 400, 476, 566, 568, 570, 572, 574, 576},
183 {12, 12, 12, 12, 12, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 76, 90, 2, 2, 2, 2, 2},
184 {0, 24, 48, 72, 108, 156, 216, 288, 372, 480, 486, 492, 498, 576},
185 {8, 8, 8, 12, 16, 20, 24, 28, 36, 2, 2, 2, 26} }
186 };
187
188 constexpr double decodeWindow[] =
189 {
190 0.000000000, -0.000015259, -0.000015259, -0.000015259, -0.000015259, -0.000015259, -0.000015259, -0.000030518,
191 -0.000030518, -0.000030518, -0.000030518, -0.000045776, -0.000045776, -0.000061035, -0.000061035, -0.000076294,
192 -0.000076294, -0.000091553, -0.000106812, -0.000106812, -0.000122070, -0.000137329, -0.000152588, -0.000167847,
193 -0.000198364, -0.000213623, -0.000244141, -0.000259399, -0.000289917, -0.000320435, -0.000366211, -0.000396729,
194 -0.000442505, -0.000473022, -0.000534058, -0.000579834, -0.000625610, -0.000686646, -0.000747681, -0.000808716,
195 -0.000885010, -0.000961304, -0.001037598, -0.001113892, -0.001205444, -0.001296997, -0.001388550, -0.001480103,
196 -0.001586914, -0.001693726, -0.001785278, -0.001907349, -0.002014160, -0.002120972, -0.002243042, -0.002349854,
197 -0.002456665, -0.002578735, -0.002685547, -0.002792358, -0.002899170, -0.002990723, -0.003082275, -0.003173828,
198 -0.003250122, -0.003326416, -0.003387451, -0.003433228, -0.003463745, -0.003479004, -0.003479004, -0.003463745,
199 -0.003417969, -0.003372192, -0.003280640, -0.003173828, -0.003051758, -0.002883911, -0.002700806, -0.002487183,
200 -0.002227783, -0.001937866, -0.001617432, -0.001266479, -0.000869751, -0.000442505, 0.000030518, 0.000549316,
201 0.001098633, 0.001693726, 0.002334595, 0.003005981, 0.003723145, 0.004486084, 0.005294800, 0.006118774,
202 0.007003784, 0.007919312, 0.008865356, 0.009841919, 0.010848999, 0.011886597, 0.012939453, 0.014022827,
203 0.015121460, 0.016235352, 0.017349243, 0.018463135, 0.019577026, 0.020690918, 0.021789551, 0.022857666,
204 0.023910522, 0.024932861, 0.025909424, 0.026840210, 0.027725220, 0.028533936, 0.029281616, 0.029937744,
205 0.030532837, 0.031005859, 0.031387329, 0.031661987, 0.031814575, 0.031845093, 0.031738281, 0.031478882,
206 0.031082153, 0.030517578, 0.029785156, 0.028884888, 0.027801514, 0.026535034, 0.025085449, 0.023422241,
207 0.021575928, 0.019531250, 0.017257690, 0.014801025, 0.012115479, 0.009231567, 0.006134033, 0.002822876,
208 -0.000686646, -0.004394531, -0.008316040, -0.012420654, -0.016708374, -0.021179199, -0.025817871, -0.030609131,
209 -0.035552979, -0.040634155, -0.045837402, -0.051132202, -0.056533813, -0.061996460, -0.067520142, -0.073059082,
210 -0.078628540, -0.084182739, -0.089706421, -0.095169067, -0.100540161, -0.105819702, -0.110946655, -0.115921021,
211 -0.120697021, -0.125259399, -0.129562378, -0.133590698, -0.137298584, -0.140670776, -0.143676758, -0.146255493,
212 -0.148422241, -0.150115967, -0.151306152, -0.151962280, -0.152069092, -0.151596069, -0.150497437, -0.148773193,
213 -0.146362305, -0.143264771, -0.139450073, -0.134887695, -0.129577637, -0.123474121, -0.116577148, -0.108856201,
214 -0.100311279, -0.090927124, -0.080688477, -0.069595337, -0.057617187, -0.044784546, -0.031082153, -0.016510010,
215 -0.001068115, 0.015228271, 0.032379150, 0.050354004, 0.069168091, 0.088775635, 0.109161377, 0.130310059,
216 0.152206421, 0.174789429, 0.198059082, 0.221984863, 0.246505737, 0.271591187, 0.297210693, 0.323318481,
217 0.349868774, 0.376800537, 0.404083252, 0.431655884, 0.459472656, 0.487472534, 0.515609741, 0.543823242,
218 0.572036743, 0.600219727, 0.628295898, 0.656219482, 0.683914185, 0.711318970, 0.738372803, 0.765029907,
219 0.791213989, 0.816864014, 0.841949463, 0.866363525, 0.890090942, 0.913055420, 0.935195923, 0.956481934,
220 0.976852417, 0.996246338, 1.014617920, 1.031936646, 1.048156738, 1.063217163, 1.077117920, 1.089782715,
221 1.101211548, 1.111373901, 1.120223999, 1.127746582, 1.133926392, 1.138763428, 1.142211914, 1.144287109,
222 1.144989014
223 };
224
225 constexpr int16 huffmanTab0[] = { 0 };
226 constexpr int16 huffmanTab1[] = { -5,-3,-1,17,1,16,0 };
227 constexpr int16 huffmanTab2[] = { -15,-11,-9,-5,-3,-1,34,2,18,-1,33,32,17,-1,1,16,0 };
228 constexpr int16 huffmanTab3[] = { -13,-11,-9,-5,-3,-1,34,2,18,-1,33,32,16,17,-1,1,0 };
229 constexpr int16 huffmanTab5[] = { -29,-25,-23,-15,-7,-5,-3,-1,51,35,50,49,-3,-1,19,3,-1,48,34,-3,-1,18,33,-1,2,32,17,-1,1,16,0 };
230 constexpr int16 huffmanTab6[] = { -25,-19,-13,-9,-5,-3,-1,51,3,35,-1,50,48,-1,19,49,-3,-1,34,2,18,-3,-1,33,32,1,-1,17,-1,16,0 };
231
232 constexpr int16 huffmanTab7[] =
233 {
234 -69,-65,-57,-39,-29,-17,-11,-7,-3,-1,85,69,-1,84,83,-1,53,68,-3,-1,37,82,21,-5,-1,81,-1,5,52,-1,80,-1,67,51,
235 -5,-3,-1,36,66,20,-1,65,64,-11,-7,-3,-1,4,35,-1,50,3,-1,19,49,-3,-1,48,34,18,-5,-1,33,-1,2,32,17,-1,1,16,0
236 };
237
238 constexpr int16 huffmanTab8[] =
239 {
240 -65,-63,-59,-45,-31,-19,-13,-7,-5,-3,-1,85,84,69,83,-3,-1,53,68,37,-3,-1,82,5,21,-5,-1,81,-1,52,67,-3,-1,80,
241 51,36,-5,-3,-1,66,20,65,-3,-1,4,64,-1,35,50,-9,-7,-3,-1,19,49,-1,3,48,34,-1,2,32,-1,18,33,17,-3,-1,1,16,0
242 };
243
244 constexpr int16 huffmanTab9[] =
245 {
246 -63,-53,-41,-29,-19,-11,-5,-3,-1,85,69,53,-1,83,-1,84,5,-3,-1,68,37,-1,82,21,-3,-1,81,52,-1,67,-1,80,4,-7,-3,
247 -1,36,66,-1,51,64,-1,20,65,-5,-3,-1,35,50,19,-1,49,-1,3,48,-5,-3,-1,34,2,18,-1,33,32,-3,-1,17,1,-1,16,0
248 };
249
250 constexpr int16 huffmanTab10[] =
251 {
252 -125,-121,-111,-83,-55,-35,-21,-13,-7,-3,-1,119,103,-1,118,87,-3,-1,117,102,71,-3,-1,116,86,-1,101,55,-9,-3,
253 -1,115,70,-3,-1,85,84,99,-1,39,114,-11,-5,-3,-1,100,7,112,-1,98,-1,69,53,-5,-1,6,-1,83,68,23,-17,-5,-1,113,
254 -1,54,38,-5,-3,-1,37,82,21,-1,81,-1,52,67,-3,-1,22,97,-1,96,-1,5,80,-19,-11,-7,-3,-1,36,66,-1,51,4,-1,20,
255 65,-3,-1,64,35,-1,50,3,-3,-1,19,49,-1,48,34,-7,-3,-1,18,33,-1,2,32,17,-1,1,16,0
256 };
257
258 constexpr int16 huffmanTab11[] =
259 {
260 -121,-113,-89,-59,-43,-27,-17,-7,-3,-1,119,103,-1,118,117,-3,-1,102,71,-1,116,-1,87,85,-5,-3,-1,86,101,55,
261 -1,115,70,-9,-7,-3,-1,69,84,-1,53,83,39,-1,114,-1,100,7,-5,-1,113,-1,23,112,-3,-1,54,99,-1,96,-1,68,37,-13,
262 -7,-5,-3,-1,82,5,21,98,-3,-1,38,6,22,-5,-1,97,-1,81,52,-5,-1,80,-1,67,51,-1,36,66,-15,-11,-7,-3,-1,20,65,
263 -1,4,64,-1,35,50,-1,19,49,-5,-3,-1,3,48,34,33,-5,-1,18,-1,2,32,17,-3,-1,1,16,0
264 };
265
266 constexpr int16 huffmanTab12[] =
267 {
268 -115,-99,-73,-45,-27,-17,-9,-5,-3,-1,119,103,118,-1,87,117,-3,-1,102,71,-1,116,101,-3,-1,86,55,-3,-1,115,
269 85,39,-7,-3,-1,114,70,-1,100,23,-5,-1,113,-1,7,112,-1,54,99,-13,-9,-3,-1,69,84,-1,68,-1,6,5,-1,38,98,-5,
270 -1,97,-1,22,96,-3,-1,53,83,-1,37,82,-17,-7,-3,-1,21,81,-1,52,67,-5,-3,-1,80,4,36,-1,66,20,-3,-1,51,65,-1,
271 35,50,-11,-7,-5,-3,-1,64,3,48,19,-1,49,34,-1,18,33,-7,-5,-3,-1,2,32,0,17,-1,1,16
272 };
273
274 constexpr int16 huffmanTab13[] =
275 {
276 -509,-503,-475,-405,-333,-265,-205,-153,-115,-83,-53,-35,-21,-13,-9,-7,-5,-3,-1,254,252,253,237,255,-1,239,223,
277 -3,-1,238,207,-1,222,191,-9,-3,-1,251,206,-1,220,-1,175,233,-1,236,221,-9,-5,-3,-1,250,205,190,-1,235,159,-3,
278 -1,249,234,-1,189,219,-17,-9,-3,-1,143,248,-1,204,-1,174,158,-5,-1,142,-1,127,126,247,-5,-1,218,-1,173,188,-3,
279 -1,203,246,111,-15,-7,-3,-1,232,95,-1,157,217,-3,-1,245,231,-1,172,187,-9,-3,-1,79,244,-3,-1,202,230,243,-1,
280 63,-1,141,216,-21,-9,-3,-1,47,242,-3,-1,110,156,15,-5,-3,-1,201,94,171,-3,-1,125,215,78,-11,-5,-3,-1,200,214,
281 62,-1,185,-1,155,170,-1,31,241,-23,-13,-5,-1,240,-1,186,229,-3,-1,228,140,-1,109,227,-5,-1,226,-1,46,14,-1,30,
282 225,-15,-7,-3,-1,224,93,-1,213,124,-3,-1,199,77,-1,139,184,-7,-3,-1,212,154,-1,169,108,-1,198,61,-37,-21,-9,-5,
283 -3,-1,211,123,45,-1,210,29,-5,-1,183,-1,92,197,-3,-1,153,122,195,-7,-5,-3,-1,167,151,75,209,-3,-1,13,208,-1,
284 138,168,-11,-7,-3,-1,76,196,-1,107,182,-1,60,44,-3,-1,194,91,-3,-1,181,137,28,-43,-23,-11,-5,-1,193,-1,152,12,
285 -1,192,-1,180,106,-5,-3,-1,166,121,59,-1,179,-1,136,90,-11,-5,-1,43,-1,165,105,-1,164,-1,120,135,-5,-1,148,-1,
286 119,118,178,-11,-3,-1,27,177,-3,-1,11,176,-1,150,74,-7,-3,-1,58,163,-1,89,149,-1,42,162,-47,-23,-9,-3,-1,26,
287 161,-3,-1,10,104,160,-5,-3,-1,134,73,147,-3,-1,57,88,-1,133,103,-9,-3,-1,41,146,-3,-1,87,117,56,-5,-1,131,-1,
288 102,71,-3,-1,116,86,-1,101,115,-11,-3,-1,25,145,-3,-1,9,144,-1,72,132,-7,-5,-1,114,-1,70,100,40,-1,130,24,-41,
289 -27,-11,-5,-3,-1,55,39,23,-1,113,-1,85,7,-7,-3,-1,112,54,-1,99,69,-3,-1,84,38,-1,98,53,-5,-1,129,-1,8,128,-3,
290 -1,22,97,-1,6,96,-13,-9,-5,-3,-1,83,68,37,-1,82,5,-1,21,81,-7,-3,-1,52,67,-1,80,36,-3,-1,66,51,20,-19,-11,
291 -5,-1,65,-1,4,64,-3,-1,35,50,19,-3,-1,49,3,-1,48,34,-3,-1,18,33,-1,2,32,-3,-1,17,1,16,0
292 };
293
294 constexpr int16 huffmanTab15[] =
295 {
296 -495,-445,-355,-263,-183,-115,-77,-43,-27,-13,-7,-3,-1,255,239,-1,254,223,-1,238,-1,253,207,-7,-3,-1,252,222,-1,
297 237,191,-1,251,-1,206,236,-7,-3,-1,221,175,-1,250,190,-3,-1,235,205,-1,220,159,-15,-7,-3,-1,249,234,-1,189,219,
298 -3,-1,143,248,-1,204,158,-7,-3,-1,233,127,-1,247,173,-3,-1,218,188,-1,111,-1,174,15,-19,-11,-3,-1,203,246,
299 -3,-1,142,232,-1,95,157,-3,-1,245,126,-1,231,172,-9,-3,-1,202,187,-3,-1,217,141,79,-3,-1,244,63,-1,243,216,
300 -33,-17,-9,-3,-1,230,47,-1,242,-1,110,240,-3,-1,31,241,-1,156,201,-7,-3,-1,94,171,-1,186,229,-3,-1,125,215,
301 -1,78,228,-15,-7,-3,-1,140,200,-1,62,109,-3,-1,214,227,-1,155,185,-7,-3,-1,46,170,-1,226,30,-5,-1,225,-1,14,
302 224,-1,93,213,-45,-25,-13,-7,-3,-1,124,199,-1,77,139,-1,212,-1,184,154,-7,-3,-1,169,108,-1,198,61,-1,211,210,
303 -9,-5,-3,-1,45,13,29,-1,123,183,-5,-1,209,-1,92,208,-1,197,138,-17,-7,-3,-1,168,76,-1,196,107,-5,-1,182,-1,
304 153,12,-1,60,195,-9,-3,-1,122,167,-1,166,-1,192,11,-1,194,-1,44,91,-55,-29,-15,-7,-3,-1,181,28,-1,137,152,-3,
305 -1,193,75,-1,180,106,-5,-3,-1,59,121,179,-3,-1,151,136,-1,43,90,-11,-5,-1,178,-1,165,27,-1,177,-1,176,105,-7,
306 -3,-1,150,74,-1,164,120,-3,-1,135,58,163,-17,-7,-3,-1,89,149,-1,42,162,-3,-1,26,161,-3,-1,10,160,104,-7,-3,
307 -1,134,73,-1,148,57,-5,-1,147,-1,119,9,-1,88,133,-53,-29,-13,-7,-3,-1,41,103,-1,118,146,-1,145,-1,25,144,-7,
308 -3,-1,72,132,-1,87,117,-3,-1,56,131,-1,102,71,-7,-3,-1,40,130,-1,24,129,-7,-3,-1,116,8,-1,128,86,-3,-1,101,
309 55,-1,115,70,-17,-7,-3,-1,39,114,-1,100,23,-3,-1,85,113,-3,-1,7,112,54,-7,-3,-1,99,69,-1,84,38,-3,-1,98,22,
310 -3,-1,6,96,53,-33,-19,-9,-5,-1,97,-1,83,68,-1,37,82,-3,-1,21,81,-3,-1,5,80,52,-7,-3,-1,67,36,-1,66,51,-1,
311 65,-1,20,4,-9,-3,-1,35,50,-3,-1,64,3,19,-3,-1,49,48,34,-9,-7,-3,-1,18,33,-1,2,32,17,-3,-1,1,16,0
312 };
313
314 constexpr int16 huffmanTab16[] =
315 {
316 -509,-503,-461,-323,-103,-37,-27,-15,-7,-3,-1,239,254,-1,223,253,-3,-1,207,252,-1,191,251,-5,-1,175,-1,250,159,
317 -3,-1,249,248,143,-7,-3,-1,127,247,-1,111,246,255,-9,-5,-3,-1,95,245,79,-1,244,243,-53,-1,240,-1,63,-29,-19,
318 -13,-7,-5,-1,206,-1,236,221,222,-1,233,-1,234,217,-1,238,-1,237,235,-3,-1,190,205,-3,-1,220,219,174,-11,-5,
319 -1,204,-1,173,218,-3,-1,126,172,202,-5,-3,-1,201,125,94,189,242,-93,-5,-3,-1,47,15,31,-1,241,-49,-25,-13,
320 -5,-1,158,-1,188,203,-3,-1,142,232,-1,157,231,-7,-3,-1,187,141,-1,216,110,-1,230,156,-13,-7,-3,-1,171,186,
321 -1,229,215,-1,78,-1,228,140,-3,-1,200,62,-1,109,-1,214,155,-19,-11,-5,-3,-1,185,170,225,-1,212,-1,184,169,
322 -5,-1,123,-1,183,208,227,-7,-3,-1,14,224,-1,93,213,-3,-1,124,199,-1,77,139,-75,-45,-27,-13,-7,-3,-1,154,
323 108,-1,198,61,-3,-1,92,197,13,-7,-3,-1,138,168,-1,153,76,-3,-1,182,122,60,-11,-5,-3,-1,91,137,28,-1,192,-1,
324 152,121,-1,226,-1,46,30,-15,-7,-3,-1,211,45,-1,210,209,-5,-1,59,-1,151,136,29,-7,-3,-1,196,107,-1,195,167,-1,
325 44,-1,194,181,-23,-13,-7,-3,-1,193,12,-1,75,180,-3,-1,106,166,179,-5,-3,-1,90,165,43,-1,178,27,-13,-5,-1,177,
326 -1,11,176,-3,-1,105,150,-1,74,164,-5,-3,-1,120,135,163,-3,-1,58,89,42,-97,-57,-33,-19,-11,-5,-3,-1,149,104,161,
327 -3,-1,134,119,148,-5,-3,-1,73,87,103,162,-5,-1,26,-1,10,160,-3,-1,57,147,-1,88,133,-9,-3,-1,41,146,-3,-1,118,
328 9,25,-5,-1,145,-1,144,72,-3,-1,132,117,-1,56,131,-21,-11,-5,-3,-1,102,40,130,-3,-1,71,116,24,-3,-1,129,128,-3,
329 -1,8,86,55,-9,-5,-1,115,-1,101,70,-1,39,114,-5,-3,-1,100,85,7,23,-23,-13,-5,-1,113,-1,112,54,-3,-1,99,69,-1,
330 84,38,-3,-1,98,22,-1,97,-1,6,96,-9,-5,-1,83,-1,53,68,-1,37,82,-1,81,-1,21,5,-33,-23,-13,-7,-3,-1,52,67,-1,80,
331 36,-3,-1,66,51,20,-5,-1,65,-1,4,64,-1,35,50,-3,-1,19,49,-3,-1,3,48,34,-3,-1,18,33,-1,2,32,-3,-1,17,1,16,0
332 };
333
334 constexpr int16 huffmanTab24[] =
335 {
336 -451,-117,-43,-25,-15,-7,-3,-1,239,254,-1,223,253,-3,-1,207,252,-1,191,251,-5,-1,250,-1,175,159,-1,249,248,-9,
337 -5,-3,-1,143,127,247,-1,111,246,-3,-1,95,245,-1,79,244,-71,-7,-3,-1,63,243,-1,47,242,-5,-1,241,-1,31,240,-25,-9,
338 -1,15,-3,-1,238,222,-1,237,206,-7,-3,-1,236,221,-1,190,235,-3,-1,205,220,-1,174,234,-15,-7,-3,-1,189,219,-1,204,
339 158,-3,-1,233,173,-1,218,188,-7,-3,-1,203,142,-1,232,157,-3,-1,217,126,-1,231,172,255,-235,-143,-77,-45,-25,-15,
340 -7,-3,-1,202,187,-1,141,216,-5,-3,-1,14,224,13,230,-5,-3,-1,110,156,201,-1,94,186,-9,-5,-1,229,-1,171,125,-1,215,
341 228,-3,-1,140,200,-3,-1,78,46,62,-15,-7,-3,-1,109,214,-1,227,155,-3,-1,185,170,-1,226,30,-7,-3,-1,225,93,-1,213,124,
342 -3,-1,199,77,-1,139,184,-31,-15,-7,-3,-1,212,154,-1,169,108,-3,-1,198,61,-1,211,45,-7,-3,-1,210,29,-1,123,183,-3,-1,
343 209,92,-1,197,138,-17,-7,-3,-1,168,153,-1,76,196,-3,-1,107,182,-3,-1,208,12,60,-7,-3,-1,195,122,-1,167,44,-3,-1,194,
344 91,-1,181,28,-57,-35,-19,-7,-3,-1,137,152,-1,193,75,-5,-3,-1,192,11,59,-3,-1,176,10,26,-5,-1,180,-1,106,166,-3,-1,121,
345 151,-3,-1,160,9,144,-9,-3,-1,179,136,-3,-1,43,90,178,-7,-3,-1,165,27,-1,177,105,-1,150,164,-17,-9,-5,-3,-1,74,120,135,
346 -1,58,163,-3,-1,89,149,-1,42,162,-7,-3,-1,161,104,-1,134,119,-3,-1,73,148,-1,57,147,-63,-31,-15,-7,-3,-1,88,133,-1,41,
347 103,-3,-1,118,146,-1,25,145,-7,-3,-1,72,132,-1,87,117,-3,-1,56,131,-1,102,40,-17,-7,-3,-1,130,24,-1,71,116,-5,-1,129,
348 -1,8,128,-1,86,101,-7,-5,-1,23,-1,7,112,115,-3,-1,55,39,114,-15,-7,-3,-1,70,100,-1,85,113,-3,-1,54,99,-1,69,84,-7,-3,
349 -1,38,98,-1,22,97,-5,-3,-1,6,96,53,-1,83,68,-51,-37,-23,-15,-9,-3,-1,37,82,-1,21,-1,5,80,-1,81,-1,52,67,-3,-1,36,66,
350 -1,51,20,-9,-5,-1,65,-1,4,64,-1,35,50,-1,19,49,-7,-5,-3,-1,3,48,34,18,-1,33,-1,2,32,-3,-1,17,1,-1,16,0
351 };
352
353 struct BitsToTableMap
354 {
355 uint32 bits;
356 const int16* table;
357 };
358
359 constexpr BitsToTableMap huffmanTables1[] =
360 {
361 { 0, huffmanTab0 }, { 0, huffmanTab1 }, { 0, huffmanTab2 }, { 0, huffmanTab3 },
362 { 0, huffmanTab0 }, { 0, huffmanTab5 }, { 0, huffmanTab6 }, { 0, huffmanTab7 },
363 { 0, huffmanTab8 }, { 0, huffmanTab9 }, { 0, huffmanTab10 }, { 0, huffmanTab11 },
364 { 0, huffmanTab12 }, { 0, huffmanTab13 }, { 0, huffmanTab0 }, { 0, huffmanTab15 },
365 { 1, huffmanTab16 }, { 2, huffmanTab16 }, { 3, huffmanTab16 }, { 4, huffmanTab16 },
366 { 6, huffmanTab16 }, { 8, huffmanTab16 }, { 10, huffmanTab16 }, { 13, huffmanTab16 },
367 { 4, huffmanTab24 }, { 5, huffmanTab24 }, { 6, huffmanTab24 }, { 7, huffmanTab24 },
368 { 8, huffmanTab24 }, { 9, huffmanTab24 }, { 11, huffmanTab24 }, { 13, huffmanTab24 }
369 };
370
371 constexpr int16 huffmanTabC0[] = { -29,-21,-13,-7,-3,-1,11,15,-1,13,14,-3,-1,7,5,9,-3,-1,6,3,-1,10,12,-3,-1,2,1,-1,4,8,0 };
372 constexpr int16 huffmanTabC1[] = { -15,-7,-3,-1,15,14,-1,13,12,-3,-1,11,10,-1,9,8,-7,-3,-1,7,6,-1,5,4,-3,-1,3,2,-1,1,0 };
373
374 constexpr BitsToTableMap huffmanTables2[] = { { 0, huffmanTabC0 }, { 0, huffmanTabC1 } };
375
376 //==============================================================================
377 struct VBRTagData
378 {
379 bool read (const uint8* data) noexcept
380 {
381 flags = 0;
382
383 const int layer = (data[1] >> 1) & 3;
384 if (layer != 1)
385 return false;
386
387 const int type = (data[1] >> 3) & 1;
388 const int sampleRateIndex = (data[2] >> 2) & 3;
389 const int mode = (data[3] >> 6) & 3;
390
391 static constexpr short bitRates[3][16] =
392 {
393 { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, -1 }, // MPEG2
394 { 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, -1 }, // MPEG1
395 { 0, 8, 16, 24, 32, 40, 48, 56, 64, -1, -1, -1, -1, -1, -1, -1 }, // MPEG 2.5
396 };
397
398 const int bitrate = bitRates[type][((data[2] >> 4) & 15)];
399
400 const int sampleRates[3][4] =
401 {
402 { 22050, 24000, 16000, -1 }, // MPEG2
403 { 44100, 48000, 32000, -1 }, // MPEG1
404 { 11025, 12000, 8000, -1 }, // MPEG2.5
405 };
406
407 if ((data[1] >> 4) == 0xe)
408 sampleRate = sampleRates[2][sampleRateIndex];
409 else
410 sampleRate = sampleRates[type][sampleRateIndex];
411
412 data += type != 0 ? (mode != 3 ? (32 + 4) : (17 + 4))
413 : (mode != 3 ? (17 + 4) : (9 + 4));
414
415 if (! isVbrTag (data))
416 return false;
417
418 data += 4;
419 flags = ByteOrder::bigEndianInt (data);
420 data += 4;
421
422 if (flags & 1)
423 {
424 frames = ByteOrder::bigEndianInt (data);
425 data += 4;
426 }
427
428 if (flags & 2)
429 {
430 bytes = ByteOrder::bigEndianInt (data);
431 data += 4;
432 }
433
434 if (flags & 4)
435 {
436 for (int i = 0; i < 100; ++i)
437 toc[i] = data[i];
438
439 data += 100;
440 }
441
442 vbrScale = -1;
443
444 if (flags & 8)
445 vbrScale = (int) ByteOrder::bigEndianInt (data);
446
447 headersize = ((type + 1) * 72000 * bitrate) / sampleRate;
448 return true;
449 }
450
451 uint8 toc[100];
452 int sampleRate, vbrScale, headersize;
453 unsigned int flags, frames, bytes;
454
455 private:
456 static bool isVbrTag (const uint8* d) noexcept
457 {
458 return (d[0] == 'X' && d[1] == 'i' && d[2] == 'n' && d[3] == 'g')
459 || (d[0] == 'I' && d[1] == 'n' && d[2] == 'f' && d[3] == 'o');
460 }
461 };
462
463 //==============================================================================
464 struct MP3Frame
465 {
466 MP3Frame()
467 {
468 zeromem (this, sizeof (MP3Frame));
469 single = -1;
470 }
471
472 void selectLayer2Table()
473 {
474 static constexpr int translate[3][2][16] =
475 {
476 { { 0, 2, 2, 2, 2, 2, 2, 0, 0, 0, 1, 1, 1, 1, 1, 0 }, { 0, 2, 2, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 } },
477 { { 0, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
478 { { 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 1, 1, 1, 1, 1, 0 }, { 0, 3, 3, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 } }
479 };
480
481 static const AllocationTable* const tables[] = { allocTable0, allocTable1, allocTable2, allocTable3, allocTable4 };
482 static constexpr int8 limits[] = { 27, 30, 8, 12, 30 };
483
484 const int index = lsf ? 4 : translate[sampleRateIndex][2 - numChannels][bitrateIndex];
485 layer2SubBandLimit = limits[index];
486 allocationTable = tables[index];
487 }
488
489 int getFrequency() const noexcept
490 {
491 const int frequencies[] = { 44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000 };
492 return frequencies[sampleRateIndex];
493 }
494
495 enum class ParseSuccessful { no, yes };
496
497 ParseSuccessful decodeHeader (const uint32 header)
498 {
499 jassert (((header >> 10) & 3) != 3);
500
501 mpeg25 = (header & (1 << 20)) == 0;
502 lsf = mpeg25 ? 1 : ((header & (1 << 19)) ? 0 : 1);
503 layer = (int) (4 - ((header >> 17) & 3));
504 sampleRateIndex = (int) ((header >> 10) & 3) + (mpeg25 ? 6 : (lsf * 3));
505 crc16FollowsHeader = ((header >> 16) & 1) == 0;
506 bitrateIndex = (header >> 12) & 15;
507 padding = (header >> 9) & 1;
508 mode = (header >> 6) & 3;
509 modeExt = (header >> 4) & 3;
510 //extension = (header >> 8) & 1;
511 //copyright = (header >> 3) & 1;
512 //original = (header >> 2) & 1;
513 //emphasis = header & 3;
514 numChannels = (mode == 3) ? 1 : 2;
515
516 static constexpr int frameSizes[2][3][16] =
517 {
518 { { 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448 },
519 { 0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384 },
520 { 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 } },
521
522 { { 0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256 },
523 { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 },
524 { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 } }
525 };
526
527 if (bitrateIndex == 0)
528 {
529 jassertfalse; // This means the file is using "free format". Apparently very few decoders
530 // support this mode, and this one certainly doesn't handle it correctly!
531 frameSize = 0;
532 return ParseSuccessful::no;
533 }
534
535 switch (layer)
536 {
537 case 1: frameSize = (((frameSizes[lsf][0][bitrateIndex] * 12000) / getFrequency() + padding) * 4) - 4; break;
538 case 2: frameSize = (frameSizes[lsf][1][bitrateIndex] * 144000) / getFrequency() + (padding - 4); break;
539 case 3: frameSize = (bitrateIndex == 0) ? 0 : ((frameSizes[lsf][2][bitrateIndex] * 144000) / (getFrequency() << lsf) + (padding - 4)); break;
540 default: break;
541 }
542
543 return ParseSuccessful::yes;
544 }
545
546 int layer, frameSize, numChannels, single;
547 int lsf; // 0 = mpeg-1, 1 = mpeg-2/LSF
548 bool mpeg25; // true = mpeg-2.5, false = mpeg-1/2
549 bool crc16FollowsHeader;
550 int bitrateIndex, sampleRateIndex, padding;
551 int mode, modeExt, layer2SubBandLimit;
552 enum { downSampleLimit = 32 };
553 const AllocationTable* allocationTable;
554 };
555
556 //==============================================================================
557 struct Constants
558 {
559 Constants()
560 {
561 cosTables[0] = cos64; cosTables[1] = cos32; cosTables[2] = cos16; cosTables[3] = cos8; cosTables[4] = cos4;
562 initDecodeTables();
563 initLayer2Tables();
564 initLayer3Tables();
565 }
566
567 const uint8* getGroupTable (const int16 d1, const uint32 index) const noexcept
568 {
569 switch (d1)
570 {
571 case 3: return &group3tab[3 * jmin (index, 3u * 3u * 3u)];
572 case 5: return &group5tab[3 * jmin (index, 5u * 5u * 5u)];
573 case 9: return &group9tab[3 * jmin (index, 9u * 9u * 9u)];
574 default: break;
575 }
576
577 static constexpr uint8 dummy[] = { 0, 0, 0 };
578 return dummy;
579 }
580
581 float muls[27][64];
582 float nToThe4Over3[8207];
583 float antiAliasingCa[8], antiAliasingCs[8];
584 float win[4][36];
585 float win1[4][36];
586 float powToGains[256 + 118 + 4];
587 int longLimit[9][23];
588 int shortLimit[9][14];
589 float tan1_1[16], tan2_1[16], tan1_2[16], tan2_2[16];
590 float pow1_1[2][16], pow2_1[2][16], pow1_2[2][16], pow2_2[2][16];
591 int* map[9][3];
592 int* mapEnd[9][3];
593 uint32 nLength2[512];
594 uint32 iLength2[256];
595 float decodeWin[512 + 32];
596 float* cosTables[5];
597
598 private:
599 int mapbuf0[9][152];
600 int mapbuf1[9][156];
601 int mapbuf2[9][44];
602 float cos64[16], cos32[8], cos16[4], cos8[2], cos4[1];
603 uint8 group3tab[32 * 3];
604 uint8 group5tab[128 * 3];
605 uint8 group9tab[1024 * 3];
606
607 void initDecodeTables()
608 {
609 int i, j, scaleval = -1;
610 float* table = decodeWin;
611
612 for (i = 0; i < 5; ++i)
613 {
614 int kr = 0x10 >> i;
615 int divv = 0x40 >> i;
616 float* costab = cosTables[i];
617
618 for (int k = 0; k < kr; ++k)
619 costab[k] = (float) (1.0 / (2.0 * std::cos (MathConstants<double>::pi * (k * 2 + 1) / divv)));
620 }
621
622 for (i = 0, j = 0; i < 256; ++i, ++j, table += 32)
623 {
624 if (table < decodeWin + 512 + 16)
625 table[16] = table[0] = (float) (decodeWindow[j] * scaleval);
626 if (i % 32 == 31)
627 table -= 1023;
628 if (i % 64 == 63)
629 scaleval = -scaleval;
630 }
631
632 for (; i < 512; ++i, --j, table += 32)
633 {
634 if (table < decodeWin + 512 + 16)
635 table[16] = table[0] = (float) (decodeWindow[j] * scaleval);
636
637 if (i % 32 == 31) table -= 1023;
638 if (i % 64 == 63) scaleval = -scaleval;
639 }
640 }
641
642 void initLayer2Tables()
643 {
644 static const uint8 base[3][9] =
645 {
646 { 1, 0, 2 },
647 { 17, 18, 0, 19, 20 },
648 { 21, 1, 22, 23, 0, 24, 25, 2, 26 }
649 };
650
651 static constexpr int tableLengths[] = { 3, 5, 9 };
652 static uint8* tables[] = { group3tab, group5tab, group9tab };
653
654 for (int i = 0; i < 3; ++i)
655 {
656 uint8* table = tables[i];
657 const int len = tableLengths[i];
658
659 for (int j = 0; j < len; ++j)
660 for (int k = 0; k < len; ++k)
661 for (int l = 0; l < len; ++l)
662 {
663 *table++ = base[i][l];
664 *table++ = base[i][k];
665 *table++ = base[i][j];
666 }
667 }
668
669 for (int k = 0; k < 27; ++k)
670 {
671 static constexpr double multipliers[] =
672 {
673 0, -2.0 / 3.0, 2.0 / 3.0, 2.0 / 7.0, 2.0 / 15.0, 2.0 / 31.0, 2.0 / 63.0, 2.0 / 127.0, 2.0 / 255.0,
674 2.0 / 511.0, 2.0 / 1023.0, 2.0 / 2047.0, 2.0 / 4095.0, 2.0 / 8191.0, 2.0 / 16383.0, 2.0 / 32767.0, 2.0 / 65535.0,
675 -4.0 / 5.0, -2.0 / 5.0, 2.0 / 5.0, 4.0 / 5.0, -8.0 / 9.0, -4.0 / 9.0, -2.0 / 9.0, 2.0 / 9.0, 4.0 / 9.0, 8.0 / 9.0
676 };
677
678 float* table = muls[k];
679 for (int j = 3, i = 0; i < 63; ++i, --j)
680 *table++ = (float) (multipliers[k] * std::pow (2.0, j / 3.0));
681 *table++ = 0;
682 }
683 }
684
685 void initLayer3Tables()
686 {
687 int i, j;
688 for (i = -256; i < 118 + 4; ++i)
689 powToGains[i + 256] = (float) std::pow (2.0, -0.25 * (i + 210));
690
691 for (i = 0; i < 8207; ++i)
692 nToThe4Over3[i] = (float) std::pow ((double) i, 4.0 / 3.0);
693
694 for (i = 0; i < 8; ++i)
695 {
696 static constexpr double Ci[] = { -0.6, -0.535, -0.33, -0.185, -0.095, -0.041, -0.0142, -0.0037 };
697 const double sq = sqrt (1.0 + Ci[i] * Ci[i]);
698 antiAliasingCs[i] = (float) (1.0 / sq);
699 antiAliasingCa[i] = (float) (Ci[i] / sq);
700 }
701
702 for (i = 0; i < 18; ++i)
703 {
704 win[0][i] = win[1][i] = (float) (0.5 * std::sin (MathConstants<double>::pi / 72.0 * (2 * i + 1)) / std::cos (MathConstants<double>::pi * (2 * i + 19) / 72.0));
705 win[0][i + 18] = win[3][i + 18] = (float) (0.5 * std::sin (MathConstants<double>::pi / 72.0 * (2 * (i + 18) + 1)) / std::cos (MathConstants<double>::pi * (2 * (i + 18) + 19) / 72.0));
706 }
707
708 const double piOver72 = MathConstants<double>::pi / 72.0;
709
710 for (i = 0; i < 6; ++i)
711 {
712 win[1][i + 18] = (float) (0.5 / std::cos (piOver72 * (2 * (i + 18) + 19)));
713 win[3][i + 12] = (float) (0.5 / std::cos (piOver72 * (2 * (i + 12) + 19)));
714 win[1][i + 24] = (float) (0.5 * std::sin (MathConstants<double>::pi / 24.0 * (2 * i + 13)) / std::cos (piOver72 * (2 * (i + 24) + 19)));
715 win[1][i + 30] = win[3][i] = 0;
716 win[3][i + 6] = (float) (0.5 * std::sin (MathConstants<double>::pi / 24.0 * (2 * i + 1)) / std::cos (piOver72 * (2 * (i + 6) + 19)));
717 }
718
719 for (i = 0; i < 12; ++i)
720 win[2][i] = (float) (0.5 * std::sin (MathConstants<double>::pi / 24.0 * (2 * i + 1)) / std::cos (MathConstants<double>::pi * (2 * i + 7) / 24.0));
721
722 for (j = 0; j < 4; ++j)
723 {
724 static constexpr int len[4] = { 36, 36, 12, 36 };
725 for (i = 0; i < len[j]; i += 2) win1[j][i] = win[j][i];
726 for (i = 1; i < len[j]; i += 2) win1[j][i] = -win[j][i];
727 }
728
729 const double sqrt2 = 1.41421356237309504880168872420969808;
730
731 for (i = 0; i < 16; ++i)
732 {
733 const double t = std::tan (i * MathConstants<double>::pi / 12.0);
734 tan1_1[i] = (float) (t / (1.0 + t));
735 tan2_1[i] = (float) (1.0 / (1.0 + t));
736 tan1_2[i] = (float) (sqrt2 * t / (1.0 + t));
737 tan2_2[i] = (float) (sqrt2 / (1.0 + t));
738
739 for (j = 0; j < 2; ++j)
740 {
741 double p1 = 1.0, p2 = 1.0;
742
743 if (i > 0)
744 {
745 const double base = std::pow (2.0, -0.25 * (j + 1));
746
747 if (i & 1)
748 p1 = std::pow (base, (i + 1) * 0.5);
749 else
750 p2 = std::pow (base, i * 0.5);
751 }
752
753 pow1_1[j][i] = (float) p1;
754 pow2_1[j][i] = (float) p2;
755 pow1_2[j][i] = (float) (sqrt2 * p1);
756 pow2_2[j][i] = (float) (sqrt2 * p2);
757 }
758 }
759
760 for (j = 0; j < 9; ++j)
761 {
762 const BandInfoStruct& bi = bandInfo[j];
763 int cb;
764 int* mp = map[j][0] = mapbuf0[j];
765 const int16* bdf = bi.longDiff;
766
767 for (i = 0, cb = 0; cb < 8; ++cb, i += *bdf++)
768 {
769 *mp++ = (*bdf) >> 1;
770 *mp++ = i;
771 *mp++ = 3;
772 *mp++ = cb;
773 }
774 bdf = bi.shortDiff + 3;
775
776 for (cb = 3; cb < 13; ++cb)
777 {
778 const int l = (*bdf++) >> 1;
779
780 for (int lwin = 0; lwin < 3; ++lwin)
781 {
782 *mp++ = l;
783 *mp++ = i + lwin;
784 *mp++ = lwin;
785 *mp++ = cb;
786 }
787 i += 6 * l;
788 }
789
790 mapEnd[j][0] = mp;
791 mp = map[j][1] = mapbuf1[j];
792 bdf = bi.shortDiff;
793
794 for (i = 0, cb = 0; cb < 13; ++cb)
795 {
796 const int l = (*bdf++) >> 1;
797 for (int lwin = 0; lwin < 3; ++lwin)
798 {
799 *mp++ = l;
800 *mp++ = i + lwin;
801 *mp++ = lwin;
802 *mp++ = cb;
803 }
804 i += 6 * l;
805 }
806 mapEnd[j][1] = mp;
807
808 mp = map[j][2] = mapbuf2[j];
809 bdf = bi.longDiff;
810 for (cb = 0; cb < 22; ++cb)
811 {
812 *mp++ = (*bdf++) >> 1;
813 *mp++ = cb;
814 }
815 mapEnd[j][2] = mp;
816
817 }
818
819 for (j = 0; j < 9; ++j)
820 {
821 for (i = 0; i < 23; ++i) longLimit[j][i] = jmin (32, (bandInfo[j].longIndex[i] - 1 + 8) / 18 + 1);
822 for (i = 0; i < 14; ++i) shortLimit[j][i] = jmin (32, (bandInfo[j].shortIndex[i] - 1) / 18 + 1);
823 }
824
825 for (i = 0; i < 5; ++i)
826 for (j = 0; j < 6; ++j)
827 for (int k = 0; k < 6; ++k)
828 {
829 const int n = k + j * 6 + i * 36;
830 iLength2[n] = (unsigned int) (i | (j << 3) | (k << 6) | (3 << 12));
831 }
832
833 for (i = 0; i < 4; ++i)
834 for (j = 0; j < 4; ++j)
835 for (int k = 0; k < 4; ++k)
836 {
837 const int n = k + j * 4 + i * 16;
838 iLength2[n + 180] = (unsigned int) (i | (j << 3) | (k << 6) | (4 << 12));
839 }
840
841 for (i = 0; i < 4; ++i)
842 for (j = 0; j < 3; ++j)
843 {
844 const int n = j + i * 3;
845 iLength2[n + 244] = (unsigned int) (i | (j << 3) | (5 << 12));
846 nLength2[n + 500] = (unsigned int) (i | (j << 3) | (2 << 12) | (1 << 15));
847 }
848
849 for (i = 0; i < 5; ++i)
850 for (j = 0; j < 5; ++j)
851 for (int k = 0; k < 4; ++k)
852 for (int l = 0; l < 4; ++l)
853 {
854 const int n = l + k * 4 + j * 16 + i * 80;
855 nLength2[n] = (unsigned int) (i | (j << 3) | (k << 6) | (l << 9) | (0 << 12));
856 }
857
858 for (i = 0; i < 5; ++i)
859 for (j = 0; j < 5; ++j)
860 for (int k = 0; k < 4; ++k)
861 {
862 const int n = k + j * 4 + i * 20;
863 nLength2[n + 400] = (unsigned int) (i | (j << 3) | (k << 6) | (1 << 12));
864 }
865 }
866 };
867
868 static const Constants constants;
869
870
871 //==============================================================================
872 struct Layer3SideInfo
873 {
874 struct Info
875 {
876 void doAntialias (float xr[32][18]) const noexcept
877 {
878 float* xr1 = xr[1];
879 int sb;
880
881 if (blockType == 2)
882 {
883 if (mixedBlockFlag == 0)
884 return;
885
886 sb = 1;
887 }
888 else
889 sb = (int) maxb - 1;
890
891 for (; sb != 0; --sb, xr1 += 10)
892 {
893 auto* cs = constants.antiAliasingCs;
894 auto* ca = constants.antiAliasingCa;
895 auto* xr2 = xr1;
896
897 for (int ss = 7; ss >= 0; --ss)
898 {
899 const float bu = *--xr2, bd = *xr1;
900 *xr2 = (bu * *cs) - (bd * *ca);
901 *xr1++ = (bd * *cs++) + (bu * *ca++);
902 }
903 }
904 }
905
906 void doIStereo (float xrBuffer[2][32][18], const int* scaleFactors,
907 int sampleRate, bool msStereo, int lsf) const noexcept
908 {
909 float (*xr) [32 * 18] = (float (*) [32 * 18]) xrBuffer;
910 auto& bi = bandInfo[sampleRate];
911 const float* tabl1, *tabl2;
912
913 if (lsf != 0)
914 {
915 auto p = scaleFactorCompression & 1;
916
917 if (msStereo)
918 {
919 tabl1 = constants.pow1_2[p];
920 tabl2 = constants.pow2_2[p];
921 }
922 else
923 {
924 tabl1 = constants.pow1_1[p];
925 tabl2 = constants.pow2_1[p];
926 }
927 }
928 else
929 {
930 if (msStereo)
931 {
932 tabl1 = constants.tan1_2;
933 tabl2 = constants.tan2_2;
934 }
935 else
936 {
937 tabl1 = constants.tan1_1;
938 tabl2 = constants.tan2_1;
939 }
940 }
941
942 if (blockType == 2)
943 {
944 bool doL = mixedBlockFlag != 0;
945
946 for (uint32 lwin = 0; lwin < 3; ++lwin)
947 {
948 uint32 sfb = maxBand[lwin];
949 doL = doL && (sfb <= 3);
950
951 for (; sfb < 12; ++sfb)
952 {
953 auto p = scaleFactors[sfb * 3 + lwin - mixedBlockFlag];
954
955 if (p != 7)
956 {
957 auto t1 = tabl1[p];
958 auto t2 = tabl2[p];
959 int sb = bi.shortDiff[sfb];
960 auto index = (uint32) sb + lwin;
961
962 for (; sb > 0; --sb, index += 3)
963 {
964 float v = xr[0][index];
965 xr[0][index] = v * t1;
966 xr[1][index] = v * t2;
967 }
968 }
969 }
970
971 auto p = scaleFactors[11 * 3 + lwin - mixedBlockFlag];
972
973 if (p != 7)
974 {
975 auto t1 = tabl1[p];
976 auto t2 = tabl2[p];
977 int sb = bi.shortDiff[12];
978 auto index = (uint32) sb + lwin;
979
980 for (; sb > 0; --sb, index += 3)
981 {
982 float v = xr[0][index];
983 xr[0][index] = v * t1;
984 xr[1][index] = v * t2;
985 }
986 }
987 }
988
989 if (doL)
990 {
991 int index = bi.longIndex[maxBandl];
992
993 for (uint32 sfb = maxBandl; sfb < 8; ++sfb)
994 {
995 int sb = bi.longDiff[sfb];
996 auto p = scaleFactors[sfb];
997
998 if (p != 7)
999 {
1000 auto t1 = tabl1[p];
1001 auto t2 = tabl2[p];
1002
1003 for (; sb > 0; --sb, ++index)
1004 {
1005 float v = xr[0][index];
1006 xr[0][index] = v * t1;
1007 xr[1][index] = v * t2;
1008 }
1009 }
1010 else
1011 index += sb;
1012 }
1013 }
1014 }
1015 else
1016 {
1017 int index = bi.longIndex[maxBandl];
1018
1019 for (uint32 sfb = maxBandl; sfb < 21; ++sfb)
1020 {
1021 int sb = bi.longDiff[sfb];
1022 auto p = scaleFactors[sfb];
1023
1024 if (p != 7)
1025 {
1026 auto t1 = tabl1[p];
1027 auto t2 = tabl2[p];
1028
1029 for (; sb > 0; --sb, ++index)
1030 {
1031 const float v = xr[0][index];
1032 xr[0][index] = v * t1;
1033 xr[1][index] = v * t2;
1034 }
1035 }
1036 else
1037 index += sb;
1038 }
1039
1040 auto p = scaleFactors[20];
1041
1042 if (p != 7)
1043 {
1044 auto t1 = tabl1[p], t2 = tabl2[p];
1045
1046 for (int sb = bi.longDiff[21]; sb > 0; --sb, ++index)
1047 {
1048 const float v = xr[0][index];
1049 xr[0][index] = v * t1;
1050 xr[1][index] = v * t2;
1051 }
1052 }
1053 }
1054 }
1055
1056 int scfsi;
1057 uint32 part2_3Length, bigValues;
1058 uint32 scaleFactorCompression, blockType, mixedBlockFlag;
1059 uint32 tableSelect[3];
1060 uint32 maxBand[3];
1061 uint32 maxBandl, maxb, region1Start, region2Start;
1062 uint32 preflag, scaleFactorScale, count1TableSelect;
1063 const float* fullGain[3];
1064 const float* pow2gain;
1065 };
1066
1067 struct InfoPair { Info gr[2]; };
1068 InfoPair ch[2];
1069
1070 uint32 mainDataStart, privateBits;
1071 };
1072
1073 //==============================================================================
1074 namespace DCT
1075 {
1076 enum { subBandLimit = 32 };
1077 static constexpr float cos6_1 = 0.866025388f;
1078 static constexpr float cos6_2 = 0.5f;
1079 static constexpr float cos9[] = { 1.0f, 0.98480773f, 0.939692616f, 0.866025388f, 0.766044438f, 0.642787635f, 0.5f, 0.342020154f, 0.173648179f };
1080 static constexpr float cos36[] = { 0.501909912f, 0.517638087f, 0.551688969f, 0.610387266f, 0.707106769f, 0.871723413f, 1.18310082f, 1.93185163f, 5.73685646f };
1081 static constexpr float cos12[] = { 0.517638087f, 0.707106769f, 1.93185163f };
1082
1083 inline void dct36_0 (int v, float* ts, float* out1, float* out2, const float* wintab, float sum0, float sum1) noexcept
1084 {
1085 auto tmp = sum0 + sum1;
1086 out2[9 + v] = tmp * wintab[27 + v];
1087 out2[8 - v] = tmp * wintab[26 - v];
1088 sum0 -= sum1;
1089 ts[subBandLimit * (8 - v)] = out1[8 - v] + sum0 * wintab[8 - v];
1090 ts[subBandLimit * (9 + v)] = out1[9 + v] + sum0 * wintab[9 + v];
1091 }
1092
1093 inline void dct36_12 (int v1, int v2, float* ts, float* out1, float* out2, const float* wintab,
1094 float tmp1a, float tmp1b, float tmp2a, float tmp2b) noexcept
1095 {
1096 dct36_0 (v1, ts, out1, out2, wintab, tmp1a + tmp2a, (tmp1b + tmp2b) * cos36[v1]);
1097 dct36_0 (v2, ts, out1, out2, wintab, tmp2a - tmp1a, (tmp2b - tmp1b) * cos36[v2]);
1098 }
1099
1100 static void dct36 (float* in, float* out1, float* out2, const float* wintab, float* ts) noexcept
1101 {
1102 in[17] += in[16]; in[16] += in[15]; in[15] += in[14]; in[14] += in[13]; in[13] += in[12];
1103 in[12] += in[11]; in[11] += in[10]; in[10] += in[9]; in[9] += in[8]; in[8] += in[7];
1104 in[7] += in[6]; in[6] += in[5]; in[5] += in[4]; in[4] += in[3]; in[3] += in[2];
1105 in[2] += in[1]; in[1] += in[0]; in[17] += in[15]; in[15] += in[13]; in[13] += in[11];
1106 in[11] += in[9]; in[9] += in[7]; in[7] += in[5]; in[5] += in[3]; in[3] += in[1];
1107
1108 auto ta33 = in[6] * cos9[3];
1109 auto ta66 = in[12] * cos9[6];
1110 auto tb33 = in[7] * cos9[3];
1111 auto tb66 = in[13] * cos9[6];
1112
1113 dct36_12 (0, 8, ts, out1, out2, wintab,
1114 in[2] * cos9[1] + ta33 + in[10] * cos9[5] + in[14] * cos9[7],
1115 in[3] * cos9[1] + tb33 + in[11] * cos9[5] + in[15] * cos9[7],
1116 in[0] + in[4] * cos9[2] + in[8] * cos9[4] + ta66 + in[16] * cos9[8],
1117 in[1] + in[5] * cos9[2] + in[9] * cos9[4] + tb66 + in[17] * cos9[8]);
1118
1119 dct36_12 (1, 7, ts, out1, out2, wintab,
1120 (in[2] - in[10] - in[14]) * cos9[3],
1121 (in[3] - in[11] - in[15]) * cos9[3],
1122 (in[4] - in[8] - in[16]) * cos9[6] - in[12] + in[0],
1123 (in[5] - in[9] - in[17]) * cos9[6] - in[13] + in[1]);
1124
1125 dct36_12 (2, 6, ts, out1, out2, wintab,
1126 in[2] * cos9[5] - ta33 - in[10] * cos9[7] + in[14] * cos9[1],
1127 in[3] * cos9[5] - tb33 - in[11] * cos9[7] + in[15] * cos9[1],
1128 in[0] - in[4] * cos9[8] - in[8] * cos9[2] + ta66 + in[16] * cos9[4],
1129 in[1] - in[5] * cos9[8] - in[9] * cos9[2] + tb66 + in[17] * cos9[4]);
1130
1131 dct36_12 (3, 5, ts, out1, out2, wintab,
1132 in[2] * cos9[7] - ta33 + in[10] * cos9[1] - in[14] * cos9[5],
1133 in[3] * cos9[7] - tb33 + in[11] * cos9[1] - in[15] * cos9[5],
1134 in[0] - in[4] * cos9[4] + in[8] * cos9[8] + ta66 - in[16] * cos9[2],
1135 in[1] - in[5] * cos9[4] + in[9] * cos9[8] + tb66 - in[17] * cos9[2]);
1136
1137 dct36_0 (4, ts, out1, out2, wintab,
1138 in[0] - in[4] + in[8] - in[12] + in[16],
1139 (in[1] - in[5] + in[9] - in[13] + in[17]) * cos36[4]);
1140 }
1141
1142 struct DCT12Inputs
1143 {
1144 float in0, in1, in2, in3, in4, in5;
1145
1146 inline DCT12Inputs (const float* in) noexcept
1147 {
1148 in5 = in[5 * 3] + (in4 = in[4 * 3]);
1149 in4 += (in3 = in[3 * 3]);
1150 in3 += (in2 = in[2 * 3]);
1151 in2 += (in1 = in[1 * 3]);
1152 in1 += (in0 = in[0 * 3]);
1153 in5 += in3; in3 += in1;
1154 in2 *= cos6_1;
1155 in3 *= cos6_1;
1156 }
1157
1158 inline void process() noexcept
1159 {
1160 in0 += in4 * cos6_2;
1161 in4 = in0 + in2; in0 -= in2;
1162 in1 += in5 * cos6_2;
1163 in5 = (in1 + in3) * cos12[0];
1164 in1 = (in1 - in3) * cos12[2];
1165 in3 = in4 + in5; in4 -= in5;
1166 in2 = in0 + in1; in0 -= in1;
1167 }
1168 };
1169
1170 static void dct12 (const float* in, float* out1, float* out2, const float* wi, float* ts) noexcept
1171 {
1172 {
1173 ts[0] = out1[0];
1174 ts[subBandLimit * 1] = out1[1];
1175 ts[subBandLimit * 2] = out1[2];
1176 ts[subBandLimit * 3] = out1[3];
1177 ts[subBandLimit * 4] = out1[4];
1178 ts[subBandLimit * 5] = out1[5];
1179
1180 DCT12Inputs inputs (in);
1181
1182 {
1183 auto tmp1 = (inputs.in0 - inputs.in4);
1184 auto tmp2 = (inputs.in1 - inputs.in5) * cos12[1];
1185 auto tmp0 = tmp1 + tmp2;
1186 tmp1 -= tmp2;
1187
1188 ts[16 * subBandLimit] = out1[16] + tmp0 * wi[10];
1189 ts[13 * subBandLimit] = out1[13] + tmp0 * wi[7];
1190 ts[7 * subBandLimit] = out1[7] + tmp1 * wi[1];
1191 ts[10 * subBandLimit] = out1[10] + tmp1 * wi[4];
1192 }
1193
1194 inputs.process();
1195
1196 ts[17 * subBandLimit] = out1[17] + inputs.in2 * wi[11];
1197 ts[12 * subBandLimit] = out1[12] + inputs.in2 * wi[6];
1198 ts[14 * subBandLimit] = out1[14] + inputs.in3 * wi[8];
1199 ts[15 * subBandLimit] = out1[15] + inputs.in3 * wi[9];
1200
1201 ts[6 * subBandLimit] = out1[6] + inputs.in0 * wi[0];
1202 ts[11 * subBandLimit] = out1[11] + inputs.in0 * wi[5];
1203 ts[8 * subBandLimit] = out1[8] + inputs.in4 * wi[2];
1204 ts[9 * subBandLimit] = out1[9] + inputs.in4 * wi[3];
1205 }
1206
1207 {
1208 DCT12Inputs inputs (++in);
1209 auto tmp1 = (inputs.in0 - inputs.in4);
1210 auto tmp2 = (inputs.in1 - inputs.in5) * cos12[1];
1211 auto tmp0 = tmp1 + tmp2;
1212 tmp1 -= tmp2;
1213 out2[4] = tmp0 * wi[10];
1214 out2[1] = tmp0 * wi[7];
1215 ts[13 * subBandLimit] += tmp1 * wi[1];
1216 ts[16 * subBandLimit] += tmp1 * wi[4];
1217
1218 inputs.process();
1219
1220 out2[5] = inputs.in2 * wi[11];
1221 out2[0] = inputs.in2 * wi[6];
1222 out2[2] = inputs.in3 * wi[8];
1223 out2[3] = inputs.in3 * wi[9];
1224 ts[12 * subBandLimit] += inputs.in0 * wi[0];
1225 ts[17 * subBandLimit] += inputs.in0 * wi[5];
1226 ts[14 * subBandLimit] += inputs.in4 * wi[2];
1227 ts[15 * subBandLimit] += inputs.in4 * wi[5 - 2];
1228 }
1229
1230 {
1231 DCT12Inputs inputs (++in);
1232 out2[12] = out2[13] = out2[14] = out2[15] = out2[16] = out2[17] = 0;
1233
1234 auto tmp1 = (inputs.in0 - inputs.in4);
1235 auto tmp2 = (inputs.in1 - inputs.in5) * cos12[1];
1236 auto tmp0 = tmp1 + tmp2;
1237 tmp1 -= tmp2;
1238
1239 out2[10] = tmp0 * wi[10];
1240 out2[7] = tmp0 * wi[7];
1241 out2[1] += tmp1 * wi[1];
1242 out2[4] += tmp1 * wi[4];
1243
1244 inputs.process();
1245
1246 out2[11] = inputs.in2 * wi[11];
1247 out2[6] = inputs.in2 * wi[6];
1248 out2[8] = inputs.in3 * wi[8];
1249 out2[9] = inputs.in3 * wi[9];
1250 out2[0] += inputs.in0 * wi[0];
1251 out2[5] += inputs.in0 * wi[5];
1252 out2[2] += inputs.in4 * wi[2];
1253 out2[3] += inputs.in4 * wi[3];
1254 }
1255 }
1256
1257 static void dct64 (float* out0, float* out1, const float* samples) noexcept
1258 {
1259 float b1[32], b2[32];
1260
1261 {
1262 auto* costab = constants.cosTables[0];
1263 b1[0x00] = samples[0x00] + samples[0x1F]; b1[0x1F] = (samples[0x00] - samples[0x1F]) * costab[0x0];
1264 b1[0x01] = samples[0x01] + samples[0x1E]; b1[0x1E] = (samples[0x01] - samples[0x1E]) * costab[0x1];
1265 b1[0x02] = samples[0x02] + samples[0x1D]; b1[0x1D] = (samples[0x02] - samples[0x1D]) * costab[0x2];
1266 b1[0x03] = samples[0x03] + samples[0x1C]; b1[0x1C] = (samples[0x03] - samples[0x1C]) * costab[0x3];
1267 b1[0x04] = samples[0x04] + samples[0x1B]; b1[0x1B] = (samples[0x04] - samples[0x1B]) * costab[0x4];
1268 b1[0x05] = samples[0x05] + samples[0x1A]; b1[0x1A] = (samples[0x05] - samples[0x1A]) * costab[0x5];
1269 b1[0x06] = samples[0x06] + samples[0x19]; b1[0x19] = (samples[0x06] - samples[0x19]) * costab[0x6];
1270 b1[0x07] = samples[0x07] + samples[0x18]; b1[0x18] = (samples[0x07] - samples[0x18]) * costab[0x7];
1271 b1[0x08] = samples[0x08] + samples[0x17]; b1[0x17] = (samples[0x08] - samples[0x17]) * costab[0x8];
1272 b1[0x09] = samples[0x09] + samples[0x16]; b1[0x16] = (samples[0x09] - samples[0x16]) * costab[0x9];
1273 b1[0x0A] = samples[0x0A] + samples[0x15]; b1[0x15] = (samples[0x0A] - samples[0x15]) * costab[0xA];
1274 b1[0x0B] = samples[0x0B] + samples[0x14]; b1[0x14] = (samples[0x0B] - samples[0x14]) * costab[0xB];
1275 b1[0x0C] = samples[0x0C] + samples[0x13]; b1[0x13] = (samples[0x0C] - samples[0x13]) * costab[0xC];
1276 b1[0x0D] = samples[0x0D] + samples[0x12]; b1[0x12] = (samples[0x0D] - samples[0x12]) * costab[0xD];
1277 b1[0x0E] = samples[0x0E] + samples[0x11]; b1[0x11] = (samples[0x0E] - samples[0x11]) * costab[0xE];
1278 b1[0x0F] = samples[0x0F] + samples[0x10]; b1[0x10] = (samples[0x0F] - samples[0x10]) * costab[0xF];
1279 }
1280
1281 {
1282 auto* costab = constants.cosTables[1];
1283 b2[0x00] = b1[0x00] + b1[0x0F]; b2[0x0F] = (b1[0x00] - b1[0x0F]) * costab[0];
1284 b2[0x01] = b1[0x01] + b1[0x0E]; b2[0x0E] = (b1[0x01] - b1[0x0E]) * costab[1];
1285 b2[0x02] = b1[0x02] + b1[0x0D]; b2[0x0D] = (b1[0x02] - b1[0x0D]) * costab[2];
1286 b2[0x03] = b1[0x03] + b1[0x0C]; b2[0x0C] = (b1[0x03] - b1[0x0C]) * costab[3];
1287 b2[0x04] = b1[0x04] + b1[0x0B]; b2[0x0B] = (b1[0x04] - b1[0x0B]) * costab[4];
1288 b2[0x05] = b1[0x05] + b1[0x0A]; b2[0x0A] = (b1[0x05] - b1[0x0A]) * costab[5];
1289 b2[0x06] = b1[0x06] + b1[0x09]; b2[0x09] = (b1[0x06] - b1[0x09]) * costab[6];
1290 b2[0x07] = b1[0x07] + b1[0x08]; b2[0x08] = (b1[0x07] - b1[0x08]) * costab[7];
1291 b2[0x10] = b1[0x10] + b1[0x1F]; b2[0x1F] = (b1[0x1F] - b1[0x10]) * costab[0];
1292 b2[0x11] = b1[0x11] + b1[0x1E]; b2[0x1E] = (b1[0x1E] - b1[0x11]) * costab[1];
1293 b2[0x12] = b1[0x12] + b1[0x1D]; b2[0x1D] = (b1[0x1D] - b1[0x12]) * costab[2];
1294 b2[0x13] = b1[0x13] + b1[0x1C]; b2[0x1C] = (b1[0x1C] - b1[0x13]) * costab[3];
1295 b2[0x14] = b1[0x14] + b1[0x1B]; b2[0x1B] = (b1[0x1B] - b1[0x14]) * costab[4];
1296 b2[0x15] = b1[0x15] + b1[0x1A]; b2[0x1A] = (b1[0x1A] - b1[0x15]) * costab[5];
1297 b2[0x16] = b1[0x16] + b1[0x19]; b2[0x19] = (b1[0x19] - b1[0x16]) * costab[6];
1298 b2[0x17] = b1[0x17] + b1[0x18]; b2[0x18] = (b1[0x18] - b1[0x17]) * costab[7];
1299 }
1300
1301 {
1302 auto* costab = constants.cosTables[2];
1303 b1[0x00] = b2[0x00] + b2[0x07]; b1[0x07] = (b2[0x00] - b2[0x07]) * costab[0];
1304 b1[0x01] = b2[0x01] + b2[0x06]; b1[0x06] = (b2[0x01] - b2[0x06]) * costab[1];
1305 b1[0x02] = b2[0x02] + b2[0x05]; b1[0x05] = (b2[0x02] - b2[0x05]) * costab[2];
1306 b1[0x03] = b2[0x03] + b2[0x04]; b1[0x04] = (b2[0x03] - b2[0x04]) * costab[3];
1307 b1[0x08] = b2[0x08] + b2[0x0F]; b1[0x0F] = (b2[0x0F] - b2[0x08]) * costab[0];
1308 b1[0x09] = b2[0x09] + b2[0x0E]; b1[0x0E] = (b2[0x0E] - b2[0x09]) * costab[1];
1309 b1[0x0A] = b2[0x0A] + b2[0x0D]; b1[0x0D] = (b2[0x0D] - b2[0x0A]) * costab[2];
1310 b1[0x0B] = b2[0x0B] + b2[0x0C]; b1[0x0C] = (b2[0x0C] - b2[0x0B]) * costab[3];
1311 b1[0x10] = b2[0x10] + b2[0x17]; b1[0x17] = (b2[0x10] - b2[0x17]) * costab[0];
1312 b1[0x11] = b2[0x11] + b2[0x16]; b1[0x16] = (b2[0x11] - b2[0x16]) * costab[1];
1313 b1[0x12] = b2[0x12] + b2[0x15]; b1[0x15] = (b2[0x12] - b2[0x15]) * costab[2];
1314 b1[0x13] = b2[0x13] + b2[0x14]; b1[0x14] = (b2[0x13] - b2[0x14]) * costab[3];
1315 b1[0x18] = b2[0x18] + b2[0x1F]; b1[0x1F] = (b2[0x1F] - b2[0x18]) * costab[0];
1316 b1[0x19] = b2[0x19] + b2[0x1E]; b1[0x1E] = (b2[0x1E] - b2[0x19]) * costab[1];
1317 b1[0x1A] = b2[0x1A] + b2[0x1D]; b1[0x1D] = (b2[0x1D] - b2[0x1A]) * costab[2];
1318 b1[0x1B] = b2[0x1B] + b2[0x1C]; b1[0x1C] = (b2[0x1C] - b2[0x1B]) * costab[3];
1319 }
1320
1321 {
1322 auto cos0 = constants.cosTables[3][0];
1323 auto cos1 = constants.cosTables[3][1];
1324 b2[0x00] = b1[0x00] + b1[0x03]; b2[0x03] = (b1[0x00] - b1[0x03]) * cos0;
1325 b2[0x01] = b1[0x01] + b1[0x02]; b2[0x02] = (b1[0x01] - b1[0x02]) * cos1;
1326 b2[0x04] = b1[0x04] + b1[0x07]; b2[0x07] = (b1[0x07] - b1[0x04]) * cos0;
1327 b2[0x05] = b1[0x05] + b1[0x06]; b2[0x06] = (b1[0x06] - b1[0x05]) * cos1;
1328 b2[0x08] = b1[0x08] + b1[0x0B]; b2[0x0B] = (b1[0x08] - b1[0x0B]) * cos0;
1329 b2[0x09] = b1[0x09] + b1[0x0A]; b2[0x0A] = (b1[0x09] - b1[0x0A]) * cos1;
1330 b2[0x0C] = b1[0x0C] + b1[0x0F]; b2[0x0F] = (b1[0x0F] - b1[0x0C]) * cos0;
1331 b2[0x0D] = b1[0x0D] + b1[0x0E]; b2[0x0E] = (b1[0x0E] - b1[0x0D]) * cos1;
1332 b2[0x10] = b1[0x10] + b1[0x13]; b2[0x13] = (b1[0x10] - b1[0x13]) * cos0;
1333 b2[0x11] = b1[0x11] + b1[0x12]; b2[0x12] = (b1[0x11] - b1[0x12]) * cos1;
1334 b2[0x14] = b1[0x14] + b1[0x17]; b2[0x17] = (b1[0x17] - b1[0x14]) * cos0;
1335 b2[0x15] = b1[0x15] + b1[0x16]; b2[0x16] = (b1[0x16] - b1[0x15]) * cos1;
1336 b2[0x18] = b1[0x18] + b1[0x1B]; b2[0x1B] = (b1[0x18] - b1[0x1B]) * cos0;
1337 b2[0x19] = b1[0x19] + b1[0x1A]; b2[0x1A] = (b1[0x19] - b1[0x1A]) * cos1;
1338 b2[0x1C] = b1[0x1C] + b1[0x1F]; b2[0x1F] = (b1[0x1F] - b1[0x1C]) * cos0;
1339 b2[0x1D] = b1[0x1D] + b1[0x1E]; b2[0x1E] = (b1[0x1E] - b1[0x1D]) * cos1;
1340 }
1341
1342 {
1343 auto cos0 = constants.cosTables[4][0];
1344 b1[0x00] = b2[0x00] + b2[0x01]; b1[0x01] = (b2[0x00] - b2[0x01]) * cos0;
1345 b1[0x02] = b2[0x02] + b2[0x03]; b1[0x03] = (b2[0x03] - b2[0x02]) * cos0; b1[0x02] += b1[0x03];
1346 b1[0x04] = b2[0x04] + b2[0x05]; b1[0x05] = (b2[0x04] - b2[0x05]) * cos0;
1347 b1[0x06] = b2[0x06] + b2[0x07]; b1[0x07] = (b2[0x07] - b2[0x06]) * cos0;
1348 b1[0x06] += b1[0x07]; b1[0x04] += b1[0x06]; b1[0x06] += b1[0x05]; b1[0x05] += b1[0x07];
1349 b1[0x08] = b2[0x08] + b2[0x09]; b1[0x09] = (b2[0x08] - b2[0x09]) * cos0;
1350 b1[0x0A] = b2[0x0A] + b2[0x0B]; b1[0x0B] = (b2[0x0B] - b2[0x0A]) * cos0; b1[0x0A] += b1[0x0B];
1351 b1[0x0C] = b2[0x0C] + b2[0x0D]; b1[0x0D] = (b2[0x0C] - b2[0x0D]) * cos0;
1352 b1[0x0E] = b2[0x0E] + b2[0x0F]; b1[0x0F] = (b2[0x0F] - b2[0x0E]) * cos0;
1353 b1[0x0E] += b1[0x0F]; b1[0x0C] += b1[0x0E]; b1[0x0E] += b1[0x0D]; b1[0x0D] += b1[0x0F];
1354 b1[0x10] = b2[0x10] + b2[0x11]; b1[0x11] = (b2[0x10] - b2[0x11]) * cos0;
1355 b1[0x12] = b2[0x12] + b2[0x13]; b1[0x13] = (b2[0x13] - b2[0x12]) * cos0; b1[0x12] += b1[0x13];
1356 b1[0x14] = b2[0x14] + b2[0x15]; b1[0x15] = (b2[0x14] - b2[0x15]) * cos0;
1357 b1[0x16] = b2[0x16] + b2[0x17]; b1[0x17] = (b2[0x17] - b2[0x16]) * cos0;
1358 b1[0x16] += b1[0x17]; b1[0x14] += b1[0x16]; b1[0x16] += b1[0x15]; b1[0x15] += b1[0x17];
1359 b1[0x18] = b2[0x18] + b2[0x19]; b1[0x19] = (b2[0x18] - b2[0x19]) * cos0;
1360 b1[0x1A] = b2[0x1A] + b2[0x1B]; b1[0x1B] = (b2[0x1B] - b2[0x1A]) * cos0; b1[0x1A] += b1[0x1B];
1361 b1[0x1C] = b2[0x1C] + b2[0x1D]; b1[0x1D] = (b2[0x1C] - b2[0x1D]) * cos0;
1362 b1[0x1E] = b2[0x1E] + b2[0x1F]; b1[0x1F] = (b2[0x1F] - b2[0x1E]) * cos0;
1363 b1[0x1E] += b1[0x1F]; b1[0x1C] += b1[0x1E]; b1[0x1E] += b1[0x1D]; b1[0x1D] += b1[0x1F];
1364 }
1365
1366 out0[0x10 * 16] = b1[0x00]; out0[0x10 * 12] = b1[0x04]; out0[0x10 * 8] = b1[0x02]; out0[0x10 * 4] = b1[0x06];
1367 out0[0] = b1[0x01]; out1[0] = b1[0x01]; out1[0x10 * 4] = b1[0x05]; out1[0x10 * 8] = b1[0x03];
1368 out1[0x10 * 12] = b1[0x07];
1369
1370 b1[0x08] += b1[0x0C]; out0[0x10 * 14] = b1[0x08]; b1[0x0C] += b1[0x0a]; out0[0x10 * 10] = b1[0x0C];
1371 b1[0x0A] += b1[0x0E]; out0[0x10 * 6] = b1[0x0A]; b1[0x0E] += b1[0x09]; out0[0x10 * 2] = b1[0x0E];
1372 b1[0x09] += b1[0x0D]; out1[0x10 * 2] = b1[0x09]; b1[0x0D] += b1[0x0B]; out1[0x10 * 6] = b1[0x0D];
1373 b1[0x0B] += b1[0x0F]; out1[0x10 * 10] = b1[0x0B]; out1[0x10 * 14] = b1[0x0F];
1374
1375 b1[0x18] += b1[0x1C]; out0[0x10 * 15] = b1[0x10] + b1[0x18]; out0[0x10 * 13] = b1[0x18] + b1[0x14];
1376 b1[0x1C] += b1[0x1a]; out0[0x10 * 11] = b1[0x14] + b1[0x1C]; out0[0x10 * 9] = b1[0x1C] + b1[0x12];
1377 b1[0x1A] += b1[0x1E]; out0[0x10 * 7] = b1[0x12] + b1[0x1A]; out0[0x10 * 5] = b1[0x1A] + b1[0x16];
1378 b1[0x1E] += b1[0x19]; out0[0x10 * 3] = b1[0x16] + b1[0x1E]; out0[0x10 * 1] = b1[0x1E] + b1[0x11];
1379 b1[0x19] += b1[0x1D]; out1[0x10 * 1] = b1[0x11] + b1[0x19]; out1[0x10 * 3] = b1[0x19] + b1[0x15];
1380 b1[0x1D] += b1[0x1B]; out1[0x10 * 5] = b1[0x15] + b1[0x1D]; out1[0x10 * 7] = b1[0x1D] + b1[0x13];
1381 b1[0x1B] += b1[0x1F]; out1[0x10 * 9] = b1[0x13] + b1[0x1B]; out1[0x10 * 11] = b1[0x1B] + b1[0x17];
1382 out1[0x10 * 13] = b1[0x17] + b1[0x1F]; out1[0x10 * 15] = b1[0x1F];
1383 }
1384 }
1385
1386 //==============================================================================
1387 struct MP3Stream
1388 {
1389 MP3Stream (InputStream& source) : stream (source, 8192)
1390 {
1391 reset();
1392 }
1393
1394 int decodeNextBlock (float* out0, float* out1, int& done)
1395 {
1396 if (! headerParsed)
1397 {
1398 auto nextFrameOffset = scanForNextFrameHeader (false);
1399
1400 if (lastFrameSize == -1 || needToSyncBitStream)
1401 {
1402 needToSyncBitStream = false;
1403 readVBRHeader();
1404
1405 if (vbrHeaderFound)
1406 return 1;
1407 }
1408
1409 if (nextFrameOffset < 0)
1410 return -1;
1411
1412 if (nextFrameOffset > 0)
1413 {
1414 wasFreeFormat = false;
1415 needToSyncBitStream = true;
1416 auto size = (int) (bufferPointer - (bufferSpace[bufferSpaceIndex] + 512));
1417
1418 if (size > 2880)
1419 {
1420 size = 0;
1421 bufferPointer = bufferSpace[bufferSpaceIndex] + 512;
1422 }
1423
1424 auto toSkip = (size + nextFrameOffset) - 2880;
1425
1426 if (toSkip > 0)
1427 {
1428 stream.skipNextBytes (toSkip);
1429 nextFrameOffset -= toSkip;
1430 }
1431
1432 stream.read (bufferPointer, nextFrameOffset);
1433 lastFrameSize += nextFrameOffset;
1434 }
1435
1436 const auto successful = frame.decodeHeader ((uint32) stream.readIntBigEndian());
1437
1438 if (successful == MP3Frame::ParseSuccessful::no)
1439 return -1;
1440
1441 headerParsed = true;
1442 frameSize = frame.frameSize;
1443 isFreeFormat = (frameSize == 0);
1444 sideInfoSize = frame.lsf != 0 ? ((frame.numChannels == 1) ? 9 : 17)
1445 : ((frame.numChannels == 1) ? 17 : 32);
1446
1447 if (frame.crc16FollowsHeader)
1448 sideInfoSize += 2;
1449
1450 bufferSpaceIndex = 1 - bufferSpaceIndex;
1451 bufferPointer = bufferSpace[bufferSpaceIndex] + 512;
1452 bitIndex = 0;
1453
1454 if (lastFrameSize < 0)
1455 return 1;
1456 }
1457
1458 if (! sideParsed)
1459 {
1460 if (frame.layer == 3)
1461 {
1462 stream.read (bufferPointer, sideInfoSize);
1463
1464 if (frame.crc16FollowsHeader)
1465 getBits (16);
1466
1467 auto bits = jmax (0, decodeLayer3SideInfo());
1468 dataSize = (bits + 7) / 8;
1469
1470 if (! isFreeFormat)
1471 dataSize = jmin (dataSize, frame.frameSize - sideInfoSize);
1472 }
1473 else
1474 {
1475 dataSize = frame.frameSize;
1476 sideInfoSize = 0;
1477 }
1478
1479 sideParsed = true;
1480 }
1481
1482 int result = 1;
1483
1484 if (! dataParsed)
1485 {
1486 stream.read (bufferPointer, dataSize);
1487
1488 if (out0 != nullptr)
1489 {
1490 if (frame.layer < 3 && frame.crc16FollowsHeader)
1491 getBits (16);
1492
1493 switch (frame.layer)
1494 {
1495 case 1: decodeLayer1Frame (out0, out1, done); break;
1496 case 2: decodeLayer2Frame (out0, out1, done); break;
1497 case 3: decodeLayer3Frame (out0, out1, done); break;
1498 default: break;
1499 }
1500 }
1501
1502 bufferPointer = bufferSpace[bufferSpaceIndex] + 512 + sideInfoSize + dataSize;
1503 dataParsed = true;
1504 result = 0;
1505 }
1506
1507 if (isFreeFormat)
1508 {
1509 if (wasFreeFormat)
1510 {
1511 frameSize = lastFrameSizeNoPadding + frame.padding;
1512 }
1513 else
1514 {
1515 auto nextFrameOffset = scanForNextFrameHeader (true);
1516
1517 wasFreeFormat = isFreeFormat;
1518
1519 if (nextFrameOffset < 0)
1520 {
1521 lastFrameSize = frameSize;
1522 return result;
1523 }
1524
1525 frameSize = nextFrameOffset + sideInfoSize + dataSize;
1526 lastFrameSizeNoPadding = frameSize - frame.padding;
1527 }
1528 }
1529
1530 if (result == 0)
1531 return result;
1532
1533 int bytes = frameSize - (sideInfoSize + dataSize);
1534
1535 if (bytes > 0)
1536 {
1537 auto toSkip = bytes - 512;
1538
1539 if (toSkip > 0)
1540 {
1541 stream.skipNextBytes (toSkip);
1542 bytes -= toSkip;
1543 frameSize -= toSkip;
1544 }
1545
1546 stream.read (bufferPointer, bytes);
1547 bufferPointer += bytes;
1548 }
1549
1550 lastFrameSize = frameSize;
1551 wasFreeFormat = isFreeFormat;
1552 frameSize = 0;
1553 headerParsed = sideParsed = dataParsed = false;
1554 return result;
1555 }
1556
1557 bool seek (int frameIndex)
1558 {
1559 frameIndex = jmax (0, frameIndex);
1560
1561 while (frameIndex >= frameStreamPositions.size() * storedStartPosInterval)
1562 {
1563 int dummy = 0;
1564 auto result = decodeNextBlock (nullptr, nullptr, dummy);
1565
1566 if (result < 0)
1567 return false;
1568
1569 if (result > 0)
1570 break;
1571 }
1572
1573 frameIndex = jmin (frameIndex & ~(storedStartPosInterval - 1),
1574 (frameStreamPositions.size() - 1) * storedStartPosInterval);
1575
1576 stream.setPosition (frameStreamPositions.getUnchecked (frameIndex / storedStartPosInterval));
1577 currentFrameIndex = frameIndex;
1578 reset();
1579 return true;
1580 }
1581
1582 MP3Frame frame;
1583 VBRTagData vbrTagData;
1584 BufferedInputStream stream;
1585 int numFrames = 0, currentFrameIndex = 0;
1586 bool vbrHeaderFound = false;
1587
1588 private:
1589 bool headerParsed, sideParsed, dataParsed, needToSyncBitStream;
1590 bool isFreeFormat, wasFreeFormat;
1591 int sideInfoSize, dataSize;
1592 int frameSize, lastFrameSize, lastFrameSizeNoPadding;
1593 int bufferSpaceIndex;
1594 Layer3SideInfo sideinfo;
1595 uint8 bufferSpace[2][2880 + 1024];
1596 uint8* bufferPointer;
1597 int bitIndex, synthBo;
1598 float hybridBlock[2][2][32 * 18];
1599 int hybridBlockIndex[2];
1600 float synthBuffers[2][2][0x110];
1601 float hybridIn[2][32][18];
1602 float hybridOut[2][18][32];
1603
1604 void reset() noexcept
1605 {
1606 headerParsed = sideParsed = dataParsed = isFreeFormat = wasFreeFormat = false;
1607 lastFrameSize = -1;
1608 needToSyncBitStream = true;
1609 frameSize = sideInfoSize = dataSize = bitIndex = 0;
1610 lastFrameSizeNoPadding = bufferSpaceIndex = 0;
1611 bufferPointer = bufferSpace[bufferSpaceIndex] + 512;
1612 synthBo = 1;
1613
1614 zerostruct (sideinfo);
1615 zeromem (bufferSpace, sizeof (bufferSpace));
1616 zeromem (hybridBlock, sizeof (hybridBlock));
1617 zeromem (hybridBlockIndex, sizeof (hybridBlockIndex));
1618 zeromem (synthBuffers, sizeof (synthBuffers));
1619 }
1620
1621 enum { storedStartPosInterval = 4 };
1622 Array<int64> frameStreamPositions;
1623
1624 struct SideInfoLayer1
1625 {
1626 uint8 allocation[32][2];
1627 uint8 scaleFactor[32][2];
1628 };
1629
1630 struct SideInfoLayer2
1631 {
1632 uint8 allocation[32][2];
1633 uint8 scaleFactor[32][2][3];
1634 };
1635
1636 static bool isValidHeader (uint32 header, int oldLayer) noexcept
1637 {
1638 auto newLayer = (int) (4 - ((header >> 17) & 3));
1639
1640 return (header & 0xffe00000) == 0xffe00000
1641 && newLayer != 4
1642 && (oldLayer <= 0 || newLayer == oldLayer)
1643 && ((header >> 12) & 15) != 15
1644 && ((header >> 10) & 3) != 3
1645 && (header & 3) != 2;
1646 }
1647
1648 bool rollBackBufferPointer (int backstep) noexcept
1649 {
1650 if (lastFrameSize < 0 && backstep > 0)
1651 return false;
1652
1653 auto* oldBuffer = bufferSpace[1 - bufferSpaceIndex] + 512;
1654 bufferPointer -= backstep;
1655
1656 if (backstep != 0)
1657 memcpy (bufferPointer, oldBuffer + lastFrameSize - backstep, (size_t) backstep);
1658
1659 bitIndex = 0;
1660 return true;
1661 }
1662
1663 uint32 getBits (int numBits) noexcept
1664 {
1665 if (numBits <= 0 || bufferPointer == nullptr)
1666 return 0;
1667
1668 const auto result = (uint32) (((((((bufferPointer[0] << 8) | bufferPointer[1]) << 8)
1669 | bufferPointer[2]) << bitIndex) & 0xffffff) >> (24 - numBits));
1670 bitIndex += numBits;
1671 bufferPointer += (bitIndex >> 3);
1672 bitIndex &= 7;
1673 return result;
1674 }
1675
1676 uint32 getOneBit() noexcept
1677 {
1678 auto result = (uint8) (*bufferPointer << bitIndex);
1679 ++bitIndex;
1680 bufferPointer += (bitIndex >> 3);
1681 bitIndex &= 7;
1682 return (uint32) (result >> 7);
1683 }
1684
1685 uint32 getBitsUnchecked (int numBits) noexcept
1686 {
1687 const auto result = (uint32) (((((bufferPointer[0] << 8) | bufferPointer[1]) << bitIndex) & 0xffff) >> (16 - numBits));
1688 bitIndex += numBits;
1689 bufferPointer += (bitIndex >> 3);
1690 bitIndex &= 7;
1691 return result;
1692 }
1693
1694 inline uint8 getBitsUint8 (int numBits) noexcept { return (uint8) getBitsUnchecked (numBits); }
1695 inline uint16 getBitsUint16 (int numBits) noexcept { return (uint16) getBitsUnchecked (numBits); }
1696
1697 int scanForNextFrameHeader (bool checkTypeAgainstLastFrame) noexcept
1698 {
1699 auto oldPos = stream.getPosition();
1700 int offset = -3;
1701 uint32 header = 0;
1702
1703 for (;;)
1704 {
1705 if (stream.isExhausted() || stream.getPosition() > oldPos + 32768)
1706 {
1707 offset = -1;
1708 break;
1709 }
1710
1711 header = (header << 8) | (uint8) stream.readByte();
1712
1713 if (offset >= 0 && isValidHeader (header, frame.layer))
1714 {
1715 if (! checkTypeAgainstLastFrame)
1716 break;
1717
1718 const bool mpeg25 = (header & (1 << 20)) == 0;
1719 const uint32 lsf = mpeg25 ? 1 : ((header & (1 << 19)) ? 0 : 1);
1720 const uint32 sampleRateIndex = mpeg25 ? (6 + ((header >> 10) & 3)) : (((header >> 10) & 3) + (lsf * 3));
1721 const uint32 mode = (header >> 6) & 3;
1722 const uint32 numChannels = (mode == 3) ? 1 : 2;
1723
1724 if (numChannels == (uint32) frame.numChannels && lsf == (uint32) frame.lsf
1725 && mpeg25 == frame.mpeg25 && sampleRateIndex == (uint32) frame.sampleRateIndex)
1726 break;
1727 }
1728
1729 ++offset;
1730 }
1731
1732 if (offset >= 0)
1733 {
1734 if ((currentFrameIndex & (storedStartPosInterval - 1)) == 0)
1735 frameStreamPositions.set (currentFrameIndex / storedStartPosInterval, oldPos + offset);
1736
1737 ++currentFrameIndex;
1738 }
1739
1740 stream.setPosition (oldPos);
1741 return offset;
1742 }
1743
1744 void readVBRHeader()
1745 {
1746 auto oldPos = stream.getPosition();
1747 uint8 xing[194];
1748 stream.read (xing, sizeof (xing));
1749
1750 vbrHeaderFound = vbrTagData.read (xing);
1751
1752 if (vbrHeaderFound)
1753 {
1754 numFrames = (int) vbrTagData.frames;
1755 oldPos += jmax (vbrTagData.headersize, 1);
1756 }
1757
1758 stream.setPosition (oldPos);
1759 }
1760
1761 void decodeLayer1Frame (float* pcm0, float* pcm1, int& samplesDone) noexcept
1762 {
1763 float fraction[2][32];
1764 SideInfoLayer1 si;
1765 layer1Step1 (si);
1766 auto single = (frame.numChannels == 1 || frame.single == 3) ? 0 : frame.single;
1767
1768 if (single >= 0)
1769 {
1770 for (int i = 0; i < 12; ++i)
1771 {
1772 layer1Step2 (si, fraction);
1773 synthesise (fraction[single], 0, pcm0, samplesDone);
1774 }
1775 }
1776 else
1777 {
1778 for (int i = 0; i < 12; ++i)
1779 {
1780 layer1Step2 (si, fraction);
1781 synthesiseStereo (fraction[0], fraction[1], pcm0, pcm1, samplesDone);
1782 }
1783 }
1784 }
1785
1786 void decodeLayer2Frame (float* pcm0, float* pcm1, int& samplesDone)
1787 {
1788 float fraction[2][4][32];
1789 frame.selectLayer2Table();
1790 SideInfoLayer2 si;
1791 layer2Step1 (si);
1792 auto single = (frame.numChannels == 1 || frame.single == 3) ? 0 : frame.single;
1793
1794 if (single >= 0)
1795 {
1796 for (int i = 0; i < 12; ++i)
1797 {
1798 layer2Step2 (si, i >> 2, fraction);
1799
1800 for (int j = 0; j < 3; ++j)
1801 synthesise (fraction[single][j], 0, pcm0, samplesDone);
1802 }
1803 }
1804 else
1805 {
1806 for (int i = 0; i < 12; ++i)
1807 {
1808 layer2Step2 (si, i >> 2, fraction);
1809
1810 for (int j = 0; j < 3; ++j)
1811 synthesiseStereo (fraction[0][j], fraction[1][j], pcm0, pcm1, samplesDone);
1812 }
1813 }
1814 }
1815
1816 void decodeLayer3Frame (float* pcm0, float* pcm1, int& samplesDone) noexcept
1817 {
1818 if (! rollBackBufferPointer ((int) sideinfo.mainDataStart))
1819 return;
1820
1821 const int single = frame.numChannels == 1 ? 0 : frame.single;
1822 const int numChans = (frame.numChannels == 1 || single >= 0) ? 1 : 2;
1823 const bool msStereo = (frame.mode == 1) && (frame.modeExt & 2) != 0;
1824 const bool iStereo = (frame.mode == 1) && (frame.modeExt & 1) != 0;
1825 const int granules = frame.lsf ? 1 : 2;
1826 int scaleFactors[2][39];
1827
1828 for (int gr = 0; gr < granules; ++gr)
1829 {
1830 {
1831 auto& granule = sideinfo.ch[0].gr[gr];
1832 auto part2bits = frame.lsf ? getLayer3ScaleFactors2 (scaleFactors[0], granule, 0)
1833 : getLayer3ScaleFactors1 (scaleFactors[0], granule);
1834
1835 if (layer3DequantizeSample (hybridIn[0], scaleFactors[0], granule, frame.sampleRateIndex, part2bits))
1836 return;
1837 }
1838
1839 if (frame.numChannels == 2)
1840 {
1841 auto& granule = sideinfo.ch[1].gr[gr];
1842 auto part2bits = frame.lsf ? getLayer3ScaleFactors2 (scaleFactors[1], granule, iStereo)
1843 : getLayer3ScaleFactors1 (scaleFactors[1], granule);
1844
1845 if (layer3DequantizeSample (hybridIn[1], scaleFactors[1], granule, frame.sampleRateIndex, part2bits))
1846 return;
1847
1848 if (msStereo)
1849 {
1850 for (int i = 0; i < 32 * 18; ++i)
1851 {
1852 auto tmp0 = ((const float*) hybridIn[0])[i];
1853 auto tmp1 = ((const float*) hybridIn[1])[i];
1854 ((float*) hybridIn[1])[i] = tmp0 - tmp1;
1855 ((float*) hybridIn[0])[i] = tmp0 + tmp1;
1856 }
1857 }
1858
1859 if (iStereo)
1860 granule.doIStereo (hybridIn, scaleFactors[1], frame.sampleRateIndex, msStereo, frame.lsf);
1861
1862 if (msStereo || iStereo || single == 3)
1863 {
1864 if (granule.maxb > sideinfo.ch[0].gr[gr].maxb)
1865 sideinfo.ch[0].gr[gr].maxb = granule.maxb;
1866 else
1867 granule.maxb = sideinfo.ch[0].gr[gr].maxb;
1868 }
1869
1870 switch (single)
1871 {
1872 case 3:
1873 {
1874 auto* in0 = (float*) hybridIn[0];
1875 auto* in1 = (const float*) hybridIn[1];
1876
1877 for (int i = 0; i < (int) (18 * granule.maxb); ++i, ++in0)
1878 *in0 = (*in0 + *in1++);
1879 }
1880 break;
1881
1882 case 1:
1883 {
1884 auto* in0 = (float*) hybridIn[0];
1885 auto* in1 = (const float*) hybridIn[1];
1886
1887 for (int i = 0; i < (int) (18 * granule.maxb); ++i)
1888 *in0++ = *in1++;
1889 }
1890 break;
1891
1892 default:
1893 break;
1894 }
1895 }
1896
1897 for (int ch = 0; ch < numChans; ++ch)
1898 {
1899 auto& granule = sideinfo.ch[ch].gr[gr];
1900 granule.doAntialias (hybridIn[ch]);
1901 layer3Hybrid (hybridIn[ch], hybridOut[ch], ch, granule);
1902 }
1903
1904 for (int ss = 0; ss < 18; ++ss)
1905 {
1906 if (single >= 0)
1907 synthesise (hybridOut[0][ss], 0, pcm0, samplesDone);
1908 else
1909 synthesiseStereo (hybridOut[0][ss], hybridOut[1][ss], pcm0, pcm1, samplesDone);
1910 }
1911 }
1912 }
1913
1914 int decodeLayer3SideInfo() noexcept
1915 {
1916 const int numChannels = frame.numChannels;
1917 const int sampleRate = frame.sampleRateIndex;
1918 const int single = (numChannels == 1) ? 0 : frame.single;
1919 const bool msStereo = (frame.mode == 1) && (frame.modeExt & 2) != 0;
1920 const int granules = frame.lsf ? 1 : 2;
1921
1922 if (frame.lsf == 0)
1923 getLayer3SideInfo1 (numChannels, msStereo, sampleRate, single);
1924 else
1925 getLayer3SideInfo2 (numChannels, msStereo, sampleRate, single);
1926
1927 int databits = 0;
1928
1929 for (int gr = 0; gr < granules; ++gr)
1930 for (int ch = 0; ch < numChannels; ++ch)
1931 databits += (int) sideinfo.ch[ch].gr[gr].part2_3Length;
1932
1933 return databits - 8 * (int) sideinfo.mainDataStart;
1934 }
1935
1936 void layer1Step1 (SideInfoLayer1& si) noexcept
1937 {
1938 zerostruct (si);
1939 int i, jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : 32;
1940
1941 if (frame.numChannels == 2)
1942 {
1943 for (i = 0; i < jsbound; ++i)
1944 {
1945 si.allocation[i][0] = getBitsUint8 (4);
1946 si.allocation[i][1] = getBitsUint8 (4);
1947 }
1948
1949 for (i = jsbound; i < 32; ++i)
1950 si.allocation[i][0] = si.allocation[i][1] = getBitsUint8 (4);
1951
1952 for (i = 0; i < 32; ++i)
1953 {
1954 si.scaleFactor[i][0] = si.allocation[i][0] ? getBitsUint8 (6) : 0;
1955 si.scaleFactor[i][1] = si.allocation[i][1] ? getBitsUint8 (6) : 0;
1956 }
1957 }
1958 else
1959 {
1960 for (i = 0; i < 32; ++i)
1961 si.allocation[i][0] = getBitsUint8 (4);
1962
1963 for (i = 0; i < 32; ++i)
1964 si.scaleFactor[i][0] = si.allocation[i][0] ? getBitsUint8 (6) : 0;
1965 }
1966 }
1967
1968 void layer1Step2 (SideInfoLayer1& si, float fraction[2][32]) noexcept
1969 {
1970 if (frame.numChannels == 2)
1971 {
1972 int i, jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : 32;
1973
1974 for (i = 0; i < jsbound; ++i)
1975 {
1976 const uint8 n0 = si.allocation[i][0];
1977 const uint8 n1 = si.allocation[i][1];
1978 fraction[0][i] = n0 > 0 ? ((float) (-(1 << n0) + getBitsUint16 (n0 + 1) + 1) * constants.muls[n0 + 1][si.scaleFactor[i][0]]) : 0.0f;
1979 fraction[1][i] = n1 > 0 ? ((float) (-(1 << n1) + getBitsUint16 (n1 + 1) + 1) * constants.muls[n1 + 1][si.scaleFactor[i][1]]) : 0.0f;
1980 }
1981
1982 for (i = jsbound; i < 32; ++i)
1983 {
1984 const uint8 n = si.allocation[i][0];
1985
1986 if (n > 0)
1987 {
1988 const uint32 w = ((uint32) -(1 << n) + getBitsUint16 (n + 1) + 1);
1989 fraction[0][i] = ((float) w * constants.muls[n + 1][si.scaleFactor[i][0]]);
1990 fraction[1][i] = ((float) w * constants.muls[n + 1][si.scaleFactor[i][1]]);
1991 }
1992 else
1993 fraction[0][i] = fraction[1][i] = 0;
1994 }
1995 }
1996 else
1997 {
1998 for (int i = 0; i < 32; ++i)
1999 {
2000 const uint8 n = si.allocation[i][0];
2001 const uint8 j = si.scaleFactor[i][0];
2002
2003 if (n > 0)
2004 fraction[0][i] = ((float) (-(1 << n) + getBitsUint16 (n + 1) + 1) * constants.muls[n + 1][j]);
2005 else
2006 fraction[0][i] = 0;
2007 }
2008 }
2009 }
2010
2011 void layer2Step1 (SideInfoLayer2& si) noexcept
2012 {
2013 zerostruct (si);
2014 const auto sblimit = frame.layer2SubBandLimit;
2015 const auto jsbound = (frame.mode == 1 ? jmin ((frame.modeExt << 2) + 4, sblimit) : sblimit);
2016 auto* allocTable = frame.allocationTable;
2017 uint8 scfsi[32][2];
2018
2019 if (frame.numChannels == 2)
2020 {
2021 for (int i = 0; i < jsbound; ++i)
2022 {
2023 auto step = allocTable->bits;
2024 allocTable += (static_cast<intptr_t> (1) << step);
2025 si.allocation[i][0] = getBitsUint8 (step);
2026 si.allocation[i][1] = getBitsUint8 (step);
2027 }
2028
2029 for (int i = jsbound; i < sblimit; ++i)
2030 {
2031 auto step = allocTable->bits;
2032 auto b0 = getBitsUint8 (step);
2033 allocTable += (static_cast<intptr_t> (1) << step);
2034 si.allocation[i][0] = b0;
2035 si.allocation[i][1] = b0;
2036 }
2037
2038 for (int i = 0; i < sblimit; ++i)
2039 {
2040 scfsi[i][0] = si.allocation[i][0] ? getBitsUint8 (2) : 0;
2041 scfsi[i][1] = si.allocation[i][1] ? getBitsUint8 (2) : 0;
2042 }
2043 }
2044 else
2045 {
2046 for (int i = 0; i < sblimit; ++i)
2047 {
2048 const int16 step = allocTable->bits;
2049 allocTable += (static_cast<intptr_t> (1) << step);
2050 si.allocation[i][0] = getBitsUint8 (step);
2051 }
2052
2053 for (int i = 0; i < sblimit; ++i)
2054 scfsi[i][0] = si.allocation[i][0] ? getBitsUint8 (2) : 0;
2055 }
2056
2057 for (int i = 0; i < sblimit; ++i)
2058 {
2059 for (int ch = 0; ch < frame.numChannels; ++ch)
2060 {
2061 uint8 s0 = 0, s1 = 0, s2 = 0;
2062
2063 if (si.allocation[i][ch])
2064 {
2065 switch (scfsi[i][ch])
2066 {
2067 case 0:
2068 s0 = getBitsUint8 (6);
2069 s1 = getBitsUint8 (6);
2070 s2 = getBitsUint8 (6);
2071 break;
2072 case 1:
2073 s1 = s0 = getBitsUint8 (6);
2074 s2 = getBitsUint8 (6);
2075 break;
2076 case 2:
2077 s2 = s1 = s0 = getBitsUint8 (6);
2078 break;
2079 case 3:
2080 s0 = getBitsUint8 (6);
2081 s2 = s1 = getBitsUint8 (6);
2082 break;
2083 default:
2084 break;
2085 }
2086 }
2087
2088 si.scaleFactor[i][ch][0] = s0;
2089 si.scaleFactor[i][ch][1] = s1;
2090 si.scaleFactor[i][ch][2] = s2;
2091 }
2092 }
2093 }
2094
2095 void layer2Step2 (SideInfoLayer2& si, const int gr, float fraction[2][4][32]) noexcept
2096 {
2097 auto* allocTable = frame.allocationTable;
2098 auto sblimit = frame.layer2SubBandLimit;
2099 const auto jsbound = (frame.mode == 1 ? jmin ((frame.modeExt << 2) + 4, sblimit) : sblimit);
2100
2101 for (int i = 0; i < jsbound; ++i)
2102 {
2103 auto step = allocTable->bits;
2104
2105 for (int ch = 0; ch < frame.numChannels; ++ch)
2106 {
2107 if (auto ba = si.allocation[i][ch])
2108 {
2109 auto x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);
2110 auto* alloc2 = allocTable + ba;
2111 auto k = jmin ((int16) 16, alloc2->bits);
2112 auto d1 = alloc2->d;
2113
2114 if (d1 < 0)
2115 {
2116 const double cm = constants.muls[k][x1];
2117 fraction[ch][0][i] = (float) (((int) getBits (k) + d1) * cm);
2118 fraction[ch][1][i] = (float) (((int) getBits (k) + d1) * cm);
2119 fraction[ch][2][i] = (float) (((int) getBits (k) + d1) * cm);
2120 }
2121 else
2122 {
2123 auto* tab = constants.getGroupTable (d1, getBits (k));
2124 fraction[ch][0][i] = (float) constants.muls[tab[0]][x1];
2125 fraction[ch][1][i] = (float) constants.muls[tab[1]][x1];
2126 fraction[ch][2][i] = (float) constants.muls[tab[2]][x1];
2127 }
2128 }
2129 else
2130 {
2131 fraction[ch][0][i] = fraction[ch][1][i] = fraction[ch][2][i] = 0;
2132 }
2133 }
2134
2135 allocTable += (static_cast<intptr_t> (1) << step);
2136 }
2137
2138 for (int i = jsbound; i < frame.layer2SubBandLimit; ++i)
2139 {
2140 auto step = allocTable->bits;
2141 auto ba = si.allocation[i][0];
2142
2143 if (ba != 0)
2144 {
2145 auto* alloc2 = allocTable + ba;
2146 int16 k = alloc2->bits;
2147 int16 d1 = alloc2->d;
2148 k = (k <= 16) ? k : 16;
2149
2150 if (d1 < 0)
2151 {
2152 auto v0 = (int) getBits (k);
2153 auto v1 = (int) getBits (k);
2154 auto v2 = (int) getBits (k);
2155
2156 for (int ch = 0; ch < frame.numChannels; ++ch)
2157 {
2158 auto x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);
2159 const double cm = constants.muls[k][x1];
2160 fraction[ch][0][i] = (float) ((v0 + d1) * cm);
2161 fraction[ch][1][i] = (float) ((v1 + d1) * cm);
2162 fraction[ch][2][i] = (float) ((v2 + d1) * cm);
2163 }
2164 }
2165 else
2166 {
2167 auto* tab = constants.getGroupTable (d1, getBits (k));
2168 auto k0 = tab[0];
2169 auto k1 = tab[1];
2170 auto k2 = tab[2];
2171
2172 for (int ch = 0; ch < frame.numChannels; ++ch)
2173 {
2174 auto x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);
2175 fraction[ch][0][i] = (float) constants.muls[k0][x1];
2176 fraction[ch][1][i] = (float) constants.muls[k1][x1];
2177 fraction[ch][2][i] = (float) constants.muls[k2][x1];
2178 }
2179 }
2180 }
2181 else
2182 {
2183 fraction[0][0][i] = fraction[0][1][i] = fraction[0][2][i] = 0;
2184 fraction[1][0][i] = fraction[1][1][i] = fraction[1][2][i] = 0;
2185 }
2186
2187 allocTable += (static_cast<intptr_t> (1) << step);
2188 }
2189
2190 for (int ch = 0; ch < frame.numChannels; ++ch)
2191 for (int i = frame.layer2SubBandLimit; i < 32; ++i)
2192 fraction[ch][0][i] = fraction[ch][1][i] = fraction[ch][2][i] = 0;
2193 }
2194
2195 void getLayer3SideInfo1 (const int stereo, const bool msStereo, const int sampleRate, const int single) noexcept
2196 {
2197 const int powdiff = (single == 3) ? 4 : 0;
2198 sideinfo.mainDataStart = getBits (9);
2199 sideinfo.privateBits = getBitsUnchecked (stereo == 1 ? 5 : 3);
2200
2201 for (int ch = 0; ch < stereo; ++ch)
2202 {
2203 sideinfo.ch[ch].gr[0].scfsi = -1;
2204 sideinfo.ch[ch].gr[1].scfsi = (int) getBitsUnchecked (4);
2205 }
2206
2207 for (int gr = 0; gr < 2; ++gr)
2208 {
2209 for (int ch = 0; ch < stereo; ++ch)
2210 {
2211 auto& granule = sideinfo.ch[ch].gr[gr];
2212
2213 granule.part2_3Length = getBits (12);
2214 granule.bigValues = jmin (288u, getBitsUnchecked (9));
2215
2216 const int qss = (int) getBitsUnchecked (8);
2217 granule.pow2gain = constants.powToGains + 256 - qss + powdiff;
2218
2219 if (msStereo)
2220 granule.pow2gain += 2;
2221
2222 granule.scaleFactorCompression = getBitsUnchecked (4);
2223
2224 if (getOneBit())
2225 {
2226 granule.blockType = getBitsUnchecked (2);
2227 granule.mixedBlockFlag = getOneBit();
2228 granule.tableSelect[0] = getBitsUnchecked (5);
2229 granule.tableSelect[1] = getBitsUnchecked (5);
2230 granule.tableSelect[2] = 0;
2231
2232 for (int i = 0; i < 3; ++i)
2233 {
2234 const uint32 sbg = (getBitsUnchecked (3) << 3);
2235 granule.fullGain[i] = granule.pow2gain + sbg;
2236 }
2237
2238 granule.region1Start = 36 >> 1;
2239 granule.region2Start = 576 >> 1;
2240 }
2241 else
2242 {
2243 for (int i = 0; i < 3; ++i)
2244 granule.tableSelect[i] = getBitsUnchecked (5);
2245
2246 const int r0c = (int) getBitsUnchecked (4);
2247 const int r1c = (int) getBitsUnchecked (3);
2248 const int region0index = jmin (22, r0c + 1);
2249 const int region1index = jmin (22, r0c + 1 + r1c + 1);
2250
2251 granule.region1Start = (uint32) (bandInfo[sampleRate].longIndex[region0index] >> 1);
2252 granule.region2Start = (uint32) (bandInfo[sampleRate].longIndex[region1index] >> 1);
2253 granule.blockType = 0;
2254 granule.mixedBlockFlag = 0;
2255 }
2256
2257 granule.preflag = getOneBit();
2258 granule.scaleFactorScale = getOneBit();
2259 granule.count1TableSelect = getOneBit();
2260 }
2261 }
2262 }
2263
2264 void getLayer3SideInfo2 (const int stereo, const bool msStereo, const int sampleRate, const int single) noexcept
2265 {
2266 const int powdiff = (single == 3) ? 4 : 0;
2267 sideinfo.mainDataStart = getBits (8);
2268 sideinfo.privateBits = stereo == 1 ? getOneBit() : getBitsUnchecked (2);
2269
2270 for (int ch = 0; ch < stereo; ++ch)
2271 {
2272 auto& granule = sideinfo.ch[ch].gr[0];
2273
2274 granule.part2_3Length = getBits (12);
2275 granule.bigValues = jmin (288u, getBitsUnchecked (9));
2276
2277 const uint32 qss = getBitsUnchecked (8);
2278 granule.pow2gain = constants.powToGains + 256 - qss + powdiff;
2279
2280 if (msStereo)
2281 granule.pow2gain += 2;
2282
2283 granule.scaleFactorCompression = getBits (9);
2284
2285 if (getOneBit())
2286 {
2287 granule.blockType = getBitsUnchecked (2);
2288 granule.mixedBlockFlag = getOneBit();
2289 granule.tableSelect[0] = getBitsUnchecked (5);
2290 granule.tableSelect[1] = getBitsUnchecked (5);
2291 granule.tableSelect[2] = 0;
2292
2293 for (int i = 0; i < 3; ++i)
2294 {
2295 const uint32 sbg = (getBitsUnchecked (3) << 3);
2296 granule.fullGain[i] = granule.pow2gain + sbg;
2297 }
2298
2299 if (granule.blockType == 0)
2300 {}
2301
2302 if (granule.blockType == 2)
2303 granule.region1Start = sampleRate == 8 ? 36 : (36 >> 1);
2304 else
2305 granule.region1Start = sampleRate == 8 ? (108 >> 1) : (54 >> 1);
2306
2307 granule.region2Start = 576 >> 1;
2308 }
2309 else
2310 {
2311 for (int i = 0; i < 3; ++i)
2312 granule.tableSelect[i] = getBitsUnchecked (5);
2313
2314 const int r0c = (int) getBitsUnchecked (4);
2315 const int r1c = (int) getBitsUnchecked (3);
2316 const int region0index = jmin (22, r0c + 1);
2317 const int region1index = jmin (22, r0c + 1 + r1c + 1);
2318
2319 granule.region1Start = (uint32) (bandInfo[sampleRate].longIndex[region0index] >> 1);
2320 granule.region2Start = (uint32) (bandInfo[sampleRate].longIndex[region1index] >> 1);
2321 granule.blockType = 0;
2322 granule.mixedBlockFlag = 0;
2323 }
2324 granule.scaleFactorScale = getOneBit();
2325 granule.count1TableSelect = getOneBit();
2326 }
2327 }
2328
2329 int getLayer3ScaleFactors1 (int* scf, const Layer3SideInfo::Info& granule) noexcept
2330 {
2331 static const uint8 lengths[2][16] =
2332 {
2333 { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 },
2334 { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 }
2335 };
2336
2337 int numBits;
2338 const int num0 = lengths[0][granule.scaleFactorCompression];
2339 const int num1 = lengths[1][granule.scaleFactorCompression];
2340
2341 if (granule.blockType == 2)
2342 {
2343 int i = 18;
2344 numBits = (num0 + num1) * 18;
2345
2346 if (granule.mixedBlockFlag)
2347 {
2348 for (int j = 8; --j >= 0;) *scf++ = (int) getBitsUnchecked (num0);
2349 numBits -= num0;
2350 i = 9;
2351 }
2352
2353 for (; --i >= 0;) *scf++ = (int) getBitsUnchecked (num0);
2354 for (i = 18; --i >= 0;) *scf++ = (int) getBitsUnchecked (num1);
2355
2356 *scf++ = 0;
2357 *scf++ = 0;
2358 *scf++ = 0;
2359 }
2360 else
2361 {
2362 const int scfsi = granule.scfsi;
2363
2364 if (scfsi < 0)
2365 {
2366 for (int i = 11; --i >= 0;) *scf++ = (int) getBitsUnchecked (num0);
2367 for (int j = 10; --j >= 0;) *scf++ = (int) getBitsUnchecked (num1);
2368 numBits = (num0 + num1) * 10 + num0;
2369 }
2370 else
2371 {
2372 numBits = 0;
2373 if ((scfsi & 8) == 0)
2374 {
2375 for (int i = 6; --i >= 0;) *scf++ = (int) getBitsUnchecked (num0);
2376 numBits += num0 * 6;
2377 }
2378 else
2379 scf += 6;
2380
2381 if ((scfsi & 4) == 0)
2382 {
2383 for (int i = 5; --i >= 0;) *scf++ = (int) getBitsUnchecked (num0);
2384 numBits += num0 * 5;
2385 }
2386 else
2387 scf += 5;
2388
2389 if ((scfsi & 2) == 0)
2390 {
2391 for (int i = 5; --i >= 0;) *scf++ = (int) getBitsUnchecked (num1);
2392 numBits += num1 * 5;
2393 }
2394 else
2395 scf += 5;
2396
2397 if ((scfsi & 1) == 0)
2398 {
2399 for (int i = 5; --i >= 0;) *scf++ = (int) getBitsUnchecked (num1);
2400 numBits += num1 * 5;
2401 }
2402 else
2403 scf += 5;
2404 }
2405
2406 *scf = 0;
2407 }
2408
2409 return numBits;
2410 }
2411
2412 JUCE_BEGIN_IGNORE_WARNINGS_MSVC (6385)
2413 int getLayer3ScaleFactors2 (int* scf, Layer3SideInfo::Info& granule, const bool iStereo) noexcept
2414 {
2415 static const uint8 scaleTable[3][6][4] =
2416 {
2417 { { 6, 5, 5, 5 }, { 6, 5, 7, 3 }, { 11, 10, 0, 0 }, { 7, 7, 7, 0 }, { 6, 6, 6, 3 }, { 8, 8, 5, 0 } },
2418 { { 9, 9, 9, 9 }, { 9, 9, 12, 6 }, { 18, 18, 0, 0 }, { 12, 12, 12, 0 }, { 12, 9, 9, 6 }, { 15, 12, 9, 0 } },
2419 { { 6, 9, 9, 9 }, { 6, 9, 12, 6 }, { 15, 18, 0, 0 }, { 6, 15, 12, 0 }, { 6, 12, 9, 6 }, { 6, 18, 9, 0 } }
2420 };
2421
2422 uint32 len = iStereo ? constants.iLength2[granule.scaleFactorCompression >> 1]
2423 : constants.nLength2[granule.scaleFactorCompression];
2424
2425 granule.preflag = (len >> 15) & 1;
2426
2427 int n = 0;
2428 if (granule.blockType == 2)
2429 {
2430 ++n;
2431 if (granule.mixedBlockFlag)
2432 ++n;
2433 }
2434
2435 const uint8* const data = scaleTable[n][(len >> 12) & 7];
2436 int numBits = 0;
2437
2438 for (int i = 0; i < 4; ++i)
2439 {
2440 int num = len & 7;
2441 len >>= 3;
2442
2443 if (num)
2444 {
2445 for (int j = 0; j < (int) (data[i]); ++j)
2446 *scf++ = (int) getBitsUnchecked (num);
2447
2448 numBits += data[i] * num;
2449 }
2450 else
2451 {
2452 for (int j = 0; j < (int) (data[i]); ++j)
2453 *scf++ = 0;
2454 }
2455 }
2456
2457 n = (n << 1) + 1;
2458
2459 for (int i = 0; i < n; ++i)
2460 *scf++ = 0;
2461
2462 return numBits;
2463 }
2464 JUCE_END_IGNORE_WARNINGS_MSVC
2465
2466 bool layer3DequantizeSample (float xr[32][18], int* scf, Layer3SideInfo::Info& granule, int sampleRate, int part2bits) noexcept
2467 {
2468 const uint32 shift = 1 + granule.scaleFactorScale;
2469 auto* xrpnt = (float*) xr;
2470 auto part2remain = (int) granule.part2_3Length - part2bits;
2471
2472 zeromem (xrpnt, (size_t) (&xr[32][0] - xrpnt) * sizeof (float));
2473
2474 auto bv = (int) granule.bigValues;
2475 auto region1 = (int) granule.region1Start;
2476 auto region2 = (int) granule.region2Start;
2477 int l3 = ((576 >> 1) - bv) >> 1;
2478 int l[3];
2479
2480 if (bv <= region1)
2481 {
2482 l[0] = bv;
2483 l[1] = 0;
2484 l[2] = 0;
2485 }
2486 else
2487 {
2488 l[0] = region1;
2489 if (bv <= region2)
2490 {
2491 l[1] = bv - l[0];
2492 l[2] = 0;
2493 }
2494 else
2495 {
2496 l[1] = region2 - l[0];
2497 l[2] = bv - region2;
2498 }
2499 }
2500
2501 for (int i = 0; i < 3; ++i)
2502 if (l[i] < 0)
2503 l[i] = 0;
2504
2505 if (granule.blockType == 2)
2506 {
2507 int max[4];
2508 int step = 0, lwin = 0, cb = 0, mc = 0;
2509 float v = 0;
2510 int* map;
2511 int* mapEnd;
2512
2513 if (granule.mixedBlockFlag)
2514 {
2515 max[3] = -1;
2516 max[0] = max[1] = max[2] = 2;
2517 map = constants.map [sampleRate][0];
2518 mapEnd = constants.mapEnd[sampleRate][0];
2519 }
2520 else
2521 {
2522 max[0] = max[1] = max[2] = max[3] = -1;
2523 map = constants.map [sampleRate][1];
2524 mapEnd = constants.mapEnd[sampleRate][1];
2525 }
2526
2527 for (int i = 0; i < 2; ++i)
2528 {
2529 auto* h = huffmanTables1 + granule.tableSelect[i];
2530
2531 for (int lp = l[i]; lp != 0; --lp, --mc)
2532 {
2533 int x, y;
2534 if (mc == 0)
2535 {
2536 mc = *map++;
2537 xrpnt = ((float*) xr) + (*map++);
2538 lwin = *map++;
2539 cb = *map++;
2540
2541 if (lwin == 3)
2542 {
2543 v = granule.pow2gain[ (*scf++) << shift];
2544 step = 1;
2545 }
2546 else
2547 {
2548 v = granule.fullGain[lwin][ (*scf++) << shift];
2549 step = 3;
2550 }
2551 }
2552
2553 auto* val = h->table;
2554
2555 while ((y = *val++) < 0)
2556 {
2557 if (getOneBit())
2558 val -= y;
2559
2560 --part2remain;
2561 }
2562
2563 x = y >> 4;
2564 y &= 15;
2565
2566 if (x == 15)
2567 {
2568 max[lwin] = cb;
2569 part2remain -= (int) (h->bits + 1);
2570 x += (int) getBits ((int) h->bits);
2571 *xrpnt = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);
2572 }
2573 else if (x)
2574 {
2575 max[lwin] = cb;
2576 *xrpnt = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);
2577 --part2remain;
2578 }
2579 else
2580 *xrpnt = 0;
2581
2582 xrpnt += step;
2583
2584 if (y == 15)
2585 {
2586 max[lwin] = cb;
2587 part2remain -= (int) (h->bits + 1);
2588 y += (int) getBits ((int) h->bits);
2589 *xrpnt = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);
2590 }
2591 else if (y)
2592 {
2593 max[lwin] = cb;
2594 *xrpnt = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);
2595 --part2remain;
2596 }
2597 else
2598 *xrpnt = 0;
2599
2600 xrpnt += step;
2601 }
2602 }
2603
2604 for (; l3 && (part2remain > 0); --l3)
2605 {
2606 auto* h = huffmanTables2 + granule.count1TableSelect;
2607 auto* val = h->table;
2608 int16 a;
2609
2610 while ((a = *val++) < 0)
2611 {
2612 if (part2remain <= 0)
2613 {
2614 a = 0;
2615 break;
2616 }
2617
2618 --part2remain;
2619
2620 if (getOneBit())
2621 val -= a;
2622 }
2623
2624 for (int i = 0; i < 4; ++i)
2625 {
2626 if ((i & 1) == 0)
2627 {
2628 if (mc == 0)
2629 {
2630 mc = *map++;
2631 xrpnt = ((float*) xr) + (*map++);
2632 lwin = *map++;
2633 cb = *map++;
2634
2635 if (lwin == 3)
2636 {
2637 v = granule.pow2gain[ (*scf++) << shift];
2638 step = 1;
2639 }
2640 else
2641 {
2642 v = granule.fullGain[lwin][ (*scf++) << shift];
2643 step = 3;
2644 }
2645 }
2646
2647 --mc;
2648 }
2649
2650 if ((a & (8 >> i)))
2651 {
2652 max[lwin] = cb;
2653
2654 if (part2remain == 0)
2655 break;
2656
2657 --part2remain;
2658 *xrpnt = getOneBit() ? -v : v;
2659 }
2660 else
2661 *xrpnt = 0;
2662
2663 xrpnt += step;
2664 }
2665 }
2666
2667 while (map < mapEnd)
2668 {
2669 if (mc == 0)
2670 {
2671 mc = *map++;
2672 xrpnt = ((float*) xr) + *map++;
2673 step = (*map++ == 3) ? 1 : 3;
2674 ++map;
2675 }
2676
2677 --mc;
2678 *xrpnt = 0; xrpnt += step;
2679 *xrpnt = 0; xrpnt += step;
2680 }
2681
2682 granule.maxBand[0] = (uint32) (max[0] + 1);
2683 granule.maxBand[1] = (uint32) (max[1] + 1);
2684 granule.maxBand[2] = (uint32) (max[2] + 1);
2685 granule.maxBandl = (uint32) (max[3] + 1);
2686
2687 const int rmax = jmax (max[0], max[1], max[3]) + 1;
2688 granule.maxb = rmax ? (uint32) constants.shortLimit[sampleRate][rmax]
2689 : (uint32) constants.longLimit[sampleRate][max[3] + 1];
2690 }
2691 else
2692 {
2693 static const int pretab1[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0 };
2694 static const int pretab2[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
2695
2696 auto* pretab = (const int*) (granule.preflag ? pretab1 : pretab2);
2697 int max = -1, cb = 0, mc = 0;
2698 auto* map = constants.map[sampleRate][2];
2699 float v = 0;
2700
2701 for (int i = 0; i < 3; ++i)
2702 {
2703 auto* h = huffmanTables1 + granule.tableSelect[i];
2704
2705 for (int lp = l[i]; lp != 0; --lp, --mc)
2706 {
2707 if (mc == 0)
2708 {
2709 mc = *map++;
2710 v = granule.pow2gain[((*scf++) + (*pretab++)) << shift];
2711 cb = *map++;
2712 }
2713
2714 auto* val = h->table;
2715 int y;
2716
2717 while ((y = *val++) < 0)
2718 {
2719 if (getOneBit()) val -= y;
2720 --part2remain;
2721 }
2722
2723 int x = y >> 4;
2724 y &= 15;
2725
2726 if (x == 15)
2727 {
2728 max = cb;
2729 part2remain -= (int) (h->bits + 1);
2730 x += (int) getBits ((int) h->bits);
2731 *xrpnt++ = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);
2732 }
2733 else if (x)
2734 {
2735 max = cb;
2736 *xrpnt++ = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);
2737 --part2remain;
2738 }
2739 else
2740 *xrpnt++ = 0;
2741
2742 if (y == 15)
2743 {
2744 max = cb;
2745 part2remain -= (int) (h->bits + 1);
2746 y += (int) getBits ((int) h->bits);
2747 *xrpnt++ = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);
2748 }
2749 else if (y)
2750 {
2751 max = cb;
2752 *xrpnt++ = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);
2753 --part2remain;
2754 }
2755 else
2756 *xrpnt++ = 0;
2757 }
2758 }
2759
2760 for (; l3 && part2remain > 0; --l3)
2761 {
2762 auto* h = huffmanTables2 + granule.count1TableSelect;
2763 auto* values = h->table;
2764 int16 a;
2765
2766 while ((a = *values++) < 0)
2767 {
2768 if (part2remain <= 0)
2769 {
2770 a = 0;
2771 break;
2772 }
2773
2774 --part2remain;
2775
2776 if (getOneBit())
2777 values -= a;
2778 }
2779
2780 for (int i = 0; i < 4; ++i)
2781 {
2782 if ((i & 1) == 0)
2783 {
2784 if (mc == 0)
2785 {
2786 mc = *map++;
2787 cb = *map++;
2788 v = granule.pow2gain[((*scf++) + (*pretab++)) << shift];
2789 }
2790 --mc;
2791 }
2792
2793 if ((a & (0x8 >> i)))
2794 {
2795 max = cb;
2796
2797 if (part2remain <= 0)
2798 break;
2799
2800 --part2remain;
2801 *xrpnt++ = getOneBit() ? -v : v;
2802 }
2803 else
2804 *xrpnt++ = 0;
2805 }
2806 }
2807
2808 zeromem (xrpnt, (size_t) (&xr[32][0] - xrpnt) * sizeof (float));
2809
2810 granule.maxBandl = (uint32) (max + 1);
2811 granule.maxb = (uint32) constants.longLimit[sampleRate][granule.maxBandl];
2812 }
2813
2814 while (part2remain > 16)
2815 {
2816 getBits (16);
2817 part2remain -= 16;
2818 }
2819
2820 if (part2remain > 0)
2821 getBits (part2remain);
2822 else if (part2remain < 0)
2823 return true;
2824
2825 return false;
2826 }
2827
2828 void layer3Hybrid (float fsIn[32][18], float tsOut[18][32], int ch, const Layer3SideInfo::Info& granule) noexcept
2829 {
2830 auto* ts = (float*) tsOut;
2831 float* rawout1, *rawout2;
2832 int sb = 0;
2833
2834 {
2835 int b = hybridBlockIndex[ch];
2836 rawout1 = hybridBlock[b][ch];
2837 b = 1 - b;
2838 rawout2 = hybridBlock[b][ch];
2839 hybridBlockIndex[ch] = b;
2840 }
2841
2842 if (granule.mixedBlockFlag)
2843 {
2844 sb = 2;
2845 DCT::dct36 (fsIn[0], rawout1, rawout2, constants.win[0], ts);
2846 DCT::dct36 (fsIn[1], rawout1 + 18, rawout2 + 18, constants.win1[0], ts + 1);
2847 rawout1 += 36;
2848 rawout2 += 36;
2849 ts += 2;
2850 }
2851
2852 auto bt = granule.blockType;
2853
2854 if (bt == 2)
2855 {
2856 for (; sb < (int) granule.maxb; sb += 2, ts += 2, rawout1 += 36, rawout2 += 36)
2857 {
2858 DCT::dct12 (fsIn[sb], rawout1, rawout2, constants.win[2], ts);
2859 DCT::dct12 (fsIn[sb + 1], rawout1 + 18, rawout2 + 18, constants.win1[2], ts + 1);
2860 }
2861 }
2862 else
2863 {
2864 for (; sb < (int) granule.maxb; sb += 2, ts += 2, rawout1 += 36, rawout2 += 36)
2865 {
2866 DCT::dct36 (fsIn[sb], rawout1, rawout2, constants.win[bt], ts);
2867 DCT::dct36 (fsIn[sb + 1], rawout1 + 18, rawout2 + 18, constants.win1[bt], ts + 1);
2868 }
2869 }
2870
2871 for (; sb < 32; ++sb, ++ts)
2872 {
2873 for (int i = 0; i < 18; ++i)
2874 {
2875 ts[i * 32] = *rawout1++;
2876 *rawout2++ = 0;
2877 }
2878 }
2879 }
2880
2881 void synthesiseStereo (const float* bandPtr0, const float* bandPtr1, float* out0, float* out1, int& samplesDone) noexcept
2882 {
2883 auto dummy = samplesDone;
2884 synthesise (bandPtr0, 0, out0, dummy);
2885 synthesise (bandPtr1, 1, out1, samplesDone);
2886 }
2887
2888 void synthesise (const float* bandPtr, int channel, float* out, int& samplesDone)
2889 {
2890 out += samplesDone;
2891 const int bo = channel == 0 ? ((synthBo - 1) & 15) : synthBo;
2892 float (*buf)[0x110] = synthBuffers[channel];
2893 float* b0;
2894 auto bo1 = bo;
2895
2896 if (bo & 1)
2897 {
2898 b0 = buf[0];
2899 DCT::dct64 (buf[1] + ((bo + 1) & 15), buf[0] + bo, bandPtr);
2900 }
2901 else
2902 {
2903 ++bo1;
2904 b0 = buf[1];
2905 DCT::dct64 (buf[0] + bo, buf[1] + bo1, bandPtr);
2906 }
2907
2908 synthBo = bo;
2909 const float* window = constants.decodeWin + 16 - bo1;
2910
2911 for (int j = 16; j != 0; --j, b0 += 16, window += 32)
2912 {
2913 auto sum = window[0] * b0[0]; sum -= window[1] * b0[1];
2914 sum += window[2] * b0[2]; sum -= window[3] * b0[3];
2915 sum += window[4] * b0[4]; sum -= window[5] * b0[5];
2916 sum += window[6] * b0[6]; sum -= window[7] * b0[7];
2917 sum += window[8] * b0[8]; sum -= window[9] * b0[9];
2918 sum += window[10] * b0[10]; sum -= window[11] * b0[11];
2919 sum += window[12] * b0[12]; sum -= window[13] * b0[13];
2920 sum += window[14] * b0[14]; sum -= window[15] * b0[15];
2921 *out++ = sum;
2922 }
2923
2924 {
2925 auto sum = window[0] * b0[0]; sum += window[2] * b0[2];
2926 sum += window[4] * b0[4]; sum += window[6] * b0[6];
2927 sum += window[8] * b0[8]; sum += window[10] * b0[10];
2928 sum += window[12] * b0[12]; sum += window[14] * b0[14];
2929 *out++ = sum;
2930 b0 -= 16; window -= 32;
2931 window += (ptrdiff_t) bo1 << 1;
2932 }
2933
2934 for (int j = 15; j != 0; --j, b0 -= 16, window -= 32)
2935 {
2936 auto sum = -window[-1] * b0[0]; sum -= window[-2] * b0[1];
2937 sum -= window[-3] * b0[2]; sum -= window[-4] * b0[3];
2938 sum -= window[-5] * b0[4]; sum -= window[-6] * b0[5];
2939 sum -= window[-7] * b0[6]; sum -= window[-8] * b0[7];
2940 sum -= window[-9] * b0[8]; sum -= window[-10] * b0[9];
2941 sum -= window[-11] * b0[10]; sum -= window[-12] * b0[11];
2942 sum -= window[-13] * b0[12]; sum -= window[-14] * b0[13];
2943 sum -= window[-15] * b0[14]; sum -= window[0] * b0[15];
2944 *out++ = sum;
2945 }
2946
2947 samplesDone += 32;
2948 }
2949
2950 JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MP3Stream)
2951 };
2952
2953 //==============================================================================
2954 static const char* const mp3FormatName = "MP3 file";
2955
2956 //==============================================================================
2957 class MP3Reader : public AudioFormatReader
2958 {
2959 public:
2960 MP3Reader (InputStream* const in)
2961 : AudioFormatReader (in, mp3FormatName),
2962 stream (*in), currentPosition (0),
2963 decodedStart (0), decodedEnd (0)
2964 {
2965 skipID3();
2966 const int64 streamPos = stream.stream.getPosition();
2967
2968 if (readNextBlock())
2969 {
2970 bitsPerSample = 32;
2971 usesFloatingPointData = true;
2972 sampleRate = stream.frame.getFrequency();
2973 numChannels = (unsigned int) stream.frame.numChannels;
2974 lengthInSamples = findLength (streamPos);
2975 }
2976 }
2977
2978 bool readSamples (int** destSamples, int numDestChannels, int startOffsetInDestBuffer,
2979 int64 startSampleInFile, int numSamples) override
2980 {
2981 if (destSamples == nullptr)
2982 {
2983 jassertfalse;
2984 return false;
2985 }
2986
2987 if (currentPosition != startSampleInFile)
2988 {
2989 if (! stream.seek ((int) (startSampleInFile / 1152 - 1)))
2990 {
2991 currentPosition = -1;
2992 createEmptyDecodedData();
2993 }
2994 else
2995 {
2996 decodedStart = decodedEnd = 0;
2997 const int64 streamPos = stream.currentFrameIndex * 1152;
2998 int toSkip = (int) (startSampleInFile - streamPos);
2999 jassert (toSkip >= 0);
3000
3001 while (toSkip > 0)
3002 {
3003 if (! readNextBlock())
3004 {
3005 createEmptyDecodedData();
3006 break;
3007 }
3008
3009 const int numReady = decodedEnd - decodedStart;
3010
3011 if (numReady > toSkip)
3012 {
3013 decodedStart += toSkip;
3014 break;
3015 }
3016
3017 toSkip -= numReady;
3018 }
3019
3020 currentPosition = startSampleInFile;
3021 }
3022 }
3023
3024 while (numSamples > 0)
3025 {
3026 if (decodedEnd <= decodedStart && ! readNextBlock())
3027 {
3028 for (int i = numDestChannels; --i >= 0;)
3029 if (destSamples[i] != nullptr)
3030 zeromem (destSamples[i] + startOffsetInDestBuffer, (size_t) numSamples * sizeof (float));
3031
3032 return false;
3033 }
3034
3035 const int numToCopy = jmin (decodedEnd - decodedStart, numSamples);
3036 float* const* const dst = reinterpret_cast<float**> (destSamples);
3037 memcpy (dst[0] + startOffsetInDestBuffer, decoded0 + decodedStart, (size_t) numToCopy * sizeof (float));
3038
3039 if (numDestChannels > 1 && dst[1] != nullptr)
3040 memcpy (dst[1] + startOffsetInDestBuffer, (numChannels < 2 ? decoded0 : decoded1) + decodedStart, (size_t) numToCopy * sizeof (float));
3041
3042 startOffsetInDestBuffer += numToCopy;
3043 decodedStart += numToCopy;
3044 currentPosition += numToCopy;
3045 numSamples -= numToCopy;
3046 }
3047
3048 return true;
3049 }
3050
3051 private:
3052 MP3Stream stream;
3053 int64 currentPosition;
3054 enum { decodedDataSize = 1152 };
3055 float decoded0[decodedDataSize], decoded1[decodedDataSize];
3056 int decodedStart, decodedEnd;
3057
3058 void createEmptyDecodedData() noexcept
3059 {
3060 zeromem (decoded0, sizeof (decoded0));
3061 zeromem (decoded1, sizeof (decoded1));
3062 decodedStart = 0;
3063 decodedEnd = decodedDataSize;
3064 }
3065
3066 bool readNextBlock()
3067 {
3068 for (int attempts = 10; --attempts >= 0;)
3069 {
3070 int samplesDone = 0;
3071 const int result = stream.decodeNextBlock (decoded0, decoded1, samplesDone);
3072
3073 if (result > 0 && stream.stream.isExhausted())
3074 {
3075 createEmptyDecodedData();
3076 return true;
3077 }
3078
3079 if (result <= 0)
3080 {
3081 decodedStart = 0;
3082 decodedEnd = samplesDone;
3083 return result == 0;
3084 }
3085 }
3086
3087 return false;
3088 }
3089
3090 void skipID3()
3091 {
3092 const int64 originalPosition = stream.stream.getPosition();
3093 const uint32 firstWord = (uint32) stream.stream.readInt();
3094
3095 if ((firstWord & 0xffffff) == 0x334449)
3096 {
3097 uint8 buffer[6];
3098
3099 if (stream.stream.read (buffer, 6) == 6
3100 && buffer[0] != 0xff
3101 && ((buffer[2] | buffer[3] | buffer[4] | buffer[5]) & 0x80) == 0)
3102 {
3103 const uint32 length = (((uint32) buffer[2]) << 21)
3104 | (((uint32) buffer[3]) << 14)
3105 | (((uint32) buffer[4]) << 7)
3106 | ((uint32) buffer[5]);
3107
3108 stream.stream.skipNextBytes (length);
3109 return;
3110 }
3111 }
3112
3113 stream.stream.setPosition (originalPosition);
3114 }
3115
3116 int64 findLength (int64 streamStartPos)
3117 {
3118 int64 numFrames = stream.numFrames;
3119
3120 if (numFrames <= 0)
3121 {
3122 const int64 streamSize = stream.stream.getTotalLength();
3123
3124 if (streamSize > 0)
3125 {
3126 const int bytesPerFrame = stream.frame.frameSize + 4;
3127
3128 if (bytesPerFrame == 417 || bytesPerFrame == 418)
3129 numFrames = roundToInt ((double) (streamSize - streamStartPos) / 417.95918); // more accurate for 128k
3130 else
3131 numFrames = (streamSize - streamStartPos) / bytesPerFrame;
3132 }
3133 }
3134
3135 return numFrames * 1152;
3136 }
3137
3138 JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MP3Reader)
3139 };
3140
3141 }
3142
3143 //==============================================================================
3144 MP3AudioFormat::MP3AudioFormat() : AudioFormat (MP3Decoder::mp3FormatName, ".mp3") {}
3145 MP3AudioFormat::~MP3AudioFormat() {}
3146
3147 Array<int> MP3AudioFormat::getPossibleSampleRates() { return {}; }
3148 Array<int> MP3AudioFormat::getPossibleBitDepths() { return {}; }
3149 bool MP3AudioFormat::canDoStereo() { return true; }
3150 bool MP3AudioFormat::canDoMono() { return true; }
3151 bool MP3AudioFormat::isCompressed() { return true; }
3152 StringArray MP3AudioFormat::getQualityOptions() { return {}; }
3153
3154 AudioFormatReader* MP3AudioFormat::createReaderFor (InputStream* sourceStream, const bool deleteStreamIfOpeningFails)
3155 {
3156 std::unique_ptr<MP3Decoder::MP3Reader> r (new MP3Decoder::MP3Reader (sourceStream));
3157
3158 if (r->lengthInSamples > 0)
3159 return r.release();
3160
3161 if (! deleteStreamIfOpeningFails)
3162 r->input = nullptr;
3163
3164 return nullptr;
3165 }
3166
3167 AudioFormatWriter* MP3AudioFormat::createWriterFor (OutputStream*, double /*sampleRateToUse*/,
3168 unsigned int /*numberOfChannels*/, int /*bitsPerSample*/,
3169 const StringPairArray& /*metadataValues*/, int /*qualityOptionIndex*/)
3170 {
3171 jassertfalse; // not yet implemented!
3172 return nullptr;
3173 }
3174
3175 #endif
3176
3177 } // namespace juce