utils/makemhr/loaddef.cpp

   1 /*
   2  * HRTF utility for producing and demonstrating the process of creating an
   3  * OpenAL Soft compatible HRIR data set.
   4  *
   5  * Copyright (C) 2011-2019  Christopher Fitzgerald
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Or visit:  http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
  22  */
  23
  24 #include "loaddef.h"
  25
  26 #include <algorithm>
  27 #include <cctype>
  28 #include <cmath>
  29 #include <cstdarg>
  30 #include <cstdio>
  31 #include <cstdlib>
  32 #include <cstring>
  33 #include <iterator>
  34 #include <limits>
  35 #include <memory>
  36 #include <cstdarg>
  37 #include <vector>
  38
  39 #include "alfstream.h"
  40 #include "aloptional.h"
  41 #include "alspan.h"
  42 #include "alstring.h"
  43 #include "makemhr.h"
  44 #include "polyphase_resampler.h"
  45
  46 #include "mysofa.h"
  47
  48 // Constants for accessing the token reader's ring buffer.
  49 #define TR_RING_BITS                 (16)
  50 #define TR_RING_SIZE                 (1 << TR_RING_BITS)
  51 #define TR_RING_MASK                 (TR_RING_SIZE - 1)
  52
  53 // The token reader's load interval in bytes.
  54 #define TR_LOAD_SIZE                 (TR_RING_SIZE >> 2)
  55
  56 // Token reader state for parsing the data set definition.
  57 struct TokenReaderT {
  58     std::istream &mIStream;
  59     const char *mName{};
  60     uint        mLine{};
  61     uint        mColumn{};
  62     char mRing[TR_RING_SIZE]{};
  63     std::streamsize mIn{};
  64     std::streamsize mOut{};
  65
  66     TokenReaderT(std::istream &istream) noexcept : mIStream{istream} { }
  67     TokenReaderT(const TokenReaderT&) = default;
  68 };
  69
  70
  71 // The maximum identifier length used when processing the data set
  72 // definition.
  73 #define MAX_IDENT_LEN                (16)
  74
  75 // The limits for the listener's head 'radius' in the data set definition.
  76 #define MIN_RADIUS                   (0.05)
  77 #define MAX_RADIUS                   (0.15)
  78
  79 // The maximum number of channels that can be addressed for a WAVE file
  80 // source listed in the data set definition.
  81 #define MAX_WAVE_CHANNELS            (65535)
  82
  83 // The limits to the byte size for a binary source listed in the definition
  84 // file.
  85 #define MIN_BIN_SIZE                 (2)
  86 #define MAX_BIN_SIZE                 (4)
  87
  88 // The minimum number of significant bits for binary sources listed in the
  89 // data set definition.  The maximum is calculated from the byte size.
  90 #define MIN_BIN_BITS                 (16)
  91
  92 // The limits to the number of significant bits for an ASCII source listed in
  93 // the data set definition.
  94 #define MIN_ASCII_BITS               (16)
  95 #define MAX_ASCII_BITS               (32)
  96
  97 // The four-character-codes for RIFF/RIFX WAVE file chunks.
  98 #define FOURCC_RIFF                  (0x46464952) // 'RIFF'
  99 #define FOURCC_RIFX                  (0x58464952) // 'RIFX'
 100 #define FOURCC_WAVE                  (0x45564157) // 'WAVE'
 101 #define FOURCC_FMT                   (0x20746D66) // 'fmt '
 102 #define FOURCC_DATA                  (0x61746164) // 'data'
 103 #define FOURCC_LIST                  (0x5453494C) // 'LIST'
 104 #define FOURCC_WAVL                  (0x6C766177) // 'wavl'
 105 #define FOURCC_SLNT                  (0x746E6C73) // 'slnt'
 106
 107 // The supported wave formats.
 108 #define WAVE_FORMAT_PCM              (0x0001)
 109 #define WAVE_FORMAT_IEEE_FLOAT       (0x0003)
 110 #define WAVE_FORMAT_EXTENSIBLE       (0xFFFE)
 111
 112
 113 enum ByteOrderT {
 114     BO_NONE,
 115     BO_LITTLE,
 116     BO_BIG
 117 };
 118
 119 // Source format for the references listed in the data set definition.
 120 enum SourceFormatT {
 121     SF_NONE,
 122     SF_ASCII,  // ASCII text file.
 123     SF_BIN_LE, // Little-endian binary file.
 124     SF_BIN_BE, // Big-endian binary file.
 125     SF_WAVE,   // RIFF/RIFX WAVE file.
 126     SF_SOFA    // Spatially Oriented Format for Accoustics (SOFA) file.
 127 };
 128
 129 // Element types for the references listed in the data set definition.
 130 enum ElementTypeT {
 131     ET_NONE,
 132     ET_INT,  // Integer elements.
 133     ET_FP    // Floating-point elements.
 134 };
 135
 136 // Source reference state used when loading sources.
 137 struct SourceRefT {
 138     SourceFormatT mFormat;
 139     ElementTypeT  mType;
 140     uint mSize;
 141     int  mBits;
 142     uint mChannel;
 143     double mAzimuth;
 144     double mElevation;
 145     double mRadius;
 146     uint mSkip;
 147     uint mOffset;
 148     char mPath[MAX_PATH_LEN+1];
 149 };
 150
 151
 152 /* Whitespace is not significant. It can process tokens as identifiers, numbers
 153  * (integer and floating-point), strings, and operators. Strings must be
 154  * encapsulated by double-quotes and cannot span multiple lines.
 155  */
 156
 157 // Setup the reader on the given file.  The filename can be NULL if no error
 158 // output is desired.
 159 static void TrSetup(const char *startbytes, std::streamsize startbytecount, const char *filename,
 160     TokenReaderT *tr)
 161 {
 162     const char *name = nullptr;
 163
 164     if(filename)
 165     {
 166         const char *slash = strrchr(filename, '/');
 167         if(slash)
 168         {
 169             const char *bslash = strrchr(slash+1, '\\');
 170             if(bslash) name = bslash+1;
 171             else name = slash+1;
 172         }
 173         else
 174         {
 175             const char *bslash = strrchr(filename, '\\');
 176             if(bslash) name = bslash+1;
 177             else name = filename;
 178         }
 179     }
 180
 181     tr->mName = name;
 182     tr->mLine = 1;
 183     tr->mColumn = 1;
 184     tr->mIn = 0;
 185     tr->mOut = 0;
 186
 187     if(startbytecount > 0)
 188     {
 189         std::copy_n(startbytes, startbytecount, std::begin(tr->mRing));
 190         tr->mIn += startbytecount;
 191     }
 192 }
 193
 194 // Prime the reader's ring buffer, and return a result indicating that there
 195 // is text to process.
 196 static int TrLoad(TokenReaderT *tr)
 197 {
 198     std::istream &istream = tr->mIStream;
 199
 200     std::streamsize toLoad{TR_RING_SIZE - static_cast<std::streamsize>(tr->mIn - tr->mOut)};
 201     if(toLoad >= TR_LOAD_SIZE && istream.good())
 202     {
 203         // Load TR_LOAD_SIZE (or less if at the end of the file) per read.
 204         toLoad = TR_LOAD_SIZE;
 205         std::streamsize in{tr->mIn&TR_RING_MASK};
 206         std::streamsize count{TR_RING_SIZE - in};
 207         if(count < toLoad)
 208         {
 209             istream.read(&tr->mRing[in], count);
 210             tr->mIn += istream.gcount();
 211             istream.read(&tr->mRing[0], toLoad-count);
 212             tr->mIn += istream.gcount();
 213         }
 214         else
 215         {
 216             istream.read(&tr->mRing[in], toLoad);
 217             tr->mIn += istream.gcount();
 218         }
 219
 220         if(tr->mOut >= TR_RING_SIZE)
 221         {
 222             tr->mOut -= TR_RING_SIZE;
 223             tr->mIn -= TR_RING_SIZE;
 224         }
 225     }
 226     if(tr->mIn > tr->mOut)
 227         return 1;
 228     return 0;
 229 }
 230
 231 // Error display routine.  Only displays when the base name is not NULL.
 232 static void TrErrorVA(const TokenReaderT *tr, uint line, uint column, const char *format, va_list argPtr)
 233 {
 234     if(!tr->mName)
 235         return;
 236     fprintf(stderr, "\nError (%s:%u:%u): ", tr->mName, line, column);
 237     vfprintf(stderr, format, argPtr);
 238 }
 239
 240 // Used to display an error at a saved line/column.
 241 static void TrErrorAt(const TokenReaderT *tr, uint line, uint column, const char *format, ...)
 242 {
 243     va_list argPtr;
 244
 245     va_start(argPtr, format);
 246     TrErrorVA(tr, line, column, format, argPtr);
 247     va_end(argPtr);
 248 }
 249
 250 // Used to display an error at the current line/column.
 251 static void TrError(const TokenReaderT *tr, const char *format, ...)
 252 {
 253     va_list argPtr;
 254
 255     va_start(argPtr, format);
 256     TrErrorVA(tr, tr->mLine, tr->mColumn, format, argPtr);
 257     va_end(argPtr);
 258 }
 259
 260 // Skips to the next line.
 261 static void TrSkipLine(TokenReaderT *tr)
 262 {
 263     char ch;
 264
 265     while(TrLoad(tr))
 266     {
 267         ch = tr->mRing[tr->mOut&TR_RING_MASK];
 268         tr->mOut++;
 269         if(ch == '\n')
 270         {
 271             tr->mLine++;
 272             tr->mColumn = 1;
 273             break;
 274         }
 275         tr->mColumn ++;
 276     }
 277 }
 278
 279 // Skips to the next token.
 280 static int TrSkipWhitespace(TokenReaderT *tr)
 281 {
 282     while(TrLoad(tr))
 283     {
 284         char ch{tr->mRing[tr->mOut&TR_RING_MASK]};
 285         if(isspace(ch))
 286         {
 287             tr->mOut++;
 288             if(ch == '\n')
 289             {
 290                 tr->mLine++;
 291                 tr->mColumn = 1;
 292             }
 293             else
 294                 tr->mColumn++;
 295         }
 296         else if(ch == '#')
 297             TrSkipLine(tr);
 298         else
 299             return 1;
 300     }
 301     return 0;
 302 }
 303
 304 // Get the line and/or column of the next token (or the end of input).
 305 static void TrIndication(TokenReaderT *tr, uint *line, uint *column)
 306 {
 307     TrSkipWhitespace(tr);
 308     if(line) *line = tr->mLine;
 309     if(column) *column = tr->mColumn;
 310 }
 311
 312 // Checks to see if a token is (likely to be) an identifier.  It does not
 313 // display any errors and will not proceed to the next token.
 314 static int TrIsIdent(TokenReaderT *tr)
 315 {
 316     if(!TrSkipWhitespace(tr))
 317         return 0;
 318     char ch{tr->mRing[tr->mOut&TR_RING_MASK]};
 319     return ch == '_' || isalpha(ch);
 320 }
 321
 322
 323 // Checks to see if a token is the given operator.  It does not display any
 324 // errors and will not proceed to the next token.
 325 static int TrIsOperator(TokenReaderT *tr, const char *op)
 326 {
 327     std::streamsize out;
 328     size_t len;
 329     char ch;
 330
 331     if(!TrSkipWhitespace(tr))
 332         return 0;
 333     out = tr->mOut;
 334     len = 0;
 335     while(op[len] != '\0' && out < tr->mIn)
 336     {
 337         ch = tr->mRing[out&TR_RING_MASK];
 338         if(ch != op[len]) break;
 339         len++;
 340         out++;
 341     }
 342     if(op[len] == '\0')
 343         return 1;
 344     return 0;
 345 }
 346
 347 /* The TrRead*() routines obtain the value of a matching token type.  They
 348  * display type, form, and boundary errors and will proceed to the next
 349  * token.
 350  */
 351
 352 // Reads and validates an identifier token.
 353 static int TrReadIdent(TokenReaderT *tr, const uint maxLen, char *ident)
 354 {
 355     uint col, len;
 356     char ch;
 357
 358     col = tr->mColumn;
 359     if(TrSkipWhitespace(tr))
 360     {
 361         col = tr->mColumn;
 362         ch = tr->mRing[tr->mOut&TR_RING_MASK];
 363         if(ch == '_' || isalpha(ch))
 364         {
 365             len = 0;
 366             do {
 367                 if(len < maxLen)
 368                     ident[len] = ch;
 369                 len++;
 370                 tr->mOut++;
 371                 if(!TrLoad(tr))
 372                     break;
 373                 ch = tr->mRing[tr->mOut&TR_RING_MASK];
 374             } while(ch == '_' || isdigit(ch) || isalpha(ch));
 375
 376             tr->mColumn += len;
 377             if(len < maxLen)
 378             {
 379                 ident[len] = '\0';
 380                 return 1;
 381             }
 382             TrErrorAt(tr, tr->mLine, col, "Identifier is too long.\n");
 383             return 0;
 384         }
 385     }
 386     TrErrorAt(tr, tr->mLine, col, "Expected an identifier.\n");
 387     return 0;
 388 }
 389
 390 // Reads and validates (including bounds) an integer token.
 391 static int TrReadInt(TokenReaderT *tr, const int loBound, const int hiBound, int *value)
 392 {
 393     uint col, digis, len;
 394     char ch, temp[64+1];
 395
 396     col = tr->mColumn;
 397     if(TrSkipWhitespace(tr))
 398     {
 399         col = tr->mColumn;
 400         len = 0;
 401         ch = tr->mRing[tr->mOut&TR_RING_MASK];
 402         if(ch == '+' || ch == '-')
 403         {
 404             temp[len] = ch;
 405             len++;
 406             tr->mOut++;
 407         }
 408         digis = 0;
 409         while(TrLoad(tr))
 410         {
 411             ch = tr->mRing[tr->mOut&TR_RING_MASK];
 412             if(!isdigit(ch)) break;
 413             if(len < 64)
 414                 temp[len] = ch;
 415             len++;
 416             digis++;
 417             tr->mOut++;
 418         }
 419         tr->mColumn += len;
 420         if(digis > 0 && ch != '.' && !isalpha(ch))
 421         {
 422             if(len > 64)
 423             {
 424                 TrErrorAt(tr, tr->mLine, col, "Integer is too long.");
 425                 return 0;
 426             }
 427             temp[len] = '\0';
 428             *value = static_cast<int>(strtol(temp, nullptr, 10));
 429             if(*value < loBound || *value > hiBound)
 430             {
 431                 TrErrorAt(tr, tr->mLine, col, "Expected a value from %d to %d.\n", loBound, hiBound);
 432                 return 0;
 433             }
 434             return 1;
 435         }
 436     }
 437     TrErrorAt(tr, tr->mLine, col, "Expected an integer.\n");
 438     return 0;
 439 }
 440
 441 // Reads and validates (including bounds) a float token.
 442 static int TrReadFloat(TokenReaderT *tr, const double loBound, const double hiBound, double *value)
 443 {
 444     uint col, digis, len;
 445     char ch, temp[64+1];
 446
 447     col = tr->mColumn;
 448     if(TrSkipWhitespace(tr))
 449     {
 450         col = tr->mColumn;
 451         len = 0;
 452         ch = tr->mRing[tr->mOut&TR_RING_MASK];
 453         if(ch == '+' || ch == '-')
 454         {
 455             temp[len] = ch;
 456             len++;
 457             tr->mOut++;
 458         }
 459
 460         digis = 0;
 461         while(TrLoad(tr))
 462         {
 463             ch = tr->mRing[tr->mOut&TR_RING_MASK];
 464             if(!isdigit(ch)) break;
 465             if(len < 64)
 466                 temp[len] = ch;
 467             len++;
 468             digis++;
 469             tr->mOut++;
 470         }
 471         if(ch == '.')
 472         {
 473             if(len < 64)
 474                 temp[len] = ch;
 475             len++;
 476             tr->mOut++;
 477         }
 478         while(TrLoad(tr))
 479         {
 480             ch = tr->mRing[tr->mOut&TR_RING_MASK];
 481             if(!isdigit(ch)) break;
 482             if(len < 64)
 483                 temp[len] = ch;
 484             len++;
 485             digis++;
 486             tr->mOut++;
 487         }
 488         if(digis > 0)
 489         {
 490             if(ch == 'E' || ch == 'e')
 491             {
 492                 if(len < 64)
 493                     temp[len] = ch;
 494                 len++;
 495                 digis = 0;
 496                 tr->mOut++;
 497                 if(ch == '+' || ch == '-')
 498                 {
 499                     if(len < 64)
 500                         temp[len] = ch;
 501                     len++;
 502                     tr->mOut++;
 503                 }
 504                 while(TrLoad(tr))
 505                 {
 506                     ch = tr->mRing[tr->mOut&TR_RING_MASK];
 507                     if(!isdigit(ch)) break;
 508                     if(len < 64)
 509                         temp[len] = ch;
 510                     len++;
 511                     digis++;
 512                     tr->mOut++;
 513                 }
 514             }
 515             tr->mColumn += len;
 516             if(digis > 0 && ch != '.' && !isalpha(ch))
 517             {
 518                 if(len > 64)
 519                 {
 520                     TrErrorAt(tr, tr->mLine, col, "Float is too long.");
 521                     return 0;
 522                 }
 523                 temp[len] = '\0';
 524                 *value = strtod(temp, nullptr);
 525                 if(*value < loBound || *value > hiBound)
 526                 {
 527                     TrErrorAt(tr, tr->mLine, col, "Expected a value from %f to %f.\n", loBound, hiBound);
 528                     return 0;
 529                 }
 530                 return 1;
 531             }
 532         }
 533         else
 534             tr->mColumn += len;
 535     }
 536     TrErrorAt(tr, tr->mLine, col, "Expected a float.\n");
 537     return 0;
 538 }
 539
 540 // Reads and validates a string token.
 541 static int TrReadString(TokenReaderT *tr, const uint maxLen, char *text)
 542 {
 543     uint col, len;
 544     char ch;
 545
 546     col = tr->mColumn;
 547     if(TrSkipWhitespace(tr))
 548     {
 549         col = tr->mColumn;
 550         ch = tr->mRing[tr->mOut&TR_RING_MASK];
 551         if(ch == '\"')
 552         {
 553             tr->mOut++;
 554             len = 0;
 555             while(TrLoad(tr))
 556             {
 557                 ch = tr->mRing[tr->mOut&TR_RING_MASK];
 558                 tr->mOut++;
 559                 if(ch == '\"')
 560                     break;
 561                 if(ch == '\n')
 562                 {
 563                     TrErrorAt(tr, tr->mLine, col, "Unterminated string at end of line.\n");
 564                     return 0;
 565                 }
 566                 if(len < maxLen)
 567                     text[len] = ch;
 568                 len++;
 569             }
 570             if(ch != '\"')
 571             {
 572                 tr->mColumn += 1 + len;
 573                 TrErrorAt(tr, tr->mLine, col, "Unterminated string at end of input.\n");
 574                 return 0;
 575             }
 576             tr->mColumn += 2 + len;
 577             if(len > maxLen)
 578             {
 579                 TrErrorAt(tr, tr->mLine, col, "String is too long.\n");
 580                 return 0;
 581             }
 582             text[len] = '\0';
 583             return 1;
 584         }
 585     }
 586     TrErrorAt(tr, tr->mLine, col, "Expected a string.\n");
 587     return 0;
 588 }
 589
 590 // Reads and validates the given operator.
 591 static int TrReadOperator(TokenReaderT *tr, const char *op)
 592 {
 593     uint col, len;
 594     char ch;
 595
 596     col = tr->mColumn;
 597     if(TrSkipWhitespace(tr))
 598     {
 599         col = tr->mColumn;
 600         len = 0;
 601         while(op[len] != '\0' && TrLoad(tr))
 602         {
 603             ch = tr->mRing[tr->mOut&TR_RING_MASK];
 604             if(ch != op[len]) break;
 605             len++;
 606             tr->mOut++;
 607         }
 608         tr->mColumn += len;
 609         if(op[len] == '\0')
 610             return 1;
 611     }
 612     TrErrorAt(tr, tr->mLine, col, "Expected '%s' operator.\n", op);
 613     return 0;
 614 }
 615
 616
 617 /*************************
 618  *** File source input ***
 619  *************************/
 620
 621 // Read a binary value of the specified byte order and byte size from a file,
 622 // storing it as a 32-bit unsigned integer.
 623 static int ReadBin4(std::istream &istream, const char *filename, const ByteOrderT order, const uint bytes, uint32_t *out)
 624 {
 625     uint8_t in[4];
 626     istream.read(reinterpret_cast<char*>(in), static_cast<int>(bytes));
 627     if(istream.gcount() != bytes)
 628     {
 629         fprintf(stderr, "\nError: Bad read from file '%s'.\n", filename);
 630         return 0;
 631     }
 632     uint32_t accum{0};
 633     switch(order)
 634     {
 635         case BO_LITTLE:
 636             for(uint i = 0;i < bytes;i++)
 637                 accum = (accum<<8) | in[bytes - i - 1];
 638             break;
 639         case BO_BIG:
 640             for(uint i = 0;i < bytes;i++)
 641                 accum = (accum<<8) | in[i];
 642             break;
 643         default:
 644             break;
 645     }
 646     *out = accum;
 647     return 1;
 648 }
 649
 650 // Read a binary value of the specified byte order from a file, storing it as
 651 // a 64-bit unsigned integer.
 652 static int ReadBin8(std::istream &istream, const char *filename, const ByteOrderT order, uint64_t *out)
 653 {
 654     uint8_t in[8];
 655     uint64_t accum;
 656     uint i;
 657
 658     istream.read(reinterpret_cast<char*>(in), 8);
 659     if(istream.gcount() != 8)
 660     {
 661         fprintf(stderr, "\nError: Bad read from file '%s'.\n", filename);
 662         return 0;
 663     }
 664     accum = 0;
 665     switch(order)
 666     {
 667         case BO_LITTLE:
 668             for(i = 0;i < 8;i++)
 669                 accum = (accum<<8) | in[8 - i - 1];
 670             break;
 671         case BO_BIG:
 672             for(i = 0;i < 8;i++)
 673                 accum = (accum<<8) | in[i];
 674             break;
 675         default:
 676             break;
 677     }
 678     *out = accum;
 679     return 1;
 680 }
 681
 682 /* Read a binary value of the specified type, byte order, and byte size from
 683  * a file, converting it to a double.  For integer types, the significant
 684  * bits are used to normalize the result.  The sign of bits determines
 685  * whether they are padded toward the MSB (negative) or LSB (positive).
 686  * Floating-point types are not normalized.
 687  */
 688 static int ReadBinAsDouble(std::istream &istream, const char *filename, const ByteOrderT order,
 689     const ElementTypeT type, const uint bytes, const int bits, double *out)
 690 {
 691     union {
 692         uint32_t ui;
 693         int32_t i;
 694         float f;
 695     } v4;
 696     union {
 697         uint64_t ui;
 698         double f;
 699     } v8;
 700
 701     *out = 0.0;
 702     if(bytes > 4)
 703     {
 704         if(!ReadBin8(istream, filename, order, &v8.ui))
 705             return 0;
 706         if(type == ET_FP)
 707             *out = v8.f;
 708     }
 709     else
 710     {
 711         if(!ReadBin4(istream, filename, order, bytes, &v4.ui))
 712             return 0;
 713         if(type == ET_FP)
 714             *out = v4.f;
 715         else
 716         {
 717             if(bits > 0)
 718                 v4.ui >>= (8*bytes) - (static_cast<uint>(bits));
 719             else
 720                 v4.ui &= (0xFFFFFFFF >> (32+bits));
 721
 722             if(v4.ui&static_cast<uint>(1<<(std::abs(bits)-1)))
 723                 v4.ui |= (0xFFFFFFFF << std::abs(bits));
 724             *out = v4.i / static_cast<double>(1<<(std::abs(bits)-1));
 725         }
 726     }
 727     return 1;
 728 }
 729
 730 /* Read an ascii value of the specified type from a file, converting it to a
 731  * double.  For integer types, the significant bits are used to normalize the
 732  * result.  The sign of the bits should always be positive.  This also skips
 733  * up to one separator character before the element itself.
 734  */
 735 static int ReadAsciiAsDouble(TokenReaderT *tr, const char *filename, const ElementTypeT type, const uint bits, double *out)
 736 {
 737     if(TrIsOperator(tr, ","))
 738         TrReadOperator(tr, ",");
 739     else if(TrIsOperator(tr, ":"))
 740         TrReadOperator(tr, ":");
 741     else if(TrIsOperator(tr, ";"))
 742         TrReadOperator(tr, ";");
 743     else if(TrIsOperator(tr, "|"))
 744         TrReadOperator(tr, "|");
 745
 746     if(type == ET_FP)
 747     {
 748         if(!TrReadFloat(tr, -std::numeric_limits<double>::infinity(),
 749             std::numeric_limits<double>::infinity(), out))
 750         {
 751             fprintf(stderr, "\nError: Bad read from file '%s'.\n", filename);
 752             return 0;
 753         }
 754     }
 755     else
 756     {
 757         int v;
 758         if(!TrReadInt(tr, -(1<<(bits-1)), (1<<(bits-1))-1, &v))
 759         {
 760             fprintf(stderr, "\nError: Bad read from file '%s'.\n", filename);
 761             return 0;
 762         }
 763         *out = v / static_cast<double>((1<<(bits-1))-1);
 764     }
 765     return 1;
 766 }
 767
 768 // Read the RIFF/RIFX WAVE format chunk from a file, validating it against
 769 // the source parameters and data set metrics.
 770 static int ReadWaveFormat(std::istream &istream, const ByteOrderT order, const uint hrirRate,
 771     SourceRefT *src)
 772 {
 773     uint32_t fourCC, chunkSize;
 774     uint32_t format, channels, rate, dummy, block, size, bits;
 775
 776     chunkSize = 0;
 777     do {
 778         if(chunkSize > 0)
 779             istream.seekg(static_cast<int>(chunkSize), std::ios::cur);
 780         if(!ReadBin4(istream, src->mPath, BO_LITTLE, 4, &fourCC)
 781             || !ReadBin4(istream, src->mPath, order, 4, &chunkSize))
 782             return 0;
 783     } while(fourCC != FOURCC_FMT);
 784     if(!ReadBin4(istream, src->mPath, order, 2, &format)
 785         || !ReadBin4(istream, src->mPath, order, 2, &channels)
 786         || !ReadBin4(istream, src->mPath, order, 4, &rate)
 787         || !ReadBin4(istream, src->mPath, order, 4, &dummy)
 788         || !ReadBin4(istream, src->mPath, order, 2, &block))
 789         return 0;
 790     block /= channels;
 791     if(chunkSize > 14)
 792     {
 793         if(!ReadBin4(istream, src->mPath, order, 2, &size))
 794             return 0;
 795         size /= 8;
 796         if(block > size)
 797             size = block;
 798     }
 799     else
 800         size = block;
 801     if(format == WAVE_FORMAT_EXTENSIBLE)
 802     {
 803         istream.seekg(2, std::ios::cur);
 804         if(!ReadBin4(istream, src->mPath, order, 2, &bits))
 805             return 0;
 806         if(bits == 0)
 807             bits = 8 * size;
 808         istream.seekg(4, std::ios::cur);
 809         if(!ReadBin4(istream, src->mPath, order, 2, &format))
 810             return 0;
 811         istream.seekg(static_cast<int>(chunkSize - 26), std::ios::cur);
 812     }
 813     else
 814     {
 815         bits = 8 * size;
 816         if(chunkSize > 14)
 817             istream.seekg(static_cast<int>(chunkSize - 16), std::ios::cur);
 818         else
 819             istream.seekg(static_cast<int>(chunkSize - 14), std::ios::cur);
 820     }
 821     if(format != WAVE_FORMAT_PCM && format != WAVE_FORMAT_IEEE_FLOAT)
 822     {
 823         fprintf(stderr, "\nError: Unsupported WAVE format in file '%s'.\n", src->mPath);
 824         return 0;
 825     }
 826     if(src->mChannel >= channels)
 827     {
 828         fprintf(stderr, "\nError: Missing source channel in WAVE file '%s'.\n", src->mPath);
 829         return 0;
 830     }
 831     if(rate != hrirRate)
 832     {
 833         fprintf(stderr, "\nError: Mismatched source sample rate in WAVE file '%s'.\n", src->mPath);
 834         return 0;
 835     }
 836     if(format == WAVE_FORMAT_PCM)
 837     {
 838         if(size < 2 || size > 4)
 839         {
 840             fprintf(stderr, "\nError: Unsupported sample size in WAVE file '%s'.\n", src->mPath);
 841             return 0;
 842         }
 843         if(bits < 16 || bits > (8*size))
 844         {
 845             fprintf(stderr, "\nError: Bad significant bits in WAVE file '%s'.\n", src->mPath);
 846             return 0;
 847         }
 848         src->mType = ET_INT;
 849     }
 850     else
 851     {
 852         if(size != 4 && size != 8)
 853         {
 854             fprintf(stderr, "\nError: Unsupported sample size in WAVE file '%s'.\n", src->mPath);
 855             return 0;
 856         }
 857         src->mType = ET_FP;
 858     }
 859     src->mSize = size;
 860     src->mBits = static_cast<int>(bits);
 861     src->mSkip = channels;
 862     return 1;
 863 }
 864
 865 // Read a RIFF/RIFX WAVE data chunk, converting all elements to doubles.
 866 static int ReadWaveData(std::istream &istream, const SourceRefT *src, const ByteOrderT order,
 867     const uint n, double *hrir)
 868 {
 869     int pre, post, skip;
 870     uint i;
 871
 872     pre = static_cast<int>(src->mSize * src->mChannel);
 873     post = static_cast<int>(src->mSize * (src->mSkip - src->mChannel - 1));
 874     skip = 0;
 875     for(i = 0;i < n;i++)
 876     {
 877         skip += pre;
 878         if(skip > 0)
 879             istream.seekg(skip, std::ios::cur);
 880         if(!ReadBinAsDouble(istream, src->mPath, order, src->mType, src->mSize, src->mBits, &hrir[i]))
 881             return 0;
 882         skip = post;
 883     }
 884     if(skip > 0)
 885         istream.seekg(skip, std::ios::cur);
 886     return 1;
 887 }
 888
 889 // Read the RIFF/RIFX WAVE list or data chunk, converting all elements to
 890 // doubles.
 891 static int ReadWaveList(std::istream &istream, const SourceRefT *src, const ByteOrderT order,
 892     const uint n, double *hrir)
 893 {
 894     uint32_t fourCC, chunkSize, listSize, count;
 895     uint block, skip, offset, i;
 896     double lastSample;
 897
 898     for(;;)
 899     {
 900         if(!ReadBin4(istream, src->mPath, BO_LITTLE, 4, &fourCC)
 901             || !ReadBin4(istream, src->mPath, order, 4, &chunkSize))
 902             return 0;
 903
 904         if(fourCC == FOURCC_DATA)
 905         {
 906             block = src->mSize * src->mSkip;
 907             count = chunkSize / block;
 908             if(count < (src->mOffset + n))
 909             {
 910                 fprintf(stderr, "\nError: Bad read from file '%s'.\n", src->mPath);
 911                 return 0;
 912             }
 913             istream.seekg(static_cast<long>(src->mOffset * block), std::ios::cur);
 914             if(!ReadWaveData(istream, src, order, n, &hrir[0]))
 915                 return 0;
 916             return 1;
 917         }
 918         else if(fourCC == FOURCC_LIST)
 919         {
 920             if(!ReadBin4(istream, src->mPath, BO_LITTLE, 4, &fourCC))
 921                 return 0;
 922             chunkSize -= 4;
 923             if(fourCC == FOURCC_WAVL)
 924                 break;
 925         }
 926         if(chunkSize > 0)
 927             istream.seekg(static_cast<long>(chunkSize), std::ios::cur);
 928     }
 929     listSize = chunkSize;
 930     block = src->mSize * src->mSkip;
 931     skip = src->mOffset;
 932     offset = 0;
 933     lastSample = 0.0;
 934     while(offset < n && listSize > 8)
 935     {
 936         if(!ReadBin4(istream, src->mPath, BO_LITTLE, 4, &fourCC)
 937             || !ReadBin4(istream, src->mPath, order, 4, &chunkSize))
 938             return 0;
 939         listSize -= 8 + chunkSize;
 940         if(fourCC == FOURCC_DATA)
 941         {
 942             count = chunkSize / block;
 943             if(count > skip)
 944             {
 945                 istream.seekg(static_cast<long>(skip * block), std::ios::cur);
 946                 chunkSize -= skip * block;
 947                 count -= skip;
 948                 skip = 0;
 949                 if(count > (n - offset))
 950                     count = n - offset;
 951                 if(!ReadWaveData(istream, src, order, count, &hrir[offset]))
 952                     return 0;
 953                 chunkSize -= count * block;
 954                 offset += count;
 955                 lastSample = hrir[offset - 1];
 956             }
 957             else
 958             {
 959                 skip -= count;
 960                 count = 0;
 961             }
 962         }
 963         else if(fourCC == FOURCC_SLNT)
 964         {
 965             if(!ReadBin4(istream, src->mPath, order, 4, &count))
 966                 return 0;
 967             chunkSize -= 4;
 968             if(count > skip)
 969             {
 970                 count -= skip;
 971                 skip = 0;
 972                 if(count > (n - offset))
 973                     count = n - offset;
 974                 for(i = 0; i < count; i ++)
 975                     hrir[offset + i] = lastSample;
 976                 offset += count;
 977             }
 978             else
 979             {
 980                 skip -= count;
 981                 count = 0;
 982             }
 983         }
 984         if(chunkSize > 0)
 985             istream.seekg(static_cast<long>(chunkSize), std::ios::cur);
 986     }
 987     if(offset < n)
 988     {
 989         fprintf(stderr, "\nError: Bad read from file '%s'.\n", src->mPath);
 990         return 0;
 991     }
 992     return 1;
 993 }
 994
 995 // Load a source HRIR from an ASCII text file containing a list of elements
 996 // separated by whitespace or common list operators (',', ';', ':', '|').
 997 static int LoadAsciiSource(std::istream &istream, const SourceRefT *src,
 998     const uint n, double *hrir)
 999 {
1000     TokenReaderT tr{istream};
1001     uint i, j;
1002     double dummy;
1003
1004     TrSetup(nullptr, 0, nullptr, &tr);
1005     for(i = 0;i < src->mOffset;i++)
1006     {
1007         if(!ReadAsciiAsDouble(&tr, src->mPath, src->mType, static_cast<uint>(src->mBits), &dummy))
1008             return 0;
1009     }
1010     for(i = 0;i < n;i++)
1011     {
1012         if(!ReadAsciiAsDouble(&tr, src->mPath, src->mType, static_cast<uint>(src->mBits), &hrir[i]))
1013             return 0;
1014         for(j = 0;j < src->mSkip;j++)
1015         {
1016             if(!ReadAsciiAsDouble(&tr, src->mPath, src->mType, static_cast<uint>(src->mBits), &dummy))
1017                 return 0;
1018         }
1019     }
1020     return 1;
1021 }
1022
1023 // Load a source HRIR from a binary file.
1024 static int LoadBinarySource(std::istream &istream, const SourceRefT *src, const ByteOrderT order,
1025     const uint n, double *hrir)
1026 {
1027     istream.seekg(static_cast<long>(src->mOffset), std::ios::beg);
1028     for(uint i{0};i < n;i++)
1029     {
1030         if(!ReadBinAsDouble(istream, src->mPath, order, src->mType, src->mSize, src->mBits, &hrir[i]))
1031             return 0;
1032         if(src->mSkip > 0)
1033             istream.seekg(static_cast<long>(src->mSkip), std::ios::cur);
1034     }
1035     return 1;
1036 }
1037
1038 // Load a source HRIR from a RIFF/RIFX WAVE file.
1039 static int LoadWaveSource(std::istream &istream, SourceRefT *src, const uint hrirRate,
1040     const uint n, double *hrir)
1041 {
1042     uint32_t fourCC, dummy;
1043     ByteOrderT order;
1044
1045     if(!ReadBin4(istream, src->mPath, BO_LITTLE, 4, &fourCC)
1046         || !ReadBin4(istream, src->mPath, BO_LITTLE, 4, &dummy))
1047         return 0;
1048     if(fourCC == FOURCC_RIFF)
1049         order = BO_LITTLE;
1050     else if(fourCC == FOURCC_RIFX)
1051         order = BO_BIG;
1052     else
1053     {
1054         fprintf(stderr, "\nError: No RIFF/RIFX chunk in file '%s'.\n", src->mPath);
1055         return 0;
1056     }
1057
1058     if(!ReadBin4(istream, src->mPath, BO_LITTLE, 4, &fourCC))
1059         return 0;
1060     if(fourCC != FOURCC_WAVE)
1061     {
1062         fprintf(stderr, "\nError: Not a RIFF/RIFX WAVE file '%s'.\n", src->mPath);
1063         return 0;
1064     }
1065     if(!ReadWaveFormat(istream, order, hrirRate, src))
1066         return 0;
1067     if(!ReadWaveList(istream, src, order, n, hrir))
1068         return 0;
1069     return 1;
1070 }
1071
1072
1073
1074 // Load a Spatially Oriented Format for Accoustics (SOFA) file.
1075 static MYSOFA_EASY* LoadSofaFile(SourceRefT *src, const uint hrirRate, const uint n)
1076 {
1077     struct MYSOFA_EASY *sofa{mysofa_cache_lookup(src->mPath, static_cast<float>(hrirRate))};
1078     if(sofa) return sofa;
1079
1080     sofa = static_cast<MYSOFA_EASY*>(calloc(1, sizeof(*sofa)));
1081     if(sofa == nullptr)
1082     {
1083         fprintf(stderr, "\nError:  Out of memory.\n");
1084         return nullptr;
1085     }
1086     sofa->lookup = nullptr;
1087     sofa->neighborhood = nullptr;
1088
1089     int err;
1090     sofa->hrtf = mysofa_load(src->mPath, &err);
1091     if(!sofa->hrtf)
1092     {
1093         mysofa_close(sofa);
1094         fprintf(stderr, "\nError: Could not load source file '%s'.\n", src->mPath);
1095         return nullptr;
1096     }
1097     /* NOTE: Some valid SOFA files are failing this check. */
1098     err = mysofa_check(sofa->hrtf);
1099     if(err != MYSOFA_OK)
1100         fprintf(stderr, "\nWarning: Supposedly malformed source file '%s'.\n", src->mPath);
1101     if((src->mOffset + n) > sofa->hrtf->N)
1102     {
1103         mysofa_close(sofa);
1104         fprintf(stderr, "\nError: Not enough samples in SOFA file '%s'.\n", src->mPath);
1105         return nullptr;
1106     }
1107     if(src->mChannel >= sofa->hrtf->R)
1108     {
1109         mysofa_close(sofa);
1110         fprintf(stderr, "\nError: Missing source receiver in SOFA file '%s'.\n", src->mPath);
1111         return nullptr;
1112     }
1113     mysofa_tocartesian(sofa->hrtf);
1114     sofa->lookup = mysofa_lookup_init(sofa->hrtf);
1115     if(sofa->lookup == nullptr)
1116     {
1117         mysofa_close(sofa);
1118         fprintf(stderr, "\nError:  Out of memory.\n");
1119         return nullptr;
1120     }
1121     return mysofa_cache_store(sofa, src->mPath, static_cast<float>(hrirRate));
1122 }
1123
1124 // Copies the HRIR data from a particular SOFA measurement.
1125 static void ExtractSofaHrir(const MYSOFA_EASY *sofa, const uint index, const uint channel, const uint offset, const uint n, double *hrir)
1126 {
1127     for(uint i{0u};i < n;i++)
1128         hrir[i] = sofa->hrtf->DataIR.values[(index*sofa->hrtf->R + channel)*sofa->hrtf->N + offset + i];
1129 }
1130
1131 // Load a source HRIR from a Spatially Oriented Format for Accoustics (SOFA)
1132 // file.
1133 static int LoadSofaSource(SourceRefT *src, const uint hrirRate, const uint n, double *hrir)
1134 {
1135     struct MYSOFA_EASY *sofa;
1136     float target[3];
1137     int nearest;
1138     float *coords;
1139
1140     sofa = LoadSofaFile(src, hrirRate, n);
1141     if(sofa == nullptr)
1142         return 0;
1143
1144     /* NOTE: At some point it may be benficial or necessary to consider the
1145              various coordinate systems, listener/source orientations, and
1146              direciontal vectors defined in the SOFA file.
1147     */
1148     target[0] = static_cast<float>(src->mAzimuth);
1149     target[1] = static_cast<float>(src->mElevation);
1150     target[2] = static_cast<float>(src->mRadius);
1151     mysofa_s2c(target);
1152
1153     nearest = mysofa_lookup(sofa->lookup, target);
1154     if(nearest < 0)
1155     {
1156         fprintf(stderr, "\nError: Lookup failed in source file '%s'.\n", src->mPath);
1157         return 0;
1158     }
1159
1160     coords = &sofa->hrtf->SourcePosition.values[3 * nearest];
1161     if(std::abs(coords[0] - target[0]) > 0.001 || std::abs(coords[1] - target[1]) > 0.001 || std::abs(coords[2] - target[2]) > 0.001)
1162     {
1163         fprintf(stderr, "\nError: No impulse response at coordinates (%.3fr, %.1fev, %.1faz) in file '%s'.\n", src->mRadius, src->mElevation, src->mAzimuth, src->mPath);
1164         target[0] = coords[0];
1165         target[1] = coords[1];
1166         target[2] = coords[2];
1167         mysofa_c2s(target);
1168         fprintf(stderr, "       Nearest candidate at (%.3fr, %.1fev, %.1faz).\n", target[2], target[1], target[0]);
1169         return 0;
1170     }
1171
1172     ExtractSofaHrir(sofa, static_cast<uint>(nearest), src->mChannel, src->mOffset, n, hrir);
1173
1174     return 1;
1175 }
1176
1177 // Load a source HRIR from a supported file type.
1178 static int LoadSource(SourceRefT *src, const uint hrirRate, const uint n, double *hrir)
1179 {
1180     std::unique_ptr<al::ifstream> istream;
1181     if(src->mFormat != SF_SOFA)
1182     {
1183         if(src->mFormat == SF_ASCII)
1184             istream.reset(new al::ifstream{src->mPath});
1185         else
1186             istream.reset(new al::ifstream{src->mPath, std::ios::binary});
1187         if(!istream->good())
1188         {
1189             fprintf(stderr, "\nError: Could not open source file '%s'.\n", src->mPath);
1190             return 0;
1191         }
1192     }
1193     int result{0};
1194     switch(src->mFormat)
1195     {
1196         case SF_ASCII:
1197             result = LoadAsciiSource(*istream, src, n, hrir);
1198             break;
1199         case SF_BIN_LE:
1200             result = LoadBinarySource(*istream, src, BO_LITTLE, n, hrir);
1201             break;
1202         case SF_BIN_BE:
1203             result = LoadBinarySource(*istream, src, BO_BIG, n, hrir);
1204             break;
1205         case SF_WAVE:
1206             result = LoadWaveSource(*istream, src, hrirRate, n, hrir);
1207             break;
1208         case SF_SOFA:
1209             result = LoadSofaSource(src, hrirRate, n, hrir);
1210             break;
1211         case SF_NONE:
1212             break;
1213     }
1214     return result;
1215 }
1216
1217
1218 // Match the channel type from a given identifier.
1219 static ChannelTypeT MatchChannelType(const char *ident)
1220 {
1221     if(al::strcasecmp(ident, "mono") == 0)
1222         return CT_MONO;
1223     if(al::strcasecmp(ident, "stereo") == 0)
1224         return CT_STEREO;
1225     return CT_NONE;
1226 }
1227
1228
1229 // Process the data set definition to read and validate the data set metrics.
1230 static int ProcessMetrics(TokenReaderT *tr, const uint fftSize, const uint truncSize, const ChannelModeT chanMode, HrirDataT *hData)
1231 {
1232     int hasRate = 0, hasType = 0, hasPoints = 0, hasRadius = 0;
1233     int hasDistance = 0, hasAzimuths = 0;
1234     char ident[MAX_IDENT_LEN+1];
1235     uint line, col;
1236     double fpVal;
1237     uint points;
1238     int intVal;
1239     double distances[MAX_FD_COUNT];
1240     uint fdCount = 0;
1241     uint evCounts[MAX_FD_COUNT];
1242     std::vector<uint> azCounts(MAX_FD_COUNT * MAX_EV_COUNT);
1243
1244     TrIndication(tr, &line, &col);
1245     while(TrIsIdent(tr))
1246     {
1247         TrIndication(tr, &line, &col);
1248         if(!TrReadIdent(tr, MAX_IDENT_LEN, ident))
1249             return 0;
1250         if(al::strcasecmp(ident, "rate") == 0)
1251         {
1252             if(hasRate)
1253             {
1254                 TrErrorAt(tr, line, col, "Redefinition of 'rate'.\n");
1255                 return 0;
1256             }
1257             if(!TrReadOperator(tr, "="))
1258                 return 0;
1259             if(!TrReadInt(tr, MIN_RATE, MAX_RATE, &intVal))
1260                 return 0;
1261             hData->mIrRate = static_cast<uint>(intVal);
1262             hasRate = 1;
1263         }
1264         else if(al::strcasecmp(ident, "type") == 0)
1265         {
1266             char type[MAX_IDENT_LEN+1];
1267
1268             if(hasType)
1269             {
1270                 TrErrorAt(tr, line, col, "Redefinition of 'type'.\n");
1271                 return 0;
1272             }
1273             if(!TrReadOperator(tr, "="))
1274                 return 0;
1275
1276             if(!TrReadIdent(tr, MAX_IDENT_LEN, type))
1277                 return 0;
1278             hData->mChannelType = MatchChannelType(type);
1279             if(hData->mChannelType == CT_NONE)
1280             {
1281                 TrErrorAt(tr, line, col, "Expected a channel type.\n");
1282                 return 0;
1283             }
1284             else if(hData->mChannelType == CT_STEREO)
1285             {
1286                 if(chanMode == CM_ForceMono)
1287                     hData->mChannelType = CT_MONO;
1288             }
1289             hasType = 1;
1290         }
1291         else if(al::strcasecmp(ident, "points") == 0)
1292         {
1293             if(hasPoints)
1294             {
1295                 TrErrorAt(tr, line, col, "Redefinition of 'points'.\n");
1296                 return 0;
1297             }
1298             if(!TrReadOperator(tr, "="))
1299                 return 0;
1300             TrIndication(tr, &line, &col);
1301             if(!TrReadInt(tr, MIN_POINTS, MAX_POINTS, &intVal))
1302                 return 0;
1303             points = static_cast<uint>(intVal);
1304             if(fftSize > 0 && points > fftSize)
1305             {
1306                 TrErrorAt(tr, line, col, "Value exceeds the overridden FFT size.\n");
1307                 return 0;
1308             }
1309             if(points < truncSize)
1310             {
1311                 TrErrorAt(tr, line, col, "Value is below the truncation size.\n");
1312                 return 0;
1313             }
1314             hData->mIrPoints = points;
1315             hData->mFftSize = fftSize;
1316             hData->mIrSize = 1 + (fftSize / 2);
1317             if(points > hData->mIrSize)
1318                 hData->mIrSize = points;
1319             hasPoints = 1;
1320         }
1321         else if(al::strcasecmp(ident, "radius") == 0)
1322         {
1323             if(hasRadius)
1324             {
1325                 TrErrorAt(tr, line, col, "Redefinition of 'radius'.\n");
1326                 return 0;
1327             }
1328             if(!TrReadOperator(tr, "="))
1329                 return 0;
1330             if(!TrReadFloat(tr, MIN_RADIUS, MAX_RADIUS, &fpVal))
1331                 return 0;
1332             hData->mRadius = fpVal;
1333             hasRadius = 1;
1334         }
1335         else if(al::strcasecmp(ident, "distance") == 0)
1336         {
1337             uint count = 0;
1338
1339             if(hasDistance)
1340             {
1341                 TrErrorAt(tr, line, col, "Redefinition of 'distance'.\n");
1342                 return 0;
1343             }
1344             if(!TrReadOperator(tr, "="))
1345                 return 0;
1346
1347             for(;;)
1348             {
1349                 if(!TrReadFloat(tr, MIN_DISTANCE, MAX_DISTANCE, &fpVal))
1350                     return 0;
1351                 if(count > 0 && fpVal <= distances[count - 1])
1352                 {
1353                     TrError(tr, "Distances are not ascending.\n");
1354                     return 0;
1355                 }
1356                 distances[count++] = fpVal;
1357                 if(!TrIsOperator(tr, ","))
1358                     break;
1359                 if(count >= MAX_FD_COUNT)
1360                 {
1361                     TrError(tr, "Exceeded the maximum of %d fields.\n", MAX_FD_COUNT);
1362                     return 0;
1363                 }
1364                 TrReadOperator(tr, ",");
1365             }
1366             if(fdCount != 0 && count != fdCount)
1367             {
1368                 TrError(tr, "Did not match the specified number of %d fields.\n", fdCount);
1369                 return 0;
1370             }
1371             fdCount = count;
1372             hasDistance = 1;
1373         }
1374         else if(al::strcasecmp(ident, "azimuths") == 0)
1375         {
1376             uint count = 0;
1377
1378             if(hasAzimuths)
1379             {
1380                 TrErrorAt(tr, line, col, "Redefinition of 'azimuths'.\n");
1381                 return 0;
1382             }
1383             if(!TrReadOperator(tr, "="))
1384                 return 0;
1385
1386             evCounts[0] = 0;
1387             for(;;)
1388             {
1389                 if(!TrReadInt(tr, MIN_AZ_COUNT, MAX_AZ_COUNT, &intVal))
1390                     return 0;
1391                 azCounts[(count * MAX_EV_COUNT) + evCounts[count]++] = static_cast<uint>(intVal);
1392                 if(TrIsOperator(tr, ","))
1393                 {
1394                     if(evCounts[count] >= MAX_EV_COUNT)
1395                     {
1396                         TrError(tr, "Exceeded the maximum of %d elevations.\n", MAX_EV_COUNT);
1397                         return 0;
1398                     }
1399                     TrReadOperator(tr, ",");
1400                 }
1401                 else
1402                 {
1403                     if(evCounts[count] < MIN_EV_COUNT)
1404                     {
1405                         TrErrorAt(tr, line, col, "Did not reach the minimum of %d azimuth counts.\n", MIN_EV_COUNT);
1406                         return 0;
1407                     }
1408                     if(azCounts[count * MAX_EV_COUNT] != 1 || azCounts[(count * MAX_EV_COUNT) + evCounts[count] - 1] != 1)
1409                     {
1410                         TrError(tr, "Poles are not singular for field %d.\n", count - 1);
1411                         return 0;
1412                     }
1413                     count++;
1414                     if(!TrIsOperator(tr, ";"))
1415                         break;
1416
1417                     if(count >= MAX_FD_COUNT)
1418                     {
1419                         TrError(tr, "Exceeded the maximum number of %d fields.\n", MAX_FD_COUNT);
1420                         return 0;
1421                     }
1422                     evCounts[count] = 0;
1423                     TrReadOperator(tr, ";");
1424                 }
1425             }
1426             if(fdCount != 0 && count != fdCount)
1427             {
1428                 TrError(tr, "Did not match the specified number of %d fields.\n", fdCount);
1429                 return 0;
1430             }
1431             fdCount = count;
1432             hasAzimuths = 1;
1433         }
1434         else
1435         {
1436             TrErrorAt(tr, line, col, "Expected a metric name.\n");
1437             return 0;
1438         }
1439         TrSkipWhitespace(tr);
1440     }
1441     if(!(hasRate && hasPoints && hasRadius && hasDistance && hasAzimuths))
1442     {
1443         TrErrorAt(tr, line, col, "Expected a metric name.\n");
1444         return 0;
1445     }
1446     if(distances[0] < hData->mRadius)
1447     {
1448         TrError(tr, "Distance cannot start below head radius.\n");
1449         return 0;
1450     }
1451     if(hData->mChannelType == CT_NONE)
1452         hData->mChannelType = CT_MONO;
1453     if(!PrepareHrirData(fdCount, distances, evCounts, azCounts.data(), hData))
1454     {
1455         fprintf(stderr, "Error:  Out of memory.\n");
1456         exit(-1);
1457     }
1458     return 1;
1459 }
1460
1461 // Parse an index triplet from the data set definition.
1462 static int ReadIndexTriplet(TokenReaderT *tr, const HrirDataT *hData, uint *fi, uint *ei, uint *ai)
1463 {
1464     int intVal;
1465
1466     if(hData->mFdCount > 1)
1467     {
1468         if(!TrReadInt(tr, 0, static_cast<int>(hData->mFdCount) - 1, &intVal))
1469             return 0;
1470         *fi = static_cast<uint>(intVal);
1471         if(!TrReadOperator(tr, ","))
1472             return 0;
1473     }
1474     else
1475     {
1476         *fi = 0;
1477     }
1478     if(!TrReadInt(tr, 0, static_cast<int>(hData->mFds[*fi].mEvCount) - 1, &intVal))
1479         return 0;
1480     *ei = static_cast<uint>(intVal);
1481     if(!TrReadOperator(tr, ","))
1482         return 0;
1483     if(!TrReadInt(tr, 0, static_cast<int>(hData->mFds[*fi].mEvs[*ei].mAzCount) - 1, &intVal))
1484         return 0;
1485     *ai = static_cast<uint>(intVal);
1486     return 1;
1487 }
1488
1489 // Match the source format from a given identifier.
1490 static SourceFormatT MatchSourceFormat(const char *ident)
1491 {
1492     if(al::strcasecmp(ident, "ascii") == 0)
1493         return SF_ASCII;
1494     if(al::strcasecmp(ident, "bin_le") == 0)
1495         return SF_BIN_LE;
1496     if(al::strcasecmp(ident, "bin_be") == 0)
1497         return SF_BIN_BE;
1498     if(al::strcasecmp(ident, "wave") == 0)
1499         return SF_WAVE;
1500     if(al::strcasecmp(ident, "sofa") == 0)
1501         return SF_SOFA;
1502     return SF_NONE;
1503 }
1504
1505 // Match the source element type from a given identifier.
1506 static ElementTypeT MatchElementType(const char *ident)
1507 {
1508     if(al::strcasecmp(ident, "int") == 0)
1509         return ET_INT;
1510     if(al::strcasecmp(ident, "fp") == 0)
1511         return ET_FP;
1512     return ET_NONE;
1513 }
1514
1515 // Parse and validate a source reference from the data set definition.
1516 static int ReadSourceRef(TokenReaderT *tr, SourceRefT *src)
1517 {
1518     char ident[MAX_IDENT_LEN+1];
1519     uint line, col;
1520     double fpVal;
1521     int intVal;
1522
1523     TrIndication(tr, &line, &col);
1524     if(!TrReadIdent(tr, MAX_IDENT_LEN, ident))
1525         return 0;
1526     src->mFormat = MatchSourceFormat(ident);
1527     if(src->mFormat == SF_NONE)
1528     {
1529         TrErrorAt(tr, line, col, "Expected a source format.\n");
1530         return 0;
1531     }
1532     if(!TrReadOperator(tr, "("))
1533         return 0;
1534     if(src->mFormat == SF_SOFA)
1535     {
1536         if(!TrReadFloat(tr, MIN_DISTANCE, MAX_DISTANCE, &fpVal))
1537             return 0;
1538         src->mRadius = fpVal;
1539         if(!TrReadOperator(tr, ","))
1540             return 0;
1541         if(!TrReadFloat(tr, -90.0, 90.0, &fpVal))
1542             return 0;
1543         src->mElevation = fpVal;
1544         if(!TrReadOperator(tr, ","))
1545             return 0;
1546         if(!TrReadFloat(tr, -360.0, 360.0, &fpVal))
1547             return 0;
1548         src->mAzimuth = fpVal;
1549         if(!TrReadOperator(tr, ":"))
1550             return 0;
1551         if(!TrReadInt(tr, 0, MAX_WAVE_CHANNELS, &intVal))
1552             return 0;
1553         src->mType = ET_NONE;
1554         src->mSize = 0;
1555         src->mBits = 0;
1556         src->mChannel = static_cast<uint>(intVal);
1557         src->mSkip = 0;
1558     }
1559     else if(src->mFormat == SF_WAVE)
1560     {
1561         if(!TrReadInt(tr, 0, MAX_WAVE_CHANNELS, &intVal))
1562             return 0;
1563         src->mType = ET_NONE;
1564         src->mSize = 0;
1565         src->mBits = 0;
1566         src->mChannel = static_cast<uint>(intVal);
1567         src->mSkip = 0;
1568     }
1569     else
1570     {
1571         TrIndication(tr, &line, &col);
1572         if(!TrReadIdent(tr, MAX_IDENT_LEN, ident))
1573             return 0;
1574         src->mType = MatchElementType(ident);
1575         if(src->mType == ET_NONE)
1576         {
1577             TrErrorAt(tr, line, col, "Expected a source element type.\n");
1578             return 0;
1579         }
1580         if(src->mFormat == SF_BIN_LE || src->mFormat == SF_BIN_BE)
1581         {
1582             if(!TrReadOperator(tr, ","))
1583                 return 0;
1584             if(src->mType == ET_INT)
1585             {
1586                 if(!TrReadInt(tr, MIN_BIN_SIZE, MAX_BIN_SIZE, &intVal))
1587                     return 0;
1588                 src->mSize = static_cast<uint>(intVal);
1589                 if(!TrIsOperator(tr, ","))
1590                     src->mBits = static_cast<int>(8*src->mSize);
1591                 else
1592                 {
1593                     TrReadOperator(tr, ",");
1594                     TrIndication(tr, &line, &col);
1595                     if(!TrReadInt(tr, -2147483647-1, 2147483647, &intVal))
1596                         return 0;
1597                     if(std::abs(intVal) < MIN_BIN_BITS || static_cast<uint>(std::abs(intVal)) > (8*src->mSize))
1598                     {
1599                         TrErrorAt(tr, line, col, "Expected a value of (+/-) %d to %d.\n", MIN_BIN_BITS, 8*src->mSize);
1600                         return 0;
1601                     }
1602                     src->mBits = intVal;
1603                 }
1604             }
1605             else
1606             {
1607                 TrIndication(tr, &line, &col);
1608                 if(!TrReadInt(tr, -2147483647-1, 2147483647, &intVal))
1609                     return 0;
1610                 if(intVal != 4 && intVal != 8)
1611                 {
1612                     TrErrorAt(tr, line, col, "Expected a value of 4 or 8.\n");
1613                     return 0;
1614                 }
1615                 src->mSize = static_cast<uint>(intVal);
1616                 src->mBits = 0;
1617             }
1618         }
1619         else if(src->mFormat == SF_ASCII && src->mType == ET_INT)
1620         {
1621             if(!TrReadOperator(tr, ","))
1622                 return 0;
1623             if(!TrReadInt(tr, MIN_ASCII_BITS, MAX_ASCII_BITS, &intVal))
1624                 return 0;
1625             src->mSize = 0;
1626             src->mBits = intVal;
1627         }
1628         else
1629         {
1630             src->mSize = 0;
1631             src->mBits = 0;
1632         }
1633
1634         if(!TrIsOperator(tr, ";"))
1635             src->mSkip = 0;
1636         else
1637         {
1638             TrReadOperator(tr, ";");
1639             if(!TrReadInt(tr, 0, 0x7FFFFFFF, &intVal))
1640                 return 0;
1641             src->mSkip = static_cast<uint>(intVal);
1642         }
1643     }
1644     if(!TrReadOperator(tr, ")"))
1645         return 0;
1646     if(TrIsOperator(tr, "@"))
1647     {
1648         TrReadOperator(tr, "@");
1649         if(!TrReadInt(tr, 0, 0x7FFFFFFF, &intVal))
1650             return 0;
1651         src->mOffset = static_cast<uint>(intVal);
1652     }
1653     else
1654         src->mOffset = 0;
1655     if(!TrReadOperator(tr, ":"))
1656         return 0;
1657     if(!TrReadString(tr, MAX_PATH_LEN, src->mPath))
1658         return 0;
1659     return 1;
1660 }
1661
1662 // Parse and validate a SOFA source reference from the data set definition.
1663 static int ReadSofaRef(TokenReaderT *tr, SourceRefT *src)
1664 {
1665     char ident[MAX_IDENT_LEN+1];
1666     uint line, col;
1667     int intVal;
1668
1669     TrIndication(tr, &line, &col);
1670     if(!TrReadIdent(tr, MAX_IDENT_LEN, ident))
1671         return 0;
1672     src->mFormat = MatchSourceFormat(ident);
1673     if(src->mFormat != SF_SOFA)
1674     {
1675         TrErrorAt(tr, line, col, "Expected the SOFA source format.\n");
1676         return 0;
1677     }
1678
1679     src->mType = ET_NONE;
1680     src->mSize = 0;
1681     src->mBits = 0;
1682     src->mChannel = 0;
1683     src->mSkip = 0;
1684
1685     if(TrIsOperator(tr, "@"))
1686     {
1687         TrReadOperator(tr, "@");
1688         if(!TrReadInt(tr, 0, 0x7FFFFFFF, &intVal))
1689             return 0;
1690         src->mOffset = static_cast<uint>(intVal);
1691     }
1692     else
1693         src->mOffset = 0;
1694     if(!TrReadOperator(tr, ":"))
1695         return 0;
1696     if(!TrReadString(tr, MAX_PATH_LEN, src->mPath))
1697         return 0;
1698     return 1;
1699 }
1700
1701 // Match the target ear (index) from a given identifier.
1702 static int MatchTargetEar(const char *ident)
1703 {
1704     if(al::strcasecmp(ident, "left") == 0)
1705         return 0;
1706     if(al::strcasecmp(ident, "right") == 0)
1707         return 1;
1708     return -1;
1709 }
1710
1711 // Calculate the onset time of an HRIR and average it with any existing
1712 // timing for its field, elevation, azimuth, and ear.
1713 static constexpr int OnsetRateMultiple{10};
1714 static double AverageHrirOnset(PPhaseResampler &rs, al::span<double> upsampled, const uint rate,
1715     const uint n, const double *hrir, const double f, const double onset)
1716 {
1717     rs.process(n, hrir, static_cast<uint>(upsampled.size()), upsampled.data());
1718
1719     auto abs_lt = [](const double &lhs, const double &rhs) -> bool
1720     { return std::abs(lhs) < std::abs(rhs); };
1721     auto iter = std::max_element(upsampled.cbegin(), upsampled.cend(), abs_lt);
1722     return Lerp(onset, static_cast<double>(std::distance(upsampled.cbegin(), iter))/(10*rate), f);
1723 }
1724
1725 // Calculate the magnitude response of an HRIR and average it with any
1726 // existing responses for its field, elevation, azimuth, and ear.
1727 static void AverageHrirMagnitude(const uint points, const uint n, const double *hrir, const double f, double *mag)
1728 {
1729     uint m = 1 + (n / 2), i;
1730     std::vector<complex_d> h(n);
1731     std::vector<double> r(n);
1732
1733     for(i = 0;i < points;i++)
1734         h[i] = hrir[i];
1735     for(;i < n;i++)
1736         h[i] = 0.0;
1737     FftForward(n, h.data());
1738     MagnitudeResponse(n, h.data(), r.data());
1739     for(i = 0;i < m;i++)
1740         mag[i] = Lerp(mag[i], r[i], f);
1741 }
1742
1743 // Process the list of sources in the data set definition.
1744 static int ProcessSources(TokenReaderT *tr, HrirDataT *hData, const uint outRate)
1745 {
1746     uint channels = (hData->mChannelType == CT_STEREO) ? 2 : 1;
1747     hData->mHrirsBase.resize(channels * hData->mIrCount * hData->mIrSize);
1748     double *hrirs = hData->mHrirsBase.data();
1749     auto hrir = std::make_unique<double[]>(hData->mIrSize);
1750     uint line, col, fi, ei, ai;
1751     int count;
1752
1753     std::vector<double> onsetSamples(OnsetRateMultiple * hData->mIrPoints);
1754     PPhaseResampler onsetResampler;
1755     onsetResampler.init(hData->mIrRate, OnsetRateMultiple*hData->mIrRate);
1756
1757     al::optional<PPhaseResampler> resampler;
1758     if(outRate && outRate != hData->mIrRate)
1759         resampler.emplace().init(hData->mIrRate, outRate);
1760     const double rateScale{outRate ? static_cast<double>(outRate) / hData->mIrRate : 1.0};
1761     const uint irPoints{outRate
1762         ? std::min(static_cast<uint>(std::ceil(hData->mIrPoints*rateScale)), hData->mIrPoints)
1763         : hData->mIrPoints};
1764
1765     printf("Loading sources...");
1766     fflush(stdout);
1767     count = 0;
1768     while(TrIsOperator(tr, "["))
1769     {
1770         double factor[2]{ 1.0, 1.0 };
1771
1772         TrIndication(tr, &line, &col);
1773         TrReadOperator(tr, "[");
1774
1775         if(TrIsOperator(tr, "*"))
1776         {
1777             SourceRefT src;
1778             struct MYSOFA_EASY *sofa;
1779             uint si;
1780
1781             TrReadOperator(tr, "*");
1782             if(!TrReadOperator(tr, "]") || !TrReadOperator(tr, "="))
1783                 return 0;
1784
1785             TrIndication(tr, &line, &col);
1786             if(!ReadSofaRef(tr, &src))
1787                 return 0;
1788
1789             if(hData->mChannelType == CT_STEREO)
1790             {
1791                 char type[MAX_IDENT_LEN+1];
1792                 ChannelTypeT channelType;
1793
1794                 if(!TrReadIdent(tr, MAX_IDENT_LEN, type))
1795                     return 0;
1796
1797                 channelType = MatchChannelType(type);
1798
1799                 switch(channelType)
1800                 {
1801                     case CT_NONE:
1802                         TrErrorAt(tr, line, col, "Expected a channel type.\n");
1803                         return 0;
1804                     case CT_MONO:
1805                         src.mChannel = 0;
1806                         break;
1807                     case CT_STEREO:
1808                         src.mChannel = 1;
1809                         break;
1810                 }
1811             }
1812             else
1813             {
1814                 char type[MAX_IDENT_LEN+1];
1815                 ChannelTypeT channelType;
1816
1817                 if(!TrReadIdent(tr, MAX_IDENT_LEN, type))
1818                     return 0;
1819
1820                 channelType = MatchChannelType(type);
1821                 if(channelType != CT_MONO)
1822                 {
1823                     TrErrorAt(tr, line, col, "Expected a mono channel type.\n");
1824                     return 0;
1825                 }
1826                 src.mChannel = 0;
1827             }
1828
1829             sofa = LoadSofaFile(&src, hData->mIrRate, hData->mIrPoints);
1830             if(!sofa) return 0;
1831
1832             for(si = 0;si < sofa->hrtf->M;si++)
1833             {
1834                 printf("\rLoading sources... %d of %d", si+1, sofa->hrtf->M);
1835                 fflush(stdout);
1836
1837                 float aer[3] = {
1838                     sofa->hrtf->SourcePosition.values[3*si],
1839                     sofa->hrtf->SourcePosition.values[3*si + 1],
1840                     sofa->hrtf->SourcePosition.values[3*si + 2]
1841                 };
1842                 mysofa_c2s(aer);
1843
1844                 if(std::fabs(aer[1]) >= 89.999f)
1845                     aer[0] = 0.0f;
1846                 else
1847                     aer[0] = std::fmod(360.0f - aer[0], 360.0f);
1848
1849                 for(fi = 0;fi < hData->mFdCount;fi++)
1850                 {
1851                     double delta = aer[2] - hData->mFds[fi].mDistance;
1852                     if(std::abs(delta) < 0.001) break;
1853                 }
1854                 if(fi >= hData->mFdCount)
1855                     continue;
1856
1857                 double ef{(90.0 + aer[1]) / 180.0 * (hData->mFds[fi].mEvCount - 1)};
1858                 ei = static_cast<uint>(std::round(ef));
1859                 ef = (ef - ei) * 180.0 / (hData->mFds[fi].mEvCount - 1);
1860                 if(std::abs(ef) >= 0.1)
1861                     continue;
1862
1863                 double af{aer[0] / 360.0 * hData->mFds[fi].mEvs[ei].mAzCount};
1864                 ai = static_cast<uint>(std::round(af));
1865                 af = (af - ai) * 360.0 / hData->mFds[fi].mEvs[ei].mAzCount;
1866                 ai = ai % hData->mFds[fi].mEvs[ei].mAzCount;
1867                 if(std::abs(af) >= 0.1)
1868                     continue;
1869
1870                 HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
1871                 if(azd->mIrs[0] != nullptr)
1872                 {
1873                     TrErrorAt(tr, line, col, "Redefinition of source [ %d, %d, %d ].\n", fi, ei, ai);
1874                     return 0;
1875                 }
1876
1877                 ExtractSofaHrir(sofa, si, 0, src.mOffset, hData->mIrPoints, hrir.get());
1878                 azd->mIrs[0] = &hrirs[hData->mIrSize * azd->mIndex];
1879                 azd->mDelays[0] = AverageHrirOnset(onsetResampler, onsetSamples, hData->mIrRate,
1880                     hData->mIrPoints, hrir.get(), 1.0, azd->mDelays[0]);
1881                 if(resampler)
1882                     resampler->process(hData->mIrPoints, hrir.get(), hData->mIrSize, hrir.get());
1883                 AverageHrirMagnitude(irPoints, hData->mFftSize, hrir.get(), 1.0, azd->mIrs[0]);
1884
1885                 if(src.mChannel == 1)
1886                 {
1887                     ExtractSofaHrir(sofa, si, 1, src.mOffset, hData->mIrPoints, hrir.get());
1888                     azd->mIrs[1] = &hrirs[hData->mIrSize * (hData->mIrCount + azd->mIndex)];
1889                     azd->mDelays[1] = AverageHrirOnset(onsetResampler, onsetSamples,
1890                         hData->mIrRate, hData->mIrPoints, hrir.get(), 1.0, azd->mDelays[1]);
1891                     if(resampler)
1892                         resampler->process(hData->mIrPoints, hrir.get(), hData->mIrSize,
1893                             hrir.get());
1894                     AverageHrirMagnitude(irPoints, hData->mFftSize, hrir.get(), 1.0, azd->mIrs[1]);
1895                 }
1896
1897                 // TODO: Since some SOFA files contain minimum phase HRIRs,
1898                 // it would be beneficial to check for per-measurement delays
1899                 // (when available) to reconstruct the HRTDs.
1900             }
1901
1902             continue;
1903         }
1904
1905         if(!ReadIndexTriplet(tr, hData, &fi, &ei, &ai))
1906             return 0;
1907         if(!TrReadOperator(tr, "]"))
1908             return 0;
1909         HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
1910
1911         if(azd->mIrs[0] != nullptr)
1912         {
1913             TrErrorAt(tr, line, col, "Redefinition of source.\n");
1914             return 0;
1915         }
1916         if(!TrReadOperator(tr, "="))
1917             return 0;
1918
1919         for(;;)
1920         {
1921             SourceRefT src;
1922
1923             if(!ReadSourceRef(tr, &src))
1924                 return 0;
1925
1926             // TODO: Would be nice to display 'x of y files', but that would
1927             // require preparing the source refs first to get a total count
1928             // before loading them.
1929             ++count;
1930             printf("\rLoading sources... %d file%s", count, (count==1)?"":"s");
1931             fflush(stdout);
1932
1933             if(!LoadSource(&src, hData->mIrRate, hData->mIrPoints, hrir.get()))
1934                 return 0;
1935
1936             uint ti{0};
1937             if(hData->mChannelType == CT_STEREO)
1938             {
1939                 char ident[MAX_IDENT_LEN+1];
1940
1941                 if(!TrReadIdent(tr, MAX_IDENT_LEN, ident))
1942                     return 0;
1943                 ti = static_cast<uint>(MatchTargetEar(ident));
1944                 if(static_cast<int>(ti) < 0)
1945                 {
1946                     TrErrorAt(tr, line, col, "Expected a target ear.\n");
1947                     return 0;
1948                 }
1949             }
1950             azd->mIrs[ti] = &hrirs[hData->mIrSize * (ti * hData->mIrCount + azd->mIndex)];
1951             azd->mDelays[ti] = AverageHrirOnset(onsetResampler, onsetSamples, hData->mIrRate,
1952                 hData->mIrPoints, hrir.get(), 1.0 / factor[ti], azd->mDelays[ti]);
1953             if(resampler)
1954                 resampler->process(hData->mIrPoints, hrir.get(), hData->mIrSize, hrir.get());
1955             AverageHrirMagnitude(irPoints, hData->mFftSize, hrir.get(), 1.0 / factor[ti],
1956                 azd->mIrs[ti]);
1957             factor[ti] += 1.0;
1958             if(!TrIsOperator(tr, "+"))
1959                 break;
1960             TrReadOperator(tr, "+");
1961         }
1962         if(hData->mChannelType == CT_STEREO)
1963         {
1964             if(azd->mIrs[0] == nullptr)
1965             {
1966                 TrErrorAt(tr, line, col, "Missing left ear source reference(s).\n");
1967                 return 0;
1968             }
1969             else if(azd->mIrs[1] == nullptr)
1970             {
1971                 TrErrorAt(tr, line, col, "Missing right ear source reference(s).\n");
1972                 return 0;
1973             }
1974         }
1975     }
1976     printf("\n");
1977     hrir = nullptr;
1978     if(resampler)
1979     {
1980         hData->mIrRate = outRate;
1981         hData->mIrPoints = irPoints;
1982         resampler.reset();
1983     }
1984     for(fi = 0;fi < hData->mFdCount;fi++)
1985     {
1986         for(ei = 0;ei < hData->mFds[fi].mEvCount;ei++)
1987         {
1988             for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
1989             {
1990                 HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
1991                 if(azd->mIrs[0] != nullptr)
1992                     break;
1993             }
1994             if(ai < hData->mFds[fi].mEvs[ei].mAzCount)
1995                 break;
1996         }
1997         if(ei >= hData->mFds[fi].mEvCount)
1998         {
1999             TrError(tr, "Missing source references [ %d, *, * ].\n", fi);
2000             return 0;
2001         }
2002         hData->mFds[fi].mEvStart = ei;
2003         for(;ei < hData->mFds[fi].mEvCount;ei++)
2004         {
2005             for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
2006             {
2007                 HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
2008
2009                 if(azd->mIrs[0] == nullptr)
2010                 {
2011                     TrError(tr, "Missing source reference [ %d, %d, %d ].\n", fi, ei, ai);
2012                     return 0;
2013                 }
2014             }
2015         }
2016     }
2017     for(uint ti{0};ti < channels;ti++)
2018     {
2019         for(fi = 0;fi < hData->mFdCount;fi++)
2020         {
2021             for(ei = 0;ei < hData->mFds[fi].mEvCount;ei++)
2022             {
2023                 for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzCount;ai++)
2024                 {
2025                     HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
2026
2027                     azd->mIrs[ti] = &hrirs[hData->mIrSize * (ti * hData->mIrCount + azd->mIndex)];
2028                 }
2029             }
2030         }
2031     }
2032     if(!TrLoad(tr))
2033     {
2034         mysofa_cache_release_all();
2035         return 1;
2036     }
2037
2038     TrError(tr, "Errant data at end of source list.\n");
2039     mysofa_cache_release_all();
2040     return 0;
2041 }
2042
2043
2044 bool LoadDefInput(std::istream &istream, const char *startbytes, std::streamsize startbytecount,
2045     const char *filename, const uint fftSize, const uint truncSize, const uint outRate,
2046     const ChannelModeT chanMode, HrirDataT *hData)
2047 {
2048     TokenReaderT tr{istream};
2049
2050     TrSetup(startbytes, startbytecount, filename, &tr);
2051     if(!ProcessMetrics(&tr, fftSize, truncSize, chanMode, hData)
2052         || !ProcessSources(&tr, hData, outRate))
2053         return false;
2054
2055     return true;
2056 }