You wrote a thread a while back about your callbacks not being
called and you had a fix.
http://www.digitalmars.com/d/archives/digitalmars/D/learn/Anyone_using_Portaudio_22343.html
I'm trying to get portAudio to work on my machine and it seems
everything passes yet my callbacks are not being called.
I do not know if it is the same issue you had or what. Could you
describe your fixes, if you remember? You said it was alias
issues, my source uses alias, so maybe I have the updated one.
Also, using paPrimeOutputBuffersUsingStreamCallback causes an
access violation ;/
Here are some dll's I'm using
https://github.com/spatialaudio/portaudio-binaries
I'm including the two files needed to compile what I have in case
you(or anyone else) decide to help figure this out:
Make sure to change the dll location in the DLL_PortAudio struct
and set the appropriate audio interface to use(I have it set to
12, but have tried every value on my system with no luck).
module mPortAudio;
import std.stdio, std.conv;
enum PaError : int
{
NoError = 0,
NotInitialized = -10000,
UnanticipatedHostError,
InvalidChannelCount,
InvalidSampleRate,
InvalidDevice,
InvalidFlag,
SampleFormatNotSupported,
BadIODeviceCombination,
InsufficientMemory,
BufferTooBig,
BufferTooSmall,
NullCallback,
BadStreamPtr,
TimedOut,
InternalError,
DeviceUnavailable,
IncompatibleHostApiSpecificStreamInfo,
StreamIsStopped,
StreamIsNotStopped,
InputOverflowed,
OutputUnderflowed,
HostApiNotFound,
InvalidHostApi,
CanNotReadFromACallbackStream,
CanNotWriteToACallbackStream,
CanNotReadFromAnOutputOnlyStream,
CanNotWriteToAnInputOnlyStream,
IncompatibleStreamHostApi,
BadBufferPtr,
FormatIsSupported = 0,
};
enum PaSampleFormat : ulong
{
Float32 = 0x00000001,
Int32 = 0x00000002,
Int24 = 0x00000004,
Int16 = 0x00000008,
Int8 = 0x00000010,
UInt8 = 0x00000020,
CustomFormat = 0x00010000,
NonInterleaved = 0x80000000
}
enum PaHostApiTypeId : int
{
InDevelopment=0,
DirectSound=1,
MME=2,
ASIO=3,
SoundManager=4,
CoreAudio=5,
OSS=7,
ALSA=8,
AL=9,
BeOS=10,
WDMKS=11,
JACK=12,
WASAPI=13,
AudioScienceHPI=14
};
enum PaStreamCallbackResult : int
{
paContinue=0, /**< Signal that the stream should continue
invoking the callback and processing audio. */
paComplete=1, /**< Signal that the stream should stop
invoking the callback and finish once all output samples have
played. */
paAbort=2 /**< Signal that the stream should stop
invoking the callback and finish as soon as possible. */
};
enum PaStreamFlags : ulong
{
NoFlag = 0,
ClipOff = 0x00000001,
DitherOff = 0x00000002,
NeverDropInput = 0x00000004,
PrimeOutputBuffersUsingStreamCallback = 0x00000008,
PlatformSpecificFlags = 0xFFFF0000,
}
alias void PaStream;
enum paFramesPerBufferUnspecified = 0;
enum PaStreamCallbackFlags : ulong
{
InputUnderflow = 0x00000001,
InputOverflow = 0x00000002,
OutputUnderflow = 0x00000004,
OutputOverflow = 0x00000008,
PrimingOutput = 0x00000010,
}
alias extern(C) int function(const(void) *input, void *output,
ulong frameCount, const(PaStreamCallbackTimeInfo)* timeInfo,
PaStreamCallbackFlags statusFlags, void *userData )
PaStreamCallback;
alias void function( void *userData ) PaStreamFinishedCallback;
alias int PaDeviceIndex;
enum paNoDevice = cast(PaDeviceIndex)-1;
enum paUseHostApiSpecificDeviceSpecification =
cast(PaDeviceIndex)-2;
alias int PaHostApiIndex;
alias double PaTime;
struct PaHostApiInfo
{
int structVersion;
PaHostApiTypeId type;
const(char) *name;
int deviceCount;
PaDeviceIndex defaultInputDevice;
PaDeviceIndex defaultOutputDevice;
};
struct PaDeviceInfo
{
int structVersion;
const(char) *name;
PaHostApiIndex hostApi;
int maxInputChannels;
int maxOutputChannels;
PaTime defaultLowInputLatency;
PaTime defaultLowOutputLatency;
PaTime defaultHighInputLatency;
PaTime defaultHighOutputLatency;
double defaultSampleRate;
};
struct PaStreamCallbackTimeInfo
{
PaTime inputBufferAdcTime;
PaTime currentTime;
PaTime outputBufferDacTime;
};
struct PaStreamInfo
{
int structVersion;
PaTime inputLatency;
PaTime outputLatency;
double sampleRate;
};
struct PaHostErrorInfo
{
PaHostApiTypeId hostApiType;
long errorCode;
const(char) *errorText;
};
struct PaStreamParameters
{
PaDeviceIndex device;
int channelCount;
PaSampleFormat sampleFormat;
PaTime suggestedLatency;
void *hostApiSpecificStreamInfo;
};
struct DLL_PortAudio
{
@("DLLImport") public static extern(Windows)
{
@(r"D:\D\DLLs\portaudio_x86.dll")
{
int function() Pa_GetVersion;
const(char)* function() Pa_GetVersionText;
const(char) *function(PaError errorCode)
Pa_GetErrorText;
PaError function() Pa_Initialize;
PaError function() Pa_Terminate;
PaHostApiIndex function() Pa_GetHostApiCount;
PaHostApiIndex function() Pa_GetDefaultHostApi;
const(PaHostApiInfo)* function(PaHostApiIndex hostApi)
Pa_GetHostApiInfo;
PaHostApiIndex function(PaHostApiTypeId type)
Pa_HostApiTypeIdToHostApiIndex;
PaDeviceIndex function(PaHostApiIndex hostApi, int
hostApiDeviceIndex) Pa_HostApiDeviceIndexToDeviceIndex;
const(PaHostErrorInfo)* function()
Pa_GetLastHostErrorInfo;
PaDeviceIndex function() Pa_GetDeviceCount;
PaDeviceIndex function() Pa_GetDefaultInputDevice;
PaDeviceIndex function() Pa_GetDefaultOutputDevice;
const(PaDeviceInfo)* function(PaDeviceIndex device)
Pa_GetDeviceInfo;
PaError function(PaStream *stream, PaStreamFinishedCallback
streamFinishedCallback) Pa_SetStreamFinishedCallback;
PaError function(PaStream *stream) Pa_StartStream;
PaError function(PaStream *stream) Pa_StopStream;
PaError function(PaStream *stream) Pa_AbortStream;
PaError function(PaStream *stream) Pa_IsStreamStopped;
PaError function(PaStream *stream) Pa_IsStreamActive;
PaError function(PaStream* stream, void *buffer, ulong frames)
Pa_ReadStream;
const(PaStreamInfo)* function(PaStream *stream)
Pa_GetStreamInfo;
PaTime function(PaStream *stream) Pa_GetStreamTime;
double function(PaStream* stream) Pa_GetStreamCpuLoad;
PaError function(PaStream* stream, const void *buffer, ulong
frames) Pa_WriteStream;
long function(PaStream* stream)
Pa_GetStreamReadAvailable;
long function(PaStream* stream)
Pa_GetStreamWriteAvailable;
PaError function(PaSampleFormat format)
Pa_GetSampleSize;
void function(long msec) Pa_Sleep;
PaError function(PaStream** stream, const PaStreamParameters
*inputParameters, const PaStreamParameters *outputParameters,
double sampleRate, ulong framesPerBuffer, PaStreamFlags
streamFlags, PaStreamCallback streamCallback, void *userData)
Pa_OpenStream;
PaError function(PaStream** stream, int numInputChannels, int
numOutputChannels, PaSampleFormat sampleFormat, double
sampleRate, ulong framesPerBuffer, PaStreamCallback
streamCallback, void *userData) Pa_OpenDefaultStream;
PaError function(PaStream *stream) Pa_CloseStream;
PaError function(const PaStreamParameters *inputParameters,
const PaStreamParameters *outputParameters, double sampleRate)
Pa_IsFormatSupported;
}
}
}
// Fixes static functions and function pointers to point to their
specified DLL's
static this()
{
version(Windows)
{
import DLLImport;
ImportDLLs!DLL_PortAudio;
}
}
struct Phase
{
float left=0, right=0;
}
bool callbackCalled = false;
extern(C) int sawtooth(const(void)* inputBuffer, void*
outputBuffer, ulong framesPerBuffer,
const(PaStreamCallbackTimeInfo)* timeInfo, PaStreamCallbackFlags
statusFlags, void *userData)
{
callbackCalled = true;
auto phase = cast(Phase*)userData;
auto pout = cast(float*)outputBuffer;
enum vol = 1f;
foreach(i; 0 .. framesPerBuffer)
{
*pout++ = vol * phase.left;
*pout++ = vol * phase.right;
phase.left += 0.01f;
if (phase.left >= 1.0f) phase.left -= 2.0f;
phase.right += 0.03f;
if (phase.right >= 1.0f) phase.right -= 2.0f;
}
return 1;
}
int main()
{
import core.stdc.stdio, std.stdio, std.conv;
with(DLL_PortAudio)
{
enum NUM_SECONDS = 5;
PaStream* stream;
PaError err;
Phase phase_data;
if ((err = Pa_Initialize()) == PaError.NoError)
{
writeln("---------------------------------------------------------------------------");
auto numDevices = Pa_GetDeviceCount();
if(numDevices < 0)
{
printf("ERROR: Pa_CountDevices returned
0x%x\n", numDevices);
err = cast(PaError)numDevices;
goto Lerror;
}
for(auto i = 0; i < numDevices; i++ )
{
auto deviceInfo = Pa_GetDeviceInfo(i);
auto deviceApiInfo =
Pa_GetHostApiInfo(deviceInfo.hostApi);
write("Device "~to!string(i)~" >
"~to!string(deviceInfo.name)~",
"~to!string(deviceInfo.maxInputChannels)~",
"~to!string(deviceInfo.maxOutputChannels)~",
"~to!string(deviceInfo.defaultLowOutputLatency)~","~to!string(deviceInfo.defaultHighOutputLatency)~", "~to!string(deviceInfo.defaultSampleRate)~", "~to!string(deviceInfo.hostApi));
write(", "~to!string(deviceApiInfo.name)~",
"~to!string(deviceApiInfo.type));
writeln();
}
double sampleRate = 44100;
PaStreamParameters* input; // = new
PaStreamParameters();
if (input != null)
{
input.device = 12;
auto id = Pa_GetDeviceInfo(input.device);
input.hostApiSpecificStreamInfo = null;
input.channelCount = id.maxInputChannels;
input.sampleFormat = PaSampleFormat.Float32;
input.suggestedLatency = (id.defaultLowInputLatency +
id.defaultHighInputLatency)/2;
sampleRate = id.defaultSampleRate;
}
PaStreamParameters* output = new PaStreamParameters();
if (output != null)
{
output.device = 12;
auto od = Pa_GetDeviceInfo(output.device);
output.hostApiSpecificStreamInfo = null;
output.channelCount = od.maxOutputChannels;
output.sampleFormat = PaSampleFormat.Float32;
output.suggestedLatency = (od.defaultLowOutputLatency +
od.defaultHighOutputLatency)/2;
sampleRate = od.defaultSampleRate;
} else
{
writeln("ERROR: Invalid output stream
Parameters");
return -1;
}
Pa_SetStreamFinishedCallback(&stream, (data) {
writeln("WFWFWEFWEFWEF"); });
writeln("Opening Device!");
if ((err = Pa_OpenStream(&stream, input, output, sampleRate,
cast(ulong)paFramesPerBufferUnspecified,
cast(PaStreamFlags)(PaStreamFlags.NoFlag +
0*PaStreamFlags.PrimeOutputBuffersUsingStreamCallback),
&sawtooth, &phase_data)) != PaError.NoError) goto Lerror;
writeln("Starting Device!");
if ((err = Pa_StartStream(stream)) != PaError.NoError) goto
Lerror;
Pa_Sleep(NUM_SECONDS * 1000);
writeln("Stopping Device!");
if ((err = Pa_StopStream(stream)) != PaError.NoError) goto
Lerror;
if ((err = Pa_CloseStream(stream)) != PaError.NoError) goto
Lerror;
if ((err = Pa_Terminate()) != PaError.NoError) goto
Lerror;
if (!callbackCalled) writeln("Callback was not
called!");
writeln("DONE!");
getchar();
return 0;
} else
{
Lerror:
writeln(to!string(Pa_GetErrorText(err)));
getchar();
return 1;
}
}
return 0;
}
module DLLImport;
void ImportDLLs(T)()
{
version(Windows)
{
import core.sys.windows.windows, std.conv, std.meta, std.traits;
HINSTANCE[string] DLLs;
foreach(fname; __traits(allMembers, T))
{
mixin("enum isf = isFunction!(T."~fname~");");
mixin("enum isfp = isFunctionPointer!(T."~fname~");");
mixin("enum attrs = __traits(getAttributes,
T."~fname~");");
static if ((isf || isfp) && attrs.length == 2 && attrs[0] ==
"DLLImport")
{
auto dllName = attrs[1];
if (dllName !in DLLs)
DLLs[dllName] =
LoadLibrary(to!wstring(dllName~"\0").ptr);
auto dll = DLLs[dllName];
if (dll == null)
assert(0, "Cannot load DLL
`"~dllName~"'");
auto func = GetProcAddress(dll, fname);
mixin("import "~moduleName!(T)~";");
static if (isf)
mixin("auto p = cast(void**)&"~T.stringof~"."~fname~"; *p =
cast(typeof(p))func;");
else static if (isfp)
mixin(""~T.stringof~"."~fname~" =
cast(typeof("~T.stringof~"."~fname~"))func;");
else
static assert("DLLImport Error");
}
}
}
}
