29a8f73f |
1 | /* |
2 | * Copyright (C) 2013 nu774 |
3 | * For conditions of distribution and use, see copyright notice in COPYING |
4 | */ |
5 | |
6 | #if HAVE_CONFIG_H |
7 | # include "config.h" |
8 | #endif |
9 | |
10 | #if HAVE_STDINT_H |
11 | # include <stdint.h> |
12 | #endif |
13 | |
14 | #include <stdio.h> |
1af8624b |
15 | #include <stdlib.h> |
16 | #include <string.h> |
29a8f73f |
17 | #include <stdarg.h> |
18 | #include "pcm_reader.h" |
19 | #include "m4af_endian.h" |
1af8624b |
20 | #include "catypes.h" |
29a8f73f |
21 | |
22 | int pcm_read(pcm_io_context_t *io, void *buffer, uint32_t size) |
23 | { |
24 | int rc; |
25 | uint32_t count = 0; |
26 | |
27 | do { |
28 | rc = io->vtbl->read(io->cookie, buffer, size - count); |
29 | if (rc > 0) |
30 | count += rc; |
31 | } while (rc > 0 && count < size); |
32 | return count > 0 ? count : rc; |
33 | } |
34 | |
35 | int pcm_skip(pcm_io_context_t *io, int64_t count) |
36 | { |
37 | char buff[8192]; |
38 | int rc; |
39 | pcm_io_vtbl_t *vp = io->vtbl; |
40 | |
41 | if (count == 0 || pcm_seek(io, count, SEEK_CUR) >= 0) |
42 | return 0; |
43 | do { |
44 | if ((rc = vp->read(io->cookie, buff, count > 8192 ? 8192 : count)) > 0) |
45 | count -= rc; |
46 | } while (rc > 0 && count > 0); |
47 | |
48 | return count == 0 ? 0 : -1; |
49 | } |
50 | |
51 | int pcm_read16le(pcm_io_context_t *io, uint16_t *value) |
52 | { |
53 | if (pcm_read(io, value, 2) == 2) { |
54 | *value = m4af_ltoh16(*value); |
55 | return 0; |
56 | } |
57 | return -1; |
58 | } |
59 | |
60 | int pcm_read16be(pcm_io_context_t *io, uint16_t *value) |
61 | { |
62 | if (pcm_read(io, value, 2) == 2) { |
63 | *value = m4af_btoh16(*value); |
64 | return 0; |
65 | } |
66 | return -1; |
67 | } |
68 | |
69 | int pcm_read32le(pcm_io_context_t *io, uint32_t *value) |
70 | { |
71 | if (pcm_read(io, value, 4) == 4) { |
72 | *value = m4af_ltoh32(*value); |
73 | return 0; |
74 | } |
75 | return -1; |
76 | } |
77 | |
78 | int pcm_read32be(pcm_io_context_t *io, uint32_t *value) |
79 | { |
80 | if (pcm_read(io, value, 4) == 4) { |
81 | *value = m4af_btoh32(*value); |
82 | return 0; |
83 | } |
84 | return -1; |
85 | } |
86 | |
87 | int pcm_read64le(pcm_io_context_t *io, uint64_t *value) |
88 | { |
89 | if (pcm_read(io, value, 8) == 8) { |
90 | *value = m4af_ltoh64(*value); |
91 | return 0; |
92 | } |
93 | return -1; |
94 | } |
95 | |
96 | int pcm_read64be(pcm_io_context_t *io, uint64_t *value) |
97 | { |
98 | if (pcm_read(io, value, 8) == 8) { |
99 | *value = m4af_btoh64(*value); |
100 | return 0; |
101 | } |
102 | return -1; |
103 | } |
104 | |
105 | int pcm_scanl(pcm_io_context_t *io, const char *fmt, ...) |
106 | { |
107 | int c, count = 0; |
108 | va_list ap; |
109 | |
110 | va_start(ap, fmt); |
111 | while ((c = *fmt++)) { |
112 | switch (c) { |
113 | case 'S': |
114 | TRY_IO(pcm_read16le(io, va_arg(ap, uint16_t*))); |
115 | ++count; |
116 | break; |
117 | case 'L': |
118 | TRY_IO(pcm_read32le(io, va_arg(ap, uint32_t*))); |
119 | ++count; |
120 | break; |
121 | case 'Q': |
122 | TRY_IO(pcm_read64le(io, va_arg(ap, uint64_t*))); |
123 | ++count; |
124 | break; |
125 | } |
126 | } |
127 | FAIL: |
128 | va_end(ap); |
129 | return count; |
130 | } |
131 | |
132 | int pcm_scanb(pcm_io_context_t *io, const char *fmt, ...) |
133 | { |
134 | int c, count = 0; |
135 | va_list ap; |
136 | |
137 | va_start(ap, fmt); |
138 | while ((c = *fmt++)) { |
139 | switch (c) { |
140 | case 'S': |
141 | TRY_IO(pcm_read16be(io, va_arg(ap, uint16_t*))); |
142 | ++count; |
143 | break; |
144 | case 'L': |
145 | TRY_IO(pcm_read32be(io, va_arg(ap, uint32_t*))); |
146 | ++count; |
147 | break; |
148 | case 'Q': |
149 | TRY_IO(pcm_read64be(io, va_arg(ap, uint64_t*))); |
150 | ++count; |
151 | break; |
152 | } |
153 | } |
154 | FAIL: |
155 | va_end(ap); |
156 | return count; |
157 | } |
1af8624b |
158 | |
159 | static |
160 | int channel_compare(const void *a, const void *b) |
161 | { |
162 | return (*(const uint8_t **)a)[0] - (*(const uint8_t **)b)[0]; |
163 | } |
164 | |
165 | void apple_translate_channel_labels(uint8_t *channels, unsigned n) |
166 | { |
167 | unsigned i; |
168 | char *has_side = strpbrk((char*)channels, "\x0A\x0B"); |
169 | |
170 | for (i = 0; i < n; ++i) { |
171 | switch (channels[i]) { |
172 | case kAudioChannelLabel_LeftSurround: |
173 | case kAudioChannelLabel_RightSurround: |
174 | if (!has_side) channels[i] += 5; // map to SL/SR |
175 | break; |
176 | case kAudioChannelLabel_RearSurroundLeft: |
177 | case kAudioChannelLabel_RearSurroundRight: |
178 | if (!has_side) channels[i] -= 28; // map to BL/BR |
179 | break; |
180 | case kAudioChannelLabel_Mono: |
181 | channels[i] = kAudioChannelLabel_Center; |
182 | break; |
183 | } |
184 | } |
185 | } |
186 | |
187 | int apple_chan_chunk(pcm_io_context_t *io, uint32_t chunk_size, |
188 | pcm_sample_description_t *fmt, uint8_t *mapping) |
189 | { |
190 | /* |
191 | * Although FDK encoder supports upto 5.1ch, we handle upto |
192 | * 8 channels here. |
193 | */ |
194 | uint32_t i, mChannelLayoutTag, mChannelBitmap, mNumberChannelDescriptions; |
195 | uint32_t mask = 0; |
196 | const uint32_t nchannels = fmt->channels_per_frame; |
197 | uint8_t channels[9] = { 0 }; |
198 | uint8_t *index[8] = { 0 }; |
199 | const char *layout = 0; |
200 | |
201 | ENSURE(chunk_size >= 12); |
202 | TRY_IO(pcm_scanb(io, "LLL", &mChannelLayoutTag, &mChannelBitmap, |
203 | &mNumberChannelDescriptions) != 3); |
204 | |
205 | switch (mChannelLayoutTag) { |
206 | case kAudioChannelLayoutTag_UseChannelBitmap: |
57aa9141 |
207 | ENSURE(bitcount(mChannelBitmap) == nchannels); |
1af8624b |
208 | TRY_IO(pcm_skip(io, chunk_size - 12)); |
209 | fmt->channel_mask = mChannelBitmap; |
210 | for (i = 0; i < nchannels; ++i) |
211 | mapping[i] = i; |
212 | return 0; |
213 | case kAudioChannelLayoutTag_UseChannelDescriptions: |
214 | ENSURE(mNumberChannelDescriptions == nchannels); |
215 | ENSURE(chunk_size >= 12 + nchannels * 20); |
216 | for (i = 0; i < mNumberChannelDescriptions; ++i) { |
217 | uint32_t mChannelLabel; |
218 | TRY_IO(pcm_read32be(io, &mChannelLabel)); |
219 | ENSURE(mChannelLabel && mChannelLabel <= 0xff); |
220 | channels[i] = mChannelLabel; |
221 | TRY_IO(pcm_skip(io, 16)); |
222 | } |
223 | TRY_IO(pcm_skip(io, chunk_size - 12 - nchannels * 20)); |
224 | apple_translate_channel_labels(channels, nchannels); |
225 | for (i = 0; i < nchannels; ++i) |
226 | if (channels[i] > kAudioChannelLabel_TopBackLeft) |
227 | goto FAIL; |
228 | break; |
229 | default: |
230 | ENSURE((mChannelLayoutTag & 0xffff) == nchannels); |
231 | TRY_IO(pcm_skip(io, chunk_size - 12)); |
232 | |
233 | switch (mChannelLayoutTag) { |
234 | /* 1ch */ |
235 | case kAudioChannelLayoutTag_Mono: |
236 | layout = "\x03"; break; |
237 | /* 1.1ch */ |
238 | case kAudioChannelLayoutTag_AC3_1_0_1: |
239 | layout = "\x03\x04"; break; |
240 | /* 2ch */ |
241 | case kAudioChannelLayoutTag_Stereo: |
242 | case kAudioChannelLayoutTag_MatrixStereo: |
243 | case kAudioChannelLayoutTag_Binaural: |
244 | layout = "\x01\x02"; break; |
245 | /* 2.1ch */ |
246 | case kAudioChannelLayoutTag_DVD_4: |
247 | layout = "\x01\x02\x04"; break; |
248 | /* 3ch */ |
249 | case kAudioChannelLayoutTag_MPEG_3_0_A: |
250 | layout = "\x01\x02\x03"; break; |
251 | case kAudioChannelLayoutTag_AC3_3_0: |
252 | layout = "\x01\x03\x02"; break; |
253 | case kAudioChannelLayoutTag_MPEG_3_0_B: |
254 | layout = "\x03\x01\x02"; break; |
255 | case kAudioChannelLayoutTag_ITU_2_1: |
256 | layout = "\x01\x02\x09"; break; |
257 | /* 3.1ch */ |
258 | case kAudioChannelLayoutTag_DVD_10: |
259 | layout = "\x01\x02\x03\x04"; break; |
260 | case kAudioChannelLayoutTag_AC3_3_0_1: |
261 | layout = "\x01\x03\x02\x04"; break; |
262 | case kAudioChannelLayoutTag_DVD_5: |
263 | layout = "\x01\x02\x04\x09"; break; |
264 | case kAudioChannelLayoutTag_AC3_2_1_1: |
265 | layout = "\x01\x02\x09\x04"; break; |
266 | /* 4ch */ |
267 | case kAudioChannelLayoutTag_Quadraphonic: |
268 | case kAudioChannelLayoutTag_ITU_2_2: |
269 | layout = "\x01\x02\x0A\x0B"; break; |
270 | case kAudioChannelLayoutTag_MPEG_4_0_A: |
271 | layout = "\x01\x02\x03\x09"; break; |
272 | case kAudioChannelLayoutTag_MPEG_4_0_B: |
273 | layout = "\x03\x01\x02\x09"; break; |
274 | case kAudioChannelLayoutTag_AC3_3_1: |
275 | layout = "\x01\x03\x02\x09"; break; |
276 | /* 4.1ch */ |
277 | case kAudioChannelLayoutTag_DVD_6: |
278 | layout = "\x01\x02\x04\x0A\x0B"; break; |
279 | case kAudioChannelLayoutTag_DVD_18: |
280 | layout = "\x01\x02\x0A\x0B\x04"; break; |
281 | case kAudioChannelLayoutTag_DVD_11: |
282 | layout = "\x01\x02\x03\x04\x09"; break; |
283 | case kAudioChannelLayoutTag_AC3_3_1_1: |
284 | layout = "\x01\x03\x02\x09\x04"; break; |
285 | /* 5ch */ |
286 | case kAudioChannelLayoutTag_MPEG_5_0_A: |
287 | layout = "\x01\x02\x03\x0A\x0B"; break; |
288 | case kAudioChannelLayoutTag_Pentagonal: |
289 | case kAudioChannelLayoutTag_MPEG_5_0_B: |
290 | layout = "\x01\x02\x0A\x0B\x03"; break; |
291 | case kAudioChannelLayoutTag_MPEG_5_0_C: |
292 | layout = "\x01\x03\x02\x0A\x0B"; break; |
293 | case kAudioChannelLayoutTag_MPEG_5_0_D: |
294 | layout = "\x03\x01\x02\x0A\x0B"; break; |
295 | /* 5.1ch */ |
296 | case kAudioChannelLayoutTag_MPEG_5_1_A: |
297 | layout = "\x01\x02\x03\x04\x0A\x0B"; break; |
298 | case kAudioChannelLayoutTag_MPEG_5_1_B: |
299 | layout = "\x01\x02\x0A\x0B\x03\x04"; break; |
300 | case kAudioChannelLayoutTag_MPEG_5_1_C: |
301 | layout = "\x01\x03\x02\x0A\x0B\x04"; break; |
302 | case kAudioChannelLayoutTag_MPEG_5_1_D: |
303 | layout = "\x03\x01\x02\x0A\x0B\x04"; break; |
304 | /* 6ch */ |
305 | case kAudioChannelLayoutTag_Hexagonal: |
306 | case kAudioChannelLayoutTag_AudioUnit_6_0: |
307 | layout = "\x01\x02\x0A\x0B\x03\x09"; break; |
308 | case kAudioChannelLayoutTag_AAC_6_0: |
309 | layout = "\x03\x01\x02\x0A\x0B\x09"; break; |
310 | /* 6.1ch */ |
311 | case kAudioChannelLayoutTag_MPEG_6_1_A: |
312 | layout = "\x01\x02\x03\x04\x0A\x0B\x09"; break; |
313 | case kAudioChannelLayoutTag_AAC_6_1: |
314 | layout = "\x03\x01\x02\x0A\x0B\x09\x04"; break; |
315 | /* 7ch */ |
316 | case kAudioChannelLayoutTag_AudioUnit_7_0: |
317 | layout = "\x01\x02\x0A\x0B\x03\x05\x06"; break; |
318 | case kAudioChannelLayoutTag_AudioUnit_7_0_Front: |
319 | layout = "\x01\x02\x0A\x0B\x03\x07\x08"; break; |
320 | case kAudioChannelLayoutTag_AAC_7_0: |
321 | layout = "\x03\x01\x02\x0A\x0B\x05\x06"; break; |
322 | /* 7.1ch */ |
323 | case kAudioChannelLayoutTag_MPEG_7_1_A: |
324 | layout = "\x01\x02\x03\x04\x0A\x0B\x07\x08"; break; |
325 | case kAudioChannelLayoutTag_MPEG_7_1_B: |
326 | layout = "\x03\x07\x08\x01\x02\x05\x06\x04"; break; |
327 | case kAudioChannelLayoutTag_MPEG_7_1_C: |
328 | layout = "\x01\x02\x03\x04\x0A\x0B\x05\x06"; break; |
329 | case kAudioChannelLayoutTag_Emagic_Default_7_1: |
330 | layout = "\x01\x02\x0A\x0B\x03\x04\x07\x08"; break; |
331 | /* 8ch */ |
332 | case kAudioChannelLayoutTag_Octagonal: |
333 | layout = "\x01\x02\x05\x06\x03\x09\x0A\x0B"; break; |
334 | case kAudioChannelLayoutTag_AAC_Octagonal: |
335 | layout = "\x03\x01\x02\x0A\x0B\x05\x06\x09"; break; |
336 | default: |
337 | goto FAIL; |
338 | } |
339 | strcpy((char*)channels, layout); |
340 | } |
341 | |
342 | for (i = 0; i < nchannels; ++i) |
343 | mask |= 1 << (channels[i] - 1); |
344 | fmt->channel_mask = mask; |
345 | ENSURE(bitcount(mask) == nchannels); |
346 | |
347 | for (i = 0; i < nchannels; ++i) |
348 | index[i] = channels + i; |
349 | qsort(index, nchannels, sizeof(char*), channel_compare); |
350 | for (i = 0; i < nchannels; ++i) |
351 | mapping[i] = index[i] - channels; |
352 | |
353 | return 0; |
354 | FAIL: |
355 | return -1; |
356 | } |