1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
#ifndef ALC_HRTF_H
#define ALC_HRTF_H
#include <array>
#include <memory>
#include <string>
#include "AL/al.h"
#include "AL/alc.h"
#include "vector.h"
#include "almalloc.h"
#define HRTF_HISTORY_BITS (6)
#define HRTF_HISTORY_LENGTH (1<<HRTF_HISTORY_BITS)
#define HRTF_HISTORY_MASK (HRTF_HISTORY_LENGTH-1)
#define HRIR_BITS (7)
#define HRIR_LENGTH (1<<HRIR_BITS)
#define HRIR_MASK (HRIR_LENGTH-1)
struct HrtfHandle;
struct HrtfEntry {
RefCount ref;
ALuint sampleRate;
ALsizei irSize;
struct Field {
ALfloat distance;
ALubyte evCount;
};
/* NOTE: Fields are stored *backwards*. field[0] is the farthest field, and
* field[fdCount-1] is the nearest.
*/
ALsizei fdCount;
const Field *field;
struct Elevation {
ALushort azCount;
ALushort irOffset;
};
Elevation *elev;
const ALfloat (*coeffs)[2];
const ALubyte (*delays)[2];
void IncRef();
void DecRef();
DEF_PLACE_NEWDEL()
};
struct EnumeratedHrtf {
std::string name;
HrtfHandle *hrtf;
};
using float2 = std::array<float,2>;
template<typename T>
using HrirArray = std::array<std::array<T,2>,HRIR_LENGTH>;
struct HrtfState {
alignas(16) std::array<ALfloat,HRTF_HISTORY_LENGTH> History;
alignas(16) HrirArray<ALfloat> Values;
};
struct HrtfFilter {
alignas(16) HrirArray<ALfloat> Coeffs;
ALsizei Delay[2];
ALfloat Gain;
};
struct DirectHrtfState {
/* HRTF filter state for dry buffer content */
ALsizei IrSize{0};
struct ChanData {
alignas(16) HrirArray<ALfloat> Values;
alignas(16) HrirArray<ALfloat> Coeffs;
};
al::FlexArray<ChanData> Chan;
DirectHrtfState(size_t numchans) : Chan{numchans} { }
DirectHrtfState(const DirectHrtfState&) = delete;
DirectHrtfState& operator=(const DirectHrtfState&) = delete;
static std::unique_ptr<DirectHrtfState> Create(size_t num_chans);
static constexpr size_t Sizeof(size_t numchans) noexcept
{ return al::FlexArray<ChanData>::Sizeof(numchans, offsetof(DirectHrtfState, Chan)); }
DEF_PLACE_NEWDEL()
};
struct AngularPoint {
ALfloat Elev;
ALfloat Azim;
};
al::vector<EnumeratedHrtf> EnumerateHrtf(const char *devname);
HrtfEntry *GetLoadedHrtf(HrtfHandle *handle);
void GetHrtfCoeffs(const HrtfEntry *Hrtf, ALfloat elevation, ALfloat azimuth, ALfloat distance,
ALfloat spread, HrirArray<ALfloat> &coeffs, ALsizei (&delays)[2]);
/**
* Produces HRTF filter coefficients for decoding B-Format, given a set of
* virtual speaker positions, a matching decoding matrix, and per-order high-
* frequency gains for the decoder. The calculated impulse responses are
* ordered and scaled according to the matrix input. Note the specified virtual
* positions should be in degrees, not radians!
*/
void BuildBFormatHrtf(const HrtfEntry *Hrtf, DirectHrtfState *state, const ALuint NumChannels,
const AngularPoint *AmbiPoints, const ALfloat (*RESTRICT AmbiMatrix)[MAX_AMBI_CHANNELS],
const size_t AmbiCount, const ALfloat *RESTRICT AmbiOrderHFGain);
#endif /* ALC_HRTF_H */
|
