zenilib: zenilib/jni/external/openal-soft/Alc/hrtf.c Source File

zenilib 0.5.3.0

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
hrtf.c
Go to the documentation of this file.
1
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
32
33 #ifndef PATH_MAX
34 #define PATH_MAX 4096
35 #endif
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 struct Hrtf {
50 ALuint sampleRate;
51 ALuint irSize;
52 ALubyte evCount;
53
54 const ALubyte *azCount;
55 const ALushort *evOffset;
56 const ALshort *coeffs;
57 const ALubyte *delays;
58
59 struct Hrtf *next;
60 };
61
62 static const ALchar magicMarker00[8] = "MinPHR00";
63 static const ALchar magicMarker01[8] = "MinPHR01";
64
65 /* Define the default HRTF:
66 * ALubyte defaultAzCount [DefaultHrtf.evCount]
67 * ALushort defaultEvOffset [DefaultHrtf.evCount]
68 * ALshort defaultCoeffs [DefaultHrtf.irCount * defaultHrtf.irSize]
69 * ALubyte defaultDelays [DefaultHrtf.irCount]
70 *
71 * struct Hrtf DefaultHrtf
72 */
73 #include "hrtf_tables.inc"
74
75 static struct Hrtf *LoadedHrtfs = NULL;
76
77 /* Calculate the elevation indices given the polar elevation in radians.
78 * This will return two indices between 0 and (Hrtf->evCount - 1) and an
79 * interpolation factor between 0.0 and 1.0.
80 */
81 static void CalcEvIndices(const struct Hrtf *Hrtf, ALfloat ev, ALuint *evidx, ALfloat *evmu)
82 {
83 ev = (F_PI_2 + ev) * (Hrtf->evCount-1) / F_PI;
84 evidx[0] = fastf2u(ev);
85 evidx[1] = minu(evidx[0] + 1, Hrtf->evCount-1);
86 *evmu = ev - evidx[0];
87 }
88
89 /* Calculate the azimuth indices given the polar azimuth in radians. This
90 * will return two indices between 0 and (Hrtf->azCount[ei] - 1) and an
91 * interpolation factor between 0.0 and 1.0.
92 */
93 static void CalcAzIndices(const struct Hrtf *Hrtf, ALuint evidx, ALfloat az, ALuint *azidx, ALfloat *azmu)
94 {
95 az = (F_PI*2.0f + az) * Hrtf->azCount[evidx] / (F_PI*2.0f);
96 azidx[0] = fastf2u(az) % Hrtf->azCount[evidx];
97 azidx[1] = (azidx[0] + 1) % Hrtf->azCount[evidx];
98 *azmu = az - floorf(az);
99 }
100
101 /* Calculates the normalized HRTF transition factor (delta) from the changes
102 * in gain and listener to source angle between updates. The result is a
103 * normalized delta factor that can be used to calculate moving HRIR stepping
104 * values.
105 */
106 ALfloat CalcHrtfDelta(ALfloat oldGain, ALfloat newGain, const ALfloat olddir[3], const ALfloat newdir[3])
107 {
108 ALfloat gainChange, angleChange, change;
109
110 // Calculate the normalized dB gain change.
111 newGain = maxf(newGain, 0.0001f);
112 oldGain = maxf(oldGain, 0.0001f);
113 gainChange = fabsf(log10f(newGain / oldGain) / log10f(0.0001f));
114
115 // Calculate the normalized listener to source angle change when there is
116 // enough gain to notice it.
117 angleChange = 0.0f;
118 if(gainChange > 0.0001f || newGain > 0.0001f)
119 {
120 // No angle change when the directions are equal or degenerate (when
121 // both have zero length).
122 if(newdir[0]-olddir[0] || newdir[1]-olddir[1] || newdir[2]-olddir[2])
123 angleChange = acosf(olddir[0]*newdir[0] +
124 olddir[1]*newdir[1] +
125 olddir[2]*newdir[2]) / F_PI;
126
127 }
128
129 // Use the largest of the two changes for the delta factor, and apply a
130 // significance shaping function to it.
131 change = maxf(angleChange * 25.0f, gainChange) * 2.0f;
132 return minf(change, 1.0f);
133 }
134
135 /* Calculates static HRIR coefficients and delays for the given polar
136 * elevation and azimuth in radians. Linear interpolation is used to
137 * increase the apparent resolution of the HRIR data set. The coefficients
138 * are also normalized and attenuated by the specified gain.
139 */
140 void GetLerpedHrtfCoeffs(const struct Hrtf *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat gain, ALfloat (*coeffs)[2], ALuint *delays)
141 {
142 ALuint evidx[2], azidx[2];
143 ALuint lidx[4], ridx[4];
144 ALfloat mu[3], blend[4];
145 ALuint i;
146
147 // Claculate elevation indices and interpolation factor.
148 CalcEvIndices(Hrtf, elevation, evidx, &mu[2]);
149
150 // Calculate azimuth indices and interpolation factor for the first
151 // elevation.
152 CalcAzIndices(Hrtf, evidx[0], azimuth, azidx, &mu[0]);
153
154 // Calculate the first set of linear HRIR indices for left and right
155 // channels.
156 lidx[0] = Hrtf->evOffset[evidx[0]] + azidx[0];
157 lidx[1] = Hrtf->evOffset[evidx[0]] + azidx[1];
158 ridx[0] = Hrtf->evOffset[evidx[0]] + ((Hrtf->azCount[evidx[0]]-azidx[0]) % Hrtf->azCount[evidx[0]]);
159 ridx[1] = Hrtf->evOffset[evidx[0]] + ((Hrtf->azCount[evidx[0]]-azidx[1]) % Hrtf->azCount[evidx[0]]);
160
161 // Calculate azimuth indices and interpolation factor for the second
162 // elevation.
163 CalcAzIndices(Hrtf, evidx[1], azimuth, azidx, &mu[1]);
164
165 // Calculate the second set of linear HRIR indices for left and right
166 // channels.
167 lidx[2] = Hrtf->evOffset[evidx[1]] + azidx[0];
168 lidx[3] = Hrtf->evOffset[evidx[1]] + azidx[1];
169 ridx[2] = Hrtf->evOffset[evidx[1]] + ((Hrtf->azCount[evidx[1]]-azidx[0]) % Hrtf->azCount[evidx[1]]);
170 ridx[3] = Hrtf->evOffset[evidx[1]] + ((Hrtf->azCount[evidx[1]]-azidx[1]) % Hrtf->azCount[evidx[1]]);
171
172 /* Calculate 4 blending weights for 2D bilinear interpolation. */
173 blend[0] = (1.0f-mu[0]) * (1.0f-mu[2]);
174 blend[1] = ( mu[0]) * (1.0f-mu[2]);
175 blend[2] = (1.0f-mu[1]) * ( mu[2]);
176 blend[3] = ( mu[1]) * ( mu[2]);
177
178 /* Calculate the HRIR delays using linear interpolation. */
179 delays[0] = fastf2u(Hrtf->delays[lidx[0]]*blend[0] + Hrtf->delays[lidx[1]]*blend[1] +
180 Hrtf->delays[lidx[2]]*blend[2] + Hrtf->delays[lidx[3]]*blend[3] +
181 0.5f) << HRTFDELAY_BITS;
182 delays[1] = fastf2u(Hrtf->delays[ridx[0]]*blend[0] + Hrtf->delays[ridx[1]]*blend[1] +
183 Hrtf->delays[ridx[2]]*blend[2] + Hrtf->delays[ridx[3]]*blend[3] +
184 0.5f) << HRTFDELAY_BITS;
185
186 /* Calculate the sample offsets for the HRIR indices. */
187 lidx[0] *= Hrtf->irSize;
188 lidx[1] *= Hrtf->irSize;
189 lidx[2] *= Hrtf->irSize;
190 lidx[3] *= Hrtf->irSize;
191 ridx[0] *= Hrtf->irSize;
192 ridx[1] *= Hrtf->irSize;
193 ridx[2] *= Hrtf->irSize;
194 ridx[3] *= Hrtf->irSize;
195
196 /* Calculate the normalized and attenuated HRIR coefficients using linear
197 * interpolation when there is enough gain to warrant it. Zero the
198 * coefficients if gain is too low.
199 */
200 if(gain > 0.0001f)
201 {
202 gain *= 1.0f/32767.0f;
203 for(i = 0;i < Hrtf->irSize;i++)
204 {
205 coeffs[i][0] = (Hrtf->coeffs[lidx[0]+i]*blend[0] +
206 Hrtf->coeffs[lidx[1]+i]*blend[1] +
207 Hrtf->coeffs[lidx[2]+i]*blend[2] +
208 Hrtf->coeffs[lidx[3]+i]*blend[3]) * gain;
209 coeffs[i][1] = (Hrtf->coeffs[ridx[0]+i]*blend[0] +
210 Hrtf->coeffs[ridx[1]+i]*blend[1] +
211 Hrtf->coeffs[ridx[2]+i]*blend[2] +
212 Hrtf->coeffs[ridx[3]+i]*blend[3]) * gain;
213 }
214 }
215 else
216 {
217 for(i = 0;i < Hrtf->irSize;i++)
218 {
219 coeffs[i][0] = 0.0f;
220 coeffs[i][1] = 0.0f;
221 }
222 }
223 }
224
225 /* Calculates the moving HRIR target coefficients, target delays, and
226 * stepping values for the given polar elevation and azimuth in radians.
227 * Linear interpolation is used to increase the apparent resolution of the
228 * HRIR data set. The coefficients are also normalized and attenuated by the
229 * specified gain. Stepping resolution and count is determined using the
230 * given delta factor between 0.0 and 1.0.
231 */
232 ALuint GetMovingHrtfCoeffs(const struct Hrtf *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat gain, ALfloat delta, ALint counter, ALfloat (*coeffs)[2], ALuint *delays, ALfloat (*coeffStep)[2], ALint *delayStep)
233 {
234 ALuint evidx[2], azidx[2];
235 ALuint lidx[4], ridx[4];
236 ALfloat mu[3], blend[4];
237 ALfloat left, right;
238 ALfloat step;
239 ALuint i;
240
241 // Claculate elevation indices and interpolation factor.
242 CalcEvIndices(Hrtf, elevation, evidx, &mu[2]);
243
244 // Calculate azimuth indices and interpolation factor for the first
245 // elevation.
246 CalcAzIndices(Hrtf, evidx[0], azimuth, azidx, &mu[0]);
247
248 // Calculate the first set of linear HRIR indices for left and right
249 // channels.
250 lidx[0] = Hrtf->evOffset[evidx[0]] + azidx[0];
251 lidx[1] = Hrtf->evOffset[evidx[0]] + azidx[1];
252 ridx[0] = Hrtf->evOffset[evidx[0]] + ((Hrtf->azCount[evidx[0]]-azidx[0]) % Hrtf->azCount[evidx[0]]);
253 ridx[1] = Hrtf->evOffset[evidx[0]] + ((Hrtf->azCount[evidx[0]]-azidx[1]) % Hrtf->azCount[evidx[0]]);
254
255 // Calculate azimuth indices and interpolation factor for the second
256 // elevation.
257 CalcAzIndices(Hrtf, evidx[1], azimuth, azidx, &mu[1]);
258
259 // Calculate the second set of linear HRIR indices for left and right
260 // channels.
261 lidx[2] = Hrtf->evOffset[evidx[1]] + azidx[0];
262 lidx[3] = Hrtf->evOffset[evidx[1]] + azidx[1];
263 ridx[2] = Hrtf->evOffset[evidx[1]] + ((Hrtf->azCount[evidx[1]]-azidx[0]) % Hrtf->azCount[evidx[1]]);
264 ridx[3] = Hrtf->evOffset[evidx[1]] + ((Hrtf->azCount[evidx[1]]-azidx[1]) % Hrtf->azCount[evidx[1]]);
265
266 // Calculate the stepping parameters.
267 delta = maxf(floorf(delta*(Hrtf->sampleRate*0.015f) + 0.5f), 1.0f);
268 step = 1.0f / delta;
269
270 /* Calculate 4 blending weights for 2D bilinear interpolation. */
271 blend[0] = (1.0f-mu[0]) * (1.0f-mu[2]);
272 blend[1] = ( mu[0]) * (1.0f-mu[2]);
273 blend[2] = (1.0f-mu[1]) * ( mu[2]);
274 blend[3] = ( mu[1]) * ( mu[2]);
275
276 /* Calculate the HRIR delays using linear interpolation. Then calculate
277 * the delay stepping values using the target and previous running
278 * delays.
279 */
280 left = (ALfloat)(delays[0] - (delayStep[0] * counter));
281 right = (ALfloat)(delays[1] - (delayStep[1] * counter));
282
283 delays[0] = fastf2u(Hrtf->delays[lidx[0]]*blend[0] + Hrtf->delays[lidx[1]]*blend[1] +
284 Hrtf->delays[lidx[2]]*blend[2] + Hrtf->delays[lidx[3]]*blend[3] +
285 0.5f) << HRTFDELAY_BITS;
286 delays[1] = fastf2u(Hrtf->delays[ridx[0]]*blend[0] + Hrtf->delays[ridx[1]]*blend[1] +
287 Hrtf->delays[ridx[2]]*blend[2] + Hrtf->delays[ridx[3]]*blend[3] +
288 0.5f) << HRTFDELAY_BITS;
289
290 delayStep[0] = fastf2i(step * (delays[0] - left));
291 delayStep[1] = fastf2i(step * (delays[1] - right));
292
293 /* Calculate the sample offsets for the HRIR indices. */
294 lidx[0] *= Hrtf->irSize;
295 lidx[1] *= Hrtf->irSize;
296 lidx[2] *= Hrtf->irSize;
297 lidx[3] *= Hrtf->irSize;
298 ridx[0] *= Hrtf->irSize;
299 ridx[1] *= Hrtf->irSize;
300 ridx[2] *= Hrtf->irSize;
301 ridx[3] *= Hrtf->irSize;
302
303 /* Calculate the normalized and attenuated target HRIR coefficients using
304 * linear interpolation when there is enough gain to warrant it. Zero
305 * the target coefficients if gain is too low. Then calculate the
306 * coefficient stepping values using the target and previous running
307 * coefficients.
308 */
309 if(gain > 0.0001f)
310 {
311 gain *= 1.0f/32767.0f;
312 for(i = 0;i < HRIR_LENGTH;i++)
313 {
314 left = coeffs[i][0] - (coeffStep[i][0] * counter);
315 right = coeffs[i][1] - (coeffStep[i][1] * counter);
316
317 coeffs[i][0] = (Hrtf->coeffs[lidx[0]+i]*blend[0] +
318 Hrtf->coeffs[lidx[1]+i]*blend[1] +
319 Hrtf->coeffs[lidx[2]+i]*blend[2] +
320 Hrtf->coeffs[lidx[3]+i]*blend[3]) * gain;
321 coeffs[i][1] = (Hrtf->coeffs[ridx[0]+i]*blend[0] +
322 Hrtf->coeffs[ridx[1]+i]*blend[1] +
323 Hrtf->coeffs[ridx[2]+i]*blend[2] +
324 Hrtf->coeffs[ridx[3]+i]*blend[3]) * gain;
325
326 coeffStep[i][0] = step * (coeffs[i][0] - left);
327 coeffStep[i][1] = step * (coeffs[i][1] - right);
328 }
329 }
330 else
331 {
332 for(i = 0;i < HRIR_LENGTH;i++)
333 {
334 left = coeffs[i][0] - (coeffStep[i][0] * counter);
335 right = coeffs[i][1] - (coeffStep[i][1] * counter);
336
337 coeffs[i][0] = 0.0f;
338 coeffs[i][1] = 0.0f;
339
340 coeffStep[i][0] = step * -left;
341 coeffStep[i][1] = step * -right;
342 }
343 }
344
345 /* The stepping count is the number of samples necessary for the HRIR to
346 * complete its transition. The mixer will only apply stepping for this
347 * many samples.
348 */
349 return fastf2u(delta);
350 }
351
352
353 static struct Hrtf *LoadHrtf00(FILE *f, ALuint deviceRate)
354 {
355 const ALubyte maxDelay = SRC_HISTORY_LENGTH-1;
356 struct Hrtf *Hrtf = NULL;
357 ALboolean failed = AL_FALSE;
358 ALuint rate = 0, irCount = 0;
359 ALushort irSize = 0;
360 ALubyte evCount = 0;
361 ALubyte *azCount = NULL;
362 ALushort *evOffset = NULL;
363 ALshort *coeffs = NULL;
364 ALubyte *delays = NULL;
365 ALuint i, j;
366
367 rate = fgetc(f);
368 rate |= fgetc(f)<<8;
369 rate |= fgetc(f)<<16;
370 rate |= fgetc(f)<<24;
371
372 irCount = fgetc(f);
373 irCount |= fgetc(f)<<8;
374
375 irSize = fgetc(f);
376 irSize |= fgetc(f)<<8;
377
378 evCount = fgetc(f);
379
380 if(rate != deviceRate)
381 {
382 ERR("HRIR rate does not match device rate: rate=%d (%d)\n",
383 rate, deviceRate);
384 failed = AL_TRUE;
385 }
386 if(irSize < MIN_IR_SIZE || irSize > MAX_IR_SIZE || (irSize%MOD_IR_SIZE))
387 {
388 ERR("Unsupported HRIR size: irSize=%d (%d to %d by %d)\n",
389 irSize, MIN_IR_SIZE, MAX_IR_SIZE, MOD_IR_SIZE);
390 failed = AL_TRUE;
391 }
392 if(evCount < MIN_EV_COUNT || evCount > MAX_EV_COUNT)
393 {
394 ERR("Unsupported elevation count: evCount=%d (%d to %d)\n",
395 evCount, MIN_EV_COUNT, MAX_EV_COUNT);
396 failed = AL_TRUE;
397 }
398
399 if(failed)
400 return NULL;
401
402 azCount = malloc(sizeof(azCount[0])*evCount);
403 evOffset = malloc(sizeof(evOffset[0])*evCount);
404 if(azCount == NULL || evOffset == NULL)
405 {
406 ERR("Out of memory.\n");
407 failed = AL_TRUE;
408 }
409
410 if(!failed)
411 {
412 evOffset[0] = fgetc(f);
413 evOffset[0] |= fgetc(f)<<8;
414 for(i = 1;i < evCount;i++)
415 {
416 evOffset[i] = fgetc(f);
417 evOffset[i] |= fgetc(f)<<8;
418 if(evOffset[i] <= evOffset[i-1])
419 {
420 ERR("Invalid evOffset: evOffset[%d]=%d (last=%d)\n",
421 i, evOffset[i], evOffset[i-1]);
422 failed = AL_TRUE;
423 }
424
425 azCount[i-1] = evOffset[i] - evOffset[i-1];
426 if(azCount[i-1] < MIN_AZ_COUNT || azCount[i-1] > MAX_AZ_COUNT)
427 {
428 ERR("Unsupported azimuth count: azCount[%d]=%d (%d to %d)\n",
429 i-1, azCount[i-1], MIN_AZ_COUNT, MAX_AZ_COUNT);
430 failed = AL_TRUE;
431 }
432 }
433 if(irCount <= evOffset[i-1])
434 {
435 ERR("Invalid evOffset: evOffset[%d]=%d (irCount=%d)\n",
436 i-1, evOffset[i-1], irCount);
437 failed = AL_TRUE;
438 }
439
440 azCount[i-1] = irCount - evOffset[i-1];
441 if(azCount[i-1] < MIN_AZ_COUNT || azCount[i-1] > MAX_AZ_COUNT)
442 {
443 ERR("Unsupported azimuth count: azCount[%d]=%d (%d to %d)\n",
444 i-1, azCount[i-1], MIN_AZ_COUNT, MAX_AZ_COUNT);
445 failed = AL_TRUE;
446 }
447 }
448
449 if(!failed)
450 {
451 coeffs = malloc(sizeof(coeffs[0])*irSize*irCount);
452 delays = malloc(sizeof(delays[0])*irCount);
453 if(coeffs == NULL || delays == NULL)
454 {
455 ERR("Out of memory.\n");
456 failed = AL_TRUE;
457 }
458 }
459
460 if(!failed)
461 {
462 for(i = 0;i < irCount*irSize;i+=irSize)
463 {
464 for(j = 0;j < irSize;j++)
465 {
466 ALshort coeff;
467 coeff = fgetc(f);
468 coeff |= fgetc(f)<<8;
469 coeffs[i+j] = coeff;
470 }
471 }
472 for(i = 0;i < irCount;i++)
473 {
474 delays[i] = fgetc(f);
475 if(delays[i] > maxDelay)
476 {
477 ERR("Invalid delays[%d]: %d (%d)\n", i, delays[i], maxDelay);
478 failed = AL_TRUE;
479 }
480 }
481
482 if(feof(f))
483 {
484 ERR("Premature end of data\n");
485 failed = AL_TRUE;
486 }
487 }
488
489 if(!failed)
490 {
491 Hrtf = malloc(sizeof(struct Hrtf));
492 if(Hrtf == NULL)
493 {
494 ERR("Out of memory.\n");
495 failed = AL_TRUE;
496 }
497 }
498
499 if(!failed)
500 {
501 Hrtf->sampleRate = rate;
502 Hrtf->irSize = irSize;
503 Hrtf->evCount = evCount;
504 Hrtf->azCount = azCount;
505 Hrtf->evOffset = evOffset;
506 Hrtf->coeffs = coeffs;
507 Hrtf->delays = delays;
508 Hrtf->next = NULL;
509 return Hrtf;
510 }
511
512 free(azCount);
513 free(evOffset);
514 free(coeffs);
515 free(delays);
516 return NULL;
517 }
518
519
520 static struct Hrtf *LoadHrtf01(FILE *f, ALuint deviceRate)
521 {
522 const ALubyte maxDelay = SRC_HISTORY_LENGTH-1;
523 struct Hrtf *Hrtf = NULL;
524 ALboolean failed = AL_FALSE;
525 ALuint rate = 0, irCount = 0;
526 ALubyte irSize = 0, evCount = 0;
527 ALubyte *azCount = NULL;
528 ALushort *evOffset = NULL;
529 ALshort *coeffs = NULL;
530 ALubyte *delays = NULL;
531 ALuint i, j;
532
533 rate = fgetc(f);
534 rate |= fgetc(f)<<8;
535 rate |= fgetc(f)<<16;
536 rate |= fgetc(f)<<24;
537
538 irSize = fgetc(f);
539
540 evCount = fgetc(f);
541
542 if(rate != deviceRate)
543 {
544 ERR("HRIR rate does not match device rate: rate=%d (%d)\n",
545 rate, deviceRate);
546 failed = AL_TRUE;
547 }
548 if(irSize < MIN_IR_SIZE || irSize > MAX_IR_SIZE || (irSize%MOD_IR_SIZE))
549 {
550 ERR("Unsupported HRIR size: irSize=%d (%d to %d by %d)\n",
551 irSize, MIN_IR_SIZE, MAX_IR_SIZE, MOD_IR_SIZE);
552 failed = AL_TRUE;
553 }
554 if(evCount < MIN_EV_COUNT || evCount > MAX_EV_COUNT)
555 {
556 ERR("Unsupported elevation count: evCount=%d (%d to %d)\n",
557 evCount, MIN_EV_COUNT, MAX_EV_COUNT);
558 failed = AL_TRUE;
559 }
560
561 if(failed)
562 return NULL;
563
564 azCount = malloc(sizeof(azCount[0])*evCount);
565 evOffset = malloc(sizeof(evOffset[0])*evCount);
566 if(azCount == NULL || evOffset == NULL)
567 {
568 ERR("Out of memory.\n");
569 failed = AL_TRUE;
570 }
571
572 if(!failed)
573 {
574 for(i = 0;i < evCount;i++)
575 {
576 azCount[i] = fgetc(f);
577 if(azCount[i] < MIN_AZ_COUNT || azCount[i] > MAX_AZ_COUNT)
578 {
579 ERR("Unsupported azimuth count: azCount[%d]=%d (%d to %d)\n",
580 i, azCount[i], MIN_AZ_COUNT, MAX_AZ_COUNT);
581 failed = AL_TRUE;
582 }
583 }
584 }
585
586 if(!failed)
587 {
588 evOffset[0] = 0;
589 irCount = azCount[0];
590 for(i = 1;i < evCount;i++)
591 {
592 evOffset[i] = evOffset[i-1] + azCount[i-1];
593 irCount += azCount[i];
594 }
595
596 coeffs = malloc(sizeof(coeffs[0])*irSize*irCount);
597 delays = malloc(sizeof(delays[0])*irCount);
598 if(coeffs == NULL || delays == NULL)
599 {
600 ERR("Out of memory.\n");
601 failed = AL_TRUE;
602 }
603 }
604
605 if(!failed)
606 {
607 for(i = 0;i < irCount*irSize;i+=irSize)
608 {
609 for(j = 0;j < irSize;j++)
610 {
611 ALshort coeff;
612 coeff = fgetc(f);
613 coeff |= fgetc(f)<<8;
614 coeffs[i+j] = coeff;
615 }
616 }
617 for(i = 0;i < irCount;i++)
618 {
619 delays[i] = fgetc(f);
620 if(delays[i] > maxDelay)
621 {
622 ERR("Invalid delays[%d]: %d (%d)\n", i, delays[i], maxDelay);
623 failed = AL_TRUE;
624 }
625 }
626
627 if(feof(f))
628 {
629 ERR("Premature end of data\n");
630 failed = AL_TRUE;
631 }
632 }
633
634 if(!failed)
635 {
636 Hrtf = malloc(sizeof(struct Hrtf));
637 if(Hrtf == NULL)
638 {
639 ERR("Out of memory.\n");
640 failed = AL_TRUE;
641 }
642 }
643
644 if(!failed)
645 {
646 Hrtf->sampleRate = rate;
647 Hrtf->irSize = irSize;
648 Hrtf->evCount = evCount;
649 Hrtf->azCount = azCount;
650 Hrtf->evOffset = evOffset;
651 Hrtf->coeffs = coeffs;
652 Hrtf->delays = delays;
653 Hrtf->next = NULL;
654 return Hrtf;
655 }
656
657 free(azCount);
658 free(evOffset);
659 free(coeffs);
660 free(delays);
661 return NULL;
662 }
663
664
665 static struct Hrtf *LoadHrtf(ALuint deviceRate)
666 {
667 const char *fnamelist = NULL;
668
669 if(!ConfigValueStr(NULL, "hrtf_tables", &fnamelist))
670 return NULL;
671 while(*fnamelist != '\0')
672 {
673 struct Hrtf *Hrtf = NULL;
674 char fname[PATH_MAX];
675 ALchar magic[8];
676 ALuint i;
677 FILE *f;
678
679 while(isspace(*fnamelist) || *fnamelist == ',')
680 fnamelist++;
681 i = 0;
682 while(*fnamelist != '\0' && *fnamelist != ',')
683 {
684 const char *next = strpbrk(fnamelist, "%,");
685 while(fnamelist != next && *fnamelist && i < sizeof(fname))
686 fname[i++] = *(fnamelist++);
687
688 if(!next || *next == ',')
689 break;
690
691 /* *next == '%' */
692 next++;
693 if(*next == 'r')
694 {
695 int wrote = snprintf(&fname[i], sizeof(fname)-i, "%u", deviceRate);
696 i += minu(wrote, sizeof(fname)-i);
697 next++;
698 }
699 else if(*next == '%')
700 {
701 if(i < sizeof(fname))
702 fname[i++] = '%';
703 next++;
704 }
705 else
706 ERR("Invalid marker '%%%c'\n", *next);
707 fnamelist = next;
708 }
709 i = minu(i, sizeof(fname)-1);
710 fname[i] = '\0';
711 while(i > 0 && isspace(fname[i-1]))
712 i--;
713 fname[i] = '\0';
714
715 if(fname[0] == '\0')
716 continue;
717
718 TRACE("Loading %s...\n", fname);
719 f = fopen(fname, "rb");
720 if(f == NULL)
721 {
722 ERR("Could not open %s\n", fname);
723 continue;
724 }
725
726 if(fread(magic, 1, sizeof(magic), f) != sizeof(magic))
727 ERR("Failed to read header from %s\n", fname);
728 else
729 {
730 if(memcmp(magic, magicMarker00, sizeof(magicMarker00)) == 0)
731 {
732 TRACE("Detected data set format v0\n");
733 Hrtf = LoadHrtf00(f, deviceRate);
734 }
735 else if(memcmp(magic, magicMarker01, sizeof(magicMarker01)) == 0)
736 {
737 TRACE("Detected data set format v1\n");
738 Hrtf = LoadHrtf01(f, deviceRate);
739 }
740 else
741 ERR("Invalid header in %s: \"%.8s\"\n", fname, magic);
742 }
743
744 fclose(f);
745 f = NULL;
746
747 if(Hrtf)
748 {
749 Hrtf->next = LoadedHrtfs;
750 LoadedHrtfs = Hrtf;
751 TRACE("Loaded HRTF support for format: %s %uhz\n",
752 DevFmtChannelsString(DevFmtStereo), Hrtf->sampleRate);
753 return Hrtf;
754 }
755
756 ERR("Failed to load %s\n", fname);
757 }
758
759 return NULL;
760 }
761
762 const struct Hrtf *GetHrtf(ALCdevice *device)
763 {
764 if(device->FmtChans == DevFmtStereo)
765 {
766 struct Hrtf *Hrtf = LoadedHrtfs;
767 while(Hrtf != NULL)
768 {
769 if(device->Frequency == Hrtf->sampleRate)
770 return Hrtf;
771 Hrtf = Hrtf->next;
772 }
773
774 Hrtf = LoadHrtf(device->Frequency);
775 if(Hrtf != NULL)
776 return Hrtf;
777
778 if(device->Frequency == DefaultHrtf.sampleRate)
779 return &DefaultHrtf;
780 }
781 ERR("Incompatible format: %s %uhz\n",
782 DevFmtChannelsString(device->FmtChans), device->Frequency);
783 return NULL;
784 }
785
786 void FreeHrtfs(void)
787 {
788 struct Hrtf *Hrtf = NULL;
789
790 while((Hrtf=LoadedHrtfs) != NULL)
791 {
792 LoadedHrtfs = Hrtf->next;
793 free((void*)Hrtf->azCount);
794 free((void*)Hrtf->evOffset);
795 free((void*)Hrtf->coeffs);
796 free((void*)Hrtf->delays);
797 free(Hrtf);
798 }
799 }
800
801 ALuint GetHrtfIrSize (const struct Hrtf *Hrtf)
802 {
803 return Hrtf->irSize;
804 }
ConfigValueStr
int ConfigValueStr(const char *blockName, const char *keyName, const char **ret)
Definition: alcConfig.c:316
ALubyte
unsigned char ALubyte
Definition: al.h:47
GetLerpedHrtfCoeffs
void GetLerpedHrtfCoeffs(const struct Hrtf *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat gain, ALfloat(*coeffs)[2], ALuint *delays)
Definition: hrtf.c:140
LoadHrtf01
static struct Hrtf * LoadHrtf01(FILE *f, ALuint deviceRate)
Definition: hrtf.c:520
F_PI
#define F_PI
Definition: alu.h:16
LoadHrtf
static struct Hrtf * LoadHrtf(ALuint deviceRate)
Definition: hrtf.c:665
GetMovingHrtfCoeffs
ALuint GetMovingHrtfCoeffs(const struct Hrtf *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat gain, ALfloat delta, ALint counter, ALfloat(*coeffs)[2], ALuint *delays, ALfloat(*coeffStep)[2], ALint *delayStep)
Definition: hrtf.c:232
AL_TRUE
#define AL_TRUE
Definition: al.h:86
left
GLint left
Definition: glew.h:7291
ALchar
char ALchar
Definition: al.h:41
NULL
#define NULL
Definition: ftobjs.h:61
TRACE
#define TRACE(...)
Definition: alMain.h:806
f
GLclampf f
Definition: glew.h:3390
DevFmtChannelsString
const ALCchar * DevFmtChannelsString(enum DevFmtChannels chans)
Definition: ALc.c:1150
SRC_HISTORY_LENGTH
#define SRC_HISTORY_LENGTH
Definition: alSource.h:15
HRTFDELAY_BITS
#define HRTFDELAY_BITS
Definition: alMain.h:778
alu.h
free
SDL_EventEntry * free
Definition: SDL_events.c:80
ALCdevice_struct::Frequency
ALuint Frequency
Definition: alMain.h:569
ALCdevice_struct
Definition: alMain.h:560
ALint
int ALint
Definition: al.h:56
hrtf_tables.inc
j
int32_t j
Definition: e_log.c:102
AL_FALSE
#define AL_FALSE
Definition: al.h:83
magicMarker01
static const ALchar magicMarker01[8]
Definition: hrtf.c:63
GetHrtfIrSize
ALuint GetHrtfIrSize(const struct Hrtf *Hrtf)
Definition: hrtf.c:801
ALshort
short ALshort
Definition: al.h:50
alSource.h
magicMarker00
static const ALchar magicMarker00[8]
Definition: hrtf.c:62
counter
GLuint counter
Definition: gl2ext.h:936
CalcHrtfDelta
ALfloat CalcHrtfDelta(ALfloat oldGain, ALfloat newGain, const ALfloat olddir[3], const ALfloat newdir[3])
Definition: hrtf.c:106
maxf
static __inline ALfloat maxf(ALfloat a, ALfloat b)
Definition: alu.h:56
HRIR_LENGTH
#define HRIR_LENGTH
Definition: alMain.h:776
ALfloat
float ALfloat
Definition: al.h:68
CalcEvIndices
static void CalcEvIndices(const struct Hrtf *Hrtf, ALfloat ev, ALuint *evidx, ALfloat *evmu)
Definition: hrtf.c:81
MAX_EV_COUNT
#define MAX_EV_COUNT
Definition: hrtf.c:44
DevFmtStereo
Definition: alMain.h:509
alMain.h
ALushort
unsigned short ALushort
Definition: al.h:53
MIN_EV_COUNT
#define MIN_EV_COUNT
Definition: hrtf.c:43
LoadedHrtfs
static struct Hrtf * LoadedHrtfs
Definition: hrtf.c:75
fastf2u
static __inline ALuint fastf2u(ALfloat f)
Definition: alMain.h:379
MAX_AZ_COUNT
#define MAX_AZ_COUNT
Definition: hrtf.c:47
ALuint
unsigned int ALuint
Definition: al.h:59
FreeHrtfs
void FreeHrtfs(void)
Definition: hrtf.c:786
MIN_IR_SIZE
#define MIN_IR_SIZE
Definition: hrtf.c:39
ALCdevice_struct::FmtChans
enum DevFmtChannels FmtChans
Definition: alMain.h:572
minu
static __inline ALuint minu(ALuint a, ALuint b)
Definition: alu.h:61
MIN_AZ_COUNT
#define MIN_AZ_COUNT
Definition: hrtf.c:46
MAX_IR_SIZE
#define MAX_IR_SIZE
Definition: hrtf.c:40
PATH_MAX
#define PATH_MAX
Definition: hrtf.c:34
malloc
#define malloc
Definition: SDL_malloc.c:635
ERR
#define ERR(...)
Definition: alMain.h:816
F_PI_2
#define F_PI_2
Definition: alu.h:17
ALboolean
char ALboolean
Definition: al.h:38
CalcAzIndices
static void CalcAzIndices(const struct Hrtf *Hrtf, ALuint evidx, ALfloat az, ALuint *azidx, ALfloat *azmu)
Definition: hrtf.c:93
MOD_IR_SIZE
#define MOD_IR_SIZE
Definition: hrtf.c:41
minf
static __inline ALfloat minf(ALfloat a, ALfloat b)
Definition: alu.h:54
i
int i
Definition: pngrutil.c:1377
fastf2i
static __inline ALint fastf2i(ALfloat f)
Definition: alMain.h:363
right
GLfloat right
Definition: glew.h:13816
GetHrtf
struct Hrtf * GetHrtf(ALCdevice *device)
Definition: hrtf.c:762
LoadHrtf00
static struct Hrtf * LoadHrtf00(FILE *f, ALuint deviceRate)
Definition: hrtf.c:353
coeffs
GLenum GLenum const GLfloat * coeffs
Definition: glew.h:12405