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 = (int) (4 - ((header >> 17) & 3));
500 sampleRateIndex = (int) ((header >> 10) & 3) + (mpeg25 ? 6 : (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 auto newLayer = (int) (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 auto result = (uint32) (((((((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);
1672 return (uint32) (result >> 7);
1675 uint32 getBitsUnchecked (
int numBits)
noexcept
1677 const auto result = (uint32) (((((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);
1916 for (
int gr = 0; gr < granules; ++gr)
1917 for (
int ch = 0; ch < numChannels; ++ch)
1918 databits += (
int) sideinfo.ch[ch].gr[gr].part2_3Length;
1920 return databits - 8 * (int) sideinfo.mainDataStart;
1923 void layer1Step1 (SideInfoLayer1& si)
noexcept
1926 int i, jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : 32;
1928 if (frame.numChannels == 2)
1930 for (i = 0; i < jsbound; ++i)
1932 si.allocation[i][0] = getBitsUint8 (4);
1933 si.allocation[i][1] = getBitsUint8 (4);
1936 for (i = jsbound; i < 32; ++i)
1937 si.allocation[i][0] = si.allocation[i][1] = getBitsUint8 (4);
1939 for (i = 0; i < 32; ++i)
1941 si.scaleFactor[i][0] = si.allocation[i][0] ? getBitsUint8 (6) : 0;
1942 si.scaleFactor[i][1] = si.allocation[i][1] ? getBitsUint8 (6) : 0;
1947 for (i = 0; i < 32; ++i)
1948 si.allocation[i][0] = getBitsUint8 (4);
1950 for (i = 0; i < 32; ++i)
1951 si.scaleFactor[i][0] = si.allocation[i][0] ? getBitsUint8 (6) : 0;
1955 void layer1Step2 (SideInfoLayer1& si,
float fraction[2][32])
noexcept
1957 if (frame.numChannels == 2)
1959 int i, jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : 32;
1961 for (i = 0; i < jsbound; ++i)
1963 const uint8 n0 = si.allocation[i][0];
1964 const uint8 n1 = si.allocation[i][1];
1965 fraction[0][i] = n0 > 0 ? (float) ((-(1 << n0) + getBitsUint16 (n0 + 1) + 1) * constants.muls[n0 + 1][si.scaleFactor[i][0]]) : 0;
1966 fraction[1][i] = n1 > 0 ? (float) ((-(1 << n1) + getBitsUint16 (n1 + 1) + 1) * constants.muls[n1 + 1][si.scaleFactor[i][1]]) : 0;
1969 for (i = jsbound; i < 32; ++i)
1971 const uint8 n = si.allocation[i][0];
1975 const uint32 w = ((uint32) -(1 << n) + getBitsUint16 (n + 1) + 1);
1976 fraction[0][i] = (float) (w * constants.muls[n + 1][si.scaleFactor[i][0]]);
1977 fraction[1][i] = (float) (w * constants.muls[n + 1][si.scaleFactor[i][1]]);
1980 fraction[0][i] = fraction[1][i] = 0;
1985 for (
int i = 0; i < 32; ++i)
1987 const uint8 n = si.allocation[i][0];
1988 const uint8 j = si.scaleFactor[i][0];
1991 fraction[0][i] = (float) ((-(1 << n) + getBitsUint16 (n + 1) + 1) * constants.muls[n + 1][j]);
1998 void layer2Step1 (SideInfoLayer2& si)
noexcept
2001 const int sblimit = frame.layer2SubBandLimit;
2002 const int jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : frame.layer2SubBandLimit;
2003 auto* allocTable = frame.allocationTable;
2006 if (frame.numChannels == 2)
2008 for (
int i = 0; i < jsbound; ++i)
2010 auto step = allocTable->bits;
2011 allocTable += (
static_cast<intptr_t
> (1) << step);
2012 si.allocation[i][0] = getBitsUint8 (step);
2013 si.allocation[i][1] = getBitsUint8 (step);
2016 for (
int i = jsbound; i < sblimit; ++i)
2018 auto step = allocTable->bits;
2019 auto b0 = getBitsUint8 (step);
2020 allocTable += (
static_cast<intptr_t
> (1) << step);
2021 si.allocation[i][0] = b0;
2022 si.allocation[i][1] = b0;
2025 for (
int i = 0; i < sblimit; ++i)
2027 scfsi[i][0] = si.allocation[i][0] ? getBitsUint8 (2) : 0;
2028 scfsi[i][1] = si.allocation[i][1] ? getBitsUint8 (2) : 0;
2033 for (
int i = 0; i < sblimit; ++i)
2035 const int16 step = allocTable->bits;
2036 allocTable += (
static_cast<intptr_t
> (1) << step);
2037 si.allocation[i][0] = getBitsUint8 (step);
2040 for (
int i = 0; i < sblimit; ++i)
2041 scfsi[i][0] = si.allocation[i][0] ? getBitsUint8 (2) : 0;
2044 for (
int i = 0; i < sblimit; ++i)
2046 for (
int ch = 0; ch < frame.numChannels; ++ch)
2048 uint8 s0 = 0, s1 = 0, s2 = 0;
2050 if (si.allocation[i][ch])
2052 switch (scfsi[i][ch])
2055 s0 = getBitsUint8 (6);
2056 s1 = getBitsUint8 (6);
2057 s2 = getBitsUint8 (6);
2060 s1 = s0 = getBitsUint8 (6);
2061 s2 = getBitsUint8 (6);
2064 s2 = s1 = s0 = getBitsUint8 (6);
2067 s0 = getBitsUint8 (6);
2068 s2 = s1 = getBitsUint8 (6);
2075 si.scaleFactor[i][ch][0] = s0;
2076 si.scaleFactor[i][ch][1] = s1;
2077 si.scaleFactor[i][ch][2] = s2;
2082 void layer2Step2 (SideInfoLayer2& si,
const int gr,
float fraction[2][4][32])
noexcept
2084 auto* allocTable = frame.allocationTable;
2085 const int jsbound = (frame.mode == 1) ? (frame.modeExt << 2) + 4 : frame.layer2SubBandLimit;
2087 for (
int i = 0; i < jsbound; ++i)
2089 auto step = allocTable->bits;
2091 for (
int ch = 0; ch < frame.numChannels; ++ch)
2093 if (
auto ba = si.allocation[i][ch])
2095 auto x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);
2096 auto* alloc2 = allocTable + ba;
2097 auto k = jmin ((int16) 16, alloc2->bits);
2098 auto d1 = alloc2->d;
2102 const double cm = constants.muls[k][x1];
2103 fraction[ch][0][i] = (float) (((
int) getBits (k) + d1) * cm);
2104 fraction[ch][1][i] = (float) (((
int) getBits (k) + d1) * cm);
2105 fraction[ch][2][i] = (float) (((
int) getBits (k) + d1) * cm);
2109 auto* tab = constants.getGroupTable (d1, getBits (k));
2110 fraction[ch][0][i] = (float) constants.muls[tab[0]][x1];
2111 fraction[ch][1][i] = (float) constants.muls[tab[1]][x1];
2112 fraction[ch][2][i] = (float) constants.muls[tab[2]][x1];
2117 fraction[ch][0][i] = fraction[ch][1][i] = fraction[ch][2][i] = 0;
2121 allocTable += (
static_cast<intptr_t
> (1) << step);
2124 for (
int i = jsbound; i < frame.layer2SubBandLimit; ++i)
2126 auto step = allocTable->bits;
2127 auto ba = si.allocation[i][0];
2131 auto* alloc2 = allocTable + ba;
2132 int16 k = alloc2->bits;
2133 int16 d1 = alloc2->d;
2134 k = (k <= 16) ? k : 16;
2138 auto v0 = (int) getBits (k);
2139 auto v1 = (int) getBits (k);
2140 auto v2 = (int) getBits (k);
2142 for (
int ch = 0; ch < frame.numChannels; ++ch)
2144 auto x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);
2145 const double cm = constants.muls[k][x1];
2146 fraction[ch][0][i] = (float) ((v0 + d1) * cm);
2147 fraction[ch][1][i] = (float) ((v1 + d1) * cm);
2148 fraction[ch][2][i] = (float) ((v2 + d1) * cm);
2153 auto* tab = constants.getGroupTable (d1, getBits (k));
2158 for (
int ch = 0; ch < frame.numChannels; ++ch)
2160 auto x1 = jmin ((uint8) 63, si.scaleFactor[i][ch][gr]);
2161 fraction[ch][0][i] = (float) constants.muls[k0][x1];
2162 fraction[ch][1][i] = (float) constants.muls[k1][x1];
2163 fraction[ch][2][i] = (float) constants.muls[k2][x1];
2169 fraction[0][0][i] = fraction[0][1][i] = fraction[0][2][i] = 0;
2170 fraction[1][0][i] = fraction[1][1][i] = fraction[1][2][i] = 0;
2173 allocTable += (
static_cast<intptr_t
> (1) << step);
2176 for (
int ch = 0; ch < frame.numChannels; ++ch)
2177 for (
int i = frame.layer2SubBandLimit; i < 32; ++i)
2178 fraction[ch][0][i] = fraction[ch][1][i] = fraction[ch][2][i] = 0;
2181 void getLayer3SideInfo1 (
const int stereo,
const bool msStereo,
const int sampleRate,
const int single)
noexcept
2183 const int powdiff = (single == 3) ? 4 : 0;
2184 sideinfo.mainDataStart = getBits (9);
2185 sideinfo.privateBits = getBitsUnchecked (stereo == 1 ? 5 : 3);
2187 for (
int ch = 0; ch < stereo; ++ch)
2189 sideinfo.ch[ch].gr[0].scfsi = -1;
2190 sideinfo.ch[ch].gr[1].scfsi = (int) getBitsUnchecked (4);
2193 for (
int gr = 0; gr < 2; ++gr)
2195 for (
int ch = 0; ch < stereo; ++ch)
2197 auto& granule = sideinfo.ch[ch].gr[gr];
2199 granule.part2_3Length = getBits (12);
2200 granule.bigValues = jmin (288u, getBitsUnchecked (9));
2202 const int qss = (int) getBitsUnchecked (8);
2203 granule.pow2gain = constants.powToGains + 256 - qss + powdiff;
2206 granule.pow2gain += 2;
2208 granule.scaleFactorCompression = getBitsUnchecked (4);
2212 granule.blockType = getBitsUnchecked (2);
2213 granule.mixedBlockFlag = getOneBit();
2214 granule.tableSelect[0] = getBitsUnchecked (5);
2215 granule.tableSelect[1] = getBitsUnchecked (5);
2216 granule.tableSelect[2] = 0;
2218 for (
int i = 0; i < 3; ++i)
2220 const uint32 sbg = (getBitsUnchecked (3) << 3);
2221 granule.fullGain[i] = granule.pow2gain + sbg;
2224 granule.region1Start = 36 >> 1;
2225 granule.region2Start = 576 >> 1;
2229 for (
int i = 0; i < 3; ++i)
2230 granule.tableSelect[i] = getBitsUnchecked (5);
2232 const int r0c = (int) getBitsUnchecked (4);
2233 const int r1c = (int) getBitsUnchecked (3);
2234 const int region0index = jmin (22, r0c + 1);
2235 const int region1index = jmin (22, r0c + 1 + r1c + 1);
2237 granule.region1Start = (uint32) (bandInfo[sampleRate].longIndex[region0index] >> 1);
2238 granule.region2Start = (uint32) (bandInfo[sampleRate].longIndex[region1index] >> 1);
2239 granule.blockType = 0;
2240 granule.mixedBlockFlag = 0;
2243 granule.preflag = getOneBit();
2244 granule.scaleFactorScale = getOneBit();
2245 granule.count1TableSelect = getOneBit();
2250 void getLayer3SideInfo2 (
const int stereo,
const bool msStereo,
const int sampleRate,
const int single)
noexcept
2252 const int powdiff = (single == 3) ? 4 : 0;
2253 sideinfo.mainDataStart = getBits (8);
2254 sideinfo.privateBits = stereo == 1 ? getOneBit() : getBitsUnchecked (2);
2256 for (
int ch = 0; ch < stereo; ++ch)
2258 auto& granule = sideinfo.ch[ch].gr[0];
2260 granule.part2_3Length = getBits (12);
2261 granule.bigValues = jmin (288u, getBitsUnchecked (9));
2263 const uint32 qss = getBitsUnchecked (8);
2264 granule.pow2gain = constants.powToGains + 256 - qss + powdiff;
2267 granule.pow2gain += 2;
2269 granule.scaleFactorCompression = getBits (9);
2273 granule.blockType = getBitsUnchecked (2);
2274 granule.mixedBlockFlag = getOneBit();
2275 granule.tableSelect[0] = getBitsUnchecked (5);
2276 granule.tableSelect[1] = getBitsUnchecked (5);
2277 granule.tableSelect[2] = 0;
2279 for (
int i = 0; i < 3; ++i)
2281 const uint32 sbg = (getBitsUnchecked (3) << 3);
2282 granule.fullGain[i] = granule.pow2gain + sbg;
2285 if (granule.blockType == 0)
2288 if (granule.blockType == 2)
2289 granule.region1Start = sampleRate == 8 ? 36 : (36 >> 1);
2291 granule.region1Start = sampleRate == 8 ? (108 >> 1) : (54 >> 1);
2293 granule.region2Start = 576 >> 1;
2297 for (
int i = 0; i < 3; ++i)
2298 granule.tableSelect[i] = getBitsUnchecked (5);
2300 const int r0c = (int) getBitsUnchecked (4);
2301 const int r1c = (int) getBitsUnchecked (3);
2302 const int region0index = jmin (22, r0c + 1);
2303 const int region1index = jmin (22, r0c + 1 + r1c + 1);
2305 granule.region1Start = (uint32) (bandInfo[sampleRate].longIndex[region0index] >> 1);
2306 granule.region2Start = (uint32) (bandInfo[sampleRate].longIndex[region1index] >> 1);
2307 granule.blockType = 0;
2308 granule.mixedBlockFlag = 0;
2310 granule.scaleFactorScale = getOneBit();
2311 granule.count1TableSelect = getOneBit();
2315 int getLayer3ScaleFactors1 (
int* scf,
const Layer3SideInfo::Info& granule)
noexcept
2317 static const uint8 lengths[2][16] =
2319 { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 },
2320 { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 }
2324 const int num0 = lengths[0][granule.scaleFactorCompression];
2325 const int num1 = lengths[1][granule.scaleFactorCompression];
2327 if (granule.blockType == 2)
2330 numBits = (num0 + num1) * 18;
2332 if (granule.mixedBlockFlag)
2334 for (
int j = 8; --j >= 0;) *scf++ = (
int) getBitsUnchecked (num0);
2339 for (; --i >= 0;) *scf++ = (
int) getBitsUnchecked (num0);
2340 for (i = 18; --i >= 0;) *scf++ = (
int) getBitsUnchecked (num1);
2348 const int scfsi = granule.scfsi;
2352 for (
int i = 11; --i >= 0;) *scf++ = (
int) getBitsUnchecked (num0);
2353 for (
int j = 10; --j >= 0;) *scf++ = (
int) getBitsUnchecked (num1);
2354 numBits = (num0 + num1) * 10 + num0;
2359 if ((scfsi & 8) == 0)
2361 for (
int i = 6; --i >= 0;) *scf++ = (
int) getBitsUnchecked (num0);
2362 numBits += num0 * 6;
2367 if ((scfsi & 4) == 0)
2369 for (
int i = 5; --i >= 0;) *scf++ = (
int) getBitsUnchecked (num0);
2370 numBits += num0 * 5;
2375 if ((scfsi & 2) == 0)
2377 for (
int i = 5; --i >= 0;) *scf++ = (
int) getBitsUnchecked (num1);
2378 numBits += num1 * 5;
2383 if ((scfsi & 1) == 0)
2385 for (
int i = 5; --i >= 0;) *scf++ = (
int) getBitsUnchecked (num1);
2386 numBits += num1 * 5;
2398 int getLayer3ScaleFactors2 (
int* scf, Layer3SideInfo::Info& granule,
const bool iStereo)
noexcept
2400 static const uint8 scaleTable[3][6][4] =
2402 { { 6, 5, 5, 5 }, { 6, 5, 7, 3 }, { 11, 10, 0, 0 }, { 7, 7, 7, 0 }, { 6, 6, 6, 3 }, { 8, 8, 5, 0 } },
2403 { { 9, 9, 9, 9 }, { 9, 9, 12, 6 }, { 18, 18, 0, 0 }, { 12, 12, 12, 0 }, { 12, 9, 9, 6 }, { 15, 12, 9, 0 } },
2404 { { 6, 9, 9, 9 }, { 6, 9, 12, 6 }, { 15, 18, 0, 0 }, { 6, 15, 12, 0 }, { 6, 12, 9, 6 }, { 6, 18, 9, 0 } }
2407 uint32 len = iStereo ? constants.iLength2[granule.scaleFactorCompression >> 1]
2408 : constants.nLength2[granule.scaleFactorCompression];
2410 granule.preflag = (len >> 15) & 1;
2413 if (granule.blockType == 2)
2416 if (granule.mixedBlockFlag)
2420 const uint8*
const data = scaleTable[n][(len >> 12) & 7];
2423 for (
int i = 0; i < 4; ++i)
2430 for (
int j = 0; j < (int) (data[i]); ++j)
2431 *scf++ = (
int) getBitsUnchecked (num);
2433 numBits += data[i] * num;
2437 for (
int j = 0; j < (int) (data[i]); ++j)
2444 for (
int i = 0; i < n; ++i)
2450 bool layer3DequantizeSample (
float xr[32][18],
int* scf, Layer3SideInfo::Info& granule,
int sampleRate,
int part2bits)
noexcept
2452 const uint32 shift = 1 + granule.scaleFactorScale;
2453 auto* xrpnt = (
float*) xr;
2454 auto part2remain = (int) granule.part2_3Length - part2bits;
2456 zeromem (xrpnt, (
size_t) (&xr[32][0] - xrpnt) *
sizeof (
float));
2458 auto bv = (int) granule.bigValues;
2459 auto region1 = (int) granule.region1Start;
2460 auto region2 = (int) granule.region2Start;
2461 int l3 = ((576 >> 1) - bv) >> 1;
2480 l[1] = region2 - l[0];
2481 l[2] = bv - region2;
2485 for (
int i = 0; i < 3; ++i)
2489 if (granule.blockType == 2)
2492 int step = 0, lwin = 0, cb = 0, mc = 0;
2497 if (granule.mixedBlockFlag)
2500 max[0] = max[1] = max[2] = 2;
2501 map = constants.map [sampleRate][0];
2502 mapEnd = constants.mapEnd[sampleRate][0];
2506 max[0] = max[1] = max[2] = max[3] = -1;
2507 map = constants.map [sampleRate][1];
2508 mapEnd = constants.mapEnd[sampleRate][1];
2511 for (
int i = 0; i < 2; ++i)
2513 auto* h = huffmanTables1 + granule.tableSelect[i];
2515 for (
int lp = l[i]; lp != 0; --lp, --mc)
2521 xrpnt = ((
float*) xr) + (*map++);
2527 v = granule.pow2gain[ (*scf++) << shift];
2532 v = granule.fullGain[lwin][ (*scf++) << shift];
2537 auto* val = h->table;
2539 while ((y = *val++) < 0)
2553 part2remain -= (int) (h->bits + 1);
2554 x += (int) getBits ((
int) h->bits);
2555 *xrpnt = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);
2560 *xrpnt = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);
2571 part2remain -= (int) (h->bits + 1);
2572 y += (int) getBits ((
int) h->bits);
2573 *xrpnt = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);
2578 *xrpnt = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);
2588 for (; l3 && (part2remain > 0); --l3)
2590 auto* h = huffmanTables2 + granule.count1TableSelect;
2591 auto* val = h->table;
2594 while ((a = *val++) < 0)
2596 if (part2remain <= 0)
2608 for (
int i = 0; i < 4; ++i)
2615 xrpnt = ((
float*) xr) + (*map++);
2621 v = granule.pow2gain[ (*scf++) << shift];
2626 v = granule.fullGain[lwin][ (*scf++) << shift];
2638 if (part2remain == 0)
2642 *xrpnt = getOneBit() ? -v : v;
2651 while (map < mapEnd)
2656 xrpnt = ((
float*) xr) + *map++;
2657 step = (*map++ == 3) ? 1 : 3;
2662 *xrpnt = 0; xrpnt += step;
2663 *xrpnt = 0; xrpnt += step;
2666 granule.maxBand[0] = (uint32) (max[0] + 1);
2667 granule.maxBand[1] = (uint32) (max[1] + 1);
2668 granule.maxBand[2] = (uint32) (max[2] + 1);
2669 granule.maxBandl = (uint32) (max[3] + 1);
2671 const int rmax = jmax (max[0], max[1], max[3]) + 1;
2672 granule.maxb = rmax ? (uint32) constants.shortLimit[sampleRate][rmax]
2673 : (uint32) constants.longLimit[sampleRate][max[3] + 1];
2677 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 };
2678 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 };
2680 auto* pretab = (
const int*) (granule.preflag ? pretab1 : pretab2);
2681 int max = -1, cb = 0, mc = 0;
2682 auto* map = constants.map[sampleRate][2];
2685 for (
int i = 0; i < 3; ++i)
2687 auto* h = huffmanTables1 + granule.tableSelect[i];
2689 for (
int lp = l[i]; lp != 0; --lp, --mc)
2694 v = granule.pow2gain[((*scf++) + (*pretab++)) << shift];
2698 auto* val = h->table;
2701 while ((y = *val++) < 0)
2703 if (getOneBit()) val -= y;
2713 part2remain -= (int) (h->bits + 1);
2714 x += (int) getBits ((
int) h->bits);
2715 *xrpnt++ = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);
2720 *xrpnt++ = constants.nToThe4Over3[x] * (getOneBit() ? -v : v);
2729 part2remain -= (int) (h->bits + 1);
2730 y += (int) getBits ((
int) h->bits);
2731 *xrpnt++ = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);
2736 *xrpnt++ = constants.nToThe4Over3[y] * (getOneBit() ? -v : v);
2744 for (; l3 && part2remain > 0; --l3)
2746 auto* h = huffmanTables2 + granule.count1TableSelect;
2747 auto* values = h->table;
2750 while ((a = *values++) < 0)
2752 if (part2remain <= 0)
2764 for (
int i = 0; i < 4; ++i)
2772 v = granule.pow2gain[((*scf++) + (*pretab++)) << shift];
2777 if ((a & (0x8 >> i)))
2781 if (part2remain <= 0)
2785 *xrpnt++ = getOneBit() ? -v : v;
2792 zeromem (xrpnt, (
size_t) (&xr[32][0] - xrpnt) *
sizeof (
float));
2794 granule.maxBandl = (uint32) (max + 1);
2795 granule.maxb = (uint32) constants.longLimit[sampleRate][granule.maxBandl];
2798 while (part2remain > 16)
2804 if (part2remain > 0)
2805 getBits (part2remain);
2806 else if (part2remain < 0)
2812 void layer3Hybrid (
float fsIn[32][18],
float tsOut[18][32],
int ch,
const Layer3SideInfo::Info& granule)
noexcept
2814 auto* ts = (
float*) tsOut;
2815 float* rawout1, *rawout2;
2819 int b = hybridBlockIndex[ch];
2820 rawout1 = hybridBlock[b][ch];
2822 rawout2 = hybridBlock[b][ch];
2823 hybridBlockIndex[ch] = b;
2826 if (granule.mixedBlockFlag)
2829 DCT::dct36 (fsIn[0], rawout1, rawout2, constants.win[0], ts);
2830 DCT::dct36 (fsIn[1], rawout1 + 18, rawout2 + 18, constants.win1[0], ts + 1);
2836 auto bt = granule.blockType;
2840 for (; sb < (int) granule.maxb; sb += 2, ts += 2, rawout1 += 36, rawout2 += 36)
2842 DCT::dct12 (fsIn[sb], rawout1, rawout2, constants.win[2], ts);
2843 DCT::dct12 (fsIn[sb + 1], rawout1 + 18, rawout2 + 18, constants.win1[2], ts + 1);
2848 for (; sb < (int) granule.maxb; sb += 2, ts += 2, rawout1 += 36, rawout2 += 36)
2850 DCT::dct36 (fsIn[sb], rawout1, rawout2, constants.win[bt], ts);
2851 DCT::dct36 (fsIn[sb + 1], rawout1 + 18, rawout2 + 18, constants.win1[bt], ts + 1);
2855 for (; sb < 32; ++sb, ++ts)
2857 for (
int i = 0; i < 18; ++i)
2859 ts[i * 32] = *rawout1++;
2865 void synthesiseStereo (
const float* bandPtr0,
const float* bandPtr1,
float* out0,
float* out1,
int& samplesDone)
noexcept
2867 auto dummy = samplesDone;
2868 synthesise (bandPtr0, 0, out0, dummy);
2869 synthesise (bandPtr1, 1, out1, samplesDone);
2872 void synthesise (
const float* bandPtr,
int channel,
float* out,
int& samplesDone)
2875 const int bo = channel == 0 ? ((synthBo - 1) & 15) : synthBo;
2876 float (*buf)[0x110] = synthBuffers[channel];
2883 DCT::dct64 (buf[1] + ((bo + 1) & 15), buf[0] + bo, bandPtr);
2889 DCT::dct64 (buf[0] + bo, buf[1] + bo1, bandPtr);
2893 const float* window = constants.decodeWin + 16 - bo1;
2895 for (
int j = 16; j != 0; --j, b0 += 16, window += 32)
2897 auto sum = window[0] * b0[0]; sum -= window[1] * b0[1];
2898 sum += window[2] * b0[2]; sum -= window[3] * b0[3];
2899 sum += window[4] * b0[4]; sum -= window[5] * b0[5];
2900 sum += window[6] * b0[6]; sum -= window[7] * b0[7];
2901 sum += window[8] * b0[8]; sum -= window[9] * b0[9];
2902 sum += window[10] * b0[10]; sum -= window[11] * b0[11];
2903 sum += window[12] * b0[12]; sum -= window[13] * b0[13];
2904 sum += window[14] * b0[14]; sum -= window[15] * b0[15];
2909 auto sum = window[0] * b0[0]; sum += window[2] * b0[2];
2910 sum += window[4] * b0[4]; sum += window[6] * b0[6];
2911 sum += window[8] * b0[8]; sum += window[10] * b0[10];
2912 sum += window[12] * b0[12]; sum += window[14] * b0[14];
2914 b0 -= 16; window -= 32;
2918 for (
int j = 15; j != 0; --j, b0 -= 16, window -= 32)
2920 auto sum = -window[-1] * b0[0]; sum -= window[-2] * b0[1];
2921 sum -= window[-3] * b0[2]; sum -= window[-4] * b0[3];
2922 sum -= window[-5] * b0[4]; sum -= window[-6] * b0[5];
2923 sum -= window[-7] * b0[6]; sum -= window[-8] * b0[7];
2924 sum -= window[-9] * b0[8]; sum -= window[-10] * b0[9];
2925 sum -= window[-11] * b0[10]; sum -= window[-12] * b0[11];
2926 sum -= window[-13] * b0[12]; sum -= window[-14] * b0[13];
2927 sum -= window[-15] * b0[14]; sum -= window[0] * b0[15];
2934 JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MP3Stream)
2941class MP3Reader :
public AudioFormatReader
2944 MP3Reader (InputStream*
const in)
2945 : AudioFormatReader (in, mp3FormatName),
2946 stream (*in), currentPosition (0),
2947 decodedStart (0), decodedEnd (0)
2950 const int64 streamPos = stream.stream.getPosition();
2952 if (readNextBlock())
2955 usesFloatingPointData =
true;
2956 sampleRate = stream.frame.getFrequency();
2957 numChannels = (
unsigned int) stream.frame.numChannels;
2958 lengthInSamples = findLength (streamPos);
2962 bool readSamples (
int** destSamples,
int numDestChannels,
int startOffsetInDestBuffer,
2963 int64 startSampleInFile,
int numSamples)
override
2965 jassert (destSamples !=
nullptr);
2967 if (currentPosition != startSampleInFile)
2969 if (! stream.seek ((
int) (startSampleInFile / 1152 - 1)))
2971 currentPosition = -1;
2972 createEmptyDecodedData();
2976 decodedStart = decodedEnd = 0;
2977 const int64 streamPos = stream.currentFrameIndex * 1152;
2978 int toSkip = (int) (startSampleInFile - streamPos);
2979 jassert (toSkip >= 0);
2983 if (! readNextBlock())
2985 createEmptyDecodedData();
2989 const int numReady = decodedEnd - decodedStart;
2991 if (numReady > toSkip)
2993 decodedStart += toSkip;
3000 currentPosition = startSampleInFile;
3004 while (numSamples > 0)
3006 if (decodedEnd <= decodedStart && ! readNextBlock())
3008 for (
int i = numDestChannels; --i >= 0;)
3009 if (destSamples[i] !=
nullptr)
3010 zeromem (destSamples[i] + startOffsetInDestBuffer, (
size_t) numSamples *
sizeof (
float));
3015 const int numToCopy = jmin (decodedEnd - decodedStart, numSamples);
3016 float*
const*
const dst =
reinterpret_cast<float**
> (destSamples);
3017 memcpy (dst[0] + startOffsetInDestBuffer, decoded0 + decodedStart, (
size_t) numToCopy *
sizeof (
float));
3019 if (numDestChannels > 1 && dst[1] !=
nullptr)
3020 memcpy (dst[1] + startOffsetInDestBuffer, (numChannels < 2 ? decoded0 : decoded1) + decodedStart, (size_t) numToCopy * sizeof (float));
3022 startOffsetInDestBuffer += numToCopy;
3023 decodedStart += numToCopy;
3024 currentPosition += numToCopy;
3025 numSamples -= numToCopy;
3033 int64 currentPosition;
3034 enum { decodedDataSize = 1152 };
3035 float decoded0[decodedDataSize], decoded1[decodedDataSize];
3036 int decodedStart, decodedEnd;
3038 void createEmptyDecodedData() noexcept
3040 zeromem (decoded0,
sizeof (decoded0));
3041 zeromem (decoded1,
sizeof (decoded1));
3043 decodedEnd = decodedDataSize;
3046 bool readNextBlock()
3048 for (
int attempts = 10; --attempts >= 0;)
3050 int samplesDone = 0;
3051 const int result = stream.decodeNextBlock (decoded0, decoded1, samplesDone);
3053 if (result > 0 && stream.stream.isExhausted())
3055 createEmptyDecodedData();
3062 decodedEnd = samplesDone;
3072 const int64 originalPosition = stream.stream.getPosition();
3073 const uint32 firstWord = (uint32) stream.stream.readInt();
3075 if ((firstWord & 0xffffff) == 0x334449)
3079 if (stream.stream.read (buffer, 6) == 6
3080 && buffer[0] != 0xff
3081 && ((buffer[2] | buffer[3] | buffer[4] | buffer[5]) & 0x80) == 0)
3083 const uint32 length = (((uint32) buffer[2]) << 21)
3084 | (((uint32) buffer[3]) << 14)
3085 | (((uint32) buffer[4]) << 7)
3086 | ((uint32) buffer[5]);
3088 stream.stream.skipNextBytes (length);
3093 stream.stream.setPosition (originalPosition);
3096 int64 findLength (int64 streamStartPos)
3098 int64 numFrames = stream.numFrames;
3102 const int64 streamSize = stream.stream.getTotalLength();
3106 const int bytesPerFrame = stream.frame.frameSize + 4;
3108 if (bytesPerFrame == 417 || bytesPerFrame == 418)
3109 numFrames = roundToInt ((streamSize - streamStartPos) / 417.95918);
3111 numFrames = (streamSize - streamStartPos) / bytesPerFrame;
3115 return numFrames * 1152;
3118 JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MP3Reader)
3124MP3AudioFormat::MP3AudioFormat() : AudioFormat (MP3Decoder::mp3FormatName,
".mp3") {}
3125MP3AudioFormat::~MP3AudioFormat() {}
3127Array<int> MP3AudioFormat::getPossibleSampleRates() {
return {}; }
3128Array<int> MP3AudioFormat::getPossibleBitDepths() {
return {}; }
3129bool MP3AudioFormat::canDoStereo() {
return true; }
3130bool MP3AudioFormat::canDoMono() {
return true; }
3131bool MP3AudioFormat::isCompressed() {
return true; }
3132StringArray MP3AudioFormat::getQualityOptions() {
return {}; }
3134AudioFormatReader* MP3AudioFormat::createReaderFor (InputStream* sourceStream,
const bool deleteStreamIfOpeningFails)
3136 std::unique_ptr<MP3Decoder::MP3Reader> r (
new MP3Decoder::MP3Reader (sourceStream));
3138 if (r->lengthInSamples > 0)
3141 if (! deleteStreamIfOpeningFails)
3147AudioFormatWriter* MP3AudioFormat::createWriterFor (OutputStream*,
double ,
3148 unsigned int ,
int ,
3149 const StringPairArray& ,
int )