/* * $Id: pa_skeleton.c 1097 2006-08-26 08:27:53Z rossb $ * Portable Audio I/O Library skeleton implementation * demonstrates how to use the common functions to implement support * for a host API * * Based on the Open Source API proposed by Ross Bencina * Copyright (c) 1999-2002 Ross Bencina, Phil Burk * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files * (the "Software"), to deal in the Software without restriction, * including without limitation the rights to use, copy, modify, merge, * publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, * subject to the following conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. *//* * The text above constitutes the entire PortAudio license; however,  * the PortAudio community also makes the following non-binding requests: * * Any person wishing to distribute modifications to the Software is * requested to send the modifications to the original developer so that * they can be incorporated into the canonical version. It is also  * requested that these non-binding requests be included along with the  * license above. *//** @file @ingroup common_src @brief Skeleton implementation of support for a host API. @note This file is provided as a starting point for implementing support for a new host API. IMPLEMENT ME comments are used to indicate functionality which much be customised for each implementation.*/#include <string.h> /* strlen() */#include "pa_util.h"#include "pa_allocation.h"#include "pa_hostapi.h"#include "pa_stream.h"#include "pa_cpuload.h"#include "pa_process.h"/* prototypes for functions declared in this file */#ifdef __cplusplusextern "C"{#endif /* __cplusplus */PaError PaSkeleton_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index );#ifdef __cplusplus}#endif /* __cplusplus */static void Terminate( struct PaUtilHostApiRepresentation *hostApi );static PaError IsFormatSupported( struct PaUtilHostApiRepresentation *hostApi,                                  const PaStreamParameters *inputParameters,                                  const PaStreamParameters *outputParameters,                                  double sampleRate );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 );static PaError CloseStream( PaStream* stream );static PaError StartStream( PaStream *stream );static PaError StopStream( PaStream *stream );static PaError AbortStream( PaStream *stream );static PaError IsStreamStopped( PaStream *s );static PaError IsStreamActive( PaStream *stream );static PaTime GetStreamTime( PaStream *stream );static double GetStreamCpuLoad( PaStream* stream );static PaError ReadStream( PaStream* stream, void *buffer, unsigned long frames );static PaError WriteStream( PaStream* stream, const void *buffer, unsigned long frames );static signed long GetStreamReadAvailable( PaStream* stream );static signed long GetStreamWriteAvailable( PaStream* stream );/* IMPLEMENT ME: a macro like the following one should be used for reporting host errors */#define PA_SKELETON_SET_LAST_HOST_ERROR( errorCode, errorText ) \    PaUtil_SetLastHostErrorInfo( paInDevelopment, errorCode, errorText )/* PaSkeletonHostApiRepresentation - host api datastructure specific to this implementation */typedef struct{    PaUtilHostApiRepresentation inheritedHostApiRep;    PaUtilStreamInterface callbackStreamInterface;    PaUtilStreamInterface blockingStreamInterface;    PaUtilAllocationGroup *allocations;    /* implementation specific data goes here */}PaSkeletonHostApiRepresentation;  /* IMPLEMENT ME: rename this */PaError PaSkeleton_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex hostApiIndex ){    PaError result = paNoError;    int i, deviceCount;    PaSkeletonHostApiRepresentation *skeletonHostApi;    PaDeviceInfo *deviceInfoArray;    skeletonHostApi = (PaSkeletonHostApiRepresentation*)PaUtil_AllocateMemory( sizeof(PaSkeletonHostApiRepresentation) );    if( !skeletonHostApi )    {        result = paInsufficientMemory;        goto error;    }    skeletonHostApi->allocations = PaUtil_CreateAllocationGroup();    if( !skeletonHostApi->allocations )    {        result = paInsufficientMemory;        goto error;    }    *hostApi = &skeletonHostApi->inheritedHostApiRep;    (*hostApi)->info.structVersion = 1;    (*hostApi)->info.type = paInDevelopment;            /* IMPLEMENT ME: change to correct type id */    (*hostApi)->info.name = "skeleton implementation";  /* IMPLEMENT ME: change to correct name */    (*hostApi)->info.defaultInputDevice = paNoDevice;  /* IMPLEMENT ME */    (*hostApi)->info.defaultOutputDevice = paNoDevice; /* IMPLEMENT ME */    (*hostApi)->info.deviceCount = 0;      deviceCount = 0; /* IMPLEMENT ME */        if( deviceCount > 0 )    {        (*hostApi)->deviceInfos = (PaDeviceInfo**)PaUtil_GroupAllocateMemory(                skeletonHostApi->allocations, sizeof(PaDeviceInfo*) * deviceCount );        if( !(*hostApi)->deviceInfos )        {            result = paInsufficientMemory;            goto error;        }        /* allocate all device info structs in a contiguous block */        deviceInfoArray = (PaDeviceInfo*)PaUtil_GroupAllocateMemory(                skeletonHostApi->allocations, sizeof(PaDeviceInfo) * deviceCount );        if( !deviceInfoArray )        {            result = paInsufficientMemory;            goto error;        }        for( i=0; i < deviceCount; ++i )        {            PaDeviceInfo *deviceInfo = &deviceInfoArray[i];            deviceInfo->structVersion = 2;            deviceInfo->hostApi = hostApiIndex;            deviceInfo->name = 0; /* IMPLEMENT ME: allocate block and copy name eg:                deviceName = (char*)PaUtil_GroupAllocateMemory( skeletonHostApi->allocations, strlen(srcName) + 1 );                if( !deviceName )                {                    result = paInsufficientMemory;                    goto error;                }                strcpy( deviceName, srcName );                deviceInfo->name = deviceName;            */            deviceInfo->maxInputChannels = 0;  /* IMPLEMENT ME */            deviceInfo->maxOutputChannels = 0;  /* IMPLEMENT ME */                        deviceInfo->defaultLowInputLatency = 0.;  /* IMPLEMENT ME */            deviceInfo->defaultLowOutputLatency = 0.;  /* IMPLEMENT ME */            deviceInfo->defaultHighInputLatency = 0.;  /* IMPLEMENT ME */            deviceInfo->defaultHighOutputLatency = 0.;  /* IMPLEMENT ME */              deviceInfo->defaultSampleRate = 0.; /* IMPLEMENT ME */                        (*hostApi)->deviceInfos[i] = deviceInfo;            ++(*hostApi)->info.deviceCount;        }    }    (*hostApi)->Terminate = Terminate;    (*hostApi)->OpenStream = OpenStream;    (*hostApi)->IsFormatSupported = IsFormatSupported;    PaUtil_InitializeStreamInterface( &skeletonHostApi->callbackStreamInterface, CloseStream, StartStream,                                      StopStream, AbortStream, IsStreamStopped, IsStreamActive,                                      GetStreamTime, GetStreamCpuLoad,                                      PaUtil_DummyRead, PaUtil_DummyWrite,                                      PaUtil_DummyGetReadAvailable, PaUtil_DummyGetWriteAvailable );    PaUtil_InitializeStreamInterface( &skeletonHostApi->blockingStreamInterface, CloseStream, StartStream,                                      StopStream, AbortStream, IsStreamStopped, IsStreamActive,                                      GetStreamTime, PaUtil_DummyGetCpuLoad,                                      ReadStream, WriteStream, GetStreamReadAvailable, GetStreamWriteAvailable );    return result;error:    if( skeletonHostApi )    {        if( skeletonHostApi->allocations )        {            PaUtil_FreeAllAllocations( skeletonHostApi->allocations );            PaUtil_DestroyAllocationGroup( skeletonHostApi->allocations );        }                        PaUtil_FreeMemory( skeletonHostApi );    }    return result;}static void Terminate( struct PaUtilHostApiRepresentation *hostApi ){    PaSkeletonHostApiRepresentation *skeletonHostApi = (PaSkeletonHostApiRepresentation*)hostApi;    /*        IMPLEMENT ME:            - clean up any resources not handled by the allocation group    */    if( skeletonHostApi->allocations )    {        PaUtil_FreeAllAllocations( skeletonHostApi->allocations );        PaUtil_DestroyAllocationGroup( skeletonHostApi->allocations );    }    PaUtil_FreeMemory( skeletonHostApi );}static PaError IsFormatSupported( struct PaUtilHostApiRepresentation *hostApi,                                  const PaStreamParameters *inputParameters,                                  const PaStreamParameters *outputParameters,                                  double sampleRate ){    int inputChannelCount, outputChannelCount;    PaSampleFormat inputSampleFormat, outputSampleFormat;        if( inputParameters )    {        inputChannelCount = inputParameters->channelCount;        inputSampleFormat = inputParameters->sampleFormat;        /* all standard sample formats are supported by the buffer adapter,            this implementation doesn't support any custom sample formats */        if( inputSampleFormat & paCustomFormat )            return paSampleFormatNotSupported;                    /* 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;        /* all standard sample formats are supported by the buffer adapter,            this implementation doesn't support any custom sample formats */        if( outputSampleFormat & paCustomFormat )            return paSampleFormatNotSupported;                    /* unless alternate device specification is supported, reject the use of            paUseHostApiSpecificDeviceSpecification */        if( outputParameters->device == paUseHostApiSpecificDeviceSpecification )            return paInvalidDevice;        /* check that output device can support outputChannelCount */        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;    }        /*        IMPLEMENT ME:            - if a full duplex stream is requested, check that the combination                of input and output parameters is supported if necessary            - check that the device supports sampleRate        Because the buffer adapter handles conversion between all standard        sample formats, the following checks are only required if paCustomFormat        is implemented, or under some other unusual conditions.            - check that input device can support inputSampleFormat, or that                we have the capability to convert from inputSampleFormat 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    */    /* suppress unused variable warnings */    (void) sampleRate;    return paFormatIsSupported;}/* PaSkeletonStream - a stream data structure specifically for this implementation */typedef struct PaSkeletonStream{ /* IMPLEMENT ME: rename this */    PaUtilStreamRepresentation streamRepresentation;    PaUtilCpuLoadMeasurer cpuLoadMeasurer;    PaUtilBufferProcessor bufferProcessor;    /* IMPLEMENT ME:            - implementation specific data goes here    */    unsigned long framesPerHostCallback; /* just an example */}PaSkeletonStream;/* see pa_hostapi.h for a list of validity guarantees made about OpenStream parameters */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;    PaSkeletonHostApiRepresentation *skeletonHostApi = (PaSkeletonHostApiRepresentation*)hostApi;    PaSkeletonStream *stream = 0;    unsigned long framesPerHostBuffer = framesPerBuffer; /* these may not be equivalent for all implementations */    int inputChannelCount, outputChannelCount;    PaSampleFormat inputSampleFormat, outputSampleFormat;    PaSampleFormat hostInputSampleFormat, hostOutputSampleFormat;    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 */        /* IMPLEMENT ME - establish which  host formats are available */        hostInputSampleFormat =            PaUtil_SelectClosestAvailableFormat( paInt16 /* native formats */, inputSampleFormat );