Alc/hrtf.c

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