summaryrefslogtreecommitdiffstats
path: root/utils
diff options
context:
space:
mode:
authorChris Robinson <[email protected]>2012-11-18 09:29:58 -0800
committerChris Robinson <[email protected]>2012-11-18 09:29:58 -0800
commit2d800e99e269a87bb938920e406f37207c3b428f (patch)
tree755741008394da34f8cf999a832de87e3276ff73 /utils
parent0518ecca14ee166d04d53aecc8e737b28e7f9810 (diff)
Fix off-by-one error in the makehrtf dither and add a resample option
Also fixes some size_t type warnings
Diffstat (limited to 'utils')
-rw-r--r--utils/makehrtf.c517
1 files changed, 389 insertions, 128 deletions
diff --git a/utils/makehrtf.c b/utils/makehrtf.c
index d3917d5d..592f7316 100644
--- a/utils/makehrtf.c
+++ b/utils/makehrtf.c
@@ -49,6 +49,13 @@
* Music 150, Musical Acoustics, Stanford University
* December 2, 2001
*
+ * The formulae for calculating the Kaiser window metrics are from the
+ * the textbook:
+ *
+ * Discrete-Time Signal Processing
+ * Alan V. Oppenheim and Ronald W. Schafer
+ * Prentice-Hall Signal Processing Series
+ * 1999
*/
/* Needed for 64-bit unsigned integer. */
@@ -65,11 +72,11 @@
#include "AL/al.h"
#ifndef M_PI
-#define M_PI 3.14159265358979323846
+#define M_PI (3.14159265358979323846)
#endif
#ifndef HUGE_VAL
-#define HUGE_VAL (1.0/0.0)
+#define HUGE_VAL (1.0 / 0.0)
#endif
// The epsilon used to maintain signal stability.
@@ -90,7 +97,8 @@
// The maximum path length used when processing filenames.
#define MAX_PATH_LEN (256)
-// The limits for the sample 'rate' metric in the data set definition.
+// The limits for the sample 'rate' metric in the data set definition and for
+// resampling.
#define MIN_RATE (32000)
#define MAX_RATE (96000)
@@ -236,6 +244,7 @@ typedef enum OutputFormatT OutputFormatT;
typedef struct TokenReaderT TokenReaderT;
typedef struct SourceRefT SourceRefT;
typedef struct HrirDataT HrirDataT;
+typedef struct ResamplerT ResamplerT;
// Token reader state for parsing the data set definition.
struct TokenReaderT {
@@ -264,11 +273,11 @@ struct SourceRefT {
// the resulting HRTF.
struct HrirDataT {
uint mIrRate,
- mIrCount;
- size_t mIrSize,
+ mIrCount,
+ mIrSize,
mIrPoints,
- mFftSize;
- uint mEvCount,
+ mFftSize,
+ mEvCount,
mEvStart,
mAzCount [MAX_EV_COUNT],
mEvOffset [MAX_EV_COUNT];
@@ -279,6 +288,15 @@ struct HrirDataT {
mMaxHrtd;
};
+// The resampler metrics and FIR filter.
+struct ResamplerT {
+ uint mP,
+ mQ,
+ mM,
+ mL;
+ double * mF;
+};
+
/* Token reader routines for parsing text files. Whitespace is not
* significant. It can process tokens as identifiers, numbers (integer and
* floating-point), strings, and operators. Strings must be encapsulated by
@@ -338,7 +356,7 @@ static int TrLoad (TokenReaderT * tr) {
// Error display routine. Only displays when the base name is not NULL.
static void TrErrorVA (const TokenReaderT * tr, uint line, uint column, const char * format, va_list argPtr) {
if (tr -> mName != NULL) {
- fprintf (stderr, "Error (%s:%d:%d): ", tr -> mName, line, column);
+ fprintf (stderr, "Error (%s:%u:%u): ", tr -> mName, line, column);
vfprintf (stderr, format, argPtr);
}
}
@@ -437,9 +455,8 @@ static int TrIsOperator (TokenReaderT * tr, const char * op) {
*/
// Reads and validates an identifier token.
-static int TrReadIdent (TokenReaderT * tr, const size_t maxLen, char * ident) {
- uint col;
- size_t len;
+static int TrReadIdent (TokenReaderT * tr, const uint maxLen, char * ident) {
+ uint col, len;
char ch;
col = tr -> mColumn;
@@ -472,8 +489,7 @@ static int TrReadIdent (TokenReaderT * tr, const size_t maxLen, char * ident) {
// Reads and validates (including bounds) an integer token.
static int TrReadInt (TokenReaderT * tr, const int loBound, const int hiBound, int * value) {
- uint col, digis;
- size_t len;
+ uint col, digis, len;
char ch, temp [64 + 1];
col = tr -> mColumn;
@@ -518,8 +534,7 @@ static int TrReadInt (TokenReaderT * tr, const int loBound, const int hiBound, i
// Reads and validates (including bounds) a float token.
static int TrReadFloat (TokenReaderT * tr, const double loBound, const double hiBound, double * value) {
- uint col, digis;
- size_t len;
+ uint col, digis, len;
char ch, temp [64 + 1];
col = tr -> mColumn;
@@ -606,9 +621,8 @@ static int TrReadFloat (TokenReaderT * tr, const double loBound, const double hi
}
// Reads and validates a string token.
-static int TrReadString (TokenReaderT * tr, const size_t maxLen, char * text) {
- uint col;
- size_t len;
+static int TrReadString (TokenReaderT * tr, const uint maxLen, char * text) {
+ uint col, len;
char ch;
col = tr -> mColumn;
@@ -651,8 +665,7 @@ static int TrReadString (TokenReaderT * tr, const size_t maxLen, char * text) {
// Reads and validates the given operator.
static int TrReadOperator (TokenReaderT * tr, const char * op) {
- uint col;
- size_t len;
+ uint col, len;
char ch;
col = tr -> mColumn;
@@ -741,7 +754,7 @@ static double Lerp (const double a, const double b, const double f) {
// Performs a high-passed triangular probability density function dither from
// a double to an integer. It assumes the input sample is already scaled.
static int HpTpdfDither (const double in, int * hpHist) {
- const double PRNG_SCALE = 1.0 / RAND_MAX;
+ const double PRNG_SCALE = 1.0 / (RAND_MAX + 1.0);
int prn;
double out;
@@ -796,8 +809,8 @@ static void ComplexExp (const double inR, const double inI, double * outR, doubl
*/
// Performs bit-reversal ordering.
-static void FftArrange (const size_t n, const double * inR, const double * inI, double * outR, double * outI) {
- size_t rk, k, m;
+static void FftArrange (const uint n, const double * inR, const double * inI, double * outR, double * outI) {
+ uint rk, k, m;
double tempR, tempI;
if ((inR == outR) && (inI == outI)) {
@@ -832,11 +845,11 @@ static void FftArrange (const size_t n, const double * inR, const double * inI,
}
// Performs the summation.
-static void FftSummation (const size_t n, const double s, double * re, double * im) {
+static void FftSummation (const uint n, const double s, double * re, double * im) {
double pi;
- size_t m, m2;
+ uint m, m2;
double vR, vI, wR, wI;
- size_t i, k, mk;
+ uint i, k, mk;
double tR, tI;
pi = s * M_PI;
@@ -872,15 +885,15 @@ static void FftSummation (const size_t n, const double s, double * re, double *
}
// Performs a forward FFT.
-static void FftForward (const size_t n, const double * inR, const double * inI, double * outR, double * outI) {
+static void FftForward (const uint n, const double * inR, const double * inI, double * outR, double * outI) {
FftArrange (n, inR, inI, outR, outI);
FftSummation (n, 1.0, outR, outI);
}
// Performs an inverse FFT.
-static void FftInverse (const size_t n, const double * inR, const double * inI, double * outR, double * outI) {
+static void FftInverse (const uint n, const double * inR, const double * inI, double * outR, double * outI) {
double f;
- size_t i;
+ uint i;
FftArrange (n, inR, inI, outR, outI);
FftSummation (n, -1.0, outR, outI);
@@ -896,8 +909,8 @@ static void FftInverse (const size_t n, const double * inR, const double * inI,
* negative natural logarithm of a signal's magnitude response, the imaginary
* components can be used as the angles for minimum-phase reconstruction.
*/
-static void Hilbert (const size_t n, const double * in, double * outR, double * outI) {
- size_t i;
+static void Hilbert (const uint n, const double * in, double * outR, double * outI) {
+ uint i;
if (in == outR) {
// Handle in-place operation.
@@ -933,9 +946,9 @@ static void Hilbert (const size_t n, const double * in, double * outR, double *
* minimum phase reconstruction. The mirrored half of the response is also
* discarded.
*/
-static void MagnitudeResponse (const size_t n, const double * inR, const double * inI, double * out) {
- const size_t m = 1 + (n / 2);
- size_t i;
+static void MagnitudeResponse (const uint n, const double * inR, const double * inI, double * out) {
+ const uint m = 1 + (n / 2);
+ uint i;
for (i = 0; i < m; i ++)
out [i] = fmax (ComplexAbs (inR [i], inI [i]), EPSILON);
@@ -945,10 +958,10 @@ static void MagnitudeResponse (const size_t n, const double * inR, const double
* to adjust the effects of the diffuse-field average on the equalization
* process.
*/
-static void LimitMagnitudeResponse (const size_t n, const double limit, const double * in, double * out) {
- const size_t m = 1 + (n / 2);
+static void LimitMagnitudeResponse (const uint n, const double limit, const double * in, double * out) {
+ const uint m = 1 + (n / 2);
double halfLim;
- size_t i, lower, upper;
+ uint i, lower, upper;
double ave;
halfLim = limit / 2.0;
@@ -956,8 +969,8 @@ static void LimitMagnitudeResponse (const size_t n, const double limit, const do
for (i = 0; i < m; i ++)
out [i] = 20.0 * log10 (in [i]);
// Use six octaves to calculate the average magnitude of the signal.
- lower = ((size_t) ceil (n / pow (2.0, 8.0))) - 1;
- upper = ((size_t) floor (n / pow (2.0, 2.0))) - 1;
+ lower = ((uint) ceil (n / pow (2.0, 8.0))) - 1;
+ upper = ((uint) floor (n / pow (2.0, 2.0))) - 1;
ave = 0.0;
for (i = lower; i <= upper; i ++)
ave += out [i];
@@ -975,10 +988,10 @@ static void LimitMagnitudeResponse (const size_t n, const double limit, const do
* residuals (which were discarded). The mirrored half of the response is
* reconstructed.
*/
-static void MinimumPhase (const size_t n, const double * in, double * outR, double * outI) {
- const size_t m = 1 + (n / 2);
+static void MinimumPhase (const uint n, const double * in, double * outR, double * outI) {
+ const uint m = 1 + (n / 2);
double * mags = NULL;
- size_t i;
+ uint i;
double aR, aI;
mags = CreateArray (n);
@@ -1001,6 +1014,228 @@ static void MinimumPhase (const size_t n, const double * in, double * outR, doub
DestroyArray (mags);
}
+/* This is the normalized cardinal sine (sinc) function.
+ *
+ * sinc(x) = { 0, x = 0
+ * { sin(pi x) / (pi x), otherwise.
+ */
+static double Sinc (const double x) {
+ if (fabs (x) < EPSILON)
+ return (1.0);
+ return (sin (M_PI * x) / (M_PI * x));
+}
+
+/* The zero-order modified Bessel function of the first kind, used for the
+ * Kaiser window.
+ *
+ * I_0(x) = sum_{k=0}^inf (1 / k!)^2 (x / 2)^(2 k)
+ * = sum_{k=0}^inf ((x / 2)^k / k!)^2
+ */
+static double BesselI_0 (const double x) {
+ double term, sum, x2, y, last_sum;
+ int k;
+
+ // Start at k=1 since k=0 is trivial.
+ term = 1.0;
+ sum = 1.0;
+ x2 = x / 2.0;
+ k = 1;
+ // Let the integration converge until the term of the sum is no longer
+ // significant.
+ do {
+ y = x2 / k;
+ k ++;
+ last_sum = sum;
+ term *= y * y;
+ sum += term;
+ } while (sum != last_sum);
+ return (sum);
+}
+
+/* Calculate a Kaiser window from the given beta value and a normalized k
+ * [-1, 1].
+ *
+ * w(k) = { I_0(B sqrt(1 - k^2)) / I_0(B), -1 <= k <= 1
+ * { 0, elsewhere.
+ *
+ * Where k can be calculated as:
+ *
+ * k = i / l, where -l <= i <= l.
+ *
+ * or:
+ *
+ * k = 2 i / M - 1, where 0 <= i <= M.
+ */
+static double Kaiser (const double b, const double k) {
+ double k2;
+
+ k2 = Clamp (k, -1.0, 1.0);
+ if ((k < -1.0) || (k > 1.0))
+ return (0.0);
+ k2 *= k2;
+ return (BesselI_0 (b * sqrt (1.0 - k2)) / BesselI_0 (b));
+}
+
+// Calculates the greatest common divisor of a and b.
+static uint Gcd (const uint a, const uint b) {
+ uint x, y, z;
+
+ x = a;
+ y = b;
+ while (y > 0) {
+ z = y;
+ y = x % y;
+ x = z;
+ }
+ return (x);
+}
+
+/* Calculates the size (order) of the Kaiser window. Rejection is in dB and
+ * the transition width is normalized frequency (0.5 is nyquist).
+ *
+ * M = { ceil((r - 7.95) / (2.285 2 pi f_t)), r > 21
+ * { ceil(5.79 / 2 pi f_t), r <= 21.
+ *
+ */
+static uint CalcKaiserOrder (const double rejection, const double transition) {
+ double w_t;
+
+ w_t = 2.0 * M_PI * transition;
+ if (rejection > 21.0)
+ return ((uint) ceil ((rejection - 7.95) / (2.285 * w_t)));
+ return ((uint) ceil (5.79 / w_t));
+}
+
+// Calculates the beta value of the Kaiser window. Rejection is in dB.
+static double CalcKaiserBeta (const double rejection) {
+ if (rejection > 50.0)
+ return (0.1102 * (rejection - 8.7));
+ else if (rejection >= 21.0)
+ return ((0.5842 * pow (rejection - 21.0, 0.4)) +
+ (0.07886 * (rejection - 21.0)));
+ else
+ return (0.0);
+}
+
+/* Calculates a point on the Kaiser-windowed sinc filter for the given half-
+ * width, beta, gain, and cutoff. The point is specified in non-normalized
+ * samples, from 0 to M, where M = (2 l + 1).
+ *
+ * w(k) 2 p f_t sinc(2 f_t x)
+ *
+ * x -- centered sample index (i - l)
+ * k -- normalized and centered window index (x / l)
+ * w(k) -- window function (Kaiser)
+ * p -- gain compensation factor when sampling
+ * f_t -- normalized center frequency (or cutoff; 0.5 is nyquist)
+ */
+static double SincFilter (const int l, const double b, const double gain, const double cutoff, const int i) {
+ return (Kaiser (b, ((double) (i - l)) / l) * 2.0 * gain * cutoff * Sinc (2.0 * cutoff * (i - l)));
+}
+
+/* This is a polyphase sinc-filtered resampler.
+ *
+ * Upsample Downsample
+ *
+ * p/q = 3/2 p/q = 3/5
+ *
+ * M-+-+-+-> M-+-+-+->
+ * -------------------+ ---------------------+
+ * p s * f f f f|f| | p s * f f f f f |
+ * | 0 * 0 0 0|0|0 | | 0 * 0 0 0 0|0| |
+ * v 0 * 0 0|0|0 0 | v 0 * 0 0 0|0|0 |
+ * s * f|f|f f f | s * f f|f|f f |
+ * 0 * |0|0 0 0 0 | 0 * 0|0|0 0 0 |
+ * --------+=+--------+ 0 * |0|0 0 0 0 |
+ * d . d .|d|. d . d ----------+=+--------+
+ * d . . . .|d|. . . .
+ * q->
+ * q-+-+-+->
+ *
+ * P_f(i,j) = q i mod p + pj
+ * P_s(i,j) = floor(q i / p) - j
+ * d[i=0..N-1] = sum_{j=0}^{floor((M - 1) / p)} {
+ * { f[P_f(i,j)] s[P_s(i,j)], P_f(i,j) < M
+ * { 0, P_f(i,j) >= M. }
+ */
+
+// Calculate the resampling metrics and build the Kaiser-windowed sinc filter
+// that's used to cut frequencies above the destination nyquist.
+static void ResamplerSetup (ResamplerT * rs, const uint srcRate, const uint dstRate) {
+ uint gcd, l;
+ double cutoff, width, beta;
+ int i;
+
+ gcd = Gcd (srcRate, dstRate);
+ rs -> mP = dstRate / gcd;
+ rs -> mQ = srcRate / gcd;
+ /* The cutoff is adjusted by half the transition width, so the transition
+ * ends before the nyquist (0.5). Both are scaled by the downsampling
+ * factor.
+ */
+ if (rs -> mP > rs -> mQ) {
+ cutoff = 0.45 / rs -> mP;
+ width = 0.1 / rs -> mP;
+ } else {
+ cutoff = 0.45 / rs -> mQ;
+ width = 0.1 / rs -> mQ;
+ }
+ // A rejection of -180 dB is used for the stop band.
+ l = CalcKaiserOrder (180.0, width) / 2;
+ beta = CalcKaiserBeta (180.0);
+ rs -> mM = (2 * l) + 1;
+ rs -> mL = l;
+ rs -> mF = CreateArray (rs -> mM);
+ for (i = 0; i < ((int) rs -> mM); i ++)
+ rs -> mF [i] = SincFilter ((int) l, beta, rs -> mP, cutoff, i);
+}
+
+// Clean up after the resampler.
+static void ResamplerClear (ResamplerT * rs) {
+ DestroyArray (rs -> mF);
+ rs -> mF = NULL;
+}
+
+// Perform the upsample-filter-downsample resampling operation using a
+// polyphase filter implementation.
+static void ResamplerRun (ResamplerT * rs, const uint inN, const double * in, const uint outN, double * out) {
+ const uint p = rs -> mP, q = rs -> mQ, m = rs -> mM, l = rs -> mL;
+ const double * f = rs -> mF;
+ double * work = NULL;
+ uint i;
+ double r;
+ uint j_f, j_s;
+
+ // Handle in-place operation.
+ if (in == out)
+ work = CreateArray (outN);
+ else
+ work = out;
+ // Resample the input.
+ for (i = 0; i < outN; i ++) {
+ r = 0.0;
+ // Input starts at l to compensate for the filter delay. This will
+ // drop any build-up from the first half of the filter.
+ j_f = (l + (q * i)) % p;
+ j_s = (l + (q * i)) / p;
+ while (j_f < m) {
+ // Only take input when 0 <= j_s < inN. This single unsigned
+ // comparison catches both cases.
+ if (j_s < inN)
+ r += f [j_f] * in [j_s];
+ j_f += p;
+ j_s --;
+ }
+ work [i] = r;
+ }
+ // Clean up after in-place operation.
+ if (in == out) {
+ for (i = 0; i < outN; i ++)
+ out [i] = work [i];
+ DestroyArray (work);
+ }
+}
+
// Read a binary value of the specified byte order and byte size from a file,
// storing it as a 32-bit unsigned integer.
static int ReadBin4 (FILE * fp, const char * filename, const ByteOrderT order, const uint bytes, uint4 * out) {
@@ -1125,10 +1360,10 @@ static int ReadBinAsDouble (FILE * fp, const char * filename, const ByteOrderT o
(* out) = (double) v4 . f;
} else {
if (bits > 0)
- v4 . ui >>= (8 * bytes) - bits;
+ v4 . ui >>= (8 * bytes) - ((uint) bits);
else
v4 . ui &= (0xFFFFFFFF >> (32 + bits));
- if (v4 . ui & (1 << (abs (bits) - 1)))
+ if (v4 . ui & ((uint) (1 << (abs (bits) - 1))))
v4 . ui |= (0xFFFFFFFF << abs (bits));
(* out) = v4 . i / ((double) (1 << (abs (bits) - 1)));
}
@@ -1176,7 +1411,7 @@ static int ReadWaveFormat (FILE * fp, const ByteOrderT order, const uint hrirRat
chunkSize = 0;
do {
if (chunkSize > 0)
- fseek (fp, chunkSize, SEEK_CUR);
+ fseek (fp, (long) chunkSize, SEEK_CUR);
if ((! ReadBin4 (fp, src -> mPath, BO_LITTLE, 4, & fourCC)) ||
(! ReadBin4 (fp, src -> mPath, order, 4, & chunkSize)))
return (0);
@@ -1206,13 +1441,13 @@ static int ReadWaveFormat (FILE * fp, const ByteOrderT order, const uint hrirRat
fseek (fp, 4, SEEK_CUR);
if (! ReadBin4 (fp, src -> mPath, order, 2, & format))
return (0);
- fseek (fp, chunkSize - 26, SEEK_CUR);
+ fseek (fp, (long) (chunkSize - 26), SEEK_CUR);
} else {
bits = 8 * size;
if (chunkSize > 14)
- fseek (fp, chunkSize - 16, SEEK_CUR);
+ fseek (fp, (long) (chunkSize - 16), SEEK_CUR);
else
- fseek (fp, chunkSize - 14, SEEK_CUR);
+ fseek (fp, (long) (chunkSize - 14), SEEK_CUR);
}
if ((format != WAVE_FORMAT_PCM) && (format != WAVE_FORMAT_IEEE_FLOAT)) {
fprintf (stderr, "Error: Unsupported WAVE format in file '%s'.\n", src -> mPath);
@@ -1250,9 +1485,9 @@ static int ReadWaveFormat (FILE * fp, const ByteOrderT order, const uint hrirRat
}
// Read a RIFF/RIFX WAVE data chunk, converting all elements to doubles.
-static int ReadWaveData (FILE * fp, const SourceRefT * src, const ByteOrderT order, const size_t n, double * hrir) {
+static int ReadWaveData (FILE * fp, const SourceRefT * src, const ByteOrderT order, const uint n, double * hrir) {
int pre, post, skip;
- size_t i;
+ uint i;
pre = (int) (src -> mSize * src -> mChannel);
post = (int) (src -> mSize * (src -> mSkip - src -> mChannel - 1));
@@ -1272,9 +1507,9 @@ static int ReadWaveData (FILE * fp, const SourceRefT * src, const ByteOrderT ord
// Read the RIFF/RIFX WAVE list or data chunk, converting all elements to
// doubles.
-static int ReadWaveList (FILE * fp, const SourceRefT * src, const ByteOrderT order, const size_t n, double * hrir) {
+static int ReadWaveList (FILE * fp, const SourceRefT * src, const ByteOrderT order, const uint n, double * hrir) {
uint4 fourCC, chunkSize, listSize, count;
- size_t block, skip, offset, i;
+ uint block, skip, offset, i;
double lastSample;
for (;;) {
@@ -1288,7 +1523,7 @@ static int ReadWaveList (FILE * fp, const SourceRefT * src, const ByteOrderT ord
fprintf (stderr, "Error: Bad read from file '%s'.\n", src -> mPath);
return (0);
}
- fseek (fp, src -> mOffset * block, SEEK_CUR);
+ fseek (fp, (long) (src -> mOffset * block), SEEK_CUR);
if (! ReadWaveData (fp, src, order, n, & hrir [0]))
return (0);
return (1);
@@ -1300,7 +1535,7 @@ static int ReadWaveList (FILE * fp, const SourceRefT * src, const ByteOrderT ord
break;
}
if (chunkSize > 0)
- fseek (fp, chunkSize, SEEK_CUR);
+ fseek (fp, (long) chunkSize, SEEK_CUR);
}
listSize = chunkSize;
block = src -> mSize * src -> mSkip;
@@ -1315,7 +1550,7 @@ static int ReadWaveList (FILE * fp, const SourceRefT * src, const ByteOrderT ord
if (fourCC == FOURCC_DATA) {
count = chunkSize / block;
if (count > skip) {
- fseek (fp, skip * block, SEEK_CUR);
+ fseek (fp, (long) (skip * block), SEEK_CUR);
chunkSize -= skip * block;
count -= skip;
skip = 0;
@@ -1348,7 +1583,7 @@ static int ReadWaveList (FILE * fp, const SourceRefT * src, const ByteOrderT ord
}
}
if (chunkSize > 0)
- fseek (fp, chunkSize, SEEK_CUR);
+ fseek (fp, (long) chunkSize, SEEK_CUR);
}
if (offset < n) {
fprintf (stderr, "Error: Bad read from file '%s'.\n", src -> mPath);
@@ -1358,7 +1593,7 @@ static int ReadWaveList (FILE * fp, const SourceRefT * src, const ByteOrderT ord
}
// Load a source HRIR from a RIFF/RIFX WAVE file.
-static int LoadWaveSource (FILE * fp, SourceRefT * src, const uint hrirRate, const size_t n, double * hrir) {
+static int LoadWaveSource (FILE * fp, SourceRefT * src, const uint hrirRate, const uint n, double * hrir) {
uint4 fourCC, dummy;
ByteOrderT order;
@@ -1387,36 +1622,36 @@ static int LoadWaveSource (FILE * fp, SourceRefT * src, const uint hrirRate, con
}
// Load a source HRIR from a binary file.
-static int LoadBinarySource (FILE * fp, const SourceRefT * src, const ByteOrderT order, const size_t n, double * hrir) {
- size_t i;
+static int LoadBinarySource (FILE * fp, const SourceRefT * src, const ByteOrderT order, const uint n, double * hrir) {
+ uint i;
- fseek (fp, src -> mOffset, SEEK_SET);
+ fseek (fp, (long) src -> mOffset, SEEK_SET);
for (i = 0; i < n; i ++) {
if (! ReadBinAsDouble (fp, src -> mPath, order, src -> mType, src -> mSize, src -> mBits, & hrir [i]))
return (0);
if (src -> mSkip > 0)
- fseek (fp, src -> mSkip, SEEK_CUR);
+ fseek (fp, (long) src -> mSkip, SEEK_CUR);
}
return (1);
}
// Load a source HRIR from an ASCII text file containing a list of elements
// separated by whitespace or common list operators (',', ';', ':', '|').
-static int LoadAsciiSource (FILE * fp, const SourceRefT * src, const size_t n, double * hrir) {
+static int LoadAsciiSource (FILE * fp, const SourceRefT * src, const uint n, double * hrir) {
TokenReaderT tr;
- size_t i, j;
+ uint i, j;
double dummy;
TrSetup (fp, NULL, & tr);
for (i = 0; i < src -> mOffset; i ++) {
- if (! ReadAsciiAsDouble (& tr, src -> mPath, src -> mType, src -> mBits, & dummy))
+ if (! ReadAsciiAsDouble (& tr, src -> mPath, src -> mType, (uint) src -> mBits, & dummy))
return (0);
}
for (i = 0; i < n; i ++) {
- if (! ReadAsciiAsDouble (& tr, src -> mPath, src -> mType, src -> mBits, & hrir [i]))
+ if (! ReadAsciiAsDouble (& tr, src -> mPath, src -> mType, (uint) src -> mBits, & hrir [i]))
return (0);
for (j = 0; j < src -> mSkip; j ++) {
- if (! ReadAsciiAsDouble (& tr, src -> mPath, src -> mType, src -> mBits, & dummy))
+ if (! ReadAsciiAsDouble (& tr, src -> mPath, src -> mType, (uint) src -> mBits, & dummy))
return (0);
}
}
@@ -1424,7 +1659,7 @@ static int LoadAsciiSource (FILE * fp, const SourceRefT * src, const size_t n, d
}
// Load a source HRIR from a supported file type.
-static int LoadSource (SourceRefT * src, const uint hrirRate, const size_t n, double * hrir) {
+static int LoadSource (SourceRefT * src, const uint hrirRate, const uint n, double * hrir) {
FILE * fp = NULL;
int result;
@@ -1452,7 +1687,7 @@ static int LoadSource (SourceRefT * src, const uint hrirRate, const size_t n, do
// existing responses for its elevation and azimuth.
static void AverageHrirMagnitude (const double * hrir, const double f, const uint ei, const uint ai, const HrirDataT * hData) {
double * re = NULL, * im = NULL;
- size_t n, m, i, j;
+ uint n, m, i, j;
n = hData -> mFftSize;
re = CreateArray (n);
@@ -1516,8 +1751,7 @@ static void CalculateDfWeights (const HrirDataT * hData, double * weights) {
*/
static void CalculateDiffuseFieldAverage (const HrirDataT * hData, const int weighted, const double limit, double * dfa) {
double * weights = NULL;
- uint ei, ai;
- size_t count, step, start, end, m, j, i;
+ uint ei, ai, count, step, start, end, m, j, i;
double weight;
weights = CreateArray (hData -> mEvCount);
@@ -1567,7 +1801,7 @@ static void CalculateDiffuseFieldAverage (const HrirDataT * hData, const int wei
// Perform diffuse-field equalization on the magnitude responses of the HRIR
// set using the given average response.
static void DiffuseFieldEqualize (const double * dfa, const HrirDataT * hData) {
- size_t step, start, end, m, j, i;
+ uint step, start, end, m, j, i;
step = hData -> mIrSize;
start = hData -> mEvOffset [hData -> mEvStart] * step;
@@ -1583,7 +1817,7 @@ static void DiffuseFieldEqualize (const double * dfa, const HrirDataT * hData) {
// HRIR set.
static void ReconstructHrirs (const HrirDataT * hData) {
double * re = NULL, * im = NULL;
- size_t step, start, end, n, j, i;
+ uint step, start, end, n, j, i;
step = hData -> mIrSize;
start = hData -> mEvOffset [hData -> mEvStart] * step;
@@ -1601,12 +1835,27 @@ static void ReconstructHrirs (const HrirDataT * hData) {
DestroyArray (re);
}
+// Resamples the HRIRs for use at the given sampling rate.
+static void ResampleHrirs (const uint rate, HrirDataT * hData) {
+ ResamplerT rs;
+ uint n, step, start, end, j;
+
+ ResamplerSetup (& rs, hData -> mIrRate, rate);
+ n = hData -> mIrPoints;
+ step = hData -> mIrSize;
+ start = hData -> mEvOffset [hData -> mEvStart] * step;
+ end = hData -> mIrCount * step;
+ for (j = start; j < end; j += step)
+ ResamplerRun (& rs, n, & hData -> mHrirs [j], n, & hData -> mHrirs [j]);
+ ResamplerClear (& rs);
+ hData -> mIrRate = rate;
+}
+
/* Given an elevation index and an azimuth, calculate the indices of the two
* HRIRs that bound the coordinate along with a factor for calculating the
* continous HRIR using interpolation.
*/
-static void CalcAzIndices(const HrirDataT *hData, const uint ei, const double az, size_t *j0, size_t *j1, double *jf)
-{
+static void CalcAzIndices (const HrirDataT * hData, const uint ei, const double az, uint * j0, uint * j1, double * jf) {
double af;
uint ai;
@@ -1624,10 +1873,9 @@ static void CalcAzIndices(const HrirDataT *hData, const uint ei, const double az
* model.
*/
static void SynthesizeHrirs (HrirDataT * hData) {
- uint oi, a, e;
- size_t step, n, i, j;
- double of;
- size_t j0, j1;
+ uint oi, a, e, step, n, i, j;
+ double of, b;
+ uint j0, j1;
double jf;
double lp [4], s0, s1;
@@ -1645,6 +1893,7 @@ static void SynthesizeHrirs (HrirDataT * hData) {
}
for (e = 1; e < hData -> mEvStart; e ++) {
of = ((double) e) / hData -> mEvStart;
+ b = (1.0 - of) * (3.5e-6 * hData -> mIrRate);
for (a = 0; a < hData -> mAzCount [e]; a ++) {
j = (hData -> mEvOffset [e] + a) * step;
CalcAzIndices (hData, oi, a * 2.0 * M_PI / hData -> mAzCount [e], & j0, & j1, & jf);
@@ -1658,24 +1907,25 @@ static void SynthesizeHrirs (HrirDataT * hData) {
s0 = hData -> mHrirs [i];
s1 = Lerp (hData -> mHrirs [j0 + i], hData -> mHrirs [j1 + i], jf);
s0 = Lerp (s0, s1, of);
- lp [0] = Lerp (s0, lp [0], 0.15 - (0.15 * of));
- lp [1] = Lerp (lp [0], lp [1], 0.15 - (0.15 * of));
- lp [2] = Lerp (lp [1], lp [2], 0.15 - (0.15 * of));
- lp [3] = Lerp (lp [2], lp [3], 0.15 - (0.15 * of));
+ lp [0] = Lerp (s0, lp [0], b);
+ lp [1] = Lerp (lp [0], lp [1], b);
+ lp [2] = Lerp (lp [1], lp [2], b);
+ lp [3] = Lerp (lp [2], lp [3], b);
hData -> mHrirs [j + i] = lp [3];
}
}
}
+ b = 3.5e-6 * hData -> mIrRate;
lp [0] = 0.0;
lp [1] = 0.0;
lp [2] = 0.0;
lp [3] = 0.0;
for (i = 0; i < n; i ++) {
s0 = hData -> mHrirs [i];
- lp [0] = Lerp (s0, lp [0], 0.15);
- lp [1] = Lerp (lp [0], lp [1], 0.15);
- lp [2] = Lerp (lp [1], lp [2], 0.15);
- lp [3] = Lerp (lp [2], lp [3], 0.15);
+ lp [0] = Lerp (s0, lp [0], b);
+ lp [1] = Lerp (lp [0], lp [1], b);
+ lp [2] = Lerp (lp [1], lp [2], b);
+ lp [3] = Lerp (lp [2], lp [3], b);
hData -> mHrirs [i] = lp [3];
}
hData -> mEvStart = 0;
@@ -1685,7 +1935,7 @@ static void SynthesizeHrirs (HrirDataT * hData) {
// Normalize the HRIR set and slightly attenuate the result.
static void NormalizeHrirs (const HrirDataT * hData) {
- size_t step, end, n, j, i;
+ uint step, end, n, j, i;
double maxLevel;
step = hData -> mIrSize;
@@ -1745,8 +1995,7 @@ static void CalculateHrtds (HrirDataT * hData) {
// Store the OpenAL Soft HRTF data set.
static int StoreMhr (const HrirDataT * hData, const char * filename) {
FILE * fp = NULL;
- uint e;
- size_t step, end, n, j, i;
+ uint e, step, end, n, j, i;
int hpHist, v;
if ((fp = fopen (filename, "wb")) == NULL) {
@@ -1789,7 +2038,7 @@ static int StoreMhr (const HrirDataT * hData, const char * filename) {
// Store the OpenAL Soft built-in table.
static int StoreTable (const HrirDataT * hData, const char * filename) {
FILE * fp = NULL;
- size_t step, end, n, j, i;
+ uint step, end, n, j, i;
int hpHist, v;
char text [128 + 1];
@@ -1820,17 +2069,17 @@ static int StoreTable (const HrirDataT * hData, const char * filename) {
n = hData -> mIrPoints;
snprintf (text, 128, "};\n\n"
"/* HRIR Coefficients */\n"
- "static const ALshort defaultCoeffs[%zu] =\n{\n", hData -> mIrCount * n);
+ "static const ALshort defaultCoeffs[%u] =\n{\n", hData -> mIrCount * n);
if (! WriteAscii (text, fp, filename))
return (0);
srand (0x31DF840C);
for (j = 0; j < end; j += step) {
- if (! WriteAscii (" ", fp, filename))
+ if (! WriteAscii (" ", fp, filename))
return (0);
hpHist = 0;
for (i = 0; i < n; i ++) {
v = HpTpdfDither (32767.0 * hData -> mHrirs [j + i], & hpHist);
- snprintf (text, 128, "%+d, ", v);
+ snprintf (text, 128, " %+d,", v);
if (! WriteAscii (text, fp, filename))
return (0);
}
@@ -1839,13 +2088,13 @@ static int StoreTable (const HrirDataT * hData, const char * filename) {
}
snprintf (text, 128, "};\n\n"
"/* HRIR Delays */\n"
- "static const ALubyte defaultDelays[%d] =\n{\n"
- " ", hData -> mIrCount);
+ "static const ALubyte defaultDelays[%u] =\n{\n"
+ " ", hData -> mIrCount);
if (! WriteAscii (text, fp, filename))
return (0);
for (j = 0; j < hData -> mIrCount; j ++) {
v = (int) fmin (round (hData -> mIrRate * hData -> mHrtds [j]), MAX_HRTD);
- snprintf (text, 128, "%d, ", v);
+ snprintf (text, 128, " %d,", v);
if (! WriteAscii (text, fp, filename))
return (0);
}
@@ -1853,7 +2102,7 @@ static int StoreTable (const HrirDataT * hData, const char * filename) {
"/* Default HRTF Definition */\n", fp, filename))
return (0);
snprintf (text, 128, "static const struct Hrtf DefaultHrtf = {\n"
- " %u, %zu, %u, defaultAzCount, defaultEvOffset,\n",
+ " %u, %u, %u, defaultAzCount, defaultEvOffset,\n",
hData -> mIrRate, hData -> mIrPoints, hData -> mEvCount);
if (! WriteAscii (text, fp, filename))
return (0);
@@ -1865,11 +2114,11 @@ static int StoreTable (const HrirDataT * hData, const char * filename) {
}
// Process the data set definition to read and validate the data set metrics.
-static int ProcessMetrics (TokenReaderT * tr, const size_t fftSize, const size_t truncSize, HrirDataT * hData) {
+static int ProcessMetrics (TokenReaderT * tr, const uint fftSize, const uint truncSize, HrirDataT * hData) {
char ident [MAX_IDENT_LEN + 1];
uint line, col;
int intVal;
- size_t points;
+ uint points;
double fpVal;
int hasRate = 0, hasPoints = 0, hasAzimuths = 0;
int hasRadius = 0, hasDistance = 0;
@@ -1887,7 +2136,7 @@ static int ProcessMetrics (TokenReaderT * tr, const size_t fftSize, const size_t
return (0);
if (! TrReadInt (tr, MIN_RATE, MAX_RATE, & intVal))
return (0);
- hData -> mIrRate = intVal;
+ hData -> mIrRate = (uint) intVal;
hasRate = 1;
} else if (strcasecmp (ident, "points") == 0) {
if (hasPoints) {
@@ -1899,7 +2148,7 @@ static int ProcessMetrics (TokenReaderT * tr, const size_t fftSize, const size_t
TrIndication (tr, & line, & col);
if (! TrReadInt (tr, MIN_POINTS, MAX_POINTS, & intVal))
return (0);
- points = (size_t) intVal;
+ points = (uint) intVal;
if ((fftSize > 0) && (points > fftSize)) {
TrErrorAt (tr, line, col, "Value exceeds the overriden FFT size.\n");
return (0);
@@ -1936,8 +2185,8 @@ static int ProcessMetrics (TokenReaderT * tr, const size_t fftSize, const size_t
for (;;) {
if (! TrReadInt (tr, MIN_AZ_COUNT, MAX_AZ_COUNT, & intVal))
return (0);
- hData -> mAzCount [hData -> mEvCount] = intVal;
- hData -> mIrCount += intVal;
+ hData -> mAzCount [hData -> mEvCount] = (uint) intVal;
+ hData -> mIrCount += (uint) intVal;
hData -> mEvCount ++;
if (! TrIsOperator (tr, ","))
break;
@@ -1945,7 +2194,7 @@ static int ProcessMetrics (TokenReaderT * tr, const size_t fftSize, const size_t
TrError (tr, "Exceeded the maximum of %d elevations.\n", MAX_EV_COUNT);
return (0);
}
- hData -> mEvOffset [hData -> mEvCount] = hData -> mEvOffset [hData -> mEvCount - 1] + intVal;
+ hData -> mEvOffset [hData -> mEvCount] = hData -> mEvOffset [hData -> mEvCount - 1] + ((uint) intVal);
TrReadOperator (tr, ",");
}
if (hData -> mEvCount < MIN_EV_COUNT) {
@@ -1988,12 +2237,12 @@ static int ProcessMetrics (TokenReaderT * tr, const size_t fftSize, const size_t
static int ReadIndexPair (TokenReaderT * tr, const HrirDataT * hData, uint * ei, uint * ai) {
int intVal;
- if (! TrReadInt (tr, 0, hData -> mEvCount, & intVal))
+ if (! TrReadInt (tr, 0, (int) hData -> mEvCount, & intVal))
return (0);
(* ei) = (uint) intVal;
if (! TrReadOperator (tr, ","))
return (0);
- if (! TrReadInt (tr, 0, hData -> mAzCount [(* ei)], & intVal))
+ if (! TrReadInt (tr, 0, (int) hData -> mAzCount [(* ei)], & intVal))
return (0);
(* ai) = (uint) intVal;
return (1);
@@ -2060,23 +2309,23 @@ static int ReadSourceRef (TokenReaderT * tr, SourceRefT * src) {
if (src -> mType == ET_INT) {
if (! TrReadInt (tr, MIN_BIN_SIZE, MAX_BIN_SIZE, & intVal))
return (0);
- src -> mSize = intVal;
+ src -> mSize = (uint) intVal;
if (TrIsOperator (tr, ",")) {
TrReadOperator (tr, ",");
TrIndication (tr, & line, & col);
- if (! TrReadInt (tr, 0x80000000, 0x7FFFFFFF, & intVal))
+ if (! TrReadInt (tr, -2147483647 - 1, 2147483647, & intVal))
return (0);
- if ((abs (intVal) < MIN_BIN_BITS) || ((uint)abs(intVal) > (8 * src -> mSize))) {
+ if ((abs (intVal) < MIN_BIN_BITS) || (((uint) abs (intVal)) > (8 * src -> mSize))) {
TrErrorAt (tr, line, col, "Expected a value of (+/-) %d to %d.\n", MIN_BIN_BITS, 8 * src -> mSize);
return (0);
}
src -> mBits = intVal;
} else {
- src -> mBits = 8 * src -> mSize;
+ src -> mBits = (int) (8 * src -> mSize);
}
} else {
TrIndication (tr, & line, & col);
- if (! TrReadInt (tr, 0x80000000, 0x7FFFFFFF, & intVal))
+ if (! TrReadInt (tr, -2147483647 - 1, 2147483647, & intVal))
return (0);
if ((intVal != 4) && (intVal != 8)) {
TrErrorAt (tr, line, col, "Expected a value of 4 or 8.\n");
@@ -2203,22 +2452,21 @@ static int ProcessSources (TokenReaderT * tr, HrirDataT * hData) {
* resulting data set as desired. If the input name is NULL it will read
* from standard input.
*/
-static int ProcessDefinition (const char * inName, const size_t fftSize, const int equalize, const int surface, const double limit, const size_t truncSize, const OutputFormatT outFormat, const char * outName) {
+static int ProcessDefinition (const char * inName, const uint outRate, const uint fftSize, const int equalize, const int surface, const double limit, const uint truncSize, const OutputFormatT outFormat, const char * outName) {
FILE * fp = NULL;
TokenReaderT tr;
HrirDataT hData;
double * dfa = NULL;
char rateStr [8 + 1], expName [MAX_PATH_LEN];
- hData.mIrRate = 0;
- hData.mIrPoints = 0;
- hData.mFftSize = 0;
- hData.mIrSize = 0;
- hData.mIrCount = 0;
- hData.mEvCount = 0;
- hData.mRadius = 0;
- hData.mDistance = 0;
-
+ hData . mIrRate = 0;
+ hData . mIrPoints = 0;
+ hData . mFftSize = 0;
+ hData . mIrSize = 0;
+ hData . mIrCount = 0;
+ hData . mEvCount = 0;
+ hData . mRadius = 0;
+ hData . mDistance = 0;
fprintf (stdout, "Reading HRIR definition...\n");
if (inName != NULL) {
fp = fopen (inName, "r");
@@ -2257,6 +2505,10 @@ static int ProcessDefinition (const char * inName, const size_t fftSize, const i
}
fprintf (stdout, "Performing minimum phase reconstruction...\n");
ReconstructHrirs (& hData);
+ if ((outRate != 0) && (outRate != hData . mIrRate)) {
+ fprintf (stdout, "Resampling HRIRs...\n");
+ ResampleHrirs (outRate, & hData);
+ }
fprintf (stdout, "Truncating minimum-phase HRIRs...\n");
hData . mIrPoints = truncSize;
fprintf (stdout, "Synthesizing missing elevations...\n");
@@ -2291,10 +2543,10 @@ int main (const int argc, const char * argv []) {
const char * inName = NULL, * outName = NULL;
OutputFormatT outFormat;
int argi;
- size_t fftSize;
+ uint outRate, fftSize;
int equalize, surface;
double limit;
- size_t truncSize;
+ uint truncSize;
char * end = NULL;
if (argc < 2) {
@@ -2311,6 +2563,8 @@ int main (const int argc, const char * argv []) {
fprintf (stdout, " Defaults output to: ./hrtf_tables.inc\n");
fprintf (stdout, " -h, --help Displays this help information.\n\n");
fprintf (stdout, "Options:\n");
+ fprintf (stdout, " -r=<rate> Change the data set sample rate to the specified value and\n");
+ fprintf (stdout, " resample the HRIRs accordingly.\n");
fprintf (stdout, " -f=<points> Override the FFT window size (defaults to the first power-\n");
fprintf (stdout, " of-two that fits four times the number of HRIR points).\n");
fprintf (stdout, " -e={on|off} Toggle diffuse-field equalization (default: %s).\n", (DEFAULT_EQUALIZE ? "on" : "off"));
@@ -2318,7 +2572,7 @@ int main (const int argc, const char * argv []) {
fprintf (stdout, " -l={<dB>|none} Specify a limit to the magnitude range of the diffuse-field\n");
fprintf (stdout, " average (default: %.2f).\n", DEFAULT_LIMIT);
fprintf (stdout, " -w=<points> Specify the size of the truncation window that's applied\n");
- fprintf (stdout, " after minimum-phase reconstruction (default: %d).\n", DEFAULT_TRUNCSIZE);
+ fprintf (stdout, " after minimum-phase reconstruction (default: %u).\n", DEFAULT_TRUNCSIZE);
fprintf (stdout, " -i=<filename> Specify an HRIR definition file to use (defaults to stdin).\n");
fprintf (stdout, " -o=<filename> Specify an output file. Overrides command-selected default.\n");
fprintf (stdout, " Use of '%%r' will be substituted with the data set sample rate.\n");
@@ -2341,16 +2595,23 @@ int main (const int argc, const char * argv []) {
return (-1);
}
argi = 2;
+ outRate = 0;
fftSize = 0;
equalize = DEFAULT_EQUALIZE;
surface = DEFAULT_SURFACE;
limit = DEFAULT_LIMIT;
truncSize = DEFAULT_TRUNCSIZE;
while (argi < argc) {
- if (strncmp (argv [argi], "-f=", 3) == 0) {
+ if (strncmp (argv [argi], "-r=", 3) == 0) {
+ outRate = strtoul (& argv [argi] [3], & end, 10);
+ if ((end [0] != '\0') || (outRate < MIN_RATE) || (outRate > MAX_RATE)) {
+ fprintf (stderr, "Error: Expected a value from %u to %u for '-r'.\n", MIN_RATE, MAX_RATE);
+ return (-1);
+ }
+ } else if (strncmp (argv [argi], "-f=", 3) == 0) {
fftSize = strtoul (& argv [argi] [3], & end, 10);
if ((end [0] != '\0') || (fftSize & (fftSize - 1)) || (fftSize < MIN_FFTSIZE) || (fftSize > MAX_FFTSIZE)) {
- fprintf (stderr, "Error: Expected a power-of-two value from %d to %d for '-f'.\n", MIN_FFTSIZE, MAX_FFTSIZE);
+ fprintf (stderr, "Error: Expected a power-of-two value from %u to %u for '-f'.\n", MIN_FFTSIZE, MAX_FFTSIZE);
return (-1);
}
} else if (strncmp (argv [argi], "-e=", 3) == 0) {
@@ -2384,7 +2645,7 @@ int main (const int argc, const char * argv []) {
} else if (strncmp (argv [argi], "-w=", 3) == 0) {
truncSize = strtoul (& argv [argi] [3], & end, 10);
if ((end [0] != '\0') || (truncSize < MIN_TRUNCSIZE) || (truncSize > MAX_TRUNCSIZE) || (truncSize % MOD_TRUNCSIZE)) {
- fprintf (stderr, "Error: Expected a value from %d to %d in multiples of %d for '-w'.\n", MIN_TRUNCSIZE, MAX_TRUNCSIZE, MOD_TRUNCSIZE);
+ fprintf (stderr, "Error: Expected a value from %u to %u in multiples of %u for '-w'.\n", MIN_TRUNCSIZE, MAX_TRUNCSIZE, MOD_TRUNCSIZE);
return (-1);
}
} else if (strncmp (argv [argi], "-i=", 3) == 0) {
@@ -2397,7 +2658,7 @@ int main (const int argc, const char * argv []) {
}
argi ++;
}
- if (! ProcessDefinition (inName, fftSize, equalize, surface, limit, truncSize, outFormat, outName))
+ if (! ProcessDefinition (inName, outRate, fftSize, equalize, surface, limit, truncSize, outFormat, outName))
return (-1);
fprintf (stdout, "Operation completed.\n");
return (0);