static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,
PaStream** s,
PaDeviceIndex inputDevice,
int numInputChannels,
PaSampleFormat inputSampleFormat,
unsigned long inputLatency,
PaHostApiSpecificStreamInfo *inputStreamInfo,
PaDeviceIndex outputDevice,
int numOutputChannels,
PaSampleFormat outputSampleFormat,
unsigned long outputLatency,
PaHostApiSpecificStreamInfo *outputStreamInfo,
double sampleRate,
unsigned long framesPerCallback,
PaStreamFlags streamFlags,
PortAudioCallback *callback,
void *userData )
{
PaError result = paNoError;
PaSkeletonHostApiRepresentation *skeletonHostApi = (PaSkeletonHostApiRepresentation*)hostApi;
PaSkeletonStream *stream = 0;
unsigned long framesPerHostBuffer = framesPerCallback; /* these may not be equivalent for all implementations */
PaSampleFormat hostInputSampleFormat, hostOutputSampleFormat;
/* unless alternate device specification is supported, reject the use of
paUseHostApiSpecificDeviceSpecification */
if( (inputDevice == paUseHostApiSpecificDeviceSpecification)
|| (outputDevice == paUseHostApiSpecificDeviceSpecification) )
return paInvalidDevice;
/* check that input device can support numInputChannels */
if( (inputDevice != paNoDevice) &&
(numInputChannels > hostApi->deviceInfos[ inputDevice ]->maxInputChannels) )
return paInvalidChannelCount;
/* check that output device can support numInputChannels */
if( (outputDevice != paNoDevice) &&
(numOutputChannels > hostApi->deviceInfos[ outputDevice ]->maxOutputChannels) )
return paInvalidChannelCount;
/*
IMPLEMENT ME:
( the following two checks are taken care of by PaUtil_InitializeBufferProcessor() FIXME - checks needed? )
- check that input device can support inputSampleFormat, or that
we have the capability to convert from outputSampleFormat to
a native format
- check that output device can support outputSampleFormat, or that
we have the capability to convert from outputSampleFormat to
a native format
- if a full duplex stream is requested, check that the combination
of input and output parameters is supported
- check that the device supports sampleRate
- alter sampleRate to a close allowable rate if possible / necessary
- validate inputLatency and outputLatency parameters,
use default values where necessary
*/
/* validate inputStreamInfo */
if( inputStreamInfo )
return paIncompatibleStreamInfo; /* this implementation doesn't use custom stream info */
/* validate outputStreamInfo */
if( outputStreamInfo )
return paIncompatibleStreamInfo; /* this implementation doesn't use custom stream info */
/* validate platform specific flags */
if( (streamFlags & paPlatformSpecificFlags) != 0 )
return paInvalidFlag; /* unexpected platform specific flag */
stream = (PaSkeletonStream*)PaUtil_AllocateMemory( sizeof(PaSkeletonStream) );
if( !stream )
{
result = paInsufficientMemory;
goto error;
}
if( callback )
{
PaUtil_InitializeStreamRepresentation( &stream->streamRepresentation,
&skeletonHostApi->callbackStreamInterface, callback, userData );
}
else
{
PaUtil_InitializeStreamRepresentation( &stream->streamRepresentation,
&skeletonHostApi->blockingStreamInterface, callback, userData );
}
PaUtil_InitializeCpuLoadMeasurer( &stream->cpuLoadMeasurer, sampleRate );
/* IMPLEMENT ME - establish which host formats are available */
hostInputSampleFormat =
PaUtil_SelectClosestAvailableFormat( paInt16 /* native formats */, inputSampleFormat );
/* IMPLEMENT ME - establish which host formats are available */
hostOutputSampleFormat =
PaUtil_SelectClosestAvailableFormat( paInt16 /* native formats */, outputSampleFormat );
/* we assume a fixed host buffer size in this example, but the buffer processor
can also support bounded and unknown host buffer sized by passing
paUtilBoundedHostBufferSize or paUtilUnknownHostBufferSize instead of
paUtilFixedHostBufferSize below. */
result = PaUtil_InitializeBufferProcessor( &stream->bufferProcessor,
numInputChannels, inputSampleFormat, hostInputSampleFormat,
numOutputChannels, outputSampleFormat, hostOutputSampleFormat,
sampleRate, streamFlags, framesPerCallback,
framesPerHostBuffer, paUtilFixedHostBufferSize,
callback, userData );
if( result != paNoError )
goto error;
/*
IMPLEMENT ME:
- additional stream setup + opening
*/
stream->framesPerHostCallback = framesPerHostBuffer;
*s = (PaStream*)stream;
return result;
error:
if( stream )
PaUtil_FreeMemory( stream );
return result;
}
static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,
PaStream** s,
const PaStreamParameters *inputParameters,
const PaStreamParameters *outputParameters,
double sampleRate,
unsigned long framesPerBuffer,
PaStreamFlags streamFlags,
PaStreamCallback *streamCallback,
void *userData )
{
PaError result = paNoError;
PaJackHostApiRepresentation *jackHostApi = (PaJackHostApiRepresentation*)hostApi;
PaJackStream *stream = 0;
char port_string[100];
char regex_pattern[100];
const char **jack_ports;
int jack_max_buffer_size = jack_get_buffer_size( jackHostApi->jack_client );
int i;
int inputChannelCount, outputChannelCount;
PaSampleFormat inputSampleFormat, outputSampleFormat;
/* the client has no say over the frames per callback */
if( framesPerBuffer == paFramesPerBufferUnspecified )
framesPerBuffer = jack_max_buffer_size;
/* Preliminary checks */
if( inputParameters )
{
inputChannelCount = inputParameters->channelCount;
inputSampleFormat = inputParameters->sampleFormat;
/* unless alternate device specification is supported, reject the use of
paUseHostApiSpecificDeviceSpecification */
if( inputParameters->device == paUseHostApiSpecificDeviceSpecification )
return paInvalidDevice;
/* check that input device can support inputChannelCount */
if( inputChannelCount > hostApi->deviceInfos[ inputParameters->device ]->maxInputChannels )
return paInvalidChannelCount;
/* validate inputStreamInfo */
if( inputParameters->hostApiSpecificStreamInfo )
return paIncompatibleHostApiSpecificStreamInfo; /* this implementation doesn't use custom stream info */
}
else
{
inputChannelCount = 0;
}
if( outputParameters )
{
outputChannelCount = outputParameters->channelCount;
outputSampleFormat = outputParameters->sampleFormat;
/* unless alternate device specification is supported, reject the use of
paUseHostApiSpecificDeviceSpecification */
if( outputParameters->device == paUseHostApiSpecificDeviceSpecification )
return paInvalidDevice;
/* check that output device can support inputChannelCount */
if( outputChannelCount > hostApi->deviceInfos[ outputParameters->device ]->maxOutputChannels )
return paInvalidChannelCount;
/* validate outputStreamInfo */
if( outputParameters->hostApiSpecificStreamInfo )
return paIncompatibleHostApiSpecificStreamInfo; /* this implementation doesn't use custom stream info */
}
else
{
outputChannelCount = 0;
}
/* ... check that the sample rate exactly matches the ONE acceptable rate */
#define ABS(x) ( (x) > 0 ? (x) : -(x) )
if( ABS(sampleRate - hostApi->deviceInfos[0]->defaultSampleRate) > 1 )
return paInvalidSampleRate;
#undef ABS
/* Allocate memory for structuures */
#define MALLOC(size) \
(PaUtil_GroupAllocateMemory( stream->stream_memory, (size) ))
#define MEMVERIFY(ptr) \
if( (ptr) == NULL ) \
{ \
result = paInsufficientMemory; \
goto error; \
}
stream = (PaJackStream*)PaUtil_AllocateMemory( sizeof(PaJackStream) );
MEMVERIFY( stream );
stream->stream_memory = PaUtil_CreateAllocationGroup();
stream->jack_client = jackHostApi->jack_client;
PaUtil_InitializeCpuLoadMeasurer( &stream->cpuLoadMeasurer, sampleRate );
stream->local_input_ports =
(jack_port_t**) MALLOC(sizeof(jack_port_t*) * inputChannelCount );
stream->local_output_ports =
(jack_port_t**) MALLOC( sizeof(jack_port_t*) * outputChannelCount );
stream->remote_output_ports =
(jack_port_t**) MALLOC( sizeof(jack_port_t*) * inputChannelCount );
stream->remote_input_ports =
(jack_port_t**) MALLOC( sizeof(jack_port_t*) * outputChannelCount );
MEMVERIFY( stream->local_input_ports );
MEMVERIFY( stream->local_output_ports );
MEMVERIFY( stream->remote_input_ports );
MEMVERIFY( stream->remote_output_ports );
stream->num_incoming_connections = inputChannelCount;
stream->num_outgoing_connections = outputChannelCount;
if( streamCallback )
{
PaUtil_InitializeStreamRepresentation( &stream->streamRepresentation,
&jackHostApi->callbackStreamInterface, streamCallback, userData );
}
else
{
/* we do not support blocking I/O */
return paBadIODeviceCombination;
}
/* create the JACK ports. We cannot connect them until audio
* processing begins */
for( i = 0; i < inputChannelCount; i++ )
{
sprintf( port_string, "in_%d", i );
stream->local_input_ports[i] = jack_port_register(
jackHostApi->jack_client, port_string,
JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0 );
}
for( i = 0; i < outputChannelCount; i++ )
{
sprintf( port_string, "out_%d", i );
stream->local_output_ports[i] = jack_port_register(
jackHostApi->jack_client, port_string,
JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0 );
}
/* look up the jack_port_t's for the remote ports. We could do
* this at stream start time, but doing it here ensures the
* name lookup only happens once. */
if( inputChannelCount > 0 )
{
/* ... remote output ports (that we input from) */
sprintf( regex_pattern, "%s:.*", hostApi->deviceInfos[ inputParameters->device ]->name );
jack_ports = jack_get_ports( jackHostApi->jack_client, regex_pattern,
NULL, JackPortIsOutput);
for( i = 0; i < inputChannelCount && jack_ports[i]; i++ )
{
stream->remote_output_ports[i] = jack_port_by_name(
jackHostApi->jack_client, jack_ports[i] );
}
if( i < inputChannelCount )
{
/* we found fewer ports than we expected */
return paInternalError;
}
free( jack_ports ); // XXX: this doesn't happen if we exit prematurely
}
if( outputChannelCount > 0 )
{
/* ... remote input ports (that we output to) */
sprintf( regex_pattern, "%s:.*", hostApi->deviceInfos[ outputParameters->device ]->name );
jack_ports = jack_get_ports( jackHostApi->jack_client, regex_pattern,
NULL, JackPortIsInput);
for( i = 0; i < outputChannelCount && jack_ports[i]; i++ )
{
stream->remote_input_ports[i] = jack_port_by_name(
jackHostApi->jack_client, jack_ports[i] );
}
if( i < outputChannelCount )
{
/* we found fewer ports than we expected */
return paInternalError;
}
free( jack_ports ); // XXX: this doesn't happen if we exit prematurely
}
result = PaUtil_InitializeBufferProcessor(
&stream->bufferProcessor,
inputChannelCount,
inputSampleFormat,
paFloat32, /* hostInputSampleFormat */
outputChannelCount,
outputSampleFormat,
paFloat32, /* hostOutputSampleFormat */
sampleRate,
streamFlags,
framesPerBuffer,
jack_max_buffer_size,
paUtilFixedHostBufferSize,
streamCallback,
userData );
if( result != paNoError )
goto error;
stream->is_running = FALSE;
stream->t0 = -1;/* set the first time through the callback*/
stream->total_frames_sent = 0;
jack_set_process_callback( jackHostApi->jack_client, JackCallback, stream );
*s = (PaStream*)stream;
return result;
error:
if( stream )
{
if( stream->stream_memory )
{
PaUtil_FreeAllAllocations( stream->stream_memory );
PaUtil_DestroyAllocationGroup( stream->stream_memory );
}
PaUtil_FreeMemory( stream );
}
return result;
#undef MALLOC
#undef MEMVERIFY
}
static PaError
OpenStream(struct PaUtilHostApiRepresentation *hostApi,
PaStream **stream,
const PaStreamParameters *inputPar,
const PaStreamParameters *outputPar,
double sampleRate,
unsigned long framesPerBuffer,
PaStreamFlags streamFlags,
PaStreamCallback *streamCallback,
void *userData)
{
PaSndioHostApiRepresentation *sndioHostApi = (PaSndioHostApiRepresentation *)hostApi;
PaSndioStream *s;
PaError err;
struct sio_hdl *hdl;
struct sio_par par;
unsigned mode;
int inch, onch;
PaSampleFormat ifmt, ofmt, siofmt;
DPR("OpenStream:\n");
mode = 0;
inch = onch = 0;
ifmt = ofmt = 0;
sio_initpar(&par);
if (outputPar && outputPar->channelCount > 0) {
if (outputPar->device != 0) {
DPR("OpenStream: %d: bad output device\n", outputPar->device);
return paInvalidDevice;
}
if (outputPar->hostApiSpecificStreamInfo) {
DPR("OpenStream: output specific info\n");
return paIncompatibleHostApiSpecificStreamInfo;
}
if (!sndioSetFmt(&par, outputPar->sampleFormat)) {
return paSampleFormatNotSupported;
}
ofmt = outputPar->sampleFormat;
onch = par.pchan = outputPar->channelCount;
mode |= SIO_PLAY;
}
if (inputPar && inputPar->channelCount > 0) {
if (inputPar->device != 0) {
DPR("OpenStream: %d: bad input device\n", inputPar->device);
return paInvalidDevice;
}
if (inputPar->hostApiSpecificStreamInfo) {
DPR("OpenStream: input specific info\n");
return paIncompatibleHostApiSpecificStreamInfo;
}
if (!sndioSetFmt(&par, inputPar->sampleFormat)) {
return paSampleFormatNotSupported;
}
ifmt = inputPar->sampleFormat;
inch = par.rchan = inputPar->channelCount;
mode |= SIO_REC;
}
par.rate = sampleRate;
if (framesPerBuffer != paFramesPerBufferUnspecified)
par.round = framesPerBuffer;
DPR("OpenStream: mode = %x, trying rate = %u\n", mode, par.rate);
hdl = sio_open(SIO_DEVANY, mode, 0);
if (hdl == NULL)
return paUnanticipatedHostError;
if (!sio_setpar(hdl, &par)) {
sio_close(hdl);
return paUnanticipatedHostError;
}
if (!sio_getpar(hdl, &par)) {
sio_close(hdl);
return paUnanticipatedHostError;
}
if (!sndioGetFmt(&par, &siofmt)) {
sio_close(hdl);
return paSampleFormatNotSupported;
}
if ((mode & SIO_REC) && par.rchan != inputPar->channelCount) {
DPR("OpenStream: rchan(%u) != %d\n", par.rchan, inputPar->channelCount);
sio_close(hdl);
return paInvalidChannelCount;
}
if ((mode & SIO_PLAY) && par.pchan != outputPar->channelCount) {
DPR("OpenStream: pchan(%u) != %d\n", par.pchan, outputPar->channelCount);
sio_close(hdl);
return paInvalidChannelCount;
}
if ((double)par.rate < sampleRate * 0.995 ||
(double)par.rate > sampleRate * 1.005) {
DPR("OpenStream: rate(%u) != %g\n", par.rate, sampleRate);
sio_close(hdl);
return paInvalidSampleRate;
}
s = (PaSndioStream *)PaUtil_AllocateMemory(sizeof(PaSndioStream));
if (s == NULL) {
sio_close(hdl);
return paInsufficientMemory;
}
PaUtil_InitializeStreamRepresentation(&s->base,
streamCallback ? &sndioHostApi->callback : &sndioHostApi->blocking,
streamCallback, userData);
DPR("inch = %d, onch = %d, ifmt = %x, ofmt = %x\n",
inch, onch, ifmt, ofmt);
err = PaUtil_InitializeBufferProcessor(&s->bufproc,
inch, ifmt, siofmt,
onch, ofmt, siofmt,
sampleRate,
streamFlags,
framesPerBuffer,
par.round,
paUtilFixedHostBufferSize,
streamCallback, userData);
if (err) {
DPR("OpenStream: PaUtil_InitializeBufferProcessor failed\n");
PaUtil_FreeMemory(s);
sio_close(hdl);
return err;
}
if (mode & SIO_REC) {
s->rbuf = malloc(par.round * par.rchan * par.bps);
if (s->rbuf == NULL) {
DPR("OpenStream: failed to allocate rbuf\n");
PaUtil_FreeMemory(s);
sio_close(hdl);
return paInsufficientMemory;
}
}
if (mode & SIO_PLAY) {
s->wbuf = malloc(par.round * par.pchan * par.bps);
if (s->wbuf == NULL) {
DPR("OpenStream: failed to allocate wbuf\n");
free(s->rbuf);
PaUtil_FreeMemory(s);
sio_close(hdl);
return paInsufficientMemory;
}
}
s->base.streamInfo.inputLatency = 0;
s->base.streamInfo.outputLatency = (mode & SIO_PLAY) ?
(double)(par.bufsz + PaUtil_GetBufferProcessorOutputLatencyFrames(&s->bufproc)) / (double)par.rate : 0;
s->base.streamInfo.sampleRate = par.rate;
s->active = 0;
s->stopped = 1;
s->mode = mode;
s->hdl = hdl;
s->par = par;
*stream = s;
DPR("OpenStream: done\n");
return paNoError;
}
static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,
PaStream** s,
const PaStreamParameters *inputParameters,
const PaStreamParameters *outputParameters,
double sampleRate,
unsigned long framesPerBuffer,
PaStreamFlags streamFlags,
PaStreamCallback *streamCallback,
void *userData )
{
PaError err = paNoError;
PaMacCoreHostApiRepresentation *macCoreHostApi = (PaMacCoreHostApiRepresentation *)hostApi;
PaMacCoreStream *stream = PaUtil_AllocateMemory(sizeof(PaMacCoreStream));
stream->isActive = 0;
stream->isStopped = 1;
stream->inputDevice = kAudioDeviceUnknown;
stream->outputDevice = kAudioDeviceUnknown;
PaUtil_InitializeStreamRepresentation( &stream->streamRepresentation,
( (streamCallback)
? &macCoreHostApi->callbackStreamInterface
: &macCoreHostApi->blockingStreamInterface ),
streamCallback, userData );
PaUtil_InitializeCpuLoadMeasurer( &stream->cpuLoadMeasurer, sampleRate );
*s = (PaStream*)stream;
PaMacClientData *clientData = PaUtil_AllocateMemory(sizeof(PaMacClientData));
clientData->stream = stream;
clientData->callback = streamCallback;
clientData->userData = userData;
clientData->inputBuffer = 0;
clientData->outputBuffer = 0;
clientData->ditherGenerator = PaUtil_AllocateMemory(sizeof(PaUtilTriangularDitherGenerator));
PaUtil_InitializeTriangularDitherState(clientData->ditherGenerator);
if (inputParameters != NULL) {
stream->inputDevice = macCoreHostApi->macCoreDeviceIds[inputParameters->device];
clientData->inputConverter = PaUtil_SelectConverter(paFloat32, inputParameters->sampleFormat, streamFlags);
clientData->inputBuffer = PaUtil_AllocateMemory(Pa_GetSampleSize(inputParameters->sampleFormat) * framesPerBuffer * inputParameters->channelCount);
clientData->inputChannelCount = inputParameters->channelCount;
clientData->inputSampleFormat = inputParameters->sampleFormat;
err = SetUpUnidirectionalStream(stream->inputDevice, sampleRate, framesPerBuffer, 1);
}
if (err == paNoError && outputParameters != NULL) {
stream->outputDevice = macCoreHostApi->macCoreDeviceIds[outputParameters->device];
clientData->outputConverter = PaUtil_SelectConverter(outputParameters->sampleFormat, paFloat32, streamFlags);
clientData->outputBuffer = PaUtil_AllocateMemory(Pa_GetSampleSize(outputParameters->sampleFormat) * framesPerBuffer * outputParameters->channelCount);
clientData->outputChannelCount = outputParameters->channelCount;
clientData->outputSampleFormat = outputParameters->sampleFormat;
err = SetUpUnidirectionalStream(stream->outputDevice, sampleRate, framesPerBuffer, 0);
}
if (inputParameters == NULL || outputParameters == NULL || stream->inputDevice == stream->outputDevice) {
AudioDeviceID device = (inputParameters == NULL) ? stream->outputDevice : stream->inputDevice;
AudioDeviceAddIOProc(device, AudioIOProc, clientData);
}
else {
// using different devices for input and output
AudioDeviceAddIOProc(stream->inputDevice, AudioInputProc, clientData);
AudioDeviceAddIOProc(stream->outputDevice, AudioOutputProc, clientData);
}
return err;
}
