-
Notifications
You must be signed in to change notification settings - Fork 2
/
Extension.h
266 lines (216 loc) · 7.73 KB
/
Extension.h
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
//Extension class (part of RUNDATA).
class Extension
{
public:
LPRDATA rdPtr;
LPRH rhPtr;
Edif::Runtime Runtime;
static const int MinimumBuild = 251;
static const int OEFLAGS = OEFLAG_VALUES;
static const int OEPREFS = 0;
static const int Version = 2;
static const int WindowProcPriority = 100;
Extension(LPRDATA rdPtr, LPEDATA edPtr, fpcob cobPtr);
~Extension();
//Handles to the currently selected objects.
ALSource* Source;
ALuint Effect;
ALuint Filter;
ALuint AuxSlot;
//Object arrays that keep track of all OpenAL handles.
list<ALSource*> SourceList;
map<string,ALBuffer> BufferMap;
map<int,ALuint> EffectMap;
map<int,ALuint> FilterMap;
map<int,ALuint> AuxSlotMap;
int LastEffectIndex;
int LastFilterIndex;
//A list of all devices used when opening one.
const ALchar* DeviceList;
//Current device and its name.
ALCdevice* Device;
const ALchar* DeviceName;
const ALchar* EnumeratedDevice;
//The context that the device is working in (holds sources etc).
ALCcontext* Context;
//Microphone input settings.
struct InputStruct
{
const ALchar* DeviceList;
//Current recording device.
ALCdevice* Device;
const ALchar* DeviceName;
const ALchar* EnumeratedDevice;
//To keep track. No way to ask OpenAL!
bool Recording;
//Numbers used for recording.
ALuint Frequency;
ALuint Channels;
ALuint Bits;
ALuint BufferSamples;
ALsizei FFTSize;
//Calculated from above settings.
ALuint BlockAlign;
ALenum Format;
} Input;
//Stores the meters per unit.
ALfloat Unit;
//Callback stream.
ALubyte* CallbackBuffer;
ALuint CallbackAvailableBytes;
ALuint CallbackWrittenBytes;
//Microphone capture callback.
ALubyte* CaptureBuffer;
ALuint CaptureAvailableBytes;
//Helpers
void CaptureRecalculateSettings();
ALBuffer* BufferGetFromName(const char* Name);
ALuint AuxEffectSlotGetFromID(int ID);
void AuxEffectSlotLoadEffect(ALuint Handle);
ALuint FilterGetFromID(int ID);
ALuint EffectGetFromID(int ID);
ALenum EffectGetParameterIndex(const char* Name);
ALSource* SourceGetFromName(const char* Name);
void SourceCreateEffectSlot(int Slot);
bool IsSource();
bool IsSource(ALSource* Handle);
void LinkACE();
bool GenericTrigger();
static void Assert(ALboolean Statement);
//Actions
void SetDistanceModel(int DistanceModel);
void SetDopplerFactor(float DopplerFctor);
void SetSpeedOfSound(float SpeedOfSound);
void DeviceOpen(const char* Name = "");
void DeviceClose();
void DeviceEnumerate();
void CaptureSetFrequency(int Frequency);
void CaptureSetChannels(int Channels);
void CaptureSetBits(int Bits);
void CaptureSetBufferSize(int BufferSamples);
void CaptureDeviceOpen(const char* Name);
void CaptureDeviceClose();
void CaptureDeviceEnumerate();
void CaptureStart();
void CaptureStop();
void BufferCreateSampleForFile(const char* Name, const char* FilePath);
void BufferCreateStreamForFile(const char* Name, const char* FilePath);
void BufferCreateSampleForMemory(const char* Name, const ALubyte* Address, unsigned int Size);
void BufferCreateSampleForMMF(const char* Name, const char* MMFName);
void BufferCreateStreamForCapture(const char* Name);
void BufferCreateStreamForSignal(const char* Name, ALuint SampleRate, ALuint Channels, ALuint Bits, const char* Type, ALfloat Frequency, ALfloat ModulatorAmplitude, ALfloat ModulatorFrequency);
void BufferCreateStreamForCallback(const char* Name, ALuint SampleRate, ALuint Channels, ALuint Bits, ALuint BufferSize);
void BufferCallbackWriteBytes(int Bytes);
void ListenerSetGain(float Gain);
void ListenerSetPosition(float X, float Y, float Z);
void ListenerSetVelocity(float X, float Y, float Z);
void ListenerSetOrientation(float XAt, float YAt, float ZAt, float XUp, float YUp, float ZUp);
void ListenerSetMetersPerUnit(float Meters);
void SourceCreate();
void SourceCreateNamed(const char* Name);
void SourceCreateWithBuffer(const char* Buffer);
void SourceCreateNamedWithBuffer(const char* Name, const char* Buffer);
void SourceSelectByName(const char* Name);
void SourceSelectByHandle(int Handle);
void SourcePlay();
void SourcePause();
void SourceResume();
void SourceStop();
void SourceRewind();
void SourceSetPermanent(int Permanent);
void SourceSetBuffer(const char* BufferName);
void SourceSetGain(float Gain);
void SourceSetPitch(float Pitch);
void SourceSetLooping(int Looping);
void SourceSetSampleOffset(int Sample);
void SourceSetSecondOffset(float Second);
void SourceSetPosition(float X, float Y, float Z);
void SourceSetVelocity(float X, float Y, float Z);
void SourceSetDirection(float X, float Y, float Z);
void SourceSetConeAngles(float Inner, float Outer);
void SourceSetConeOuterGain(float Gain);
void SourceSetConeOuterGainHF(float GainHF);
void SourceSetRelative(int Relative);
void SourceSetMinimumGain(float Gain);
void SourceSetMaximumGain(float Gain);
void SourceSetReferenceDistance(float Distance);
void SourceSetMaximumDistance(float Distance);
void SourceSetRolloffFactor(float RolloffFactor);
void SourceSetRoomRolloffFactor(float RolloffFactor);
void SourceSetAirAbsorptionFactor(float AirAbsorption);
void SourceLoadDirectFilter();
void SourceSetAuxiliarySend(int Send, int AuxSlot);
void SourceSetAuxiliarySendWithFilter(int Send, int AuxSlot, int Filter);
void SourceSetAuxiliarySendGainAutoAdjust(int Adjust);
void SourceSetAuxiliarySendGainHFAutoAdjust(int Adjust);
void EffectCreate(int Type);
void EffectCreateReverb();
void EffectCreateEcho();
void EffectCreateRingModulator();
void EffectSelectByID(int ID);
void EffectSetFloatParameter(const char* Name, float Value);
void EffectSetIntParameter(const char* Name, int Value);
void EffectLoadReverbPreset(const char* Preset);
void FilterCreateLowPass();
void FilterSelectByID(int ID);
void FilterSetGain(float Gain);
void FilterSetGainHF(float GainHF);
void AuxEffectSlotCreate(int ID);
void AuxEffectSlotSelectByID(int ID);
void AuxEffectSlotSetGain(float Gain);
void AuxEffectSlotSetAutoAdjust(int Adjust);
void AuxEffectSlotLoadEffectByID(int ID);
//Conditions
bool SourceOnStopped();
bool SourceExists(const char* Name);
bool SourceIsPlaying(const char* Name);
//Expressions
char* DeviceGetEnumerated();
int CaptureDataGetAddress();
int CaptureDataGetBytes();
char* CaptureDeviceGetEnumerated();
int BufferCallbackGetAddress();
int BufferCallbackGetBytes();
int SourceGetCount();
ALSource* SourceSelectedGetHandle();
char* SourceSelectedGetName();
char* SourceByHandleGetName(ALSource* Handle);
float SourceByHandleGetSecondOffset(ALSource* Handle);
float SourceByHandleGetSecondLength(ALSource* Handle);
float SourceByHandleGetDistance(ALSource* Handle);
float SourceByNameGetSecondOffset(const char* Name);
float SourceByNameGetSecondLength(const char* Name);
float SourceByNameGetDistance(const char* Name);
ALSource* SourceByIndexGetHandle(unsigned int Index);
char* SourceByIndexGetName(unsigned int Index);
int EffectGetLast();
int FilterGetLast();
//Edif stuff
void Action(int ID, LPRDATA rdPtr, long param1, long param2);
long Condition(int ID, LPRDATA rdPtr, long param1, long param2);
long Expression(int ID, LPRDATA rdPtr, long param);
short Handle();
short Display();
short Pause();
short Continue();
bool Save(HANDLE File);
bool Load(HANDLE File);
static inline bool Extension::GetError(const char* File, unsigned int Line)
{
#ifdef _DEBUG
printf("%s:%04d\n\t", File, Line);
ALenum Error = alGetError();
if(Error)
printf("OpenAL: %s (%#x)\n", alGetString(Error), Error);
else if(strcmp("No error", alureGetErrorString()))
printf("Alure: %s\n", alureGetErrorString());
else
{
printf("No error\n");
return true;
}
return false;
#endif
return true;
}
};