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