41#if JUCE_USE_MP3AUDIOFORMAT
50 {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},
51 {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},
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}, {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},
54 {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},
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 {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},
62 {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},
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 {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}
72 {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},
73 {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},
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}, {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},
76 {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},
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 {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},
84 {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},
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 {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},
90 {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}, {2, 0}, {5, 3}, {7, 5}, {16, -32767}
95 {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},
96 {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},
97 {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},
98 {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},
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}
104 {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},
105 {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},
106 {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},
107 {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},
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}
115 {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},
116 {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},
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 {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},
120 {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},
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}, {2, 0}, {5, 3}, {7, 5}, {10, 9}, {2, 0}, {5, 3}, {7, 5}, {10, 9},
123 {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},
124 {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},
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}
134 int16 shortIndex[14];
140 { {0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162, 196, 238, 288, 342, 418, 576},
141 {4, 4, 4, 4, 4, 4, 6, 6, 8, 8, 10, 12, 16, 20, 24, 28, 34, 42, 50, 54, 76, 158},
142 {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},
143 {4, 4, 4, 4, 6, 8, 10, 12, 14, 18, 22, 30, 56} },
145 { {0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156, 190, 230, 276, 330, 384, 576},
146 {4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 10, 12, 16, 18, 22, 28, 34, 40, 46, 54, 54, 192},
147 {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},
148 {4, 4, 4, 4, 6, 6, 10, 12, 14, 16, 20, 26, 66} },
150 { {0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194, 240, 296, 364, 448, 550, 576},
151 {4, 4, 4, 4, 4, 4, 6, 6, 8, 10, 12, 16, 20, 24, 30, 38, 46, 56, 68, 84, 102, 26},
152 {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},
153 {4, 4, 4, 4, 6, 8, 12, 16, 20, 26, 34, 42, 12} },
155 { {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
156 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54 },
157 {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},
158 {4, 4, 4, 6, 6, 8, 10, 14, 18, 26, 32, 42, 18 } },
160 { {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194, 232, 278, 332, 394, 464, 540, 576},
161 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 18, 22, 26, 32, 38, 46, 54, 62, 70, 76, 36 },
162 {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},
163 {4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 32, 44, 12 } },
165 { {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
166 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54 },
167 {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},
168 {4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18 } },
170 { {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
171 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54},
172 {0, 12, 24, 36, 54, 78, 108, 144, 186, 240, 312, 402, 522, 576},
173 {4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18} },
175 { {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
176 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54},
177 {0, 12, 24, 36, 54, 78, 108, 144, 186, 240, 312, 402, 522, 576},
178 {4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18} },
180 { {0, 12, 24, 36, 48, 60, 72, 88, 108, 132, 160, 192, 232, 280, 336, 400, 476, 566, 568, 570, 572, 574, 576},
181 {12, 12, 12, 12, 12, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 76, 90, 2, 2, 2, 2, 2},
182 {0, 24, 48, 72, 108, 156, 216, 288, 372, 480, 486, 492, 498, 576},
183 {8, 8, 8, 12, 16, 20, 24, 28, 36, 2, 2, 2, 26} }
188 0.000000000, -0.000015259, -0.000015259, -0.000015259, -0.000015259, -0.000015259, -0.000015259, -0.000030518,
189 -0.000030518, -0.000030518, -0.000030518, -0.000045776, -0.000045776, -0.000061035, -0.000061035, -0.000076294,
190 -0.000076294, -0.000091553, -0.000106812, -0.000106812, -0.000122070, -0.000137329, -0.000152588, -0.000167847,
191 -0.000198364, -0.000213623, -0.000244141, -0.000259399, -0.000289917, -0.000320435, -0.000366211, -0.000396729,
192 -0.000442505, -0.000473022, -0.000534058, -0.000579834, -0.000625610, -0.000686646, -0.000747681, -0.000808716,
193 -0.000885010, -0.000961304, -0.001037598, -0.001113892, -0.001205444, -0.001296997, -0.001388550, -0.001480103,
194 -0.001586914, -0.001693726, -0.001785278, -0.001907349, -0.002014160, -0.002120972, -0.002243042, -0.002349854,
195 -0.002456665, -0.002578735, -0.002685547, -0.002792358, -0.002899170, -0.002990723, -0.003082275, -0.003173828,
196 -0.003250122, -0.003326416, -0.003387451, -0.003433228, -0.003463745, -0.003479004, -0.003479004, -0.003463745,
197 -0.003417969, -0.003372192, -0.003280640, -0.003173828, -0.003051758, -0.002883911, -0.002700806, -0.002487183,
198 -0.002227783, -0.001937866, -0.001617432, -0.001266479, -0.000869751, -0.000442505, 0.000030518, 0.000549316,
199 0.001098633, 0.001693726, 0.002334595, 0.003005981, 0.003723145, 0.004486084, 0.005294800, 0.006118774,
200 0.007003784, 0.007919312, 0.008865356, 0.009841919, 0.010848999, 0.011886597, 0.012939453, 0.014022827,
201 0.015121460, 0.016235352, 0.017349243, 0.018463135, 0.019577026, 0.020690918, 0.021789551, 0.022857666,
202 0.023910522, 0.024932861, 0.025909424, 0.026840210, 0.027725220, 0.028533936, 0.029281616, 0.029937744,
203 0.030532837, 0.031005859, 0.031387329, 0.031661987, 0.031814575, 0.031845093, 0.031738281, 0.031478882,
204 0.031082153, 0.030517578, 0.029785156, 0.028884888, 0.027801514, 0.026535034, 0.025085449, 0.023422241,
205 0.021575928, 0.019531250, 0.017257690, 0.014801025, 0.012115479, 0.009231567, 0.006134033, 0.002822876,
206 -0.000686646, -0.004394531, -0.008316040, -0.012420654, -0.016708374, -0.021179199, -0.025817871, -0.030609131,
207 -0.035552979, -0.040634155, -0.045837402, -0.051132202, -0.056533813, -0.061996460, -0.067520142, -0.073059082,
208 -0.078628540, -0.084182739, -0.089706421, -0.095169067, -0.100540161, -0.105819702, -0.110946655, -0.115921021,
209 -0.120697021, -0.125259399, -0.129562378, -0.133590698, -0.137298584, -0.140670776, -0.143676758, -0.146255493,
210 -0.148422241, -0.150115967, -0.151306152, -0.151962280, -0.152069092, -0.151596069, -0.150497437, -0.148773193,
211 -0.146362305, -0.143264771, -0.139450073, -0.134887695, -0.129577637, -0.123474121, -0.116577148, -0.108856201,
212 -0.100311279, -0.090927124, -0.080688477, -0.069595337, -0.057617187, -0.044784546, -0.031082153, -0.016510010,
213 -0.001068115, 0.015228271, 0.032379150, 0.050354004, 0.069168091, 0.088775635, 0.109161377, 0.130310059,
214 0.152206421, 0.174789429, 0.198059082, 0.221984863, 0.246505737, 0.271591187, 0.297210693, 0.323318481,
215 0.349868774, 0.376800537, 0.404083252, 0.431655884, 0.459472656, 0.487472534, 0.515609741, 0.543823242,
216 0.572036743, 0.600219727, 0.628295898, 0.656219482, 0.683914185, 0.711318970, 0.738372803, 0.765029907,
217 0.791213989, 0.816864014, 0.841949463, 0.866363525, 0.890090942, 0.913055420, 0.935195923, 0.956481934,
218 0.976852417, 0.996246338, 1.014617920, 1.031936646, 1.048156738, 1.063217163, 1.077117920, 1.089782715,
219 1.101211548, 1.111373901, 1.120223999, 1.127746582, 1.133926392, 1.138763428, 1.142211914, 1.144287109,
225const int16
huffmanTab2[] = { -15,-11,-9,-5,-3,-1,34,2,18,-1,33,32,17,-1,1,16,0 };
226const int16
huffmanTab3[] = { -13,-11,-9,-5,-3,-1,34,2,18,-1,33,32,16,17,-1,1,0 };
227const 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 };
228const 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 };
232 -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,
233 -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
238 -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,
239 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
244 -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,
245 -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
250 -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,
251 -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,
252 -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,
253 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
258 -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,
259 -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,
260 -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,
261 -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
266 -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,
267 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,
268 -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,
269 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
274 -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,
275 -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,
276 -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,
277 -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,
278 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,
279 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,
280 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,
281 -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,
282 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,
283 -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,
284 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,
285 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,
286 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,
287 -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,
288 -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,
289 -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
294 -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,
295 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,
296 -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,
297 -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,
298 -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,
299 -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,
300 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,
301 -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,
302 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,
303 -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,
304 -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,
305 -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,
306 -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,
307 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,
308 -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,
309 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
314 -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,
315 -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,
316 -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,
317 -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,
318 -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,
319 -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,
320 -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,
321 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,
322 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,
323 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,
324 -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,
325 -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,
326 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,
327 -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,
328 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,
329 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
334 -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,
335 -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,
336 -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,
337 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,
338 -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,
339 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,
340 -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,
341 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,
342 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,
343 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,
344 -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,
345 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,
346 -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,
347 -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,
348 -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
369const 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 };
370const 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 };
377 bool read (
const uint8* data)
noexcept
381 const int layer = (data[1] >> 1) & 3;
385 const int type = (data[1] >> 3) & 1;
386 const int sampleRateIndex = (data[2] >> 2) & 3;
387 const int mode = (data[3] >> 6) & 3;
389 static const short bitRates[3][16] =
391 { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, -1 },
392 { 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, -1 },
393 { 0, 8, 16, 24, 32, 40, 48, 56, 64, -1, -1, -1, -1, -1, -1, -1 },
396 const int bitrate = bitRates[type][((data[2] >> 4) & 15)];
398 const int sampleRates[3][4] =
400 { 22050, 24000, 16000, -1 },
401 { 44100, 48000, 32000, -1 },
402 { 11025, 12000, 8000, -1 },
405 if ((data[1] >> 4) == 0xe)
406 sampleRate = sampleRates[2][sampleRateIndex];
408 sampleRate = sampleRates[type][sampleRateIndex];
410 data += type != 0 ? (mode != 3 ? (32 + 4) : (17 + 4))
411 : (mode != 3 ? (17 + 4) : (9 + 4));
413 if (! isVbrTag (data))
417 flags = ByteOrder::bigEndianInt (data);
422 frames = ByteOrder::bigEndianInt (data);
428 bytes = ByteOrder::bigEndianInt (data);
434 for (
int i = 0; i < 100; ++i)
443 vbrScale = (int) ByteOrder::bigEndianInt (data);
445 headersize = ((type + 1) * 72000 * bitrate) / sampleRate;
450 int sampleRate, vbrScale, headersize;
451 unsigned int flags, frames, bytes;
454 static bool isVbrTag (
const uint8* d)
noexcept
456 return (d[0] ==
'X' && d[1] ==
'i' && d[2] ==
'n' && d[3] ==
'g')
457 || (d[0] ==
'I' && d[1] ==
'n' && d[2] ==
'f' && d[3] ==
'o');
466 zeromem (
this,
sizeof (MP3Frame));
470 void selectLayer2Table()
472 static const int translate[3][2][16] =
474 { { 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 } },
475 { { 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 } },
476 { { 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 static const AllocationTable*
const tables[] = { allocTable0, allocTable1, allocTable2, allocTable3, allocTable4 };
480 static const int8 limits[] = { 27, 30, 8, 12, 30 };
482 const int index = lsf ? 4 : translate[sampleRateIndex][2 - numChannels][bitrateIndex];
483 layer2SubBandLimit = limits[index];
484 allocationTable = tables[index];
487 int getFrequency() const noexcept
489 const int frequencies[] = { 44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000 };
490 return frequencies[sampleRateIndex];
493 void decodeHeader (
const uint32 header)
495 jassert (((header >> 10) & 3) != 3);
497 mpeg25 = (header & (1 << 20)) == 0;
498 lsf = mpeg25 ? 1 : ((header & (1 << 19)) ? 0 : 1);
499 layer = 4 - ((header >> 17) & 3);
500 sampleRateIndex = mpeg25 ? (6 + ((header >> 10) & 3)) : ((int) ((header >> 10) & 3) + (lsf * 3));
501 crc16FollowsHeader = ((header >> 16) & 1) == 0;
502 bitrateIndex = (header >> 12) & 15;
503 padding = (header >> 9) & 1;
504 mode = (header >> 6) & 3;
505 modeExt = (header >> 4) & 3;
510 numChannels = (mode == 3) ? 1 : 2;
512 static const int frameSizes[2][3][16] =
514 { { 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448 },
515 { 0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384 },
516 { 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 } },
518 { { 0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256 },
519 { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 },
520 { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 } }
523 if (bitrateIndex == 0)
533 case 1: frameSize = (((frameSizes[lsf][0][bitrateIndex] * 12000) / getFrequency() + padding) * 4) - 4;
break;
534 case 2: frameSize = (frameSizes[lsf][1][bitrateIndex] * 144000) / getFrequency() + (padding - 4);
break;
535 case 3: frameSize = (bitrateIndex == 0) ? 0 : ((frameSizes[lsf][2][bitrateIndex] * 144000) / (getFrequency() << lsf) + (padding - 4));
break;
541 int layer, frameSize, numChannels, single;
544 bool crc16FollowsHeader;
545 int bitrateIndex, sampleRateIndex, padding;
546 int mode, modeExt, layer2SubBandLimit;
547 enum { downSampleLimit = 32 };
548 const AllocationTable* allocationTable;
556 cosTables[0] = cos64; cosTables[1] = cos32; cosTables[2] = cos16; cosTables[3] = cos8; cosTables[4] = cos4;
562 const uint8* getGroupTable (
const int16 d1,
const uint32 index)
const noexcept
566 case 3:
return &group3tab[3 * jmin (index, 3u * 3u * 3u)];
567 case 5:
return &group5tab[3 * jmin (index, 5u * 5u * 5u)];
568 case 9:
return &group9tab[3 * jmin (index, 9u * 9u * 9u)];
572 static const uint8 dummy[] = { 0, 0, 0 };
577 float nToThe4Over3[8207];
578 float antiAliasingCa[8], antiAliasingCs[8];
581 float powToGains[256 + 118 + 4];
582 int longLimit[9][23];
583 int shortLimit[9][14];
584 float tan1_1[16], tan2_1[16], tan1_2[16], tan2_2[16];
585 float pow1_1[2][16], pow2_1[2][16], pow1_2[2][16], pow2_2[2][16];
588 uint32 nLength2[512];
589 uint32 iLength2[256];
590 float decodeWin[512 + 32];
597 float cos64[16], cos32[8], cos16[4], cos8[2], cos4[1];
598 uint8 group3tab[32 * 3];
599 uint8 group5tab[128 * 3];
600 uint8 group9tab[1024 * 3];
602 void initDecodeTables()
604 int i, j, scaleval = -1;
605 float* table = decodeWin;
607 for (i = 0; i < 5; ++i)
610 int divv = 0x40 >> i;
611 float* costab = cosTables[i];
613 for (
int k = 0; k < kr; ++k)
614 costab[k] = (
float) (1.0 / (2.0 * std::cos (MathConstants<double>::pi * (k * 2 + 1) / divv)));
617 for (i = 0, j = 0; i < 256; ++i, ++j, table += 32)
619 if (table < decodeWin + 512 + 16)
620 table[16] = table[0] = (float) (decodeWindow[j] * scaleval);
624 scaleval = -scaleval;
627 for (; i < 512; ++i, --j, table += 32)
629 if (table < decodeWin + 512 + 16)
630 table[16] = table[0] = (float) (decodeWindow[j] * scaleval);
632 if (i % 32 == 31) table -= 1023;
633 if (i % 64 == 63) scaleval = -scaleval;
637 void initLayer2Tables()
639 static const uint8 base[3][9] =
642 { 17, 18, 0, 19, 20 },
643 { 21, 1, 22, 23, 0, 24, 25, 2, 26 }
646 static const int tableLengths[] = { 3, 5, 9 };
647 static uint8* tables[] = { group3tab, group5tab, group9tab };
649 for (
int i = 0; i < 3; ++i)
651 uint8* table = tables[i];
652 const int len = tableLengths[i];
654 for (
int j = 0; j < len; ++j)
655 for (
int k = 0; k < len; ++k)
656 for (
int l = 0; l < len; ++l)
658 *table++ = base[i][l];
659 *table++ = base[i][k];
660 *table++ = base[i][j];
664 for (
int k = 0; k < 27; ++k)
666 static const double multipliers[] =
668 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,
669 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,
670 -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
673 float* table = muls[k];
674 for (
int j = 3, i = 0; i < 63; ++i, --j)
675 *table++ = (
float) (multipliers[k] * std::pow (2.0, j / 3.0));
680 void initLayer3Tables()
683 for (i = -256; i < 118 + 4; ++i)
684 powToGains[i + 256] = (
float) std::pow (2.0, -0.25 * (i + 210));
686 for (i = 0; i < 8207; ++i)
687 nToThe4Over3[i] = (
float) std::pow ((
double) i, 4.0 / 3.0);
689 for (i = 0; i < 8; ++i)
691 static double Ci[] = { -0.6, -0.535, -0.33, -0.185, -0.095, -0.041, -0.0142, -0.0037 };
692 const double sq = sqrt (1.0 + Ci[i] * Ci[i]);
693 antiAliasingCs[i] = (float) (1.0 / sq);
694 antiAliasingCa[i] = (float) (Ci[i] / sq);
697 for (i = 0; i < 18; ++i)
699 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));
700 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));
703 const double piOver72 = MathConstants<double>::pi / 72.0;
705 for (i = 0; i < 6; ++i)
707 win[1][i + 18] = (float) (0.5 / std::cos (piOver72 * (2 * (i + 18) + 19)));
708 win[3][i + 12] = (float) (0.5 / std::cos (piOver72 * (2 * (i + 12) + 19)));
709 win[1][i + 24] = (float) (0.5 * std::sin (MathConstants<double>::pi / 24.0 * (2 * i + 13)) / std::cos (piOver72 * (2 * (i + 24) + 19)));
710 win[1][i + 30] = win[3][i] = 0;
711 win[3][i + 6] = (float) (0.5 * std::sin (MathConstants<double>::pi / 24.0 * (2 * i + 1)) / std::cos (piOver72 * (2 * (i + 6) + 19)));
714 for (i = 0; i < 12; ++i)
715 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));
717 for (j = 0; j < 4; ++j)
719 static const int len[4] = { 36, 36, 12, 36 };
720 for (i = 0; i < len[j]; i += 2) win1[j][i] = win[j][i];
721 for (i = 1; i < len[j]; i += 2) win1[j][i] = -win[j][i];
724 const double sqrt2 = 1.41421356237309504880168872420969808;
726 for (i = 0; i < 16; ++i)
728 const double t = std::tan (i * MathConstants<double>::pi / 12.0);
729 tan1_1[i] = (float) (t / (1.0 + t));
730 tan2_1[i] = (float) (1.0 / (1.0 + t));
731 tan1_2[i] = (float) (sqrt2 * t / (1.0 + t));
732 tan2_2[i] = (float) (sqrt2 / (1.0 + t));
734 for (j = 0; j < 2; ++j)
736 double p1 = 1.0, p2 = 1.0;
740 const double base = std::pow (2.0, -0.25 * (j + 1));
743 p1 = std::pow (base, (i + 1) * 0.5);
745 p2 = std::pow (base, i * 0.5);
748 pow1_1[j][i] = (float) p1;
749 pow2_1[j][i] = (float) p2;
750 pow1_2[j][i] = (float) (sqrt2 * p1);
751 pow2_2[j][i] = (float) (sqrt2 * p2);
755 for (j = 0; j < 9; ++j)
757 const BandInfoStruct& bi = bandInfo[j];
759 int* mp = map[j][0] = mapbuf0[j];
760 const int16* bdf = bi.longDiff;
762 for (i = 0, cb = 0; cb < 8; ++cb, i += *bdf++)
769 bdf = bi.shortDiff + 3;
771 for (cb = 3; cb < 13; ++cb)
773 const int l = (*bdf++) >> 1;
775 for (
int lwin = 0; lwin < 3; ++lwin)
786 mp = map[j][1] = mapbuf1[j];
789 for (i = 0, cb = 0; cb < 13; ++cb)
791 const int l = (*bdf++) >> 1;
792 for (
int lwin = 0; lwin < 3; ++lwin)
803 mp = map[j][2] = mapbuf2[j];
805 for (cb = 0; cb < 22; ++cb)
807 *mp++ = (*bdf++) >> 1;
814 for (j = 0; j < 9; ++j)
816 for (i = 0; i < 23; ++i) longLimit[j][i] = jmin (32, (bandInfo[j].longIndex[i] - 1 + 8) / 18 + 1);
817 for (i = 0; i < 14; ++i) shortLimit[j][i] = jmin (32, (bandInfo[j].shortIndex[i] - 1) / 18 + 1);
820 for (i = 0; i < 5; ++i)
821 for (j = 0; j < 6; ++j)
822 for (
int k = 0; k < 6; ++k)
824 const int n = k + j * 6 + i * 36;
825 iLength2[n] = (
unsigned int) (i | (j << 3) | (k << 6) | (3 << 12));
828 for (i = 0; i < 4; ++i)
829 for (j = 0; j < 4; ++j)
830 for (
int k = 0; k < 4; ++k)
832 const int n = k + j * 4 + i * 16;
833 iLength2[n + 180] = (
unsigned int) (i | (j << 3) | (k << 6) | (4 << 12));
836 for (i = 0; i < 4; ++i)
837 for (j = 0; j < 3; ++j)
839 const int n = j + i * 3;
840 iLength2[n + 244] = (
unsigned int) (i | (j << 3) | (5 << 12));
841 nLength2[n + 500] = (
unsigned int) (i | (j << 3) | (2 << 12) | (1 << 15));
844 for (i = 0; i < 5; ++i)
845 for (j = 0; j < 5; ++j)
846 for (
int k = 0; k < 4; ++k)
847 for (
int l = 0; l < 4; ++l)
849 const int n = l + k * 4 + j * 16 + i * 80;
850 nLength2[n] = (
unsigned int) (i | (j << 3) | (k << 6) | (l << 9) | (0 << 12));
853 for (i = 0; i < 5; ++i)
854 for (j = 0; j < 5; ++j)
855 for (
int k = 0; k < 4; ++k)
857 const int n = k + j * 4 + i * 20;
858 nLength2[n + 400] = (
unsigned int) (i | (j << 3) | (k << 6) | (1 << 12));
871 void doAntialias (
float xr[32][18])
const noexcept
878 if (mixedBlockFlag == 0)
886 for (; sb != 0; --sb, xr1 += 10)
888 auto* cs = constants.antiAliasingCs;
889 auto* ca = constants.antiAliasingCa;
892 for (
int ss = 7; ss >= 0; --ss)
894 const float bu = *--xr2, bd = *xr1;
895 *xr2 = (bu * *cs) - (bd * *ca);
896 *xr1++ = (bd * *cs++) + (bu * *ca++);
901 void doIStereo (
float xrBuffer[2][32][18],
const int* scaleFactors,
902 int sampleRate,
bool msStereo,
int lsf)
const noexcept
904 float (*xr) [32 * 18] = (float (*) [32 * 18]) xrBuffer;
905 auto& bi = bandInfo[sampleRate];
906 const float* tabl1, *tabl2;
910 auto p = scaleFactorCompression & 1;
914 tabl1 = constants.pow1_2[p];
915 tabl2 = constants.pow2_2[p];
919 tabl1 = constants.pow1_1[p];
920 tabl2 = constants.pow2_1[p];
927 tabl1 = constants.tan1_2;
928 tabl2 = constants.tan2_2;
932 tabl1 = constants.tan1_1;
933 tabl2 = constants.tan2_1;
939 bool doL = mixedBlockFlag != 0;
941 for (uint32 lwin = 0; lwin < 3; ++lwin)
943 uint32 sfb = maxBand[lwin];
944 doL = doL && (sfb <= 3);
946 for (; sfb < 12; ++sfb)
948 auto p = scaleFactors[sfb * 3 + lwin - mixedBlockFlag];
954 int sb = bi.shortDiff[sfb];
955 auto index = (uint32) sb + lwin;
957 for (; sb > 0; --sb, index += 3)
959 float v = xr[0][index];
960 xr[0][index] = v * t1;
961 xr[1][index] = v * t2;
966 auto p = scaleFactors[11 * 3 + lwin - mixedBlockFlag];
972 int sb = bi.shortDiff[12];
973 auto index = (uint32) sb + lwin;
975 for (; sb > 0; --sb, index += 3)
977 float v = xr[0][index];
978 xr[0][index] = v * t1;
979 xr[1][index] = v * t2;
986 int index = bi.longIndex[maxBandl];
988 for (uint32 sfb = maxBandl; sfb < 8; ++sfb)
990 int sb = bi.longDiff[sfb];
991 auto p = scaleFactors[sfb];
998 for (; sb > 0; --sb, ++index)
1000 float v = xr[0][index];
1001 xr[0][index] = v * t1;
1002 xr[1][index] = v * t2;
1012 int index = bi.longIndex[maxBandl];
1014 for (uint32 sfb = maxBandl; sfb < 21; ++sfb)
1016 int sb = bi.longDiff[sfb];
1017 auto p = scaleFactors[sfb];
1024 for (; sb > 0; --sb, ++index)
1026 const float v = xr[0][index];
1027 xr[0][index] = v * t1;
1028 xr[1][index] = v * t2;
1035 auto p = scaleFactors[20];
1039 auto t1 = tabl1[p], t2 = tabl2[p];
1041 for (
int sb = bi.longDiff[21]; sb > 0; --sb, ++index)
1043 const float v = xr[0][index];
1044 xr[0][index] = v * t1;
1045 xr[1][index] = v * t2;
1052 uint32 part2_3Length, bigValues;
1053 uint32 scaleFactorCompression, blockType, mixedBlockFlag;
1054 uint32 tableSelect[3];
1056 uint32 maxBandl, maxb, region1Start, region2Start;
1057 uint32 preflag, scaleFactorScale, count1TableSelect;
1058 const float* fullGain[3];
1059 const float* pow2gain;
1062 struct InfoPair { Info gr[2]; };
1065 uint32 mainDataStart, privateBits;
1071 enum { subBandLimit = 32 };
1072 static const float cos6_1 = 0.866025388f;
1073 static const float cos6_2 = 0.5f;
1074 static const float cos9[] = { 1.0f, 0.98480773f, 0.939692616f, 0.866025388f, 0.766044438f, 0.642787635f, 0.5f, 0.342020154f, 0.173648179f };
1075 static const float cos36[] = { 0.501909912f, 0.517638087f, 0.551688969f, 0.610387266f, 0.707106769f, 0.871723413f, 1.18310082f, 1.93185163f, 5.73685646f };
1076 static const float cos12[] = { 0.517638087f, 0.707106769f, 1.93185163f };
1078 inline void dct36_0 (
int v,
float* ts,
float* out1,
float* out2,
const float* wintab,
float sum0,
float sum1)
noexcept
1080 auto tmp = sum0 + sum1;
1081 out2[9 + v] = tmp * wintab[27 + v];
1082 out2[8 - v] = tmp * wintab[26 - v];
1084 ts[subBandLimit * (8 - v)] = out1[8 - v] + sum0 * wintab[8 - v];
1085 ts[subBandLimit * (9 + v)] = out1[9 + v] + sum0 * wintab[9 + v];
1088 inline void dct36_12 (
int v1,
int v2,
float* ts,
float* out1,
float* out2,
const float* wintab,
1089 float tmp1a,
float tmp1b,
float tmp2a,
float tmp2b)
noexcept
1091 dct36_0 (v1, ts, out1, out2, wintab, tmp1a + tmp2a, (tmp1b + tmp2b) * cos36[v1]);
1092 dct36_0 (v2, ts, out1, out2, wintab, tmp2a - tmp1a, (tmp2b - tmp1b) * cos36[v2]);
1095 static void dct36 (
float* in,
float* out1,
float* out2,
const float* wintab,
float* ts)
noexcept
1097 in[17] += in[16]; in[16] += in[15]; in[15] += in[14]; in[14] += in[13]; in[13] += in[12];
1098 in[12] += in[11]; in[11] += in[10]; in[10] += in[9]; in[9] += in[8]; in[8] += in[7];
1099 in[7] += in[6]; in[6] += in[5]; in[5] += in[4]; in[4] += in[3]; in[3] += in[2];
1100 in[2] += in[1]; in[1] += in[0]; in[17] += in[15]; in[15] += in[13]; in[13] += in[11];
1101 in[11] += in[9]; in[9] += in[7]; in[7] += in[5]; in[5] += in[3]; in[3] += in[1];
1103 auto ta33 = in[6] * cos9[3];
1104 auto ta66 = in[12] * cos9[6];
1105 auto tb33 = in[7] * cos9[3];
1106 auto tb66 = in[13] * cos9[6];
1108 dct36_12 (0, 8, ts, out1, out2, wintab,
1109 in[2] * cos9[1] + ta33 + in[10] * cos9[5] + in[14] * cos9[7],
1110 in[3] * cos9[1] + tb33 + in[11] * cos9[5] + in[15] * cos9[7],
1111 in[0] + in[4] * cos9[2] + in[8] * cos9[4] + ta66 + in[16] * cos9[8],
1112 in[1] + in[5] * cos9[2] + in[9] * cos9[4] + tb66 + in[17] * cos9[8]);
1114 dct36_12 (1, 7, ts, out1, out2, wintab,
1115 (in[2] - in[10] - in[14]) * cos9[3],
1116 (in[3] - in[11] - in[15]) * cos9[3],
1117 (in[4] - in[8] - in[16]) * cos9[6] - in[12] + in[0],
1118 (in[5] - in[9] - in[17]) * cos9[6] - in[13] + in[1]);
1120 dct36_12 (2, 6, ts, out1, out2, wintab,
1121 in[2] * cos9[5] - ta33 - in[10] * cos9[7] + in[14] * cos9[1],
1122 in[3] * cos9[5] - tb33 - in[11] * cos9[7] + in[15] * cos9[1],
1123 in[0] - in[4] * cos9[8] - in[8] * cos9[2] + ta66 + in[16] * cos9[4],
1124 in[1] - in[5] * cos9[8] - in[9] * cos9[2] + tb66 + in[17] * cos9[4]);
1126 dct36_12 (3, 5, ts, out1, out2, wintab,
1127 in[2] * cos9[7] - ta33 + in[10] * cos9[1] - in[14] * cos9[5],
1128 in[3] * cos9[7] - tb33 + in[11] * cos9[1] - in[15] * cos9[5],
1129 in[0] - in[4] * cos9[4] + in[8] * cos9[8] + ta66 - in[16] * cos9[2],
1130 in[1] - in[5] * cos9[4] + in[9] * cos9[8] + tb66 - in[17] * cos9[2]);
1132 dct36_0 (4, ts, out1, out2, wintab,
1133 in[0] - in[4] + in[8] - in[12] + in[16],
1134 (in[1] - in[5] + in[9] - in[13] + in[17]) * cos36[4]);
1139 float in0, in1, in2, in3, in4, in5;
1141 inline DCT12Inputs (
const float* in)
noexcept
1143 in5 = in[5 * 3] + (in4 = in[4 * 3]);
1144 in4 += (in3 = in[3 * 3]);
1145 in3 += (in2 = in[2 * 3]);
1146 in2 += (in1 = in[1 * 3]);
1147 in1 += (in0 = in[0 * 3]);
1148 in5 += in3; in3 += in1;
1153 inline void process() noexcept
1155 in0 += in4 * cos6_2;
1156 in4 = in0 + in2; in0 -= in2;
1157 in1 += in5 * cos6_2;
1158 in5 = (in1 + in3) * cos12[0];
1159 in1 = (in1 - in3) * cos12[2];
1160 in3 = in4 + in5; in4 -= in5;
1161 in2 = in0 + in1; in0 -= in1;
1165 static void dct12 (
const float* in,
float* out1,
float* out2,
const float* wi,
float* ts)
noexcept
1169 ts[subBandLimit * 1] = out1[1];
1170 ts[subBandLimit * 2] = out1[2];
1171 ts[subBandLimit * 3] = out1[3];
1172 ts[subBandLimit * 4] = out1[4];
1173 ts[subBandLimit * 5] = out1[5];
1175 DCT12Inputs inputs (in);
1178 auto tmp1 = (inputs.in0 - inputs.in4);
1179 auto tmp2 = (inputs.in1 - inputs.in5) * cos12[1];
1180 auto tmp0 = tmp1 + tmp2;
1183 ts[16 * subBandLimit] = out1[16] + tmp0 * wi[10];
1184 ts[13 * subBandLimit] = out1[13] + tmp0 * wi[7];
1185 ts[7 * subBandLimit] = out1[7] + tmp1 * wi[1];
1186 ts[10 * subBandLimit] = out1[10] + tmp1 * wi[4];
1191 ts[17 * subBandLimit] = out1[17] + inputs.in2 * wi[11];
1192 ts[12 * subBandLimit] = out1[12] + inputs.in2 * wi[6];
1193 ts[14 * subBandLimit] = out1[14] + inputs.in3 * wi[8];
1194 ts[15 * subBandLimit] = out1[15] + inputs.in3 * wi[9];
1196 ts[6 * subBandLimit] = out1[6] + inputs.in0 * wi[0];
1197 ts[11 * subBandLimit] = out1[11] + inputs.in0 * wi[5];
1198 ts[8 * subBandLimit] = out1[8] + inputs.in4 * wi[2];
1199 ts[9 * subBandLimit] = out1[9] + inputs.in4 * wi[3];
1203 DCT12Inputs inputs (++in);
1204 auto tmp1 = (inputs.in0 - inputs.in4);
1205 auto tmp2 = (inputs.in1 - inputs.in5) * cos12[1];
1206 auto tmp0 = tmp1 + tmp2;
1208 out2[4] = tmp0 * wi[10];
1209 out2[1] = tmp0 * wi[7];
1210 ts[13 * subBandLimit] += tmp1 * wi[1];
1211 ts[16 * subBandLimit] += tmp1 * wi[4];
1215 out2[5] = inputs.in2 * wi[11];
1216 out2[0] = inputs.in2 * wi[6];
1217 out2[2] = inputs.in3 * wi[8];
1218 out2[3] = inputs.in3 * wi[9];
1219 ts[12 * subBandLimit] += inputs.in0 * wi[0];
1220 ts[17 * subBandLimit] += inputs.in0 * wi[5];
1221 ts[14 * subBandLimit] += inputs.in4 * wi[2];
1222 ts[15 * subBandLimit] += inputs.in4 * wi[5 - 2];
1226 DCT12Inputs inputs (++in);
1227 out2[12] = out2[13] = out2[14] = out2[15] = out2[16] = out2[17] = 0;
1229 auto tmp1 = (inputs.in0 - inputs.in4);
1230 auto tmp2 = (inputs.in1 - inputs.in5) * cos12[1];
1231 auto tmp0 = tmp1 + tmp2;
1234 out2[10] = tmp0 * wi[10];
1235 out2[7] = tmp0 * wi[7];
1236 out2[1] += tmp1 * wi[1];
1237 out2[4] += tmp1 * wi[4];
1241 out2[11] = inputs.in2 * wi[11];
1242 out2[6] = inputs.in2 * wi[6];
1243 out2[8] = inputs.in3 * wi[8];
1244 out2[9] = inputs.in3 * wi[9];
1245 out2[0] += inputs.in0 * wi[0];
1246 out2[5] += inputs.in0 * wi[5];
1247 out2[2] += inputs.in4 * wi[2];
1248 out2[3] += inputs.in4 * wi[3];
1252 static void dct64 (
float* out0,
float* out1,
const float* samples)
noexcept
1254 float b1[32], b2[32];
1257 auto* costab = constants.cosTables[0];
1258 b1[0x00] = samples[0x00] + samples[0x1F]; b1[0x1F] = (samples[0x00] - samples[0x1F]) * costab[0x0];
1259 b1[0x01] = samples[0x01] + samples[0x1E]; b1[0x1E] = (samples[0x01] - samples[0x1E]) * costab[0x1];
1260 b1[0x02] = samples[0x02] + samples[0x1D]; b1[0x1D] = (samples[0x02] - samples[0x1D]) * costab[0x2];
1261 b1[0x03] = samples[0x03] + samples[0x1C]; b1[0x1C] = (samples[0x03] - samples[0x1C]) * costab[0x3];
1262 b1[0x04] = samples[0x04] + samples[0x1B]; b1[0x1B] = (samples[0x04] - samples[0x1B]) * costab[0x4];
1263 b1[0x05] = samples[0x05] + samples[0x1A]; b1[0x1A] = (samples[0x05] - samples[0x1A]) * costab[0x5];
1264 b1[0x06] = samples[0x06] + samples[0x19]; b1[0x19] = (samples[0x06] - samples[0x19]) * costab[0x6];
1265 b1[0x07] = samples[0x07] + samples[0x18]; b1[0x18] = (samples[0x07] - samples[0x18]) * costab[0x7];
1266 b1[0x08] = samples[0x08] + samples[0x17]; b1[0x17] = (samples[0x08] - samples[0x17]) * costab[0x8];
1267 b1[0x09] = samples[0x09] + samples[0x16]; b1[0x16] = (samples[0x09] - samples[0x16]) * costab[0x9];
1268 b1[0x0A] = samples[0x0A] + samples[0x15]; b1[0x15] = (samples[0x0A] - samples[0x15]) * costab[0xA];
1269 b1[0x0B] = samples[0x0B] + samples[0x14]; b1[0x14] = (samples[0x0B] - samples[0x14]) * costab[0xB];
1270 b1[0x0C] = samples[0x0C] + samples[0x13]; b1[0x13] = (samples[0x0C] - samples[0x13]) * costab[0xC];
1271 b1[0x0D] = samples[0x0D] + samples[0x12]; b1[0x12] = (samples[0x0D] - samples[0x12]) * costab[0xD];
1272 b1[0x0E] = samples[0x0E] + samples[0x11]; b1[0x11] = (samples[0x0E] - samples[0x11]) * costab[0xE];
1273 b1[0x0F] = samples[0x0F] + samples[0x10]; b1[0x10] = (samples[0x0F] - samples[0x10]) * costab[0xF];
1277 auto* costab = constants.cosTables[1];
1278 b2[0x00] = b1[0x00] + b1[0x0F]; b2[0x0F] = (b1[0x00] - b1[0x0F]) * costab[0];
1279 b2[0x01] = b1[0x01] + b1[0x0E]; b2[0x0E] = (b1[0x01] - b1[0x0E]) * costab[1];
1280 b2[0x02] = b1[0x02] + b1[0x0D]; b2[0x0D] = (b1[0x02] - b1[0x0D]) * costab[2];
1281 b2[0x03] = b1[0x03] + b1[0x0C]; b2[0x0C] = (b1[0x03] - b1[0x0C]) * costab[3];
1282 b2[0x04] = b1[0x04] + b1[0x0B]; b2[0x0B] = (b1[0x04] - b1[0x0B]) * costab[4];
1283 b2[0x05] = b1[0x05] + b1[0x0A]; b2[0x0A] = (b1[0x05] - b1[0x0A]) * costab[5];
1284 b2[0x06] = b1[0x06] + b1[0x09]; b2[0x09] = (b1[0x06] - b1[0x09]) * costab[6];
1285 b2[0x07] = b1[0x07] + b1[0x08]; b2[0x08] = (b1[0x07] - b1[0x08]) * costab[7];
1286 b2[0x10] = b1[0x10] + b1[0x1F]; b2[0x1F] = (b1[0x1F] - b1[0x10]) * costab[0];
1287 b2[0x11] = b1[0x11] + b1[0x1E]; b2[0x1E] = (b1[0x1E] - b1[0x11]) * costab[1];
1288 b2[0x12] = b1[0x12] + b1[0x1D]; b2[0x1D] = (b1[0x1D] - b1[0x12]) * costab[2];
1289 b2[0x13] = b1[0x13] + b1[0x1C]; b2[0x1C] = (b1[0x1C] - b1[0x13]) * costab[3];
1290 b2[0x14] = b1[0x14] + b1[0x1B]; b2[0x1B] = (b1[0x1B] - b1[0x14]) * costab[4];
1291 b2[0x15] = b1[0x15] + b1[0x1A]; b2[0x1A] = (b1[0x1A] - b1[0x15]) * costab[5];
1292 b2[0x16] = b1[0x16] + b1[0x19]; b2[0x19] = (b1[0x19] - b1[0x16]) * costab[6];
1293 b2[0x17] = b1[0x17] + b1[0x18]; b2[0x18] = (b1[0x18] - b1[0x17]) * costab[7];
1297 auto* costab = constants.cosTables[2];
1298 b1[0x00] = b2[0x00] + b2[0x07]; b1[0x07] = (b2[0x00] - b2[0x07]) * costab[0];
1299 b1[0x01] = b2[0x01] + b2[0x06]; b1[0x06] = (b2[0x01] - b2[0x06]) * costab[1];
1300 b1[0x02] = b2[0x02] + b2[0x05]; b1[0x05] = (b2[0x02] - b2[0x05]) * costab[2];
1301 b1[0x03] = b2[0x03] + b2[0x04]; b1[0x04] = (b2[0x03] - b2[0x04]) * costab[3];
1302 b1[0x08] = b2[0x08] + b2[0x0F]; b1[0x0F] = (b2[0x0F] - b2[0x08]) * costab[0];
1303 b1[0x09] = b2[0x09] + b2[0x0E]; b1[0x0E] = (b2[0x0E] - b2[0x09]) * costab[1];
1304 b1[0x0A] = b2[0x0A] + b2[0x0D]; b1[0x0D] = (b2[0x0D] - b2[0x0A]) * costab[2];
1305 b1[0x0B] = b2[0x0B] + b2[0x0C]; b1[0x0C] = (b2[0x0C] - b2[0x0B]) * costab[3];
1306 b1[0x10] = b2[0x10] + b2[0x17]; b1[0x17] = (b2[0x10] - b2[0x17]) * costab[0];
1307 b1[0x11] = b2[0x11] + b2[0x16]; b1[0x16] = (b2[0x11] - b2[0x16]) * costab[1];
1308 b1[0x12] = b2[0x12] + b2[0x15]; b1[0x15] = (b2[0x12] - b2[0x15]) * costab[2];
1309 b1[0x13] = b2[0x13] + b2[0x14]; b1[0x14] = (b2[0x13] - b2[0x14]) * costab[3];
1310 b1[0x18] = b2[0x18] + b2[0x1F]; b1[0x1F] = (b2[0x1F] - b2[0x18]) * costab[0];
1311 b1[0x19] = b2[0x19] + b2[0x1E]; b1[0x1E] = (b2[0x1E] - b2[0x19]) * costab[1];
1312 b1[0x1A] = b2[0x1A] + b2[0x1D]; b1[0x1D] = (b2[0x1D] - b2[0x1A]) * costab[2];
1313 b1[0x1B] = b2[0x1B] + b2[0x1C]; b1[0x1C] = (b2[0x1C] - b2[0x1B]) * costab[3];
1317 auto cos0 = constants.cosTables[3][0];
1318 auto cos1 = constants.cosTables[3][1];
1319 b2[0x00] = b1[0x00] + b1[0x03]; b2[0x03] = (b1[0x00] - b1[0x03]) * cos0;
1320 b2[0x01] = b1[0x01] + b1[0x02]; b2[0x02] = (b1[0x01] - b1[0x02]) * cos1;
1321 b2[0x04] = b1[0x04] + b1[0x07]; b2[0x07] = (b1[0x07] - b1[0x04]) * cos0;
1322 b2[0x05] = b1[0x05] + b1[0x06]; b2[0x06] = (b1[0x06] - b1[0x05]) * cos1;
1323 b2[0x08] = b1[0x08] + b1[0x0B]; b2[0x0B] = (b1[0x08] - b1[0x0B]) * cos0;
1324 b2[0x09] = b1[0x09] + b1[0x0A]; b2[0x0A] = (b1[0x09] - b1[0x0A]) * cos1;
1325 b2[0x0C] = b1[0x0C] + b1[0x0F]; b2[0x0F] = (b1[0x0F] - b1[0x0C]) * cos0;
1326 b2[0x0D] = b1[0x0D] + b1[0x0E]; b2[0x0E] = (b1[0x0E] - b1[0x0D]) * cos1;
1327 b2[0x10] = b1[0x10] + b1[0x13]; b2[0x13] = (b1[0x10] - b1[0x13]) * cos0;
1328 b2[0x11] = b1[0x11] + b1[0x12]; b2[0x12] = (b1[0x11] - b1[0x12]) * cos1;
1329 b2[0x14] = b1[0x14] + b1[0x17]; b2[0x17] = (b1[0x17] - b1[0x14]) * cos0;
1330 b2[0x15] = b1[0x15] + b1[0x16]; b2[0x16] = (b1[0x16] - b1[0x15]) * cos1;
1331 b2[0x18] = b1[0x18] + b1[0x1B]; b2[0x1B] = (b1[0x18] - b1[0x1B]) * cos0;
1332 b2[0x19] = b1[0x19] + b1[0x1A]; b2[0x1A] = (b1[0x19] - b1[0x1A]) * cos1;
1333 b2[0x1C] = b1[0x1C] + b1[0x1F]; b2[0x1F] = (b1[0x1F] - b1[0x1C]) * cos0;
1334 b2[0x1D] = b1[0x1D] + b1[0x1E]; b2[0x1E] = (b1[0x1E] - b1[0x1D]) * cos1;
1338 auto cos0 = constants.cosTables[4][0];
1339 b1[0x00] = b2[0x00] + b2[0x01]; b1[0x01] = (b2[0x00] - b2[0x01]) * cos0;
1340 b1[0x02] = b2[0x02] + b2[0x03]; b1[0x03] = (b2[0x03] - b2[0x02]) * cos0; b1[0x02] += b1[0x03];
1341 b1[0x04] = b2[0x04] + b2[0x05]; b1[0x05] = (b2[0x04] - b2[0x05]) * cos0;
1342 b1[0x06] = b2[0x06] + b2[0x07]; b1[0x07] = (b2[0x07] - b2[0x06]) * cos0;
1343 b1[0x06] += b1[0x07]; b1[0x04] += b1[0x06]; b1[0x06] += b1[0x05]; b1[0x05] += b1[0x07];
1344 b1[0x08] = b2[0x08] + b2[0x09]; b1[0x09] = (b2[0x08] - b2[0x09]) * cos0;
1345 b1[0x0A] = b2[0x0A] + b2[0x0B]; b1[0x0B] = (b2[0x0B] - b2[0x0A]) * cos0; b1[0x0A] += b1[0x0B];
1346 b1[0x0C] = b2[0x0C] + b2[0x0D]; b1[0x0D] = (b2[0x0C] - b2[0x0D]) * cos0;
1347 b1[0x0E] = b2[0x0E] + b2[0x0F]; b1[0x0F] = (b2[0x0F] - b2[0x0E]) * cos0;
1348 b1[0x0E] += b1[0x0F]; b1[0x0C] += b1[0x0E]; b1[0x0E] += b1[0x0D]; b1[0x0D] += b1[0x0F];
1349 b1[0x10] = b2[0x10] + b2[0x11]; b1[0x11] = (b2[0x10] - b2[0x11]) * cos0;
1350 b1[0x12] = b2[0x12] + b2[0x13]; b1[0x13] = (b2[0x13] - b2[0x12]) * cos0; b1[0x12] += b1[0x13];
1351 b1[0x14] = b2[0x14] + b2[0x15]; b1[0x15] = (b2[0x14] - b2[0x15]) * cos0;
1352 b1[0x16] = b2[0x16] + b2[0x17]; b1[0x17] = (b2[0x17] - b2[0x16]) * cos0;
1353 b1[0x16] += b1[0x17]; b1[0x14] += b1[0x16]; b1[0x16] += b1[0x15]; b1[0x15] += b1[0x17];
1354 b1[0x18] = b2[0x18] + b2[0x19]; b1[0x19] = (b2[0x18] - b2[0x19]) * cos0;
1355 b1[0x1A] = b2[0x1A] + b2[0x1B]; b1[0x1B] = (b2[0x1B] - b2[0x1A]) * cos0; b1[0x1A] += b1[0x1B];
1356 b1[0x1C] = b2[0x1C] + b2[0x1D]; b1[0x1D] = (b2[0x1C] - b2[0x1D]) * cos0;
1357 b1[0x1E] = b2[0x1E] + b2[0x1F]; b1[0x1F] = (b2[0x1F] - b2[0x1E]) * cos0;
1358 b1[0x1E] += b1[0x1F]; b1[0x1C] += b1[0x1E]; b1[0x1E] += b1[0x1D]; b1[0x1D] += b1[0x1F];
1361 out0[0x10 * 16] = b1[0x00]; out0[0x10 * 12] = b1[0x04]; out0[0x10 * 8] = b1[0x02]; out0[0x10 * 4] = b1[0x06];
1362 out0[0] = b1[0x01]; out1[0] = b1[0x01]; out1[0x10 * 4] = b1[0x05]; out1[0x10 * 8] = b1[0x03];
1363 out1[0x10 * 12] = b1[0x07];
1365 b1[0x08] += b1[0x0C]; out0[0x10 * 14] = b1[0x08]; b1[0x0C] += b1[0x0a]; out0[0x10 * 10] = b1[0x0C];
1366 b1[0x0A] += b1[0x0E]; out0[0x10 * 6] = b1[0x0A]; b1[0x0E] += b1[0x09]; out0[0x10 * 2] = b1[0x0E];
1367 b1[0x09] += b1[0x0D]; out1[0x10 * 2] = b1[0x09]; b1[0x0D] += b1[0x0B]; out1[0x10 * 6] = b1[0x0D];
1368 b1[0x0B] += b1[0x0F]; out1[0x10 * 10] = b1[0x0B]; out1[0x10 * 14] = b1[0x0F];
1370 b1[0x18] += b1[0x1C]; out0[0x10 * 15] = b1[0x10] + b1[0x18]; out0[0x10 * 13] = b1[0x18] + b1[0x14];
1371 b1[0x1C] += b1[0x1a]; out0[0x10 * 11] = b1[0x14] + b1[0x1C]; out0[0x10 * 9] = b1[0x1C] + b1[0x12];
1372 b1[0x1A] += b1[0x1E]; out0[0x10 * 7] = b1[0x12] + b1[0x1A]; out0[0x10 * 5] = b1[0x1A] + b1[0x16];
1373 b1[0x1E] += b1[0x19]; out0[0x10 * 3] = b1[0x16] + b1[0x1E]; out0[0x10 * 1] = b1[0x1E] + b1[0x11];
1374 b1[0x19] += b1[0x1D]; out1[0x10 * 1] = b1[0x11] + b1[0x19]; out1[0x10 * 3] = b1[0x19] + b1[0x15];
1375 b1[0x1D] += b1[0x1B]; out1[0x10 * 5] = b1[0x15] + b1[0x1D]; out1[0x10 * 7] = b1[0x1D] + b1[0x13];
1376 b1[0x1B] += b1[0x1F]; out1[0x10 * 9] = b1[0x13] + b1[0x1B]; out1[0x10 * 11] = b1[0x1B] + b1[0x17];
1377 out1[0x10 * 13] = b1[0x17] + b1[0x1F]; out1[0x10 * 15] = b1[0x1F];
1384 MP3Stream (InputStream& source) : stream (source, 8192)
1389 int decodeNextBlock (
float* out0,
float* out1,
int& done)
1393 auto nextFrameOffset = scanForNextFrameHeader (
false);
1395 if (lastFrameSize == -1 || needToSyncBitStream)
1397 needToSyncBitStream =
false;
1404 if (nextFrameOffset < 0)
1407 if (nextFrameOffset > 0)
1409 wasFreeFormat =
false;
1410 needToSyncBitStream =
true;
1411 auto size = (int) (bufferPointer - (bufferSpace[bufferSpaceIndex] + 512));
1416 bufferPointer = bufferSpace[bufferSpaceIndex] + 512;
1419 auto toSkip = (size + nextFrameOffset) - 2880;
1423 stream.skipNextBytes (toSkip);
1424 nextFrameOffset -= toSkip;
1427 stream.read (bufferPointer, nextFrameOffset);
1428 lastFrameSize += nextFrameOffset;
1431 frame.decodeHeader ((uint32) stream.readIntBigEndian());
1432 headerParsed =
true;
1433 frameSize = frame.frameSize;
1434 isFreeFormat = (frameSize == 0);
1435 sideInfoSize = frame.lsf != 0 ? ((frame.numChannels == 1) ? 9 : 17)
1436 : ((frame.numChannels == 1) ? 17 : 32);
1438 if (frame.crc16FollowsHeader)
1441 bufferSpaceIndex = 1 - bufferSpaceIndex;
1442 bufferPointer = bufferSpace[bufferSpaceIndex] + 512;
1445 if (lastFrameSize < 0)
1451 if (frame.layer == 3)
1453 stream.read (bufferPointer, sideInfoSize);
1455 if (frame.crc16FollowsHeader)
1458 auto bits = jmax (0, decodeLayer3SideInfo());
1459 dataSize = (bits + 7) / 8;
1462 dataSize = jmin (dataSize, frame.frameSize - sideInfoSize);
1466 dataSize = frame.frameSize;
1477 stream.read (bufferPointer, dataSize);
1479 if (out0 !=
nullptr)
1481 if (frame.layer < 3 && frame.crc16FollowsHeader)
1484 switch (frame.layer)
1486 case 1: decodeLayer1Frame (out0, out1, done);
break;
1487 case 2: decodeLayer2Frame (out0, out1, done);
break;
1488 case 3: decodeLayer3Frame (out0, out1, done);
break;
1493 bufferPointer = bufferSpace[bufferSpaceIndex] + 512 + sideInfoSize + dataSize;
1502 frameSize = lastFrameSizeNoPadding + frame.padding;
1506 auto nextFrameOffset = scanForNextFrameHeader (
true);
1508 wasFreeFormat = isFreeFormat;
1510 if (nextFrameOffset < 0)
1512 lastFrameSize = frameSize;
1516 frameSize = nextFrameOffset + sideInfoSize + dataSize;
1517 lastFrameSizeNoPadding = frameSize - frame.padding;
1524 int bytes = frameSize - (sideInfoSize + dataSize);
1528 auto toSkip = bytes - 512;
1532 stream.skipNextBytes (toSkip);
1534 frameSize -= toSkip;
1537 stream.read (bufferPointer, bytes);
1538 bufferPointer += bytes;
1541 lastFrameSize = frameSize;
1542 wasFreeFormat = isFreeFormat;
1544 headerParsed = sideParsed = dataParsed =
false;
1548 bool seek (
int frameIndex)
1550 frameIndex = jmax (0, frameIndex);
1552 while (frameIndex >= frameStreamPositions.size() * storedStartPosInterval)
1555 auto result = decodeNextBlock (
nullptr,
nullptr, dummy);
1564 frameIndex = jmin (frameIndex & ~(storedStartPosInterval - 1),
1565 frameStreamPositions.size() * storedStartPosInterval - 1);
1566 stream.setPosition (frameStreamPositions.getUnchecked (frameIndex / storedStartPosInterval));
1567 currentFrameIndex = frameIndex;
1573 VBRTagData vbrTagData;
1574 BufferedInputStream stream;
1575 int numFrames = 0, currentFrameIndex = 0;
1576 bool vbrHeaderFound =
false;
1579 bool headerParsed, sideParsed, dataParsed, needToSyncBitStream;
1580 bool isFreeFormat, wasFreeFormat;
1581 int sideInfoSize, dataSize;
1582 int frameSize, lastFrameSize, lastFrameSizeNoPadding;
1583 int bufferSpaceIndex;
1584 Layer3SideInfo sideinfo;
1585 uint8 bufferSpace[2][2880 + 1024];
1586 uint8* bufferPointer;
1587 int bitIndex, synthBo;
1588 float hybridBlock[2][2][32 * 18];
1589 int hybridBlockIndex[2];
1590 float synthBuffers[2][2][0x110];
1591 float hybridIn[2][32][18];
1592 float hybridOut[2][18][32];
1594 void reset() noexcept
1596 headerParsed = sideParsed = dataParsed = isFreeFormat = wasFreeFormat =
false;
1598 needToSyncBitStream =
true;
1599 frameSize = sideInfoSize = dataSize = bitIndex = 0;
1600 lastFrameSizeNoPadding = bufferSpaceIndex = 0;
1601 bufferPointer = bufferSpace[bufferSpaceIndex] + 512;
1604 zerostruct (sideinfo);
1605 zeromem (bufferSpace,
sizeof (bufferSpace));
1606 zeromem (hybridBlock,
sizeof (hybridBlock));
1607 zeromem (hybridBlockIndex,
sizeof (hybridBlockIndex));
1608 zeromem (synthBuffers,
sizeof (synthBuffers));
1611 enum { storedStartPosInterval = 4 };
1612 Array<int64> frameStreamPositions;
1614 struct SideInfoLayer1
1616 uint8 allocation[32][2];
1617 uint8 scaleFactor[32][2];
1620 struct SideInfoLayer2
1622 uint8 allocation[32][2];
1623 uint8 scaleFactor[32][2][3];
1626 static bool isValidHeader (uint32 header,
int oldLayer)
noexcept
1628 int newLayer = 4 - ((header >> 17) & 3);
1630 return (header & 0xffe00000) == 0xffe00000
1632 && (oldLayer <= 0 || newLayer == oldLayer)
1633 && ((header >> 12) & 15) != 15
1634 && ((header >> 10) & 3) != 3
1635 && (header & 3) != 2;
1638 bool rollBackBufferPointer (
int backstep)
noexcept
1640 if (lastFrameSize < 0 && backstep > 0)
1643 auto* oldBuffer = bufferSpace[1 - bufferSpaceIndex] + 512;
1644 bufferPointer -= backstep;
1647 memcpy (bufferPointer, oldBuffer + lastFrameSize - backstep, (
size_t) backstep);
1653 uint32 getBits (
int numBits)
noexcept
1655 if (numBits <= 0 || bufferPointer ==
nullptr)
1658 const uint32 result = ((((((bufferPointer[0] << 8) | bufferPointer[1]) << 8)
1659 | bufferPointer[2]) << bitIndex) & 0xffffff) >> (24 - numBits);
1660 bitIndex += numBits;
1661 bufferPointer += (bitIndex >> 3);
1666 uint32 getOneBit() noexcept
1668 auto result = (uint8) (*bufferPointer << bitIndex);
1670 bufferPointer += (bitIndex >> 3);
1675 uint32 getBitsUnchecked (
int numBits)
noexcept
1677 const uint32 result = ((((bufferPointer[0] << 8) | bufferPointer[1]) << bitIndex) & 0xffff) >> (16 - numBits);
1678 bitIndex += numBits;
1679 bufferPointer += (bitIndex >> 3);
1684 inline uint8 getBitsUint8 (
int numBits)
noexcept {
return (uint8) getBitsUnchecked (numBits); }
1685 inline uint16 getBitsUint16 (
int numBits)
noexcept {
return (uint16) getBitsUnchecked (numBits); }
1687 int scanForNextFrameHeader (
bool checkTypeAgainstLastFrame)
noexcept
1689 auto oldPos = stream.getPosition();
1695 if (stream.isExhausted() || stream.getPosition() > oldPos + 32768)
1701 header = (header << 8) | (uint8) stream.readByte();
1703 if (offset >= 0 && isValidHeader (header, frame.layer))
1705 if (! checkTypeAgainstLastFrame)
1708 const bool mpeg25 = (header & (1 << 20)) == 0;
1709 const uint32 lsf = mpeg25 ? 1 : ((header & (1 << 19)) ? 0 : 1);
1710 const uint32 sampleRateIndex = mpeg25 ? (6 + ((header >> 10) & 3)) : (((header >> 10) & 3) + (lsf * 3));
1711 const uint32 mode = (header >> 6) & 3;
1712 const uint32 numChannels = (mode == 3) ? 1 : 2;
1714 if (numChannels == (uint32) frame.numChannels && lsf == (uint32) frame.lsf
1715 && mpeg25 == frame.mpeg25 && sampleRateIndex == (uint32) frame.sampleRateIndex)
1724 if ((currentFrameIndex & (storedStartPosInterval - 1)) == 0)
1725 frameStreamPositions.set (currentFrameIndex / storedStartPosInterval, oldPos + offset);
1727 ++currentFrameIndex;
1730 stream.setPosition (oldPos);
1734 void readVBRHeader()
1736 auto oldPos = stream.getPosition();
1738 stream.read (xing,
sizeof (xing));
1740 vbrHeaderFound = vbrTagData.read (xing);
1744 numFrames = (int) vbrTagData.frames;
1745 oldPos += jmax (vbrTagData.headersize, 1);
1748 stream.setPosition (oldPos);
1751 void decodeLayer1Frame (
float* pcm0,
float* pcm1,
int& samplesDone)
noexcept
1753 float fraction[2][32];
1756 auto single = (frame.numChannels == 1 || frame.single == 3) ? 0 : frame.single;
1760 for (
int i = 0; i < 12; ++i)
1762 layer1Step2 (si, fraction);
1763 synthesise (fraction[single], 0, pcm0, samplesDone);
1768 for (
int i = 0; i < 12; ++i)
1770 layer1Step2 (si, fraction);
1771 synthesiseStereo (fraction[0], fraction[1], pcm0, pcm1, samplesDone);
1776 void decodeLayer2Frame (
float* pcm0,
float* pcm1,
int& samplesDone)
1778 float fraction[2][4][32];
1779 frame.selectLayer2Table();
1782 auto single = (frame.numChannels == 1 || frame.single == 3) ? 0 : frame.single;
1786 for (
int i = 0; i < 12; ++i)
1788 layer2Step2 (si, i >> 2, fraction);
1790 for (
int j = 0; j < 3; ++j)
1791 synthesise (fraction[single][j], 0, pcm0, samplesDone);
1796 for (
int i = 0; i < 12; ++i)
1798 layer2Step2 (si, i >> 2, fraction);
1800 for (
int j = 0; j < 3; ++j)
1801 synthesiseStereo (fraction[0][j], fraction[1][j], pcm0, pcm1, samplesDone);
1806 void decodeLayer3Frame (
float* pcm0,
float* pcm1,
int& samplesDone)
noexcept
1808 if (! rollBackBufferPointer ((
int) sideinfo.mainDataStart))
1811 const int single = frame.numChannels == 1 ? 0 : frame.single;
1812 const int numChans = (frame.numChannels == 1 || single >= 0) ? 1 : 2;
1813 const bool msStereo = (frame.mode == 1) && (frame.modeExt & 2) != 0;
1814 const bool iStereo = (frame.mode == 1) && (frame.modeExt & 1) != 0;
1815 const int granules = frame.lsf ? 1 : 2;
1816 int scaleFactors[2][39];
1818 for (
int gr = 0; gr < granules; ++gr)
1821 auto& granule = sideinfo.ch[0].gr[gr];
1822 auto part2bits = frame.lsf ? getLayer3ScaleFactors2 (scaleFactors[0], granule, 0)
1823 : getLayer3ScaleFactors1 (scaleFactors[0], granule);
1825 if (layer3DequantizeSample (hybridIn[0], scaleFactors[0], granule, frame.sampleRateIndex, part2bits))
1829 if (frame.numChannels == 2)
1831 auto& granule = sideinfo.ch[1].gr[gr];
1832 auto part2bits = frame.lsf ? getLayer3ScaleFactors2 (scaleFactors[1], granule, iStereo)
1833 : getLayer3ScaleFactors1 (scaleFactors[1], granule);
1835 if (layer3DequantizeSample (hybridIn[1], scaleFactors[1], granule, frame.sampleRateIndex, part2bits))
1840 for (
int i = 0; i < 32 * 18; ++i)
1842 auto tmp0 = ((
const float*) hybridIn[0])[i];
1843 auto tmp1 = ((
const float*) hybridIn[1])[i];
1844 ((
float*) hybridIn[1])[i] = tmp0 - tmp1;
1845 ((
float*) hybridIn[0])[i] = tmp0 + tmp1;
1850 granule.doIStereo (hybridIn, scaleFactors[1], frame.sampleRateIndex, msStereo, frame.lsf);
1852 if (msStereo || iStereo || single == 3)
1854 if (granule.maxb > sideinfo.ch[0].gr[gr].maxb)
1855 sideinfo.ch[0].gr[gr].maxb = granule.maxb;
1857 granule.maxb = sideinfo.ch[0].gr[gr].maxb;
1864 auto* in0 = (
float*) hybridIn[0];
1865 auto* in1 = (
const float*) hybridIn[1];
1867 for (
int i = 0; i < (int) (18 * granule.maxb); ++i, ++in0)
1868 *in0 = (*in0 + *in1++);
1874 auto* in0 = (
float*) hybridIn[0];
1875 auto* in1 = (
const float*) hybridIn[1];
1877 for (
int i = 0; i < (int) (18 * granule.maxb); ++i)
1884 for (
int ch = 0; ch < numChans; ++ch)
1886 auto& granule = sideinfo.ch[ch].gr[gr];
1887 granule.doAntialias (hybridIn[ch]);
1888 layer3Hybrid (hybridIn[ch], hybridOut[ch], ch, granule);
1891 for (
int ss = 0; ss < 18; ++ss)
1894 synthesise (hybridOut[0][ss], 0, pcm0, samplesDone);
1896 synthesiseStereo (hybridOut[0][ss], hybridOut[1][ss], pcm0, pcm1, samplesDone);
1901 int decodeLayer3SideInfo() noexcept
1903 const int numChannels = frame.numChannels;
1904 const int sampleRate = frame.sampleRateIndex;
1905 const int single = (numChannels == 1) ? 0 : frame.single;
1906 const bool msStereo = (frame.mode == 1) && (frame.modeExt & 2) != 0;
1907 const int granules = frame.lsf ? 1 : 2;
1910 getLayer3SideInfo1 (numChannels, msStereo, sampleRate, single);
1912 getLayer3SideInfo2 (numChannels, msStereo, sampleRate, single);
1915 for (
int gr = 0; gr < granules; ++gr)
1916 for (
int ch = 0; ch < numChannels; ++ch)
1917 databits += sideinfo.ch[ch].gr[gr].part2_3Length;
1919 return databits - 8 * (int) sideinfo.mainDataStart;
1922 void layer1Step1 (SideInfoLayer1& si)
noexcept
1925 int i, jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : 32;
1927 if (frame.numChannels == 2)
1929 for (i = 0; i < jsbound; ++i)
1931 si.allocation[i][0] = getBitsUint8 (4);
1932 si.allocation[i][1] = getBitsUint8 (4);
1935 for (i = jsbound; i < 32; ++i)
1936 si.allocation[i][0] = si.allocation[i][1] = getBitsUint8 (4);
1938 for (i = 0; i < 32; ++i)
1940 si.scaleFactor[i][0] = si.allocation[i][0] ? getBitsUint8 (6) : 0;
1941 si.scaleFactor[i][1] = si.allocation[i][1] ? getBitsUint8 (6) : 0;
1946 for (i = 0; i < 32; ++i)
1947 si.allocation[i][0] = getBitsUint8 (4);
1949 for (i = 0; i < 32; ++i)
1950 si.scaleFactor[i][0] = si.allocation[i][0] ? getBitsUint8 (6) : 0;
1954 void layer1Step2 (SideInfoLayer1& si,
float fraction[2][32])
noexcept
1956 if (frame.numChannels == 2)
1958 int i, jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : 32;
1960 for (i = 0; i < jsbound; ++i)
1962 const uint8 n0 = si.allocation[i][0];
1963 const uint8 n1 = si.allocation[i][1];
1964 fraction[0][i] = n0 > 0 ? (float) ((-(1 << n0) + getBitsUint16 (n0 + 1) + 1) * constants.muls[n0 + 1][si.scaleFactor[i][0]]) : 0;
1965 fraction[1][i] = n1 > 0 ? (float) ((-(1 << n1) + getBitsUint16 (n1 + 1) + 1) * constants.muls[n1 + 1][si.scaleFactor[i][1]]) : 0;
1968 for (i = jsbound; i < 32; ++i)
1970 const uint8 n = si.allocation[i][0];
1974 const uint32 w = ((uint32) -(1 << n) + getBitsUint16 (n + 1) + 1);
1975 fraction[0][i] = (float) (w * constants.muls[n + 1][si.scaleFactor[i][0]]);
1976 fraction[1][i] = (float) (w * constants.muls[n + 1][si.scaleFactor[i][1]]);
1979 fraction[0][i] = fraction[1][i] = 0;
1984 for (
int i = 0; i < 32; ++i)
1986 const uint8 n = si.allocation[i][0];
1987 const uint8 j = si.scaleFactor[i][0];
1990 fraction[0][i] = (float) ((-(1 << n) + getBitsUint16 (n + 1) + 1) * constants.muls[n + 1][j]);
1997 void layer2Step1 (SideInfoLayer2& si)
noexcept
2000 const int sblimit = frame.layer2SubBandLimit;
2001 const int jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : frame.layer2SubBandLimit;
2002 auto* allocTable = frame.allocationTable;
2005 if (frame.numChannels == 2)
2007 for (
int i = 0; i < jsbound; ++i)
2009 auto step = allocTable->bits;
2010 allocTable += (
static_cast<intptr_t
> (1) << step);
2011 si.allocation[i][0] = getBitsUint8 (step);
2012 si.allocation[i][1] = getBitsUint8 (step);
2015 for (
int i = jsbound; i < sblimit; ++i)
2017 auto step = allocTable->bits;
2018 auto b0 = getBitsUint8 (step);
2019 allocTable += (
static_cast<intptr_t
> (1) << step);
2020 si.allocation[i][0] = b0;
2021 si.allocation[i][1] = b0;
2024 for (
int i = 0; i < sblimit; ++i)
2026 scfsi[i][0] = si.allocation[i][0] ? getBitsUint8 (2) : 0;
2027 scfsi[i][1] = si.allocation[i][1] ? getBitsUint8 (2) : 0;
2032 for (
int i = 0; i < sblimit; ++i)
2034 const int16 step = allocTable->bits;
2035 allocTable += (
static_cast<intptr_t
> (1) << step);
2036 si.allocation[i][0] = getBitsUint8 (step);
2039 for (
int i = 0; i < sblimit; ++i)
2040 scfsi[i][0] = si.allocation[i][0] ? getBitsUint8 (2) : 0;
2043 for (
int i = 0; i < sblimit; ++i)
2045 for (
int ch = 0; ch < frame.numChannels; ++ch)
2047 uint8 s0 = 0, s1 = 0, s2 = 0;
2049 if (si.allocation[i][ch])
2051 switch (scfsi[i][ch])
2054 s0 = getBitsUint8 (6);
2055 s1 = getBitsUint8 (6);
2056 s2 = getBitsUint8 (6);
2059 s1 = s0 = getBitsUint8 (6);
2060 s2 = getBitsUint8 (6);
2063 s2 = s1 = s0 = getBitsUint8 (6);
2066 s0 = getBitsUint8 (6);
2067 s2 = s1 = getBitsUint8 (6);
2074 si.scaleFactor[i][ch][0] = s0;
2075 si.scaleFactor[i][ch][1] = s1;
2076 si.scaleFactor[i][ch][2] = s2;
2081 void layer2Step2 (SideInfoLayer2& si,
const int gr,
float fraction[2][4][32])
noexcept
2083 auto* allocTable = frame.allocationTable;
2084 const int jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : frame.layer2SubBandLimit;
2086 for (
int i = 0; i < jsbound; ++i)
2088 auto step = allocTable->bits;
2090 for (
int ch = 0; ch < frame.numChannels; ++ch)
2092 if (
auto ba = si.allocation[i][ch])
2094 auto x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);
2095 auto* alloc2 = allocTable + ba;
2096 auto k = jmin ((int16) 16, alloc2->bits);
2097 auto d1 = alloc2->d;
2101 const double cm = constants.muls[k][x1];
2102 fraction[ch][0][i] = (float) (((
int) getBits (k) + d1) * cm);
2103 fraction[ch][1][i] = (float) (((
int) getBits (k) + d1) * cm);
2104 fraction[ch][2][i] = (float) (((
int) getBits (k) + d1) * cm);
2108 auto* tab = constants.getGroupTable (d1, getBits (k));
2109 fraction[ch][0][i] = (float) constants.muls[tab[0]][x1];
2110 fraction[ch][1][i] = (float) constants.muls[tab[1]][x1];
2111 fraction[ch][2][i] = (float) constants.muls[tab[2]][x1];
2116 fraction[ch][0][i] = fraction[ch][1][i] = fraction[ch][2][i] = 0;
2120 allocTable += (
static_cast<intptr_t
> (1) << step);
2123 for (
int i = jsbound; i < frame.layer2SubBandLimit; ++i)
2125 auto step = allocTable->bits;
2126 auto ba = si.allocation[i][0];
2130 auto* alloc2 = allocTable + ba;
2131 int16 k = alloc2->bits;
2132 int16 d1 = alloc2->d;
2133 k = (k <= 16) ? k : 16;
2137 auto v0 = (int) getBits (k);
2138 auto v1 = (int) getBits (k);
2139 auto v2 = (int) getBits (k);
2141 for (
int ch = 0; ch < frame.numChannels; ++ch)
2143 auto x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);
2144 const double cm = constants.muls[k][x1];
2145 fraction[ch][0][i] = (float) ((v0 + d1) * cm);
2146 fraction[ch][1][i] = (float) ((v1 + d1) * cm);
2147 fraction[ch][2][i] = (float) ((v2 + d1) * cm);
2152 auto* tab = constants.getGroupTable (d1, getBits (k));
2157 for (
int ch = 0; ch < frame.numChannels; ++ch)
2159 auto x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);
2160 fraction[ch][0][i] = (float) constants.muls[k0][x1];
2161 fraction[ch][1][i] = (float) constants.muls[k1][x1];
2162 fraction[ch][2][i] = (float) constants.muls[k2][x1];
2168 fraction[0][0][i] = fraction[0][1][i] = fraction[0][2][i] = 0;
2169 fraction[1][0][i] = fraction[1][1][i] = fraction[1][2][i] = 0;
2172 allocTable += (
static_cast<intptr_t
> (1) << step);
2175 for (
int ch = 0; ch < frame.numChannels; ++ch)
2176 for (
int i = frame.layer2SubBandLimit; i < 32; ++i)
2177 fraction[ch][0][i] = fraction[ch][1][i] = fraction[ch][2][i] = 0;
2180 void getLayer3SideInfo1 (
const int stereo,
const bool msStereo,
const int sampleRate,
const int single)
noexcept
2182 const int powdiff = (single == 3) ? 4 : 0;
2183 sideinfo.mainDataStart = getBits (9);
2184 sideinfo.privateBits = getBitsUnchecked (stereo == 1 ? 5 : 3);
2186 for (
int ch = 0; ch < stereo; ++ch)
2188 sideinfo.ch[ch].gr[0].scfsi = -1;
2189 sideinfo.ch[ch].gr[1].scfsi = (int) getBitsUnchecked (4);
2192 for (
int gr = 0; gr < 2; ++gr)
2194 for (
int ch = 0; ch < stereo; ++ch)
2196 auto& granule = sideinfo.ch[ch].gr[gr];
2198 granule.part2_3Length = getBits (12);
2199 granule.bigValues = jmin (288u, getBitsUnchecked (9));
2201 const int qss = (int) getBitsUnchecked (8);
2202 granule.pow2gain = constants.powToGains + 256 - qss + powdiff;
2205 granule.pow2gain += 2;
2207 granule.scaleFactorCompression = getBitsUnchecked (4);
2211 granule.blockType = getBitsUnchecked (2);
2212 granule.mixedBlockFlag = getOneBit();
2213 granule.tableSelect[0] = getBitsUnchecked (5);
2214 granule.tableSelect[1] = getBitsUnchecked (5);
2215 granule.tableSelect[2] = 0;
2217 for (
int i = 0; i < 3; ++i)
2219 const uint32 sbg = (getBitsUnchecked (3) << 3);
2220 granule.fullGain[i] = granule.pow2gain + sbg;
2223 granule.region1Start = 36 >> 1;
2224 granule.region2Start = 576 >> 1;
2228 for (
int i = 0; i < 3; ++i)
2229 granule.tableSelect[i] = getBitsUnchecked (5);
2231 const int r0c = (int) getBitsUnchecked (4);
2232 const int r1c = (int) getBitsUnchecked (3);
2233 const int region0index = jmin (22, r0c + 1);
2234 const int region1index = jmin (22, r0c + 1 + r1c + 1);
2236 granule.region1Start = (uint32) (bandInfo[sampleRate].longIndex[region0index] >> 1);
2237 granule.region2Start = (uint32) (bandInfo[sampleRate].longIndex[region1index] >> 1);
2238 granule.blockType = 0;
2239 granule.mixedBlockFlag = 0;
2242 granule.preflag = getOneBit();
2243 granule.scaleFactorScale = getOneBit();
2244 granule.count1TableSelect = getOneBit();
2249 void getLayer3SideInfo2 (
const int stereo,
const bool msStereo,
const int sampleRate,
const int single)
noexcept
2251 const int powdiff = (single == 3) ? 4 : 0;
2252 sideinfo.mainDataStart = getBits (8);
2253 sideinfo.privateBits = stereo == 1 ? getOneBit() : getBitsUnchecked (2);
2255 for (
int ch = 0; ch < stereo; ++ch)
2257 auto& granule = sideinfo.ch[ch].gr[0];
2259 granule.part2_3Length = getBits (12);
2260 granule.bigValues = jmin (288u, getBitsUnchecked (9));
2262 const uint32 qss = getBitsUnchecked (8);
2263 granule.pow2gain = constants.powToGains + 256 - qss + powdiff;
2266 granule.pow2gain += 2;
2268 granule.scaleFactorCompression = getBits (9);
2272 granule.blockType = getBitsUnchecked (2);
2273 granule.mixedBlockFlag = getOneBit();
2274 granule.tableSelect[0] = getBitsUnchecked (5);
2275 granule.tableSelect[1] = getBitsUnchecked (5);
2276 granule.tableSelect[2] = 0;
2278 for (
int i = 0; i < 3; ++i)
2280 const uint32 sbg = (getBitsUnchecked (3) << 3);
2281 granule.fullGain[i] = granule.pow2gain + sbg;
2284 if (granule.blockType == 0)
2287 if (granule.blockType == 2)
2288 granule.region1Start = sampleRate == 8 ? 36 : (36 >> 1);
2290 granule.region1Start = sampleRate == 8 ? (108 >> 1) : (54 >> 1);
2292 granule.region2Start = 576 >> 1;
2296 for (
int i = 0; i < 3; ++i)
2297 granule.tableSelect[i] = getBitsUnchecked (5);
2299 const int r0c = (int) getBitsUnchecked (4);
2300 const int r1c = (int) getBitsUnchecked (3);
2301 const int region0index = jmin (22, r0c + 1);
2302 const int region1index = jmin (22, r0c + 1 + r1c + 1);
2304 granule.region1Start = (uint32) (bandInfo[sampleRate].longIndex[region0index] >> 1);
2305 granule.region2Start = (uint32) (bandInfo[sampleRate].longIndex[region1index] >> 1);
2306 granule.blockType = 0;
2307 granule.mixedBlockFlag = 0;
2309 granule.scaleFactorScale = getOneBit();
2310 granule.count1TableSelect = getOneBit();
2314 int getLayer3ScaleFactors1 (
int* scf,
const Layer3SideInfo::Info& granule)
noexcept
2316 static const uint8 lengths[2][16] =
2318 { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 },
2319 { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 }
2323 const int num0 = lengths[0][granule.scaleFactorCompression];
2324 const int num1 = lengths[1][granule.scaleFactorCompression];
2326 if (granule.blockType == 2)
2329 numBits = (num0 + num1) * 18;
2331 if (granule.mixedBlockFlag)
2333 for (
int j = 8; --j >= 0;) *scf++ = (
int) getBitsUnchecked (num0);
2338 for (; --i >= 0;) *scf++ = (
int) getBitsUnchecked (num0);
2339 for (i = 18; --i >= 0;) *scf++ = (
int) getBitsUnchecked (num1);
2347 const int scfsi = granule.scfsi;
2351 for (
int i = 11; --i >= 0;) *scf++ = (
int) getBitsUnchecked (num0);
2352 for (
int j = 10; --j >= 0;) *scf++ = (
int) getBitsUnchecked (num1);
2353 numBits = (num0 + num1) * 10 + num0;
2358 if ((scfsi & 8) == 0)
2360 for (
int i = 6; --i >= 0;) *scf++ = (
int) getBitsUnchecked (num0);
2361 numBits += num0 * 6;
2366 if ((scfsi & 4) == 0)
2368 for (
int i = 5; --i >= 0;) *scf++ = (
int) getBitsUnchecked (num0);
2369 numBits += num0 * 5;
2374 if ((scfsi & 2) == 0)
2376 for (
int i = 5; --i >= 0;) *scf++ = (
int) getBitsUnchecked (num1);
2377 numBits += num1 * 5;
2382 if ((scfsi & 1) == 0)
2384 for (
int i = 5; --i >= 0;) *scf++ = (
int) getBitsUnchecked (num1);
2385 numBits += num1 * 5;
2397 int getLayer3ScaleFactors2 (
int* scf, Layer3SideInfo::Info& granule,
const bool iStereo)
noexcept
2399 static const uint8 scaleTable[3][6][4] =
2401 { { 6, 5, 5, 5 }, { 6, 5, 7, 3 }, { 11, 10, 0, 0 }, { 7, 7, 7, 0 }, { 6, 6, 6, 3 }, { 8, 8, 5, 0 } },
2402 { { 9, 9, 9, 9 }, { 9, 9, 12, 6 }, { 18, 18, 0, 0 }, { 12, 12, 12, 0 }, { 12, 9, 9, 6 }, { 15, 12, 9, 0 } },
2403 { { 6, 9, 9, 9 }, { 6, 9, 12, 6 }, { 15, 18, 0, 0 }, { 6, 15, 12, 0 }, { 6, 12, 9, 6 }, { 6, 18, 9, 0 } }
2406 uint32 len = iStereo ? constants.iLength2[granule.scaleFactorCompression >> 1]
2407 : constants.nLength2[granule.scaleFactorCompression];
2409 granule.preflag = (len >> 15) & 1;
2412 if (granule.blockType == 2)
2415 if (granule.mixedBlockFlag)
2419 const uint8*
const data = scaleTable[n][(len >> 12) & 7];
2422 for (
int i = 0; i < 4; ++i)
2429 for (
int j = 0; j < (int) (data[i]); ++j)
2430 *scf++ = (
int) getBitsUnchecked (num);
2432 numBits += data[i] * num;
2436 for (
int j = 0; j < (int) (data[i]); ++j)
2443 for (
int i = 0; i < n; ++i)
2449 bool layer3DequantizeSample (
float xr[32][18],
int* scf, Layer3SideInfo::Info& granule,
int sampleRate,
int part2bits)
noexcept
2451 const uint32 shift = 1 + granule.scaleFactorScale;
2452 auto* xrpnt = (
float*) xr;
2453 auto part2remain = (int) granule.part2_3Length - part2bits;
2455 zeromem (xrpnt,
sizeof (
float) * (
size_t) (&xr[32][0] - xrpnt));
2457 auto bv = (int) granule.bigValues;
2458 auto region1 = (int) granule.region1Start;
2459 auto region2 = (int) granule.region2Start;
2460 int l3 = ((576 >> 1) - bv) >> 1;
2479 l[1] = region2 - l[0];
2480 l[2] = bv - region2;
2484 for (
int i = 0; i < 3; ++i)
2488 if (granule.blockType == 2)
2491 int step = 0, lwin = 0, cb = 0, mc = 0;
2496 if (granule.mixedBlockFlag)
2499 max[0] = max[1] = max[2] = 2;
2500 map = constants.map [sampleRate][0];
2501 mapEnd = constants.mapEnd[sampleRate][0];
2505 max[0] = max[1] = max[2] = max[3] = -1;
2506 map = constants.map [sampleRate][1];
2507 mapEnd = constants.mapEnd[sampleRate][1];
2510 for (
int i = 0; i < 2; ++i)
2512 auto* h = huffmanTables1 + granule.tableSelect[i];
2514 for (
int lp = l[i]; lp != 0; --lp, --mc)
2520 xrpnt = ((
float*) xr) + (*map++);
2526 v = granule.pow2gain[ (*scf++) << shift];
2531 v = granule.fullGain[lwin][ (*scf++) << shift];
2536 auto* val = h->table;
2538 while ((y = *val++) < 0)
2552 part2remain -= h->bits + 1;
2553 x += getBits ((
int) h->bits);
2554 *xrpnt = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);
2559 *xrpnt = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);
2570 part2remain -= h->bits + 1;
2571 y += getBits ((
int) h->bits);
2572 *xrpnt = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);
2577 *xrpnt = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);
2587 for (; l3 && (part2remain > 0); --l3)
2589 auto* h = huffmanTables2 + granule.count1TableSelect;
2590 auto* val = h->table;
2593 while ((a = *val++) < 0)
2595 if (part2remain <= 0)
2607 for (
int i = 0; i < 4; ++i)
2614 xrpnt = ((
float*) xr) + (*map++);
2620 v = granule.pow2gain[ (*scf++) << shift];
2625 v = granule.fullGain[lwin][ (*scf++) << shift];
2637 if (part2remain == 0)
2641 *xrpnt = getOneBit() ? -v : v;
2650 while (map < mapEnd)
2655 xrpnt = ((
float*) xr) + *map++;
2656 step = (*map++ == 3) ? 1 : 3;
2661 *xrpnt = 0; xrpnt += step;
2662 *xrpnt = 0; xrpnt += step;
2665 granule.maxBand[0] = (uint32) (max[0] + 1);
2666 granule.maxBand[1] = (uint32) (max[1] + 1);
2667 granule.maxBand[2] = (uint32) (max[2] + 1);
2668 granule.maxBandl = (uint32) (max[3] + 1);
2670 const int rmax = jmax (max[0], max[1], max[3]) + 1;
2671 granule.maxb = rmax ? (uint32) constants.shortLimit[sampleRate][rmax]
2672 : (uint32) constants.longLimit[sampleRate][max[3] + 1];
2676 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 };
2677 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 };
2679 auto* pretab = (
const int*) (granule.preflag ? pretab1 : pretab2);
2680 int max = -1, cb = 0, mc = 0;
2681 auto* map = constants.map[sampleRate][2];
2684 for (
int i = 0; i < 3; ++i)
2686 auto* h = huffmanTables1 + granule.tableSelect[i];
2688 for (
int lp = l[i]; lp != 0; --lp, --mc)
2693 v = granule.pow2gain[((*scf++) + (*pretab++)) << shift];
2697 auto* val = h->table;
2700 while ((y = *val++) < 0)
2702 if (getOneBit()) val -= y;
2712 part2remain -= h->bits + 1;
2713 x += getBits ((
int) h->bits);
2714 *xrpnt++ = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);
2719 *xrpnt++ = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);
2728 part2remain -= h->bits + 1;
2729 y += getBits ((
int) h->bits);
2730 *xrpnt++ = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);
2735 *xrpnt++ = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);
2743 for (; l3 && part2remain > 0; --l3)
2745 auto* h = huffmanTables2 + granule.count1TableSelect;
2746 auto* values = h->table;
2749 while ((a = *values++) < 0)
2751 if (part2remain <= 0)
2763 for (
int i = 0; i < 4; ++i)
2771 v = granule.pow2gain[((*scf++) + (*pretab++)) << shift];
2776 if ((a & (0x8 >> i)))
2780 if (part2remain <= 0)
2784 *xrpnt++ = getOneBit() ? -v : v;
2791 zeromem (xrpnt,
sizeof (
float) * (
size_t) (&xr[32][0] - xrpnt));
2793 granule.maxBandl = (uint32) (max + 1);
2794 granule.maxb = (uint32) constants.longLimit[sampleRate][granule.maxBandl];
2797 while (part2remain > 16)
2803 if (part2remain > 0)
2804 getBits (part2remain);
2805 else if (part2remain < 0)
2811 void layer3Hybrid (
float fsIn[32][18],
float tsOut[18][32],
int ch,
const Layer3SideInfo::Info& granule)
noexcept
2813 auto* ts = (
float*) tsOut;
2814 float* rawout1, *rawout2;
2818 int b = hybridBlockIndex[ch];
2819 rawout1 = hybridBlock[b][ch];
2821 rawout2 = hybridBlock[b][ch];
2822 hybridBlockIndex[ch] = b;
2825 if (granule.mixedBlockFlag)
2828 DCT::dct36 (fsIn[0], rawout1, rawout2, constants.win[0], ts);
2829 DCT::dct36 (fsIn[1], rawout1 + 18, rawout2 + 18, constants.win1[0], ts + 1);
2835 auto bt = granule.blockType;
2839 for (; sb < (int) granule.maxb; sb += 2, ts += 2, rawout1 += 36, rawout2 += 36)
2841 DCT::dct12 (fsIn[sb], rawout1, rawout2, constants.win[2], ts);
2842 DCT::dct12 (fsIn[sb + 1], rawout1 + 18, rawout2 + 18, constants.win1[2], ts + 1);
2847 for (; sb < (int) granule.maxb; sb += 2, ts += 2, rawout1 += 36, rawout2 += 36)
2849 DCT::dct36 (fsIn[sb], rawout1, rawout2, constants.win[bt], ts);
2850 DCT::dct36 (fsIn[sb + 1], rawout1 + 18, rawout2 + 18, constants.win1[bt], ts + 1);
2854 for (; sb < 32; ++sb, ++ts)
2856 for (
int i = 0; i < 18; ++i)
2858 ts[i * 32] = *rawout1++;
2864 void synthesiseStereo (
const float* bandPtr0,
const float* bandPtr1,
float* out0,
float* out1,
int& samplesDone)
noexcept
2866 auto dummy = samplesDone;
2867 synthesise (bandPtr0, 0, out0, dummy);
2868 synthesise (bandPtr1, 1, out1, samplesDone);
2871 void synthesise (
const float* bandPtr,
int channel,
float* out,
int& samplesDone)
2874 const int bo = channel == 0 ? ((synthBo - 1) & 15) : synthBo;
2875 float (*buf)[0x110] = synthBuffers[channel];
2882 DCT::dct64 (buf[1] + ((bo + 1) & 15), buf[0] + bo, bandPtr);
2888 DCT::dct64 (buf[0] + bo, buf[1] + bo1, bandPtr);
2892 const float* window = constants.decodeWin + 16 - bo1;
2894 for (
int j = 16; j != 0; --j, b0 += 16, window += 32)
2896 auto sum = window[0] * b0[0]; sum -= window[1] * b0[1];
2897 sum += window[2] * b0[2]; sum -= window[3] * b0[3];
2898 sum += window[4] * b0[4]; sum -= window[5] * b0[5];
2899 sum += window[6] * b0[6]; sum -= window[7] * b0[7];
2900 sum += window[8] * b0[8]; sum -= window[9] * b0[9];
2901 sum += window[10] * b0[10]; sum -= window[11] * b0[11];
2902 sum += window[12] * b0[12]; sum -= window[13] * b0[13];
2903 sum += window[14] * b0[14]; sum -= window[15] * b0[15];
2908 auto sum = window[0] * b0[0]; sum += window[2] * b0[2];
2909 sum += window[4] * b0[4]; sum += window[6] * b0[6];
2910 sum += window[8] * b0[8]; sum += window[10] * b0[10];
2911 sum += window[12] * b0[12]; sum += window[14] * b0[14];
2913 b0 -= 16; window -= 32;
2917 for (
int j = 15; j != 0; --j, b0 -= 16, window -= 32)
2919 auto sum = -window[-1] * b0[0]; sum -= window[-2] * b0[1];
2920 sum -= window[-3] * b0[2]; sum -= window[-4] * b0[3];
2921 sum -= window[-5] * b0[4]; sum -= window[-6] * b0[5];
2922 sum -= window[-7] * b0[6]; sum -= window[-8] * b0[7];
2923 sum -= window[-9] * b0[8]; sum -= window[-10] * b0[9];
2924 sum -= window[-11] * b0[10]; sum -= window[-12] * b0[11];
2925 sum -= window[-13] * b0[12]; sum -= window[-14] * b0[13];
2926 sum -= window[-15] * b0[14]; sum -= window[0] * b0[15];
2933 JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MP3Stream)
2940class MP3Reader :
public AudioFormatReader
2943 MP3Reader (InputStream*
const in)
2944 : AudioFormatReader (in, mp3FormatName),
2945 stream (*in), currentPosition (0),
2946 decodedStart (0), decodedEnd (0)
2949 const int64 streamPos = stream.stream.getPosition();
2951 if (readNextBlock())
2954 usesFloatingPointData =
true;
2955 sampleRate = stream.frame.getFrequency();
2956 numChannels = (
unsigned int) stream.frame.numChannels;
2957 lengthInSamples = findLength (streamPos);
2961 bool readSamples (
int** destSamples,
int numDestChannels,
int startOffsetInDestBuffer,
2962 int64 startSampleInFile,
int numSamples)
override
2964 jassert (destSamples !=
nullptr);
2966 if (currentPosition != startSampleInFile)
2968 if (! stream.seek ((
int) (startSampleInFile / 1152 - 1)))
2970 currentPosition = -1;
2971 createEmptyDecodedData();
2975 decodedStart = decodedEnd = 0;
2976 const int64 streamPos = stream.currentFrameIndex * 1152;
2977 int toSkip = (int) (startSampleInFile - streamPos);
2978 jassert (toSkip >= 0);
2982 if (! readNextBlock())
2984 createEmptyDecodedData();
2988 const int numReady = decodedEnd - decodedStart;
2990 if (numReady > toSkip)
2992 decodedStart += toSkip;
2999 currentPosition = startSampleInFile;
3003 while (numSamples > 0)
3005 if (decodedEnd <= decodedStart && ! readNextBlock())
3007 for (
int i = numDestChannels; --i >= 0;)
3008 if (destSamples[i] !=
nullptr)
3009 zeromem (destSamples[i] + startOffsetInDestBuffer,
sizeof (
float) * (
size_t) numSamples);
3014 const int numToCopy = jmin (decodedEnd - decodedStart, numSamples);
3015 float*
const*
const dst =
reinterpret_cast<float**
> (destSamples);
3016 memcpy (dst[0] + startOffsetInDestBuffer, decoded0 + decodedStart,
sizeof (
float) * (
size_t) numToCopy);
3018 if (numDestChannels > 1 && dst[1] !=
nullptr)
3019 memcpy (dst[1] + startOffsetInDestBuffer, (numChannels < 2 ? decoded0 : decoded1) + decodedStart, sizeof (float) * (size_t) numToCopy);
3021 startOffsetInDestBuffer += numToCopy;
3022 decodedStart += numToCopy;
3023 currentPosition += numToCopy;
3024 numSamples -= numToCopy;
3032 int64 currentPosition;
3033 enum { decodedDataSize = 1152 };
3034 float decoded0[decodedDataSize], decoded1[decodedDataSize];
3035 int decodedStart, decodedEnd;
3037 void createEmptyDecodedData() noexcept
3039 zeromem (decoded0,
sizeof (decoded0));
3040 zeromem (decoded1,
sizeof (decoded1));
3042 decodedEnd = decodedDataSize;
3045 bool readNextBlock()
3047 for (
int attempts = 10; --attempts >= 0;)
3049 int samplesDone = 0;
3050 const int result = stream.decodeNextBlock (decoded0, decoded1, samplesDone);
3052 if (result > 0 && stream.stream.isExhausted())
3054 createEmptyDecodedData();
3061 decodedEnd = samplesDone;
3071 const int64 originalPosition = stream.stream.getPosition();
3072 const uint32 firstWord = (uint32) stream.stream.readInt();
3074 if ((firstWord & 0xffffff) == 0x334449)
3078 if (stream.stream.read (buffer, 6) == 6
3079 && buffer[0] != 0xff
3080 && ((buffer[2] | buffer[3] | buffer[4] | buffer[5]) & 0x80) == 0)
3082 const uint32 length = (((uint32) buffer[2]) << 21)
3083 | (((uint32) buffer[3]) << 14)
3084 | (((uint32) buffer[4]) << 7)
3085 | ((uint32) buffer[5]);
3087 stream.stream.skipNextBytes (length);
3092 stream.stream.setPosition (originalPosition);
3095 int64 findLength (int64 streamStartPos)
3097 int64 numFrames = stream.numFrames;
3101 const int64 streamSize = stream.stream.getTotalLength();
3105 const int bytesPerFrame = stream.frame.frameSize + 4;
3107 if (bytesPerFrame == 417 || bytesPerFrame == 418)
3108 numFrames = roundToInt ((streamSize - streamStartPos) / 417.95918);
3110 numFrames = (streamSize - streamStartPos) / bytesPerFrame;
3114 return numFrames * 1152;
3117 JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MP3Reader)
3123MP3AudioFormat::MP3AudioFormat() : AudioFormat (MP3Decoder::mp3FormatName,
".mp3") {}
3124MP3AudioFormat::~MP3AudioFormat() {}
3126Array<int> MP3AudioFormat::getPossibleSampleRates() {
return {}; }
3127Array<int> MP3AudioFormat::getPossibleBitDepths() {
return {}; }
3128bool MP3AudioFormat::canDoStereo() {
return true; }
3129bool MP3AudioFormat::canDoMono() {
return true; }
3130bool MP3AudioFormat::isCompressed() {
return true; }
3131StringArray MP3AudioFormat::getQualityOptions() {
return {}; }
3133AudioFormatReader* MP3AudioFormat::createReaderFor (InputStream* sourceStream,
const bool deleteStreamIfOpeningFails)
3135 std::unique_ptr<MP3Decoder::MP3Reader> r (
new MP3Decoder::MP3Reader (sourceStream));
3137 if (r->lengthInSamples > 0)
3140 if (! deleteStreamIfOpeningFails)
3146AudioFormatWriter* MP3AudioFormat::createWriterFor (OutputStream*,
double ,
3147 unsigned int ,
int ,
3148 const StringPairArray& ,
int )
Array()=default
Creates an empty array.