-
Notifications
You must be signed in to change notification settings - Fork 0
/
portaudio_ffi.lua
330 lines (314 loc) · 11 KB
/
portaudio_ffi.lua
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
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
local ffi = require"ffi"
--uncomment to debug cdef calls
---[[
local ffi_cdef = function(code)
local ret,err = pcall(ffi.cdef,code)
if not ret then
local lineN = 1
for line in code:gmatch("([^\n\r]*)\r?\n") do
print(lineN, line)
lineN = lineN + 1
end
print(err)
error"bad cdef"
end
end
--]]
ffi_cdef[[
int Pa_GetVersion( void );
const char* Pa_GetVersionText( void );
typedef struct PaVersionInfo {
int versionMajor;
int versionMinor;
int versionSubMinor;
const char *versionControlRevision;
const char *versionText;
} PaVersionInfo;
const PaVersionInfo* Pa_GetVersionInfo( void );
typedef int PaError;
typedef enum PaErrorCode
{
paNoError = 0,
paNotInitialized = -10000,
paUnanticipatedHostError,
paInvalidChannelCount,
paInvalidSampleRate,
paInvalidDevice,
paInvalidFlag,
paSampleFormatNotSupported,
paBadIODeviceCombination,
paInsufficientMemory,
paBufferTooBig,
paBufferTooSmall,
paNullCallback,
paBadStreamPtr,
paTimedOut,
paInternalError,
paDeviceUnavailable,
paIncompatibleHostApiSpecificStreamInfo,
paStreamIsStopped,
paStreamIsNotStopped,
paInputOverflowed,
paOutputUnderflowed,
paHostApiNotFound,
paInvalidHostApi,
paCanNotReadFromACallbackStream,
paCanNotWriteToACallbackStream,
paCanNotReadFromAnOutputOnlyStream,
paCanNotWriteToAnInputOnlyStream,
paIncompatibleStreamHostApi,
paBadBufferPtr
} PaErrorCode;
const char *Pa_GetErrorText( PaError errorCode );
PaError Pa_Initialize( void );
PaError Pa_Terminate( void );
typedef int PaDeviceIndex;
typedef int PaHostApiIndex;
PaHostApiIndex Pa_GetHostApiCount( void );
PaHostApiIndex Pa_GetDefaultHostApi( void );
typedef enum PaHostApiTypeId
{
paInDevelopment=0,
paDirectSound=1,
paMME=2,
paASIO=3,
paSoundManager=4,
paCoreAudio=5,
paOSS=7,
paALSA=8,
paAL=9,
paBeOS=10,
paWDMKS=11,
paJACK=12,
paWASAPI=13,
paAudioScienceHPI=14,
paAudioIO=15
} PaHostApiTypeId;
typedef struct PaHostApiInfo
{
int structVersion;
PaHostApiTypeId type;
const char *name;
int deviceCount;
PaDeviceIndex defaultInputDevice;
PaDeviceIndex defaultOutputDevice;
} PaHostApiInfo;
const PaHostApiInfo * Pa_GetHostApiInfo( PaHostApiIndex hostApi );
PaHostApiIndex Pa_HostApiTypeIdToHostApiIndex( PaHostApiTypeId type );
PaDeviceIndex Pa_HostApiDeviceIndexToDeviceIndex( PaHostApiIndex hostApi,
int hostApiDeviceIndex );
typedef struct PaHostErrorInfo{
PaHostApiTypeId hostApiType;
long errorCode;
const char *errorText;
}PaHostErrorInfo;
const PaHostErrorInfo* Pa_GetLastHostErrorInfo( void );
PaDeviceIndex Pa_GetDeviceCount( void );
PaDeviceIndex Pa_GetDefaultInputDevice( void );
PaDeviceIndex Pa_GetDefaultOutputDevice( void );
typedef double PaTime;
typedef unsigned long PaSampleFormat;
typedef struct PaDeviceInfo
{
int structVersion;
const char *name;
PaHostApiIndex hostApi;
int maxInputChannels;
int maxOutputChannels;
PaTime defaultLowInputLatency;
PaTime defaultLowOutputLatency;
PaTime defaultHighInputLatency;
PaTime defaultHighOutputLatency;
double defaultSampleRate;
} PaDeviceInfo;
const PaDeviceInfo* Pa_GetDeviceInfo( PaDeviceIndex device );
typedef struct PaStreamParameters
{
PaDeviceIndex device;
int channelCount;
PaSampleFormat sampleFormat;
PaTime suggestedLatency;
void *hostApiSpecificStreamInfo;
} PaStreamParameters;
PaError Pa_IsFormatSupported( const PaStreamParameters *inputParameters,
const PaStreamParameters *outputParameters,
double sampleRate );
typedef void PaStream;
typedef unsigned long PaStreamFlags;
typedef struct PaStreamCallbackTimeInfo{
PaTime inputBufferAdcTime;
PaTime currentTime;
PaTime outputBufferDacTime;
} PaStreamCallbackTimeInfo;
typedef unsigned long PaStreamCallbackFlags;
typedef enum PaStreamCallbackResult
{
paContinue=0,
paComplete=1,
paAbort=2
} PaStreamCallbackResult;
typedef int PaStreamCallback(
const void *input, void *output,
unsigned long frameCount,
const PaStreamCallbackTimeInfo* timeInfo,
PaStreamCallbackFlags statusFlags,
void *userData );
PaError Pa_OpenStream( PaStream** stream,
const PaStreamParameters *inputParameters,
const PaStreamParameters *outputParameters,
double sampleRate,
unsigned long framesPerBuffer,
PaStreamFlags streamFlags,
PaStreamCallback *streamCallback,
void *userData );
PaError Pa_OpenDefaultStream( PaStream** stream,
int numInputChannels,
int numOutputChannels,
PaSampleFormat sampleFormat,
double sampleRate,
unsigned long framesPerBuffer,
PaStreamCallback *streamCallback,
void *userData );
PaError Pa_CloseStream( PaStream *stream );
typedef void PaStreamFinishedCallback( void *userData );
PaError Pa_SetStreamFinishedCallback( PaStream *stream, PaStreamFinishedCallback* streamFinishedCallback );
PaError Pa_StartStream( PaStream *stream );
PaError Pa_StopStream( PaStream *stream );
PaError Pa_AbortStream( PaStream *stream );
PaError Pa_IsStreamStopped( PaStream *stream );
PaError Pa_IsStreamActive( PaStream *stream );
typedef struct PaStreamInfo
{
int structVersion;
PaTime inputLatency;
PaTime outputLatency;
double sampleRate;
} PaStreamInfo;
const PaStreamInfo* Pa_GetStreamInfo( PaStream *stream );
PaTime Pa_GetStreamTime( PaStream *stream );
double Pa_GetStreamCpuLoad( PaStream* stream );
PaError Pa_ReadStream( PaStream* stream,
void *buffer,
unsigned long frames );
PaError Pa_WriteStream( PaStream* stream,
const void *buffer,
unsigned long frames );
signed long Pa_GetStreamReadAvailable( PaStream* stream );
signed long Pa_GetStreamWriteAvailable( PaStream* stream );
PaError Pa_GetSampleSize( PaSampleFormat format );
void Pa_Sleep( long msec );]]
ffi_cdef[[static const int paNoDevice = ((PaDeviceIndex)-1);
static const int paUseHostApiSpecificDeviceSpecification = ((PaDeviceIndex)-2);
static const int paFloat32 = ((PaSampleFormat) 0x00000001);
static const int paInt32 = ((PaSampleFormat) 0x00000002);
static const int paInt24 = ((PaSampleFormat) 0x00000004);
static const int paInt16 = ((PaSampleFormat) 0x00000008);
static const int paInt8 = ((PaSampleFormat) 0x00000010);
static const int paUInt8 = ((PaSampleFormat) 0x00000020);
static const int paCustomFormat = ((PaSampleFormat) 0x00010000);
static const int paNonInterleaved = ((PaSampleFormat) 0x80000000);
static const int paFormatIsSupported = (0);
static const int paFramesPerBufferUnspecified = (0);
static const int paNoFlag = ((PaStreamFlags) 0);
static const int paClipOff = ((PaStreamFlags) 0x00000001);
static const int paDitherOff = ((PaStreamFlags) 0x00000002);
static const int paNeverDropInput = ((PaStreamFlags) 0x00000004);
static const int paPrimeOutputBuffersUsingStreamCallback = ((PaStreamFlags) 0x00000008);
static const int paPlatformSpecificFlags = ((PaStreamFlags)0xFFFF0000);
static const int paInputUnderflow = ((PaStreamCallbackFlags) 0x00000001);
static const int paInputOverflow = ((PaStreamCallbackFlags) 0x00000002);
static const int paOutputUnderflow = ((PaStreamCallbackFlags) 0x00000004);
static const int paOutputOverflow = ((PaStreamCallbackFlags) 0x00000008);
static const int paPrimingOutput = ((PaStreamCallbackFlags) 0x00000010);]]
local lib = ffi.load"portaudio"
local M = {C=lib}ffi.cdef"typedef struct pa_type{} pa_type;"
local PaStream_t = {}
PaStream_t.__index = PaStream_t
function PaStream_t:CloseStream()
ffi.gc(self,nil)
return lib.Pa_CloseStream(self)
end
function PaStream_t:AbortStream()
return lib.Pa_AbortStream(self)
end
function PaStream_t:GetStreamCpuLoad()
return lib.Pa_GetStreamCpuLoad(self)
end
function PaStream_t:GetStreamInfo()
return lib.Pa_GetStreamInfo(self)
end
function PaStream_t:GetStreamReadAvailable()
return lib.Pa_GetStreamReadAvailable(self)
end
function PaStream_t:GetStreamTime()
return lib.Pa_GetStreamTime(self)
end
function PaStream_t:GetStreamWriteAvailable()
return lib.Pa_GetStreamWriteAvailable(self)
end
function PaStream_t:IsFormatSupported(outputParameters, sampleRate)
return lib.Pa_IsFormatSupported(self,outputParameters, sampleRate)
end
function PaStream_t:IsStreamActive()
return lib.Pa_IsStreamActive(self)
end
function PaStream_t:IsStreamStopped()
return lib.Pa_IsStreamStopped(self)
end
function PaStream_t:ReadStream(buffer, frames)
return lib.Pa_ReadStream(self,buffer, frames)
end
function PaStream_t:SetStreamFinishedCallback(streamFinishedCallback)
return lib.Pa_SetStreamFinishedCallback(self,streamFinishedCallback)
end
function PaStream_t:StartStream()
return lib.Pa_StartStream(self)
end
function PaStream_t:StopStream()
return lib.Pa_StopStream(self)
end
function PaStream_t:WriteStream(buffer, frames)
return lib.Pa_WriteStream(self,buffer, frames)
end
M.Pa = ffi.metatype("pa_type",PaStream_t)
function M.OpenDefaultStream(numInputChannels, numOutputChannels, sampleFormat, sampleRate, framesPerBuffer, streamCallback, userData)
local stream = ffi.new("PaStream*[1]")
local err = lib.Pa_OpenDefaultStream(stream,numInputChannels, numOutputChannels, sampleFormat, sampleRate, framesPerBuffer, streamCallback, userData)
if not(err == lib.paNoError) then
return nil, err, string.format("error: %s",ffi.string(lib.Pa_GetErrorText(err)))
end
local st = ffi.new("pa_type*",stream[0])
ffi.gc(st,lib.Pa_CloseStream)
return st
end
function M.OpenStream(inputParameters, outputParameters, sampleRate, framesPerBuffer, streamFlags, streamCallback, userData)
local stream = ffi.new("PaStream*[1]")
local err = lib.Pa_OpenStream(stream,inputParameters, outputParameters, sampleRate, framesPerBuffer, streamFlags, streamCallback, userData)
if not(err == lib.paNoError) then
return nil, err, string.format("error: %s",ffi.string(lib.Pa_GetErrorText(err)))
end
local st = ffi.new("pa_type*",stream[0])
ffi.gc(st,lib.Pa_CloseStream)
return st
end
local callback_t
local callbacks_anchor = {}
function M.MakeAudioCallback(func, ...)
if not callback_t then
local CallbackFactory = require "lj-async.callback"
callback_t = CallbackFactory("int(*)(void*,void*,unsigned long,PaStreamCallbackTimeInfo*,PaStreamCallbackFlags,void*)") --"RtAudioCallback"
end
local cb = callback_t(func, ...)
table.insert(callbacks_anchor,cb)
return cb:funcptr() , cb
end
setmetatable(M,{
__index = function(t,k)
local ok,ptr = pcall(function(str) return lib["Pa_"..str] end,k)
if not ok then ok,ptr = pcall(function(str) return lib["pa"..str] end,k) end
if not ok then error(k.." not found") end
rawset(M, k, ptr)
return ptr
end
})
return M