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., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, 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
  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 }