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