/src/vlc/modules/packetizer/mpeg4audio.h
Line | Count | Source |
1 | | /***************************************************************************** |
2 | | * mpeg4audio.h: ISO/IEC 14496-3 audio definitions |
3 | | ***************************************************************************** |
4 | | * Copyright (C) 2001-2024 VLC authors, VideoLAN and VideoLabs |
5 | | * |
6 | | * This program is free software; you can redistribute it and/or modify it |
7 | | * under the terms of the GNU Lesser General Public License as published by |
8 | | * the Free Software Foundation; either version 2.1 of the License, or |
9 | | * (at your option) any later version. |
10 | | * |
11 | | * This program is distributed in the hope that it will be useful, |
12 | | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
14 | | * GNU Lesser General Public License for more details. |
15 | | * |
16 | | * You should have received a copy of the GNU Lesser General Public License |
17 | | * along with this program; if not, write to the Free Software Foundation, |
18 | | * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. |
19 | | *****************************************************************************/ |
20 | | #include <vlc_bits.h> |
21 | | |
22 | | enum MPEG4_audioObjectType /* ISO/IEC 14496-3:2009 1.5.1 */ |
23 | | { |
24 | | MPEG4_AOT_NULL = 0, |
25 | | MPEG4_AOT_AAC_MAIN = 1, |
26 | | MPEG4_AOT_AAC_LC = 2, |
27 | | MPEG4_AOT_AAC_SSR = 3, |
28 | | MPEG4_AOT_AAC_LTP = 4, |
29 | | MPEG4_AOT_AAC_SBR = 5, |
30 | | MPEG4_AOT_AAC_SC = 6, |
31 | | MPEG4_AOT_TWINVQ = 7, |
32 | | MPEG4_AOT_CELP = 8, |
33 | | MPEG4_AOT_HVXC = 9, |
34 | | MPEG4_AOT_RESERVED10 = 10, |
35 | | MPEG4_AOT_RESERVED11 = 11, |
36 | | MPEG4_AOT_TTSI = 12, |
37 | | MPEG4_AOT_MAIN_SYNTHETIC = 13, |
38 | | MPEG4_AOT_WAVETABLES = 14, |
39 | | MPEG4_AOT_GENERAL_MIDI = 15, |
40 | | MPEG4_AOT_ALGORITHMIC = 16, |
41 | | MPEG4_AOT_ER_AAC_LC = 17, |
42 | | MPEG4_AOT_RESERVED18 = 18, |
43 | | MPEG4_AOT_ER_AAC_LTP = 19, |
44 | | MPEG4_AOT_ER_AAC_SC = 20, |
45 | | MPEG4_AOT_ER_TWINVQ = 21, |
46 | | MPEG4_AOT_ER_BSAC = 22, |
47 | | MPEG4_AOT_ER_AAC_LD = 23, |
48 | | MPEG4_AOT_ER_CELP = 24, |
49 | | MPEG4_AOT_ER_HXVC = 25, |
50 | | MPEG4_AOT_ER_HILN = 26, |
51 | | MPEG4_AOT_ER_Parametric = 27, |
52 | | MPEG4_AOT_SSC = 28, |
53 | | MPEG4_AOT_AAC_PS = 29, |
54 | | MPEG4_AOT_MPEG_SURROUND = 30, |
55 | | MPEG4_AOT_ESCAPE = 31, |
56 | | MPEG4_AOT_LAYER1 = 32, |
57 | | MPEG4_AOT_LAYER2 = 33, |
58 | | MPEG4_AOT_LAYER3 = 34, |
59 | | MPEG4_AOT_DST = 35, |
60 | | MPEG4_AOT_ALS = 36, |
61 | | MPEG4_AOT_SLS = 37, |
62 | | MPEG4_AOT_SLS_NON_CORE = 38, |
63 | | MPEG4_AOT_ER_AAC_ELD = 39, |
64 | | MPEG4_AOT_SMR_SIMPLE = 40, |
65 | | MPEG4_AOT_SMR_MAIN = 41, |
66 | | }; |
67 | | |
68 | | enum |
69 | | { |
70 | | AAC_PROFILE_MAIN = MPEG4_AOT_AAC_MAIN - 1, |
71 | | AAC_PROFILE_LC, |
72 | | AAC_PROFILE_SSR, |
73 | | AAC_PROFILE_LTP, |
74 | | AAC_PROFILE_HE, |
75 | | AAC_PROFILE_LD = MPEG4_AOT_ER_AAC_LD - 1, |
76 | | AAC_PROFILE_HEv2 = MPEG4_AOT_AAC_PS - 1, |
77 | | AAC_PROFILE_ELD = MPEG4_AOT_ER_AAC_ELD - 1, |
78 | | /* Similar shift signaling as avcodec, as signaling should have been |
79 | | done in ADTS header. Values defaults to MPEG4 */ |
80 | | AAC_PROFILE_MPEG2_LC = AAC_PROFILE_LC + 128, |
81 | | AAC_PROFILE_MPEG2_HE = AAC_PROFILE_HE + 128, |
82 | | }; |
83 | | |
84 | | static const uint32_t MPEG4_asc_channelsbyindex[] = |
85 | | { |
86 | | [0] = 0, /* Set later */ |
87 | | |
88 | | [1] = AOUT_CHAN_CENTER, // Mono |
89 | | |
90 | | [2] = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT, // Stereo |
91 | | |
92 | | [3] = AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT, // 2.1ch 3.0 |
93 | | |
94 | | [4] = AOUT_CHAN_CENTER | // 4ch 3.1 |
95 | | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | |
96 | | AOUT_CHAN_REARCENTER, |
97 | | |
98 | | [5] = AOUT_CHAN_CENTER | // 5ch 3.2 |
99 | | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | |
100 | | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT, |
101 | | |
102 | | [6] = AOUT_CHAN_CENTER | // 5.1ch 3.2.1 |
103 | | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | |
104 | | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | |
105 | | AOUT_CHAN_LFE, |
106 | | |
107 | | [7] = AOUT_CHAN_CENTER | // 7.1ch 5.2.1 |
108 | | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | |
109 | | AOUT_CHAN_MIDDLELEFT | AOUT_CHAN_MIDDLERIGHT | |
110 | | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT | |
111 | | AOUT_CHAN_LFE, |
112 | | |
113 | | [8] = 0, |
114 | | }; |
115 | | |
116 | | #define MPEG4_ASC_MAX_INDEXEDPOS ARRAY_SIZE(MPEG4_asc_channelsbyindex) |
117 | | |
118 | | typedef struct |
119 | | { |
120 | | enum MPEG4_audioObjectType i_object_type; |
121 | | unsigned i_samplerate; |
122 | | uint8_t i_channel_configuration; |
123 | | int8_t i_sbr; // 0: no sbr, 1: sbr, -1: unknown |
124 | | int8_t i_ps; // 0: no ps, 1: ps, -1: unknown |
125 | | |
126 | | struct |
127 | | { |
128 | | enum MPEG4_audioObjectType i_object_type; |
129 | | unsigned i_samplerate; |
130 | | uint8_t i_channel_configuration; |
131 | | } extension; |
132 | | |
133 | | /* GASpecific */ |
134 | | unsigned i_frame_length; // 1024 or 960 |
135 | | |
136 | | } MPEG4_asc_t; |
137 | | |
138 | | static inline int MPEG4_read_GAProgramConfigElement(bs_t *s) |
139 | 1.03k | { |
140 | | /* TODO compute channels count ? */ |
141 | 1.03k | int i_tag = bs_read(s, 4); |
142 | 1.03k | if (i_tag != 0x05) |
143 | 271 | return -1; |
144 | 764 | bs_skip(s, 2 + 4); // object type + sampling index |
145 | 764 | int i_num_front = bs_read(s, 4); |
146 | 764 | int i_num_side = bs_read(s, 4); |
147 | 764 | int i_num_back = bs_read(s, 4); |
148 | 764 | int i_num_lfe = bs_read(s, 2); |
149 | 764 | int i_num_assoc_data = bs_read(s, 3); |
150 | 764 | int i_num_valid_cc = bs_read(s, 4); |
151 | | |
152 | 764 | if (bs_read1(s)) |
153 | 147 | bs_skip(s, 4); // mono downmix |
154 | 764 | if (bs_read1(s)) |
155 | 463 | bs_skip(s, 4); // stereo downmix |
156 | 764 | if (bs_read1(s)) |
157 | 189 | bs_skip(s, 2+1); // matrix downmix + pseudo_surround |
158 | | |
159 | 764 | bs_skip(s, i_num_front * (1+4)); |
160 | 764 | bs_skip(s, i_num_side * (1+4)); |
161 | 764 | bs_skip(s, i_num_back * (1+4)); |
162 | 764 | bs_skip(s, i_num_lfe * (4)); |
163 | 764 | bs_skip(s, i_num_assoc_data * (4)); |
164 | 764 | bs_skip(s, i_num_valid_cc * (5)); |
165 | 764 | bs_align(s); |
166 | 764 | int i_comment = bs_read(s, 8); |
167 | 764 | bs_skip(s, i_comment * 8); |
168 | 764 | return 0; |
169 | 1.03k | } |
170 | | |
171 | | static inline int MPEG4_read_GASpecificConfig(MPEG4_asc_t *p_cfg, bs_t *s) |
172 | 1.55k | { |
173 | 1.55k | p_cfg->i_frame_length = bs_read1(s) ? 960 : 1024; |
174 | 1.55k | if(p_cfg->i_object_type == MPEG4_AOT_ER_AAC_LD) /* 14496-3 4.5.1.1 */ |
175 | 16 | p_cfg->i_frame_length >>= 1; |
176 | 1.53k | else if(p_cfg->i_object_type == MPEG4_AOT_AAC_SSR) |
177 | 42 | p_cfg->i_frame_length = 256; |
178 | | |
179 | 1.55k | if (bs_read1(s)) // depend on core coder |
180 | 424 | bs_skip(s, 14); // core coder delay |
181 | | |
182 | 1.55k | int i_extension_flag = bs_read1(s); |
183 | 1.55k | if (p_cfg->i_channel_configuration == 0) |
184 | 1.03k | MPEG4_read_GAProgramConfigElement(s); |
185 | 1.55k | if (p_cfg->i_object_type == MPEG4_AOT_AAC_SC || |
186 | 1.45k | p_cfg->i_object_type == MPEG4_AOT_ER_AAC_SC) |
187 | 176 | bs_skip(s, 3); // layer |
188 | | |
189 | 1.55k | if (i_extension_flag) { |
190 | 429 | if (p_cfg->i_object_type == MPEG4_AOT_ER_BSAC) |
191 | 129 | bs_skip(s, 5 + 11); // numOfSubFrame + layer length |
192 | 429 | if (p_cfg->i_object_type == MPEG4_AOT_ER_AAC_LC || |
193 | 377 | p_cfg->i_object_type == MPEG4_AOT_ER_AAC_LTP || |
194 | 354 | p_cfg->i_object_type == MPEG4_AOT_ER_AAC_SC || |
195 | 312 | p_cfg->i_object_type == MPEG4_AOT_ER_AAC_LD) |
196 | 132 | bs_skip(s, 1+1+1); // ER data : section scale spectral */ |
197 | 429 | if (bs_read1(s)) // extension 3 |
198 | 429 | fprintf(stderr, "MPEG4GASpecificConfig: error 1\n"); |
199 | 429 | } |
200 | 1.55k | return 0; |
201 | 1.55k | } |
202 | | |
203 | | static inline int MPEG4_read_ELDSpecificConfig(MPEG4_asc_t *p_cfg, bs_t *s) |
204 | 1.08k | { |
205 | 1.08k | p_cfg->i_frame_length = bs_read1(s) ? 480 : 512; |
206 | | |
207 | | /* ELDSpecificConfig Table 4.180 */ |
208 | | |
209 | 1.08k | bs_skip(s, 3); |
210 | 1.08k | if(bs_read1(s)) /* ldSbrPresentFlag */ |
211 | 904 | { |
212 | 904 | bs_skip(s, 2); |
213 | | /* ld_sbr_header(channelConfiguration) Table 4.181 */ |
214 | 904 | unsigned numSbrHeader; |
215 | 904 | switch(p_cfg->i_channel_configuration) |
216 | 904 | { |
217 | 35 | case 1: case 2: |
218 | 35 | numSbrHeader = 1; |
219 | 35 | break; |
220 | 13 | case 3: |
221 | 13 | numSbrHeader = 2; |
222 | 13 | break; |
223 | 118 | case 4: case 5: case 6: |
224 | 118 | numSbrHeader = 3; |
225 | 118 | break; |
226 | 471 | case 7: |
227 | 471 | numSbrHeader = 4; |
228 | 471 | break; |
229 | 267 | default: |
230 | 267 | numSbrHeader = 0; |
231 | 267 | break; |
232 | 904 | } |
233 | 3.20k | for( ; numSbrHeader; numSbrHeader-- ) |
234 | 2.29k | { |
235 | | /* sbr_header() Table 4.63 */ |
236 | 2.29k | bs_read(s, 14); |
237 | 2.29k | bool header_extra_1 = bs_read1(s); |
238 | 2.29k | bool header_extra_2 = bs_read1(s); |
239 | 2.29k | if(header_extra_1) |
240 | 1.22k | bs_read(s, 5); |
241 | 2.29k | if(header_extra_2) |
242 | 1.11k | bs_read(s, 6); |
243 | 2.29k | } |
244 | 904 | } |
245 | | |
246 | 1.08k | for(unsigned eldExtType = bs_read(s, 4); |
247 | 5.34k | eldExtType != 0x0 /* ELDEXT_TERM */; |
248 | 4.25k | eldExtType = bs_read(s, 4)) |
249 | 4.25k | { |
250 | 4.25k | unsigned eldExtLen = bs_read(s, 4); |
251 | 4.25k | unsigned eldExtLenAdd = 0; |
252 | 4.25k | if(eldExtLen == 15) |
253 | 180 | { |
254 | 180 | eldExtLenAdd = bs_read(s, 8); |
255 | 180 | eldExtLen += eldExtLenAdd; |
256 | 180 | } |
257 | 4.25k | if(eldExtLenAdd == 255) |
258 | 67 | eldExtLen += bs_read(s, 16); |
259 | | /* reserved extensions */ |
260 | 4.22M | for(; eldExtLen; eldExtLen--) |
261 | 4.21M | bs_skip(s, 8); |
262 | 4.25k | } |
263 | | |
264 | 1.08k | return 0; |
265 | 1.08k | } |
266 | | |
267 | | static inline enum MPEG4_audioObjectType MPEG4_read_AudioObjectType(bs_t *s) |
268 | 4.17k | { |
269 | 4.17k | int i_type = bs_read(s, 5); |
270 | 4.17k | if (i_type == 31) |
271 | 144 | i_type = 32 + bs_read(s, 6); |
272 | 4.17k | return (enum MPEG4_audioObjectType) i_type; |
273 | 4.17k | } |
274 | | |
275 | | static const int pi_sample_rates[16] = |
276 | | { |
277 | | 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, |
278 | | 16000, 12000, 11025, 8000, 7350, 0, 0, 0 |
279 | | }; |
280 | | |
281 | | static inline unsigned MPEG4_read_AudioSamplerate(bs_t *s) |
282 | 4.06k | { |
283 | 4.06k | int i_index = bs_read(s, 4); |
284 | 4.06k | if (i_index != 0x0f) |
285 | 3.90k | return pi_sample_rates[i_index]; |
286 | 156 | return bs_read(s, 24); |
287 | 4.06k | } |
288 | | |
289 | | static inline int MPEG4_read_AudioSpecificConfig(bs_t *s, MPEG4_asc_t *p_cfg, bool b_withext) |
290 | 2.74k | { |
291 | 2.74k | p_cfg->i_object_type = MPEG4_read_AudioObjectType(s); |
292 | 2.74k | p_cfg->i_samplerate = MPEG4_read_AudioSamplerate(s); |
293 | 2.74k | p_cfg->i_channel_configuration = bs_read(s, 4); |
294 | | |
295 | 2.74k | p_cfg->i_sbr = -1; |
296 | 2.74k | p_cfg->i_ps = -1; |
297 | 2.74k | p_cfg->extension.i_object_type = MPEG4_AOT_NULL; |
298 | 2.74k | p_cfg->extension.i_samplerate = 0; |
299 | 2.74k | p_cfg->extension.i_channel_configuration = 0; |
300 | 2.74k | p_cfg->i_frame_length = 0; |
301 | | |
302 | 2.74k | if (p_cfg->i_object_type == MPEG4_AOT_AAC_SBR || |
303 | 1.54k | p_cfg->i_object_type == MPEG4_AOT_AAC_PS) { |
304 | 1.25k | p_cfg->i_sbr = 1; |
305 | 1.25k | if (p_cfg->i_object_type == MPEG4_AOT_AAC_PS) |
306 | 55 | p_cfg->i_ps = 1; |
307 | 1.25k | p_cfg->extension.i_object_type = MPEG4_AOT_AAC_SBR; |
308 | 1.25k | p_cfg->extension.i_samplerate = MPEG4_read_AudioSamplerate(s); |
309 | | |
310 | 1.25k | p_cfg->i_object_type = MPEG4_read_AudioObjectType(s); |
311 | 1.25k | if(p_cfg->i_object_type == MPEG4_AOT_ER_BSAC) |
312 | 110 | p_cfg->extension.i_channel_configuration = bs_read(s, 4); |
313 | 1.25k | } |
314 | | |
315 | 2.74k | switch(p_cfg->i_object_type) |
316 | 2.74k | { |
317 | 59 | case MPEG4_AOT_AAC_MAIN: |
318 | 275 | case MPEG4_AOT_AAC_LC: |
319 | 317 | case MPEG4_AOT_AAC_SSR: |
320 | 1.05k | case MPEG4_AOT_AAC_LTP: |
321 | 1.15k | case MPEG4_AOT_AAC_SC: |
322 | 1.17k | case MPEG4_AOT_TWINVQ: |
323 | 1.24k | case MPEG4_AOT_ER_AAC_LC: |
324 | 1.28k | case MPEG4_AOT_ER_AAC_LTP: |
325 | 1.35k | case MPEG4_AOT_ER_AAC_SC: |
326 | 1.39k | case MPEG4_AOT_ER_TWINVQ: |
327 | 1.53k | case MPEG4_AOT_ER_BSAC: |
328 | 1.55k | case MPEG4_AOT_ER_AAC_LD: |
329 | 1.55k | MPEG4_read_GASpecificConfig(p_cfg, s); |
330 | 1.55k | break; |
331 | 38 | case MPEG4_AOT_CELP: |
332 | | // CelpSpecificConfig(); |
333 | 136 | case MPEG4_AOT_HVXC: |
334 | | // HvxcSpecificConfig(); |
335 | 195 | case MPEG4_AOT_TTSI: |
336 | | // TTSSSpecificConfig(); |
337 | 553 | case MPEG4_AOT_MAIN_SYNTHETIC: |
338 | 667 | case MPEG4_AOT_WAVETABLES: |
339 | 699 | case MPEG4_AOT_GENERAL_MIDI: |
340 | 730 | case MPEG4_AOT_ALGORITHMIC: |
341 | | // StructuredAudioSpecificConfig(); |
342 | 762 | case MPEG4_AOT_ER_CELP: |
343 | | // ERCelpSpecificConfig(); |
344 | 870 | case MPEG4_AOT_ER_HXVC: |
345 | | // ERHvxcSpecificConfig(); |
346 | 897 | case MPEG4_AOT_ER_HILN: |
347 | 960 | case MPEG4_AOT_ER_Parametric: |
348 | | // ParametricSpecificConfig(); |
349 | 1.00k | case MPEG4_AOT_SSC: |
350 | | // SSCSpecificConfig(); |
351 | 1.02k | case MPEG4_AOT_LAYER1: |
352 | 1.02k | case MPEG4_AOT_LAYER2: |
353 | 1.03k | case MPEG4_AOT_LAYER3: |
354 | | // MPEG_1_2_SpecificConfig(); |
355 | 1.04k | case MPEG4_AOT_DST: |
356 | | // DSTSpecificConfig(); |
357 | 1.05k | case MPEG4_AOT_ALS: |
358 | | // ALSSpecificConfig(); |
359 | 1.05k | case MPEG4_AOT_SLS: |
360 | 1.06k | case MPEG4_AOT_SLS_NON_CORE: |
361 | | // SLSSpecificConfig(); |
362 | 1.08k | case MPEG4_AOT_ER_AAC_ELD: |
363 | 1.08k | MPEG4_read_ELDSpecificConfig(p_cfg, s); |
364 | 1.08k | break; |
365 | 0 | case MPEG4_AOT_SMR_SIMPLE: |
366 | 0 | case MPEG4_AOT_SMR_MAIN: |
367 | | // SymbolicMusicSpecificConfig(); |
368 | 112 | default: |
369 | | // error |
370 | 112 | return VLC_EGENERIC; |
371 | 2.74k | } |
372 | | |
373 | 2.63k | switch(p_cfg->i_object_type) |
374 | 2.63k | { |
375 | 64 | case MPEG4_AOT_ER_AAC_LC: |
376 | 107 | case MPEG4_AOT_ER_AAC_LTP: |
377 | 180 | case MPEG4_AOT_ER_AAC_SC: |
378 | 217 | case MPEG4_AOT_ER_TWINVQ: |
379 | 361 | case MPEG4_AOT_ER_BSAC: |
380 | 377 | case MPEG4_AOT_ER_AAC_LD: |
381 | 409 | case MPEG4_AOT_ER_CELP: |
382 | 517 | case MPEG4_AOT_ER_HXVC: |
383 | 544 | case MPEG4_AOT_ER_HILN: |
384 | 607 | case MPEG4_AOT_ER_Parametric: |
385 | 629 | case MPEG4_AOT_ER_AAC_ELD: |
386 | 629 | { |
387 | 629 | int epConfig = bs_read(s, 2); |
388 | 629 | if (epConfig == 2 || epConfig == 3) |
389 | | //ErrorProtectionSpecificConfig(); |
390 | 96 | if (epConfig == 3) |
391 | 65 | if (bs_read1(s)) { |
392 | | // TODO : directMapping |
393 | 32 | } |
394 | 629 | break; |
395 | 607 | } |
396 | 2.00k | default: |
397 | 2.00k | break; |
398 | 2.63k | } |
399 | | |
400 | 2.63k | if (b_withext && p_cfg->extension.i_object_type != MPEG4_AOT_AAC_SBR && |
401 | 1.40k | !bs_eof(s) && bs_read(s, 11) == 0x2b7) |
402 | 166 | { |
403 | 166 | p_cfg->extension.i_object_type = MPEG4_read_AudioObjectType(s); |
404 | 166 | if (p_cfg->extension.i_object_type == MPEG4_AOT_AAC_SBR) |
405 | 79 | { |
406 | 79 | p_cfg->i_sbr = bs_read1(s); |
407 | 79 | if (p_cfg->i_sbr == 1) { |
408 | 42 | p_cfg->extension.i_samplerate = MPEG4_read_AudioSamplerate(s); |
409 | 42 | if (bs_read(s, 11) == 0x548) |
410 | 17 | p_cfg->i_ps = bs_read1(s); |
411 | 42 | } |
412 | 79 | } |
413 | 87 | else if (p_cfg->extension.i_object_type == MPEG4_AOT_ER_BSAC) |
414 | 43 | { |
415 | 43 | p_cfg->i_sbr = bs_read1(s); |
416 | 43 | if(p_cfg->i_sbr) |
417 | 12 | p_cfg->extension.i_samplerate = MPEG4_read_AudioSamplerate(s); |
418 | 43 | p_cfg->extension.i_channel_configuration = bs_read(s, 4); |
419 | 43 | } |
420 | 166 | } |
421 | | |
422 | | #if 0 |
423 | | static const char *ppsz_otype[] = { |
424 | | "NULL", |
425 | | "AAC Main", "AAC LC", "AAC SSR", "AAC LTP", "SBR", "AAC Scalable", |
426 | | "TwinVQ", |
427 | | "CELP", "HVXC", |
428 | | "Reserved", "Reserved", |
429 | | "TTSI", |
430 | | "Main Synthetic", "Wavetables Synthesis", "General MIDI", |
431 | | "Algorithmic Synthesis and Audio FX", |
432 | | "ER AAC LC", |
433 | | "Reserved", |
434 | | "ER AAC LTP", "ER AAC Scalable", "ER TwinVQ", "ER BSAC", "ER AAC LD", |
435 | | "ER CELP", "ER HVXC", "ER HILN", "ER Parametric", |
436 | | "SSC", |
437 | | "PS", "MPEG Surround", "Escape", |
438 | | "Layer 1", "Layer 2", "Layer 3", |
439 | | "DST", "ALS", "SLS", "SLS non-core", "ELD", |
440 | | "SMR Simple", "SMR Main", |
441 | | }; |
442 | | |
443 | | fprintf(stderr, "MPEG4ReadAudioSpecificInfo: t=%s(%d)f=%d c=%d sbr=%d\n", |
444 | | ppsz_otype[p_cfg->i_object_type], p_cfg->i_object_type, |
445 | | p_cfg->i_samplerate, p_cfg->i_channel, p_cfg->i_sbr); |
446 | | #endif |
447 | 2.63k | return bs_error(s) ? VLC_EGENERIC : VLC_SUCCESS; |
448 | 2.63k | } |
449 | | |
450 | | #define MPEG4_STREAM_MAX_EXTRADATA 64 |
451 | | typedef struct |
452 | | { |
453 | | uint8_t i_program; |
454 | | uint8_t i_layer; |
455 | | |
456 | | unsigned i_frame_length; // type 1 |
457 | | uint8_t i_frame_length_type; |
458 | | uint8_t i_frame_length_index; // type 3 4 5 6 7 |
459 | | |
460 | | MPEG4_asc_t cfg; |
461 | | |
462 | | /* Raw configuration */ |
463 | | size_t i_extra; |
464 | | uint8_t extra[MPEG4_STREAM_MAX_EXTRADATA]; |
465 | | |
466 | | } MPEG4_audio_stream_t; |
467 | | |
468 | | #define MPEG4_STREAMMUX_MAX_LAYER 8 |
469 | | #define MPEG4_STREAMMUX_MAX_PROGRAM 16 |
470 | | typedef struct |
471 | | { |
472 | | bool b_same_time_framing; |
473 | | uint8_t i_sub_frames; |
474 | | uint8_t i_programs; |
475 | | |
476 | | uint8_t pi_layers[MPEG4_STREAMMUX_MAX_PROGRAM]; |
477 | | |
478 | | uint8_t pi_stream[MPEG4_STREAMMUX_MAX_PROGRAM][MPEG4_STREAMMUX_MAX_LAYER]; |
479 | | |
480 | | uint8_t i_streams; |
481 | | MPEG4_audio_stream_t stream[MPEG4_STREAMMUX_MAX_PROGRAM*MPEG4_STREAMMUX_MAX_LAYER]; |
482 | | |
483 | | uint32_t i_other_data; |
484 | | int16_t i_crc; /* -1 if not set */ |
485 | | } MPEG4_streammux_config_t; |
486 | | |
487 | | static inline uint32_t MPEG4_LatmGetValue(bs_t *s) |
488 | 0 | { |
489 | 0 | uint32_t v = 0; |
490 | 0 | for (int i = 1 + bs_read(s, 2); i > 0; i--) |
491 | 0 | v = (v << 8) + bs_read(s, 8); |
492 | 0 | return v; |
493 | 0 | } |
494 | | |
495 | | static inline size_t AudioSpecificConfigBitsToBytes(bs_t *s, uint32_t i_bits, uint8_t *p_data) |
496 | 0 | { |
497 | 0 | size_t i_extra = __MIN((i_bits + 7) / 8, MPEG4_STREAM_MAX_EXTRADATA); |
498 | 0 | for (size_t i = 0; i < i_extra; i++) { |
499 | 0 | const uint32_t i_read = __MIN(8, i_bits - 8*i); |
500 | 0 | p_data[i] = bs_read(s, i_read) << (8-i_read); |
501 | 0 | } |
502 | 0 | return i_extra; |
503 | 0 | } |
504 | | |
505 | | static inline int MPEG4_parse_StreamMuxConfig(bs_t *s, MPEG4_streammux_config_t *m) |
506 | 0 | { |
507 | 0 | int i_mux_version; |
508 | 0 | int i_mux_versionA; |
509 | |
|
510 | 0 | i_mux_version = bs_read(s, 1); |
511 | 0 | i_mux_versionA = 0; |
512 | 0 | if (i_mux_version) |
513 | 0 | i_mux_versionA = bs_read(s, 1); |
514 | |
|
515 | 0 | if (i_mux_versionA != 0) /* support only A=0 */ |
516 | 0 | return -1; |
517 | | |
518 | 0 | memset(m, 0, sizeof(*m)); |
519 | |
|
520 | 0 | if (i_mux_versionA == 0) |
521 | 0 | if (i_mux_version == 1) |
522 | 0 | MPEG4_LatmGetValue(s); /* taraBufferFullness */ |
523 | |
|
524 | 0 | if(bs_eof(s)) |
525 | 0 | return -1; |
526 | | |
527 | 0 | m->b_same_time_framing = bs_read1(s); |
528 | 0 | m->i_sub_frames = 1 + bs_read(s, 6); |
529 | 0 | m->i_programs = 1 + bs_read(s, 4); |
530 | |
|
531 | 0 | for (uint8_t i_program = 0; i_program < m->i_programs; i_program++) { |
532 | 0 | if(bs_eof(s)) |
533 | 0 | return -1; |
534 | 0 | m->pi_layers[i_program] = 1+bs_read(s, 3); |
535 | |
|
536 | 0 | for (uint8_t i_layer = 0; i_layer < m->pi_layers[i_program]; i_layer++) { |
537 | 0 | MPEG4_audio_stream_t *st = &m->stream[m->i_streams]; |
538 | 0 | bool b_previous_cfg; |
539 | |
|
540 | 0 | m->pi_stream[i_program][i_layer] = m->i_streams; |
541 | 0 | st->i_program = i_program; |
542 | 0 | st->i_layer = i_layer; |
543 | |
|
544 | 0 | b_previous_cfg = false; |
545 | 0 | if (i_program != 0 || i_layer != 0) |
546 | 0 | b_previous_cfg = bs_read1(s); |
547 | |
|
548 | 0 | if (b_previous_cfg) { |
549 | 0 | assert(m->i_streams > 0); |
550 | 0 | st->cfg = m->stream[m->i_streams-1].cfg; |
551 | 0 | } else { |
552 | 0 | uint32_t asc_size = 0; |
553 | 0 | if(i_mux_version > 0) |
554 | 0 | asc_size = MPEG4_LatmGetValue(s); |
555 | 0 | bs_t asc_bs = *s; |
556 | 0 | MPEG4_read_AudioSpecificConfig(&asc_bs, &st->cfg, i_mux_version > 0); |
557 | 0 | if (i_mux_version == 0) |
558 | 0 | asc_size = bs_pos(&asc_bs) - bs_pos(s); |
559 | 0 | asc_bs = *s; |
560 | 0 | st->i_extra = AudioSpecificConfigBitsToBytes(&asc_bs, asc_size, st->extra); |
561 | 0 | bs_skip(s, asc_size); |
562 | 0 | } |
563 | |
|
564 | 0 | st->i_frame_length_type = bs_read(s, 3); |
565 | 0 | switch(st->i_frame_length_type) |
566 | 0 | { |
567 | 0 | case 0: |
568 | 0 | { |
569 | 0 | bs_skip(s, 8); /* latmBufferFullnes */ |
570 | 0 | if (!m->b_same_time_framing) |
571 | 0 | if (st->cfg.i_object_type == MPEG4_AOT_AAC_SC || |
572 | 0 | st->cfg.i_object_type == MPEG4_AOT_CELP || |
573 | 0 | st->cfg.i_object_type == MPEG4_AOT_ER_AAC_SC || |
574 | 0 | st->cfg.i_object_type == MPEG4_AOT_ER_CELP) |
575 | 0 | bs_skip(s, 6); /* eFrameOffset */ |
576 | 0 | break; |
577 | 0 | } |
578 | 0 | case 1: |
579 | 0 | st->i_frame_length = bs_read(s, 9); |
580 | 0 | break; |
581 | 0 | case 3: case 4: case 5: |
582 | 0 | st->i_frame_length_index = bs_read(s, 6); // celp |
583 | 0 | break; |
584 | 0 | case 6: case 7: |
585 | 0 | st->i_frame_length_index = bs_read(s, 1); // hvxc |
586 | 0 | default: |
587 | 0 | break; |
588 | 0 | } |
589 | | /* Next stream */ |
590 | 0 | m->i_streams++; |
591 | 0 | } |
592 | 0 | } |
593 | | |
594 | 0 | if(bs_error(s) || bs_eof(s)) |
595 | 0 | return -1; |
596 | | |
597 | | /* other data */ |
598 | 0 | if (bs_read1(s)) { |
599 | 0 | if (i_mux_version == 1) |
600 | 0 | m->i_other_data = MPEG4_LatmGetValue(s); |
601 | 0 | else { |
602 | 0 | int b_continue; |
603 | 0 | do { |
604 | 0 | b_continue = bs_read1(s); |
605 | 0 | m->i_other_data = (m->i_other_data << 8) + bs_read(s, 8); |
606 | 0 | } while (b_continue); |
607 | 0 | } |
608 | 0 | } |
609 | | |
610 | | /* crc */ |
611 | 0 | m->i_crc = -1; |
612 | 0 | if (bs_read1(s)) |
613 | 0 | m->i_crc = bs_read(s, 8); |
614 | |
|
615 | 0 | return bs_error(s) ? -1 : 0; |
616 | 0 | } |
617 | | |