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