?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add missing macros for OSS3/Free compatibility
[openal-soft.git] / Alc / hrtf.c
blobb3b795ac119a1818c551ab2a4e8c54f2b97c92c8
1 /**
2 * OpenAL cross platform audio library
3 * Copyright (C) 2011 by Chris Robinson
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 * Or go to http://www.gnu.org/copyleft/lgpl.html
19 */
20
21 #include "config.h"
22
23 #include <stdlib.h>
24 #include <ctype.h>
25
26 #include "AL/al.h"
27 #include "AL/alc.h"
28 #include "alMain.h"
29 #include "alSource.h"
30 #include "alu.h"
31 #include "bformatdec.h"
32 #include "hrtf.h"
33
34 #include "compat.h"
35 #include "almalloc.h"
36
37
38 /* Current data set limits defined by the makehrtf utility. */
39 #define MIN_IR_SIZE (8)
40 #define MAX_IR_SIZE (128)
41 #define MOD_IR_SIZE (8)
42
43 #define MIN_EV_COUNT (5)
44 #define MAX_EV_COUNT (128)
45
46 #define MIN_AZ_COUNT (1)
47 #define MAX_AZ_COUNT (128)
48
49 static const ALchar magicMarker00[8] = "MinPHR00";
50 static const ALchar magicMarker01[8] = "MinPHR01";
51
52 /* First value for pass-through coefficients (remaining are 0), used for omni-
53 * directional sounds. */
54 static const ALfloat PassthruCoeff = 32767.0f * 0.707106781187f/*sqrt(0.5)*/;
55
56 static struct Hrtf *LoadedHrtfs = NULL;
57
58
59 /* Calculate the elevation index given the polar elevation in radians. This
60 * will return an index between 0 and (evcount - 1). Assumes the FPU is in
61 * round-to-zero mode.
62 */
63 static ALuint CalcEvIndex(ALuint evcount, ALfloat ev)
64 {
65 ev = (F_PI_2 + ev) * (evcount-1) / F_PI;
66 return minu(fastf2u(ev + 0.5f), evcount-1);
67 }
68
69 /* Calculate the azimuth index given the polar azimuth in radians. This will
70 * return an index between 0 and (azcount - 1). Assumes the FPU is in round-to-
71 * zero mode.
72 */
73 static ALuint CalcAzIndex(ALuint azcount, ALfloat az)
74 {
75 az = (F_TAU + az) * azcount / F_TAU;
76 return fastf2u(az + 0.5f) % azcount;
77 }
78
79 /* Calculates static HRIR coefficients and delays for the given polar elevation
80 * and azimuth in radians. The coefficients are normalized and attenuated by
81 * the specified gain.
82 */
83 void GetHrtfCoeffs(const struct Hrtf *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat spread, ALfloat gain, ALfloat (*coeffs)[2], ALuint *delays)
84 {
85 ALuint evidx, azidx, lidx, ridx;
86 ALuint azcount, evoffset;
87 ALfloat dirfact;
88 ALuint i;
89
90 dirfact = 1.0f - (spread / F_TAU);
91
92 /* Claculate elevation index. */
93 evidx = CalcEvIndex(Hrtf->evCount, elevation);
94 azcount = Hrtf->azCount[evidx];
95 evoffset = Hrtf->evOffset[evidx];
96
97 /* Calculate azimuth index. */
98 azidx = CalcAzIndex(Hrtf->azCount[evidx], azimuth);
99
100 /* Calculate the HRIR indices for left and right channels. */
101 lidx = evoffset + azidx;
102 ridx = evoffset + ((azcount-azidx) % azcount);
103
104 /* Calculate the HRIR delays. */
105 delays[0] = fastf2u(Hrtf->delays[lidx]*dirfact + 0.5f) << HRTFDELAY_BITS;
106 delays[1] = fastf2u(Hrtf->delays[ridx]*dirfact + 0.5f) << HRTFDELAY_BITS;
107
108 /* Calculate the sample offsets for the HRIR indices. */
109 lidx *= Hrtf->irSize;
110 ridx *= Hrtf->irSize;
111
112 /* Calculate the normalized and attenuated HRIR coefficients. Zero the
113 * coefficients if gain is too low.
114 */
115 if(gain > 0.0001f)
116 {
117 gain /= 32767.0f;
118
119 i = 0;
120 coeffs[i][0] = lerp(PassthruCoeff, Hrtf->coeffs[lidx+i], dirfact)*gain;
121 coeffs[i][1] = lerp(PassthruCoeff, Hrtf->coeffs[ridx+i], dirfact)*gain;
122 for(i = 1;i < Hrtf->irSize;i++)
123 {
124 coeffs[i][0] = Hrtf->coeffs[lidx+i]*gain * dirfact;
125 coeffs[i][1] = Hrtf->coeffs[ridx+i]*gain * dirfact;
126 }
127 }
128 else
129 {
130 for(i = 0;i < Hrtf->irSize;i++)
131 {
132 coeffs[i][0] = 0.0f;
133 coeffs[i][1] = 0.0f;
134 }
135 }
136 }
137
138
139 ALuint BuildBFormatHrtf(const struct Hrtf *Hrtf, ALfloat (*coeffs)[HRIR_LENGTH][2], ALuint NumChannels)
140 {
141 static const struct {
142 ALfloat elevation;
143 ALfloat azimuth;
144 } Ambi3DPoints[14] = {
145 { DEG2RAD( 90.0f), DEG2RAD( 0.0f) },
146 { DEG2RAD( 35.0f), DEG2RAD( -45.0f) },
147 { DEG2RAD( 35.0f), DEG2RAD( 45.0f) },
148 { DEG2RAD( 35.0f), DEG2RAD( 135.0f) },
149 { DEG2RAD( 35.0f), DEG2RAD(-135.0f) },
150 { DEG2RAD( 0.0f), DEG2RAD( 0.0f) },
151 { DEG2RAD( 0.0f), DEG2RAD( 90.0f) },
152 { DEG2RAD( 0.0f), DEG2RAD( 180.0f) },
153 { DEG2RAD( 0.0f), DEG2RAD( -90.0f) },
154 { DEG2RAD(-35.0f), DEG2RAD( -45.0f) },
155 { DEG2RAD(-35.0f), DEG2RAD( 45.0f) },
156 { DEG2RAD(-35.0f), DEG2RAD( 135.0f) },
157 { DEG2RAD(-35.0f), DEG2RAD(-135.0f) },
158 { DEG2RAD(-90.0f), DEG2RAD( 0.0f) },
159 };
160 static const ALfloat Ambi3DMatrix[14][2][MAX_AMBI_COEFFS] = {
161 { { 0.078851598f, 0.000000000f, 0.070561967f, 0.000000000f }, { 0.0714285714f, 0.0000000000f, 0.1237180798f, 0.0000000000f } },
162 { { 0.124051278f, 0.059847972f, 0.059847972f, 0.059847972f }, { 0.0714285714f, 0.0714285714f, 0.0714285714f, 0.0714285714f } },
163 { { 0.124051278f, -0.059847972f, 0.059847972f, 0.059847972f }, { 0.0714285714f, -0.0714285714f, 0.0714285714f, 0.0714285714f } },
164 { { 0.124051278f, -0.059847972f, 0.059847972f, -0.059847972f }, { 0.0714285714f, -0.0714285714f, 0.0714285714f, -0.0714285714f } },
165 { { 0.124051278f, 0.059847972f, 0.059847972f, -0.059847972f }, { 0.0714285714f, 0.0714285714f, 0.0714285714f, -0.0714285714f } },
166 { { 0.078851598f, 0.000000000f, 0.000000000f, 0.070561967f }, { 0.0714285714f, 0.0000000000f, 0.0000000000f, 0.1237180798f } },
167 { { 0.078851598f, -0.070561967f, 0.000000000f, 0.000000000f }, { 0.0714285714f, -0.1237180798f, 0.0000000000f, 0.0000000000f } },
168 { { 0.078851598f, 0.000000000f, 0.000000000f, -0.070561967f }, { 0.0714285714f, 0.0000000000f, 0.0000000000f, -0.1237180798f } },
169 { { 0.078851598f, 0.070561967f, 0.000000000f, 0.000000000f }, { 0.0714285714f, 0.1237180798f, 0.0000000000f, 0.0000000000f } },
170 { { 0.124051278f, 0.059847972f, -0.059847972f, 0.059847972f }, { 0.0714285714f, 0.0714285714f, -0.0714285714f, 0.0714285714f } },
171 { { 0.124051278f, -0.059847972f, -0.059847972f, 0.059847972f }, { 0.0714285714f, -0.0714285714f, -0.0714285714f, 0.0714285714f } },
172 { { 0.124051278f, -0.059847972f, -0.059847972f, -0.059847972f }, { 0.0714285714f, -0.0714285714f, -0.0714285714f, -0.0714285714f } },
173 { { 0.124051278f, 0.059847972f, -0.059847972f, -0.059847972f }, { 0.0714285714f, 0.0714285714f, -0.0714285714f, -0.0714285714f } },
174 { { 0.078851598f, 0.000000000f, -0.070561967f, 0.000000000f }, { 0.0714285714f, 0.0000000000f, -0.1237180798f, 0.0000000000f } },
175 };
176 #define AMBIHF_GAIN 1.0f
177 #define AMBILF_GAIN 0.553914423f /* -5.13dB */
178
179 /* Change this to 2 for dual-band HRTF processing. May require a higher quality
180 * band-splitter, or better calculation of the new IR length to deal with the
181 * tail generated by the filter.
182 */
183 #define NUM_BANDS 2
184 BandSplitter splitter;
185 ALfloat temps[3][HRIR_LENGTH];
186 ALuint lidx[14], ridx[14];
187 ALuint min_delay = HRTF_HISTORY_LENGTH;
188 ALuint max_length = 0;
189 ALuint i, j, c, b;
190
191 assert(NumChannels == 4);
192
193 for(c = 0;c < COUNTOF(Ambi3DPoints);c++)
194 {
195 ALuint evidx, azidx;
196 ALuint evoffset;
197 ALuint azcount;
198
199 /* Calculate elevation index. */
200 evidx = (ALuint)floorf((F_PI_2 + Ambi3DPoints[c].elevation) *
201 (Hrtf->evCount-1)/F_PI + 0.5f);
202 evidx = minu(evidx, Hrtf->evCount-1);
203
204 azcount = Hrtf->azCount[evidx];
205 evoffset = Hrtf->evOffset[evidx];
206
207 /* Calculate azimuth index for this elevation. */
208 azidx = (ALuint)floorf((F_TAU+Ambi3DPoints[c].azimuth) *
209 azcount/F_TAU + 0.5f) % azcount;
210
211 /* Calculate indices for left and right channels. */
212 lidx[c] = evoffset + azidx;
213 ridx[c] = evoffset + ((azcount-azidx) % azcount);
214
215 min_delay = minu(min_delay, minu(Hrtf->delays[lidx[c]], Hrtf->delays[ridx[c]]));
216 }
217
218 memset(temps, 0, sizeof(temps));
219 bandsplit_init(&splitter, 400.0f / (ALfloat)Hrtf->sampleRate);
220 for(c = 0;c < COUNTOF(Ambi3DMatrix);c++)
221 {
222 const ALshort *fir;
223 ALuint delay;
224
225 /* Convert the left FIR from shorts to float */
226 fir = &Hrtf->coeffs[lidx[c] * Hrtf->irSize];
227 if(NUM_BANDS == 1)
228 {
229 for(i = 0;i < Hrtf->irSize;i++)
230 temps[0][i] = fir[i] / 32767.0f;
231 }
232 else
233 {
234 /* Band-split left HRIR into low and high frequency responses. */
235 bandsplit_clear(&splitter);
236 for(i = 0;i < Hrtf->irSize;i++)
237 temps[2][i] = fir[i] / 32767.0f;
238 bandsplit_process(&splitter, temps[0], temps[1], temps[2], HRIR_LENGTH);
239 /* Scale the low and high frequency responses. */
240 for(i = 0;i < HRIR_LENGTH;i++)
241 temps[0][i] *= AMBIHF_GAIN;
242 for(i = 0;i < HRIR_LENGTH;i++)
243 temps[1][i] *= AMBILF_GAIN;
244 }
245
246 /* Add to the left output coefficients with the specified delay. */
247 delay = Hrtf->delays[lidx[c]] - min_delay;
248 for(i = 0;i < NumChannels;++i)
249 {
250 for(b = 0;b < NUM_BANDS;b++)
251 {
252 ALuint k = 0;
253 for(j = delay;j < HRIR_LENGTH;++j)
254 coeffs[i][j][0] += temps[b][k++] * Ambi3DMatrix[c][b][i];
255 }
256 }
257 max_length = maxu(max_length, minu(delay + Hrtf->irSize, HRIR_LENGTH));
258
259 /* Convert the right FIR from shorts to float */
260 fir = &Hrtf->coeffs[ridx[c] * Hrtf->irSize];
261 if(NUM_BANDS == 1)
262 {
263 for(i = 0;i < Hrtf->irSize;i++)
264 temps[0][i] = fir[i] / 32767.0f;
265 }
266 else
267 {
268 /* Band-split right HRIR into low and high frequency responses. */
269 bandsplit_clear(&splitter);
270 for(i = 0;i < Hrtf->irSize;i++)
271 temps[2][i] = fir[i] / 32767.0f;
272 bandsplit_process(&splitter, temps[0], temps[1], temps[2], HRIR_LENGTH);
273 /* Scale the low and high frequency responses. */
274 for(i = 0;i < HRIR_LENGTH;i++)
275 temps[0][i] *= AMBIHF_GAIN;
276 for(i = 0;i < HRIR_LENGTH;i++)
277 temps[1][i] *= AMBILF_GAIN;
278 }
279
280 /* Add to the right output coefficients with the specified delay. */
281 delay = Hrtf->delays[ridx[c]] - min_delay;
282 for(i = 0;i < NumChannels;++i)
283 {
284 for(b = 0;b < NUM_BANDS;b++)
285 {
286 ALuint k = 0;
287 for(j = delay;j < HRIR_LENGTH;++j)
288 coeffs[i][j][1] += temps[b][k++] * Ambi3DMatrix[c][b][i];
289 }
290 }
291 max_length = maxu(max_length, minu(delay + Hrtf->irSize, HRIR_LENGTH));
292 }
293 TRACE("Skipped min delay: %u, new combined length: %u\n", min_delay, max_length);
294 #undef NUM_BANDS
295
296 return max_length;
297 }
298
299
300 static struct Hrtf *LoadHrtf00(const ALubyte *data, size_t datalen, const_al_string filename)
301 {
302 const ALubyte maxDelay = HRTF_HISTORY_LENGTH-1;
303 struct Hrtf *Hrtf = NULL;
304 ALboolean failed = AL_FALSE;
305 ALuint rate = 0, irCount = 0;
306 ALushort irSize = 0;
307 ALubyte evCount = 0;
308 ALubyte *azCount = NULL;
309 ALushort *evOffset = NULL;
310 ALshort *coeffs = NULL;
311 const ALubyte *delays = NULL;
312 ALuint i, j;
313
314 if(datalen < 9)
315 {
316 ERR("Unexpected end of %s data (req %d, rem "SZFMT")\n",
317 al_string_get_cstr(filename), 9, datalen);
318 return NULL;
319 }
320
321 rate = *(data++);
322 rate |= *(data++)<<8;
323 rate |= *(data++)<<16;
324 rate |= *(data++)<<24;
325 datalen -= 4;
326
327 irCount = *(data++);
328 irCount |= *(data++)<<8;
329 datalen -= 2;
330
331 irSize = *(data++);
332 irSize |= *(data++)<<8;
333 datalen -= 2;
334
335 evCount = *(data++);
336 datalen -= 1;
337
338 if(irSize < MIN_IR_SIZE || irSize > MAX_IR_SIZE || (irSize%MOD_IR_SIZE))
339 {
340 ERR("Unsupported HRIR size: irSize=%d (%d to %d by %d)\n",
341 irSize, MIN_IR_SIZE, MAX_IR_SIZE, MOD_IR_SIZE);
342 failed = AL_TRUE;
343 }
344 if(evCount < MIN_EV_COUNT || evCount > MAX_EV_COUNT)
345 {
346 ERR("Unsupported elevation count: evCount=%d (%d to %d)\n",
347 evCount, MIN_EV_COUNT, MAX_EV_COUNT);
348 failed = AL_TRUE;
349 }
350 if(failed)
351 return NULL;
352
353 if(datalen < evCount*2)
354 {
355 ERR("Unexpected end of %s data (req %d, rem "SZFMT")\n",
356 al_string_get_cstr(filename), evCount*2, datalen);
357 return NULL;
358 }
359
360 azCount = malloc(sizeof(azCount[0])*evCount);
361 evOffset = malloc(sizeof(evOffset[0])*evCount);
362 if(azCount == NULL || evOffset == NULL)
363 {
364 ERR("Out of memory.\n");
365 failed = AL_TRUE;
366 }
367
368 if(!failed)
369 {
370 evOffset[0] = *(data++);
371 evOffset[0] |= *(data++)<<8;
372 datalen -= 2;
373 for(i = 1;i < evCount;i++)
374 {
375 evOffset[i] = *(data++);
376 evOffset[i] |= *(data++)<<8;
377 datalen -= 2;
378 if(evOffset[i] <= evOffset[i-1])
379 {
380 ERR("Invalid evOffset: evOffset[%d]=%d (last=%d)\n",
381 i, evOffset[i], evOffset[i-1]);
382 failed = AL_TRUE;
383 }
384
385 azCount[i-1] = evOffset[i] - evOffset[i-1];
386 if(azCount[i-1] < MIN_AZ_COUNT || azCount[i-1] > MAX_AZ_COUNT)
387 {
388 ERR("Unsupported azimuth count: azCount[%d]=%d (%d to %d)\n",
389 i-1, azCount[i-1], MIN_AZ_COUNT, MAX_AZ_COUNT);
390 failed = AL_TRUE;
391 }
392 }
393 if(irCount <= evOffset[i-1])
394 {
395 ERR("Invalid evOffset: evOffset[%d]=%d (irCount=%d)\n",
396 i-1, evOffset[i-1], irCount);
397 failed = AL_TRUE;
398 }
399
400 azCount[i-1] = irCount - evOffset[i-1];
401 if(azCount[i-1] < MIN_AZ_COUNT || azCount[i-1] > MAX_AZ_COUNT)
402 {
403 ERR("Unsupported azimuth count: azCount[%d]=%d (%d to %d)\n",
404 i-1, azCount[i-1], MIN_AZ_COUNT, MAX_AZ_COUNT);
405 failed = AL_TRUE;
406 }
407 }
408
409 if(!failed)
410 {
411 coeffs = malloc(sizeof(coeffs[0])*irSize*irCount);
412 if(coeffs == NULL)
413 {
414 ERR("Out of memory.\n");
415 failed = AL_TRUE;
416 }
417 }
418
419 if(!failed)
420 {
421 size_t reqsize = 2*irSize*irCount + irCount;
422 if(datalen < reqsize)
423 {
424 ERR("Unexpected end of %s data (req "SZFMT", rem "SZFMT")\n",
425 al_string_get_cstr(filename), reqsize, datalen);
426 failed = AL_TRUE;
427 }
428 }
429
430 if(!failed)
431 {
432 for(i = 0;i < irCount*irSize;i+=irSize)
433 {
434 for(j = 0;j < irSize;j++)
435 {
436 coeffs[i+j] = *(data++);
437 coeffs[i+j] |= *(data++)<<8;
438 datalen -= 2;
439 }
440 }
441
442 delays = data;
443 data += irCount;
444 datalen -= irCount;
445 for(i = 0;i < irCount;i++)
446 {
447 if(delays[i] > maxDelay)
448 {
449 ERR("Invalid delays[%d]: %d (%d)\n", i, delays[i], maxDelay);
450 failed = AL_TRUE;
451 }
452 }
453 }
454
455 if(!failed)
456 {
457 size_t total = sizeof(struct Hrtf);
458 total += sizeof(azCount[0])*evCount;
459 total = (total+1)&~1; /* Align for (u)short fields */
460 total += sizeof(evOffset[0])*evCount;
461 total += sizeof(coeffs[0])*irSize*irCount;
462 total += sizeof(delays[0])*irCount;
463 total += al_string_length(filename)+1;
464
465 Hrtf = al_calloc(16, total);
466 if(Hrtf == NULL)
467 {
468 ERR("Out of memory.\n");
469 failed = AL_TRUE;
470 }
471 }
472
473 if(!failed)
474 {
475 char *base = (char*)Hrtf;
476 uintptr_t offset = sizeof(*Hrtf);
477
478 Hrtf->sampleRate = rate;
479 Hrtf->irSize = irSize;
480 Hrtf->evCount = evCount;
481 Hrtf->azCount = ((ALubyte*)(base + offset)); offset += evCount*sizeof(Hrtf->azCount[0]);
482 offset = (offset+1)&~1; /* Align for (u)short fields */
483 Hrtf->evOffset = ((ALushort*)(base + offset)); offset += evCount*sizeof(Hrtf->evOffset[0]);
484 Hrtf->coeffs = ((ALshort*)(base + offset)); offset += irSize*irCount*sizeof(Hrtf->coeffs[0]);
485 Hrtf->delays = ((ALubyte*)(base + offset)); offset += irCount*sizeof(Hrtf->delays[0]);
486 Hrtf->filename = ((char*)(base + offset));
487 Hrtf->next = NULL;
488
489 memcpy((void*)Hrtf->azCount, azCount, sizeof(azCount[0])*evCount);
490 memcpy((void*)Hrtf->evOffset, evOffset, sizeof(evOffset[0])*evCount);
491 memcpy((void*)Hrtf->coeffs, coeffs, sizeof(coeffs[0])*irSize*irCount);
492 memcpy((void*)Hrtf->delays, delays, sizeof(delays[0])*irCount);
493 memcpy((void*)Hrtf->filename, al_string_get_cstr(filename), al_string_length(filename)+1);
494 }
495
496 free(azCount);
497 free(evOffset);
498 free(coeffs);
499 return Hrtf;
500 }
501
502 static struct Hrtf *LoadHrtf01(const ALubyte *data, size_t datalen, const_al_string filename)
503 {
504 const ALubyte maxDelay = HRTF_HISTORY_LENGTH-1;
505 struct Hrtf *Hrtf = NULL;
506 ALboolean failed = AL_FALSE;
507 ALuint rate = 0, irCount = 0;
508 ALubyte irSize = 0, evCount = 0;
509 const ALubyte *azCount = NULL;
510 ALushort *evOffset = NULL;
511 ALshort *coeffs = NULL;
512 const ALubyte *delays = NULL;
513 ALuint i, j;
514
515 if(datalen < 6)
516 {
517 ERR("Unexpected end of %s data (req %d, rem "SZFMT"\n",
518 al_string_get_cstr(filename), 6, datalen);
519 return NULL;
520 }
521
522 rate = *(data++);
523 rate |= *(data++)<<8;
524 rate |= *(data++)<<16;
525 rate |= *(data++)<<24;
526 datalen -= 4;
527
528 irSize = *(data++);
529 datalen -= 1;
530
531 evCount = *(data++);
532 datalen -= 1;
533
534 if(irSize < MIN_IR_SIZE || irSize > MAX_IR_SIZE || (irSize%MOD_IR_SIZE))
535 {
536 ERR("Unsupported HRIR size: irSize=%d (%d to %d by %d)\n",
537 irSize, MIN_IR_SIZE, MAX_IR_SIZE, MOD_IR_SIZE);
538 failed = AL_TRUE;
539 }
540 if(evCount < MIN_EV_COUNT || evCount > MAX_EV_COUNT)
541 {
542 ERR("Unsupported elevation count: evCount=%d (%d to %d)\n",
543 evCount, MIN_EV_COUNT, MAX_EV_COUNT);
544 failed = AL_TRUE;
545 }
546 if(failed)
547 return NULL;
548
549 if(datalen < evCount)
550 {
551 ERR("Unexpected end of %s data (req %d, rem "SZFMT"\n",
552 al_string_get_cstr(filename), evCount, datalen);
553 return NULL;
554 }
555
556 azCount = data;
557 data += evCount;
558 datalen -= evCount;
559
560 evOffset = malloc(sizeof(evOffset[0])*evCount);
561 if(azCount == NULL || evOffset == NULL)
562 {
563 ERR("Out of memory.\n");
564 failed = AL_TRUE;
565 }
566
567 if(!failed)
568 {
569 for(i = 0;i < evCount;i++)
570 {
571 if(azCount[i] < MIN_AZ_COUNT || azCount[i] > MAX_AZ_COUNT)
572 {
573 ERR("Unsupported azimuth count: azCount[%d]=%d (%d to %d)\n",
574 i, azCount[i], MIN_AZ_COUNT, MAX_AZ_COUNT);
575 failed = AL_TRUE;
576 }
577 }
578 }
579
580 if(!failed)
581 {
582 evOffset[0] = 0;
583 irCount = azCount[0];
584 for(i = 1;i < evCount;i++)
585 {
586 evOffset[i] = evOffset[i-1] + azCount[i-1];
587 irCount += azCount[i];
588 }
589
590 coeffs = malloc(sizeof(coeffs[0])*irSize*irCount);
591 if(coeffs == NULL)
592 {
593 ERR("Out of memory.\n");
594 failed = AL_TRUE;
595 }
596 }
597
598 if(!failed)
599 {
600 size_t reqsize = 2*irSize*irCount + irCount;
601 if(datalen < reqsize)
602 {
603 ERR("Unexpected end of %s data (req "SZFMT", rem "SZFMT"\n",
604 al_string_get_cstr(filename), reqsize, datalen);
605 failed = AL_TRUE;
606 }
607 }
608
609 if(!failed)
610 {
611 for(i = 0;i < irCount*irSize;i+=irSize)
612 {
613 for(j = 0;j < irSize;j++)
614 {
615 ALshort coeff;
616 coeff = *(data++);
617 coeff |= *(data++)<<8;
618 datalen -= 2;
619 coeffs[i+j] = coeff;
620 }
621 }
622
623 delays = data;
624 data += irCount;
625 datalen -= irCount;
626 for(i = 0;i < irCount;i++)
627 {
628 if(delays[i] > maxDelay)
629 {
630 ERR("Invalid delays[%d]: %d (%d)\n", i, delays[i], maxDelay);
631 failed = AL_TRUE;
632 }
633 }
634 }
635
636 if(!failed)
637 {
638 size_t total = sizeof(struct Hrtf);
639 total += sizeof(azCount[0])*evCount;
640 total = (total+1)&~1; /* Align for (u)short fields */
641 total += sizeof(evOffset[0])*evCount;
642 total += sizeof(coeffs[0])*irSize*irCount;
643 total += sizeof(delays[0])*irCount;
644 total += al_string_length(filename)+1;
645
646 Hrtf = al_calloc(16, total);
647 if(Hrtf == NULL)
648 {
649 ERR("Out of memory.\n");
650 failed = AL_TRUE;
651 }
652 }
653
654 if(!failed)
655 {
656 char *base = (char*)Hrtf;
657 uintptr_t offset = sizeof(*Hrtf);
658
659 Hrtf->sampleRate = rate;
660 Hrtf->irSize = irSize;
661 Hrtf->evCount = evCount;
662 Hrtf->azCount = ((ALubyte*)(base + offset)); offset += evCount*sizeof(Hrtf->azCount[0]);
663 offset = (offset+1)&~1; /* Align for (u)short fields */
664 Hrtf->evOffset = ((ALushort*)(base + offset)); offset += evCount*sizeof(Hrtf->evOffset[0]);
665 Hrtf->coeffs = ((ALshort*)(base + offset)); offset += irSize*irCount*sizeof(Hrtf->coeffs[0]);
666 Hrtf->delays = ((ALubyte*)(base + offset)); offset += irCount*sizeof(Hrtf->delays[0]);
667 Hrtf->filename = ((char*)(base + offset));
668 Hrtf->next = NULL;
669
670 memcpy((void*)Hrtf->azCount, azCount, sizeof(azCount[0])*evCount);
671 memcpy((void*)Hrtf->evOffset, evOffset, sizeof(evOffset[0])*evCount);
672 memcpy((void*)Hrtf->coeffs, coeffs, sizeof(coeffs[0])*irSize*irCount);
673 memcpy((void*)Hrtf->delays, delays, sizeof(delays[0])*irCount);
674 memcpy((void*)Hrtf->filename, al_string_get_cstr(filename), al_string_length(filename)+1);
675 }
676
677 free(evOffset);
678 free(coeffs);
679 return Hrtf;
680 }
681
682 static void AddFileEntry(vector_HrtfEntry *list, al_string *filename)
683 {
684 HrtfEntry entry = { AL_STRING_INIT_STATIC(), NULL };
685 struct Hrtf *hrtf = NULL;
686 const HrtfEntry *iter;
687 struct FileMapping fmap;
688 const char *name;
689 const char *ext;
690 int i;
691
692 #define MATCH_FNAME(i) (al_string_cmp_cstr(*filename, (i)->hrtf->filename) == 0)
693 VECTOR_FIND_IF(iter, const HrtfEntry, *list, MATCH_FNAME);
694 if(iter != VECTOR_END(*list))
695 {
696 TRACE("Skipping duplicate file entry %s\n", al_string_get_cstr(*filename));
697 goto done;
698 }
699 #undef MATCH_FNAME
700
701 entry.hrtf = LoadedHrtfs;
702 while(entry.hrtf)
703 {
704 if(al_string_cmp_cstr(*filename, entry.hrtf->filename) == 0)
705 {
706 TRACE("Skipping load of already-loaded file %s\n", al_string_get_cstr(*filename));
707 goto skip_load;
708 }
709 entry.hrtf = entry.hrtf->next;
710 }
711
712 TRACE("Loading %s...\n", al_string_get_cstr(*filename));
713 fmap = MapFileToMem(al_string_get_cstr(*filename));
714 if(fmap.ptr == NULL)
715 {
716 ERR("Could not open %s\n", al_string_get_cstr(*filename));
717 goto done;
718 }
719
720 if(fmap.len < sizeof(magicMarker01))
721 ERR("%s data is too short ("SZFMT" bytes)\n", al_string_get_cstr(*filename), fmap.len);
722 else if(memcmp(fmap.ptr, magicMarker01, sizeof(magicMarker01)) == 0)
723 {
724 TRACE("Detected data set format v1\n");
725 hrtf = LoadHrtf01((const ALubyte*)fmap.ptr+sizeof(magicMarker01),
726 fmap.len-sizeof(magicMarker01), *filename
727 );
728 }
729 else if(memcmp(fmap.ptr, magicMarker00, sizeof(magicMarker00)) == 0)
730 {
731 TRACE("Detected data set format v0\n");
732 hrtf = LoadHrtf00((const ALubyte*)fmap.ptr+sizeof(magicMarker00),
733 fmap.len-sizeof(magicMarker00), *filename
734 );
735 }
736 else
737 ERR("Invalid header in %s: \"%.8s\"\n", al_string_get_cstr(*filename), (const char*)fmap.ptr);
738 UnmapFileMem(&fmap);
739
740 if(!hrtf)
741 {
742 ERR("Failed to load %s\n", al_string_get_cstr(*filename));
743 goto done;
744 }
745
746 hrtf->next = LoadedHrtfs;
747 LoadedHrtfs = hrtf;
748 TRACE("Loaded HRTF support for format: %s %uhz\n",
749 DevFmtChannelsString(DevFmtStereo), hrtf->sampleRate);
750 entry.hrtf = hrtf;
751
752 skip_load:
753 /* TODO: Get a human-readable name from the HRTF data (possibly coming in a
754 * format update). */
755 name = strrchr(al_string_get_cstr(*filename), '/');
756 if(!name) name = strrchr(al_string_get_cstr(*filename), '\\');
757 if(!name) name = al_string_get_cstr(*filename);
758 else ++name;
759
760 ext = strrchr(name, '.');
761
762 i = 0;
763 do {
764 if(!ext)
765 al_string_copy_cstr(&entry.name, name);
766 else
767 al_string_copy_range(&entry.name, name, ext);
768 if(i != 0)
769 {
770 char str[64];
771 snprintf(str, sizeof(str), " #%d", i+1);
772 al_string_append_cstr(&entry.name, str);
773 }
774 ++i;
775
776 #define MATCH_NAME(i) (al_string_cmp(entry.name, (i)->name) == 0)
777 VECTOR_FIND_IF(iter, const HrtfEntry, *list, MATCH_NAME);
778 #undef MATCH_NAME
779 } while(iter != VECTOR_END(*list));
780
781 TRACE("Adding entry \"%s\" from file \"%s\"\n", al_string_get_cstr(entry.name),
782 al_string_get_cstr(*filename));
783 VECTOR_PUSH_BACK(*list, entry);
784
785 done:
786 al_string_deinit(filename);
787 }
788
789 /* Unfortunate that we have to duplicate AddFileEntry to take a memory buffer
790 * for input instead of opening the given filename.
791 */
792 static void AddBuiltInEntry(vector_HrtfEntry *list, const ALubyte *data, size_t datalen, al_string *filename)
793 {
794 HrtfEntry entry = { AL_STRING_INIT_STATIC(), NULL };
795 struct Hrtf *hrtf = NULL;
796 const HrtfEntry *iter;
797 int i;
798
799 #define MATCH_FNAME(i) (al_string_cmp_cstr(*filename, (i)->hrtf->filename) == 0)
800 VECTOR_FIND_IF(iter, const HrtfEntry, *list, MATCH_FNAME);
801 if(iter != VECTOR_END(*list))
802 {
803 TRACE("Skipping duplicate file entry %s\n", al_string_get_cstr(*filename));
804 goto done;
805 }
806 #undef MATCH_FNAME
807
808 entry.hrtf = LoadedHrtfs;
809 while(entry.hrtf)
810 {
811 if(al_string_cmp_cstr(*filename, entry.hrtf->filename) == 0)
812 {
813 TRACE("Skipping load of already-loaded file %s\n", al_string_get_cstr(*filename));
814 goto skip_load;
815 }
816 entry.hrtf = entry.hrtf->next;
817 }
818
819 TRACE("Loading %s...\n", al_string_get_cstr(*filename));
820 if(datalen < sizeof(magicMarker01))
821 {
822 ERR("%s data is too short ("SZFMT" bytes)\n", al_string_get_cstr(*filename), datalen);
823 goto done;
824 }
825
826 if(memcmp(data, magicMarker01, sizeof(magicMarker01)) == 0)
827 {
828 TRACE("Detected data set format v1\n");
829 hrtf = LoadHrtf01(data+sizeof(magicMarker01),
830 datalen-sizeof(magicMarker01), *filename
831 );
832 }
833 else if(memcmp(data, magicMarker00, sizeof(magicMarker00)) == 0)
834 {
835 TRACE("Detected data set format v0\n");
836 hrtf = LoadHrtf00(data+sizeof(magicMarker00),
837 datalen-sizeof(magicMarker00), *filename
838 );
839 }
840 else
841 ERR("Invalid header in %s: \"%.8s\"\n", al_string_get_cstr(*filename), data);
842
843 if(!hrtf)
844 {
845 ERR("Failed to load %s\n", al_string_get_cstr(*filename));
846 goto done;
847 }
848
849 hrtf->next = LoadedHrtfs;
850 LoadedHrtfs = hrtf;
851 TRACE("Loaded HRTF support for format: %s %uhz\n",
852 DevFmtChannelsString(DevFmtStereo), hrtf->sampleRate);
853 entry.hrtf = hrtf;
854
855 skip_load:
856 i = 0;
857 do {
858 al_string_copy(&entry.name, *filename);
859 if(i != 0)
860 {
861 char str[64];
862 snprintf(str, sizeof(str), " #%d", i+1);
863 al_string_append_cstr(&entry.name, str);
864 }
865 ++i;
866
867 #define MATCH_NAME(i) (al_string_cmp(entry.name, (i)->name) == 0)
868 VECTOR_FIND_IF(iter, const HrtfEntry, *list, MATCH_NAME);
869 #undef MATCH_NAME
870 } while(iter != VECTOR_END(*list));
871
872 TRACE("Adding built-in entry \"%s\"\n", al_string_get_cstr(entry.name));
873 VECTOR_PUSH_BACK(*list, entry);
874
875 done:
876 al_string_deinit(filename);
877 }
878
879
880 #ifndef ALSOFT_EMBED_HRTF_DATA
881 #define IDR_DEFAULT_44100_MHR 1
882 #define IDR_DEFAULT_48000_MHR 2
883
884 static const ALubyte *GetResource(int UNUSED(name), size_t *size)
885 {
886 *size = 0;
887 return NULL;
888 }
889
890 #else
891 #include "hrtf_res.h"
892
893 #ifdef _WIN32
894 static const ALubyte *GetResource(int name, size_t *size)
895 {
896 HMODULE handle;
897 HGLOBAL res;
898 HRSRC rc;
899
900 GetModuleHandleExW(
901 GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT | GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
902 (LPCWSTR)GetResource, &handle
903 );
904 rc = FindResourceW(handle, MAKEINTRESOURCEW(name), MAKEINTRESOURCEW(MHRTYPE));
905 res = LoadResource(handle, rc);
906
907 *size = SizeofResource(handle, rc);
908 return LockResource(res);
909 }
910
911 #elif defined(__APPLE__)
912
913 #include <Availability.h>
914 #include <mach-o/getsect.h>
915 #include <mach-o/ldsyms.h>
916
917 static const ALubyte *GetResource(int name, size_t *size)
918 {
919 #if defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && (__MAC_OS_X_VERSION_MAX_ALLOWED >= 1070)
920 /* NOTE: OSX 10.7 and up need to call getsectiondata(&_mh_dylib_header, ...). However, that
921 * call requires 10.7.
922 */
923 if(name == IDR_DEFAULT_44100_MHR)
924 return getsectiondata(&_mh_dylib_header, "binary", "default_44100", size);
925 if(name == IDR_DEFAULT_48000_MHR)
926 return getsectiondata(&_mh_dylib_header, "binary", "default_48000", size);
927 #else
928 if(name == IDR_DEFAULT_44100_MHR)
929 return getsectdata("binary", "default_44100", size);
930 if(name == IDR_DEFAULT_48000_MHR)
931 return getsectdata("binary", "default_48000", size);
932 #endif
933 *size = 0;
934 return NULL;
935 }
936
937 #else
938
939 extern const ALubyte _binary_default_44100_mhr_start[] HIDDEN_DECL;
940 extern const ALubyte _binary_default_44100_mhr_end[] HIDDEN_DECL;
941 extern const ALubyte _binary_default_44100_mhr_size[] HIDDEN_DECL;
942
943 extern const ALubyte _binary_default_48000_mhr_start[] HIDDEN_DECL;
944 extern const ALubyte _binary_default_48000_mhr_end[] HIDDEN_DECL;
945 extern const ALubyte _binary_default_48000_mhr_size[] HIDDEN_DECL;
946
947 static const ALubyte *GetResource(int name, size_t *size)
948 {
949 if(name == IDR_DEFAULT_44100_MHR)
950 {
951 /* Make sure all symbols are referenced, to ensure the compiler won't
952 * ignore the declarations and lose the visibility attribute used to
953 * hide them (would be nice if ld or objcopy could automatically mark
954 * them as hidden when generating them, but apparently they can't).
955 */
956 const void *volatile ptr =_binary_default_44100_mhr_size;
957 (void)ptr;
958 *size = _binary_default_44100_mhr_end - _binary_default_44100_mhr_start;
959 return _binary_default_44100_mhr_start;
960 }
961 if(name == IDR_DEFAULT_48000_MHR)
962 {
963 const void *volatile ptr =_binary_default_48000_mhr_size;
964 (void)ptr;
965 *size = _binary_default_48000_mhr_end - _binary_default_48000_mhr_start;
966 return _binary_default_48000_mhr_start;
967 }
968 *size = 0;
969 return NULL;
970 }
971 #endif
972 #endif
973
974 vector_HrtfEntry EnumerateHrtf(const_al_string devname)
975 {
976 vector_HrtfEntry list = VECTOR_INIT_STATIC();
977 const char *defaulthrtf = "";
978 const char *pathlist = "";
979 bool usedefaults = true;
980
981 if(ConfigValueStr(al_string_get_cstr(devname), NULL, "hrtf-paths", &pathlist))
982 {
983 while(pathlist && *pathlist)
984 {
985 const char *next, *end;
986
987 while(isspace(*pathlist) || *pathlist == ',')
988 pathlist++;
989 if(*pathlist == '\0')
990 continue;
991
992 next = strchr(pathlist, ',');
993 if(next)
994 end = next++;
995 else
996 {
997 end = pathlist + strlen(pathlist);
998 usedefaults = false;
999 }
1000
1001 while(end != pathlist && isspace(*(end-1)))
1002 --end;
1003 if(end != pathlist)
1004 {
1005 al_string pname = AL_STRING_INIT_STATIC();
1006 vector_al_string flist;
1007
1008 al_string_append_range(&pname, pathlist, end);
1009
1010 flist = SearchDataFiles(".mhr", al_string_get_cstr(pname));
1011 VECTOR_FOR_EACH_PARAMS(al_string, flist, AddFileEntry, &list);
1012 VECTOR_DEINIT(flist);
1013
1014 al_string_deinit(&pname);
1015 }
1016
1017 pathlist = next;
1018 }
1019 }
1020 else if(ConfigValueExists(al_string_get_cstr(devname), NULL, "hrtf_tables"))
1021 ERR("The hrtf_tables option is deprecated, please use hrtf-paths instead.\n");
1022
1023 if(usedefaults)
1024 {
1025 vector_al_string flist;
1026 const ALubyte *rdata;
1027 size_t rsize;
1028
1029 flist = SearchDataFiles(".mhr", "openal/hrtf");
1030 VECTOR_FOR_EACH_PARAMS(al_string, flist, AddFileEntry, &list);
1031 VECTOR_DEINIT(flist);
1032
1033 rdata = GetResource(IDR_DEFAULT_44100_MHR, &rsize);
1034 if(rdata != NULL && rsize > 0)
1035 {
1036 al_string ename = AL_STRING_INIT_STATIC();
1037 al_string_copy_cstr(&ename, "Built-In 44100hz");
1038 AddBuiltInEntry(&list, rdata, rsize, &ename);
1039 }
1040
1041 rdata = GetResource(IDR_DEFAULT_48000_MHR, &rsize);
1042 if(rdata != NULL && rsize > 0)
1043 {
1044 al_string ename = AL_STRING_INIT_STATIC();
1045 al_string_copy_cstr(&ename, "Built-In 48000hz");
1046 AddBuiltInEntry(&list, rdata, rsize, &ename);
1047 }
1048 }
1049
1050 if(VECTOR_SIZE(list) > 1 && ConfigValueStr(al_string_get_cstr(devname), NULL, "default-hrtf", &defaulthrtf))
1051 {
1052 const HrtfEntry *iter;
1053 /* Find the preferred HRTF and move it to the front of the list. */
1054 #define FIND_ENTRY(i) (al_string_cmp_cstr((i)->name, defaulthrtf) == 0)
1055 VECTOR_FIND_IF(iter, const HrtfEntry, list, FIND_ENTRY);
1056 #undef FIND_ENTRY
1057 if(iter == VECTOR_END(list))
1058 WARN("Failed to find default HRTF \"%s\"\n", defaulthrtf);
1059 else if(iter != VECTOR_BEGIN(list))
1060 {
1061 HrtfEntry entry = *iter;
1062 memmove(&VECTOR_ELEM(list,1), &VECTOR_ELEM(list,0),
1063 (iter-VECTOR_BEGIN(list))*sizeof(HrtfEntry));
1064 VECTOR_ELEM(list,0) = entry;
1065 }
1066 }
1067
1068 return list;
1069 }
1070
1071 void FreeHrtfList(vector_HrtfEntry *list)
1072 {
1073 #define CLEAR_ENTRY(i) do { \
1074 al_string_deinit(&(i)->name); \
1075 } while(0)
1076 VECTOR_FOR_EACH(HrtfEntry, *list, CLEAR_ENTRY);
1077 VECTOR_DEINIT(*list);
1078 #undef CLEAR_ENTRY
1079 }
1080
1081
1082 void FreeHrtfs(void)
1083 {
1084 struct Hrtf *Hrtf = LoadedHrtfs;
1085 LoadedHrtfs = NULL;
1086
1087 while(Hrtf != NULL)
1088 {
1089 struct Hrtf *next = Hrtf->next;
1090 al_free(Hrtf);
1091 Hrtf = next;
1092 }
1093 }
Software OpenAL implementation