summaryrefslogtreecommitdiff
path: root/portaudio/src/hostapi/asihpi
diff options
context:
space:
mode:
Diffstat (limited to 'portaudio/src/hostapi/asihpi')
-rw-r--r--portaudio/src/hostapi/asihpi/pa_linux_asihpi.c2893
1 files changed, 2893 insertions, 0 deletions
diff --git a/portaudio/src/hostapi/asihpi/pa_linux_asihpi.c b/portaudio/src/hostapi/asihpi/pa_linux_asihpi.c
new file mode 100644
index 0000000..79eb1d7
--- /dev/null
+++ b/portaudio/src/hostapi/asihpi/pa_linux_asihpi.c
@@ -0,0 +1,2893 @@
+/*
+ * $Id:$
+ * PortAudio Portable Real-Time Audio Library
+ * Latest Version at: http://www.portaudio.com
+ * AudioScience HPI implementation by Fred Gleason, Ludwig Schwardt and
+ * Eliot Blennerhassett
+ *
+ * Copyright (c) 2003 Fred Gleason <fredg@salemradiolabs.com>
+ * Copyright (c) 2005,2006 Ludwig Schwardt <schwardt@sun.ac.za>
+ * Copyright (c) 2011 Eliot Blennerhassett <eblennerhassett@audioscience.com>
+ *
+ * Based on the Open Source API proposed by Ross Bencina
+ * Copyright (c) 1999-2008 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.
+ */
+
+/*
+ * Modification History
+ * 12/2003 - Initial version
+ * 09/2005 - v19 version [rewrite]
+ */
+
+/** @file
+ @ingroup hostapi_src
+ @brief Host API implementation supporting AudioScience cards
+ via the Linux HPI interface.
+
+ <h3>Overview</h3>
+
+ This is a PortAudio implementation for the AudioScience HPI Audio API
+ on the Linux platform. AudioScience makes a range of audio adapters customised
+ for the broadcasting industry, with support for both Windows and Linux.
+ More information on their products can be found on their website:
+
+ http://www.audioscience.com
+
+ Documentation for the HPI API can be found at:
+
+ http://www.audioscience.com/internet/download/sdk/hpi_usermanual_html/html/index.html
+
+ The Linux HPI driver itself (a kernel module + library) can be downloaded from:
+
+ http://www.audioscience.com/internet/download/linux_drivers.htm
+
+ <h3>Implementation strategy</h3>
+
+ *Note* Ideally, AudioScience cards should be handled by the PortAudio ALSA
+ implementation on Linux, as ALSA is the preferred Linux soundcard API. The existence
+ of this host API implementation might therefore seem a bit flawed. Unfortunately, at
+ the time of the creation of this implementation (June 2006), the PA ALSA implementation
+ could not make use of the existing AudioScience ALSA driver. PA ALSA uses the
+ "memory-mapped" (mmap) ALSA access mode to interact with the ALSA library, while the
+ AudioScience ALSA driver only supports the "read-write" access mode. The appropriate
+ solution to this problem is to add "read-write" support to PortAudio ALSA, thereby
+ extending the range of soundcards it supports (AudioScience cards are not the only
+ ones with this problem). Given the author's limited knowledge of ALSA and the
+ simplicity of the HPI API, the second-best solution was born...
+
+ The following mapping between HPI and PA was followed:
+ HPI subsystem => PortAudio host API
+ HPI adapter => nothing specific
+ HPI stream => PortAudio device
+
+ Each HPI stream is either input or output (not both), and can support
+ different channel counts, sampling rates and sample formats. It is therefore
+ a more natural fit to a PA device. A PA stream can therefore combine two
+ HPI streams (one input and one output) into a "full-duplex" stream. These
+ HPI streams can even be on different physical adapters. The two streams ought to be
+ sample-synchronised when they reside on the same adapter, as most AudioScience adapters
+ derive their ADC and DAC clocks from one master clock. When combining two adapters
+ into one full-duplex stream, however, the use of a word clock connection between the
+ adapters is strongly recommended.
+
+ The HPI interface is inherently blocking, making use of read and write calls to
+ transfer data between user buffers and driver buffers. The callback interface therefore
+ requires a helper thread ("callback engine") which periodically transfers data (one thread
+ per PA stream, in fact). The current implementation explicitly sleeps via Pa_Sleep() until
+ enough samples can be transferred (select() or poll() would be better, but currently seems
+ impossible...). The thread implementation makes use of the Unix thread helper functions
+ and some pthread calls here and there. If a unified PA thread exists, this host API
+ implementation might also compile on Windows, as this is the only real Linux-specific
+ part of the code.
+
+ There is no inherent fixed buffer size in the HPI interface, as in some other host APIs.
+ The PortAudio implementation contains a buffer that is allocated during OpenStream and
+ used to transfer data between the callback and the HPI driver buffer. The size of this
+ buffer is quite flexible and is derived from latency suggestions and matched to the
+ requested callback buffer size as far as possible. It can become quite huge, as the
+ AudioScience cards are typically geared towards higher-latency applications and contain
+ large hardware buffers.
+
+ The HPI interface natively supports most common sample formats and sample rates (some
+ conversion is done on the adapter itself).
+
+ Stream time is measured based on the number of processed frames, which is adjusted by the
+ number of frames currently buffered by the HPI driver.
+
+ There is basic support for detecting overflow and underflow. The HPI interface does not
+ explicitly indicate this, so thresholds on buffer levels are used in combination with
+ stream state. Recovery from overflow and underflow is left to the PA client.
+
+ Blocking streams are also implemented. It makes use of the same polling routines that
+ the callback interface uses, in order to prevent the allocation of variable-sized
+ buffers during reading and writing. The framesPerBuffer parameter is therefore still
+ relevant, and this can be increased in the blocking case to improve efficiency.
+
+ The implementation contains extensive reporting macros (slightly modified PA_ENSURE and
+ PA_UNLESS versions) and a useful stream dump routine to provide debugging feedback.
+
+ Output buffer priming via the user callback (i.e. paPrimeOutputBuffersUsingStreamCallback
+ and friends) is not implemented yet. All output is primed with silence.
+ */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h> /* strlen() */
+#include <pthread.h> /* pthreads and friends */
+#include <assert.h> /* assert */
+#include <math.h> /* ceil, floor */
+
+#include <asihpi/hpi.h> /* HPI API */
+
+#include "portaudio.h" /* PortAudio API */
+#include "pa_util.h" /* PA_DEBUG, other small utilities */
+#include "pa_unix_util.h" /* Unix threading utilities */
+#include "pa_allocation.h" /* Group memory allocation */
+#include "pa_hostapi.h" /* Host API structs */
+#include "pa_stream.h" /* Stream interface structs */
+#include "pa_cpuload.h" /* CPU load measurer */
+#include "pa_process.h" /* Buffer processor */
+#include "pa_converters.h" /* PaUtilZeroer */
+#include "pa_debugprint.h"
+
+/* -------------------------------------------------------------------------- */
+
+/*
+ * Defines
+ */
+
+/* Error reporting and assertions */
+
+/** Evaluate expression, and return on any PortAudio errors */
+#define PA_ENSURE_(expr) \
+ do { \
+ PaError paError = (expr); \
+ if( UNLIKELY( paError < paNoError ) ) \
+ { \
+ PA_DEBUG(( "Expression '" #expr "' failed in '" __FILE__ "', line: " STRINGIZE( __LINE__ ) "\n" )); \
+ result = paError; \
+ goto error; \
+ } \
+ } while (0);
+
+/** Assert expression, else return the provided PaError */
+#define PA_UNLESS_(expr, paError) \
+ do { \
+ if( UNLIKELY( (expr) == 0 ) ) \
+ { \
+ PA_DEBUG(( "Expression '" #expr "' failed in '" __FILE__ "', line: " STRINGIZE( __LINE__ ) "\n" )); \
+ result = (paError); \
+ goto error; \
+ } \
+ } while( 0 );
+
+/** Check return value of HPI function, and map it to PaError */
+#define PA_ASIHPI_UNLESS_(expr, paError) \
+ do { \
+ hpi_err_t hpiError = (expr); \
+ /* If HPI error occurred */ \
+ if( UNLIKELY( hpiError ) ) \
+ { \
+ char szError[256]; \
+ HPI_GetErrorText( hpiError, szError ); \
+ PA_DEBUG(( "HPI error %d occurred: %s\n", hpiError, szError )); \
+ /* This message will always be displayed, even if debug info is disabled */ \
+ PA_DEBUG(( "Expression '" #expr "' failed in '" __FILE__ "', line: " STRINGIZE( __LINE__ ) "\n" )); \
+ if( (paError) == paUnanticipatedHostError ) \
+ { \
+ PA_DEBUG(( "Host error description: %s\n", szError )); \
+ /* PaUtil_SetLastHostErrorInfo should only be used in the main thread */ \
+ if( pthread_equal( pthread_self(), paUnixMainThread ) ) \
+ { \
+ PaUtil_SetLastHostErrorInfo( paInDevelopment, hpiError, szError ); \
+ } \
+ } \
+ /* If paNoError is specified, continue as usual */ \
+ /* (useful if you only want to print out the debug messages above) */ \
+ if( (paError) < 0 ) \
+ { \
+ result = (paError); \
+ goto error; \
+ } \
+ } \
+ } while( 0 );
+
+/** Report HPI error code and text */
+#define PA_ASIHPI_REPORT_ERROR_(hpiErrorCode) \
+ do { \
+ char szError[256]; \
+ HPI_GetErrorText( hpiError, szError ); \
+ PA_DEBUG(( "HPI error %d occurred: %s\n", hpiError, szError )); \
+ /* PaUtil_SetLastHostErrorInfo should only be used in the main thread */ \
+ if( pthread_equal( pthread_self(), paUnixMainThread ) ) \
+ { \
+ PaUtil_SetLastHostErrorInfo( paInDevelopment, (hpiErrorCode), szError ); \
+ } \
+ } while( 0 );
+
+/* Defaults */
+
+/** Sample formats available natively on AudioScience hardware */
+#define PA_ASIHPI_AVAILABLE_FORMATS_ (paFloat32 | paInt32 | paInt24 | paInt16 | paUInt8)
+/** Enable background bus mastering (BBM) for buffer transfers, if available (see HPI docs) */
+#define PA_ASIHPI_USE_BBM_ 1
+/** Minimum number of frames in HPI buffer (for either data or available space).
+ If buffer contains less data/space, it indicates xrun or completion. */
+#define PA_ASIHPI_MIN_FRAMES_ 1152
+/** Minimum polling interval in milliseconds, which determines minimum host buffer size */
+#define PA_ASIHPI_MIN_POLLING_INTERVAL_ 10
+
+/* -------------------------------------------------------------------------- */
+
+/*
+ * Structures
+ */
+
+/** Host API global data */
+typedef struct PaAsiHpiHostApiRepresentation
+{
+ /* PortAudio "base class" - keep the baseRep first! (C-style inheritance) */
+ PaUtilHostApiRepresentation baseHostApiRep;
+ PaUtilStreamInterface callbackStreamInterface;
+ PaUtilStreamInterface blockingStreamInterface;
+
+ PaUtilAllocationGroup *allocations;
+
+ /* implementation specific data goes here */
+
+ PaHostApiIndex hostApiIndex;
+}
+PaAsiHpiHostApiRepresentation;
+
+
+/** Device data */
+typedef struct PaAsiHpiDeviceInfo
+{
+ /* PortAudio "base class" - keep the baseRep first! (C-style inheritance) */
+ /** Common PortAudio device information */
+ PaDeviceInfo baseDeviceInfo;
+
+ /* implementation specific data goes here */
+
+ /** Adapter index */
+ uint16_t adapterIndex;
+ /** Adapter model number (hex) */
+ uint16_t adapterType;
+ /** Adapter HW/SW version */
+ uint16_t adapterVersion;
+ /** Adapter serial number */
+ uint32_t adapterSerialNumber;
+ /** Stream number */
+ uint16_t streamIndex;
+ /** 0=Input, 1=Output (HPI streams are either input or output but not both) */
+ uint16_t streamIsOutput;
+}
+PaAsiHpiDeviceInfo;
+
+
+/** Stream state as defined by PortAudio.
+ It seems that the host API implementation has to keep track of the PortAudio stream state.
+ Please note that this is NOT the same as the state of the underlying HPI stream. By separating
+ these two concepts, a lot of flexibility is gained. There is a rough match between the two,
+ of course, but forcing a precise match is difficult. For example, HPI_STATE_DRAINED can occur
+ during the Active state of PortAudio (due to underruns) and also during CallBackFinished in
+ the case of an output stream. Similarly, HPI_STATE_STOPPED mostly coincides with the Stopped
+ PortAudio state, by may also occur in the CallbackFinished state when recording is finished.
+
+ Here is a rough match-up:
+
+ PortAudio state => HPI state
+ --------------- ---------
+ Active => HPI_STATE_RECORDING, HPI_STATE_PLAYING, (HPI_STATE_DRAINED)
+ Stopped => HPI_STATE_STOPPED
+ CallbackFinished => HPI_STATE_STOPPED, HPI_STATE_DRAINED */
+typedef enum PaAsiHpiStreamState
+{
+ paAsiHpiStoppedState=0,
+ paAsiHpiActiveState=1,
+ paAsiHpiCallbackFinishedState=2
+}
+PaAsiHpiStreamState;
+
+
+/** Stream component data (associated with one direction, i.e. either input or output) */
+typedef struct PaAsiHpiStreamComponent
+{
+ /** Device information (HPI handles, etc) */
+ PaAsiHpiDeviceInfo *hpiDevice;
+ /** Stream handle, as passed to HPI interface. */
+ hpi_handle_t hpiStream;
+ /** Stream format, as passed to HPI interface */
+ struct hpi_format hpiFormat;
+ /** Number of bytes per frame, derived from hpiFormat and saved for convenience */
+ uint32_t bytesPerFrame;
+ /** Size of hardware (on-card) buffer of stream in bytes */
+ uint32_t hardwareBufferSize;
+ /** Size of host (BBM) buffer of stream in bytes (if used) */
+ uint32_t hostBufferSize;
+ /** Upper limit on the utilization of output stream buffer (both hardware and host).
+ This prevents large latencies in an output-only stream with a potentially huge buffer
+ and a fast data generator, which would otherwise keep the hardware buffer filled to
+ capacity. See also the "Hardware Buffering=off" option in the AudioScience WAV driver. */
+ uint32_t outputBufferCap;
+ /** Sample buffer (halfway station between HPI and buffer processor) */
+ uint8_t *tempBuffer;
+ /** Sample buffer size, in bytes */
+ uint32_t tempBufferSize;
+}
+PaAsiHpiStreamComponent;
+
+
+/** Stream data */
+typedef struct PaAsiHpiStream
+{
+ /* PortAudio "base class" - keep the baseRep first! (C-style inheritance) */
+ PaUtilStreamRepresentation baseStreamRep;
+ PaUtilCpuLoadMeasurer cpuLoadMeasurer;
+ PaUtilBufferProcessor bufferProcessor;
+
+ PaUtilAllocationGroup *allocations;
+
+ /* implementation specific data goes here */
+
+ /** Separate structs for input and output sides of stream */
+ PaAsiHpiStreamComponent *input, *output;
+
+ /** Polling interval (in milliseconds) */
+ uint32_t pollingInterval;
+ /** Are we running in callback mode? */
+ int callbackMode;
+ /** Number of frames to transfer at a time to/from HPI */
+ unsigned long maxFramesPerHostBuffer;
+ /** Indicates that the stream is in the paNeverDropInput mode */
+ int neverDropInput;
+ /** Contains copy of user buffers, used by blocking interface to transfer non-interleaved data.
+ It went here instead of to each stream component, as the stream component buffer setup in
+ PaAsiHpi_SetupBuffers doesn't know the stream details such as callbackMode.
+ (Maybe a problem later if ReadStream and WriteStream happens concurrently on same stream.) */
+ void **blockingUserBufferCopy;
+
+ /* Thread-related variables */
+
+ /** Helper thread which will deliver data to user callback */
+ PaUnixThread thread;
+ /** PortAudio stream state (Active/Stopped/CallbackFinished) */
+ volatile sig_atomic_t state;
+ /** Hard abort, i.e. drop frames? */
+ volatile sig_atomic_t callbackAbort;
+ /** True if stream stopped via exiting callback with paComplete/paAbort flag
+ (as opposed to explicit call to StopStream/AbortStream) */
+ volatile sig_atomic_t callbackFinished;
+}
+PaAsiHpiStream;
+
+
+/** Stream state information, collected together for convenience */
+typedef struct PaAsiHpiStreamInfo
+{
+ /** HPI stream state (HPI_STATE_STOPPED, HPI_STATE_PLAYING, etc.) */
+ uint16_t state;
+ /** Size (in bytes) of recording/playback data buffer in HPI driver */
+ uint32_t bufferSize;
+ /** Amount of data (in bytes) available in the buffer */
+ uint32_t dataSize;
+ /** Number of frames played/recorded since last stream reset */
+ uint32_t frameCounter;
+ /** Amount of data (in bytes) in hardware (on-card) buffer.
+ This differs from dataSize if bus mastering (BBM) is used, which introduces another
+ driver-level buffer to which dataSize/bufferSize then refers. */
+ uint32_t auxDataSize;
+ /** Total number of data frames currently buffered by HPI driver (host + hw buffers) */
+ uint32_t totalBufferedData;
+ /** Size of immediately available data (for input) or space (for output) in frames.
+ This only checks the first-level buffer (typically host buffer). This amount can be
+ transferred immediately. */
+ uint32_t availableFrames;
+ /** Indicates that hardware buffer is getting too full */
+ int overflow;
+ /** Indicates that hardware buffer is getting too empty */
+ int underflow;
+}
+PaAsiHpiStreamInfo;
+
+/* -------------------------------------------------------------------------- */
+
+/*
+ * Function prototypes
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+ /* The only exposed function in the entire host API implementation */
+ PaError PaAsiHpi_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 );
+
+/* Stream prototypes */
+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 *s );
+static PaError StartStream( PaStream *s );
+static PaError StopStream( PaStream *s );
+static PaError AbortStream( PaStream *s );
+static PaError IsStreamStopped( PaStream *s );
+static PaError IsStreamActive( PaStream *s );
+static PaTime GetStreamTime( PaStream *s );
+static double GetStreamCpuLoad( PaStream *s );
+
+/* Blocking prototypes */
+static PaError ReadStream( PaStream *s, void *buffer, unsigned long frames );
+static PaError WriteStream( PaStream *s, const void *buffer, unsigned long frames );
+static signed long GetStreamReadAvailable( PaStream *s );
+static signed long GetStreamWriteAvailable( PaStream *s );
+
+/* Callback prototypes */
+static void *CallbackThreadFunc( void *userData );
+
+/* Functions specific to this API */
+static PaError PaAsiHpi_BuildDeviceList( PaAsiHpiHostApiRepresentation *hpiHostApi );
+static uint16_t PaAsiHpi_PaToHpiFormat( PaSampleFormat paFormat );
+static PaSampleFormat PaAsiHpi_HpiToPaFormat( uint16_t hpiFormat );
+static PaError PaAsiHpi_CreateFormat( struct PaUtilHostApiRepresentation *hostApi,
+ const PaStreamParameters *parameters, double sampleRate,
+ PaAsiHpiDeviceInfo **hpiDevice, struct hpi_format *hpiFormat );
+static PaError PaAsiHpi_OpenInput( struct PaUtilHostApiRepresentation *hostApi,
+ const PaAsiHpiDeviceInfo *hpiDevice, const struct hpi_format *hpiFormat,
+ hpi_handle_t *hpiStream );
+static PaError PaAsiHpi_OpenOutput( struct PaUtilHostApiRepresentation *hostApi,
+ const PaAsiHpiDeviceInfo *hpiDevice, const struct hpi_format *hpiFormat,
+ hpi_handle_t *hpiStream );
+static PaError PaAsiHpi_GetStreamInfo( PaAsiHpiStreamComponent *streamComp, PaAsiHpiStreamInfo *info );
+static void PaAsiHpi_StreamComponentDump( PaAsiHpiStreamComponent *streamComp, PaAsiHpiStream *stream );
+static void PaAsiHpi_StreamDump( PaAsiHpiStream *stream );
+static PaError PaAsiHpi_SetupBuffers( PaAsiHpiStreamComponent *streamComp, uint32_t pollingInterval,
+ unsigned long framesPerPaHostBuffer, PaTime suggestedLatency );
+static PaError PaAsiHpi_PrimeOutputWithSilence( PaAsiHpiStream *stream );
+static PaError PaAsiHpi_StartStream( PaAsiHpiStream *stream, int outputPrimed );
+static PaError PaAsiHpi_StopStream( PaAsiHpiStream *stream, int abort );
+static PaError PaAsiHpi_ExplicitStop( PaAsiHpiStream *stream, int abort );
+static void PaAsiHpi_OnThreadExit( void *userData );
+static PaError PaAsiHpi_WaitForFrames( PaAsiHpiStream *stream, unsigned long *framesAvail,
+ PaStreamCallbackFlags *cbFlags );
+static void PaAsiHpi_CalculateTimeInfo( PaAsiHpiStream *stream, PaStreamCallbackTimeInfo *timeInfo );
+static PaError PaAsiHpi_BeginProcessing( PaAsiHpiStream* stream, unsigned long* numFrames,
+ PaStreamCallbackFlags *cbFlags );
+static PaError PaAsiHpi_EndProcessing( PaAsiHpiStream *stream, unsigned long numFrames,
+ PaStreamCallbackFlags *cbFlags );
+
+/* ==========================================================================
+ * ============================= IMPLEMENTATION =============================
+ * ========================================================================== */
+
+/* --------------------------- Host API Interface --------------------------- */
+
+/** Enumerate all PA devices (= HPI streams).
+ This compiles a list of all HPI adapters, and registers a PA device for each input and
+ output stream it finds. Most errors are ignored, as missing or erroneous devices are
+ simply skipped.
+
+ @param hpiHostApi Pointer to HPI host API struct
+
+ @return PortAudio error code (only paInsufficientMemory in practice)
+ */
+static PaError PaAsiHpi_BuildDeviceList( PaAsiHpiHostApiRepresentation *hpiHostApi )
+{
+ PaError result = paNoError;
+ PaUtilHostApiRepresentation *hostApi = &hpiHostApi->baseHostApiRep;
+ PaHostApiInfo *baseApiInfo = &hostApi->info;
+ PaAsiHpiDeviceInfo *hpiDeviceList;
+ int numAdapters;
+ hpi_err_t hpiError = 0;
+ int i, j, deviceCount = 0, deviceIndex = 0;
+
+ assert( hpiHostApi );
+
+ /* Errors not considered critical here (subsystem may report 0 devices), but report them */
+ /* in debug mode. */
+ PA_ASIHPI_UNLESS_( HPI_SubSysGetNumAdapters( NULL, &numAdapters), paNoError );
+
+ for( i=0; i < numAdapters; ++i )
+ {
+ uint16_t inStreams, outStreams;
+ uint16_t version;
+ uint32_t serial;
+ uint16_t type;
+ uint32_t idx;
+
+ hpiError = HPI_SubSysGetAdapter(NULL, i, &idx, &type);
+ if (hpiError)
+ continue;
+
+ /* Try to open adapter */
+ hpiError = HPI_AdapterOpen( NULL, idx );
+ /* Report error and skip to next device on failure */
+ if( hpiError )
+ {
+ PA_ASIHPI_REPORT_ERROR_( hpiError );
+ continue;
+ }
+ hpiError = HPI_AdapterGetInfo( NULL, idx, &outStreams, &inStreams,
+ &version, &serial, &type );
+ /* Skip to next device on failure */
+ if( hpiError )
+ {
+ PA_ASIHPI_REPORT_ERROR_( hpiError );
+ continue;
+ }
+ else
+ {
+ /* Assign default devices if available and increment device count */
+ if( (baseApiInfo->defaultInputDevice == paNoDevice) && (inStreams > 0) )
+ baseApiInfo->defaultInputDevice = deviceCount;
+ deviceCount += inStreams;
+ if( (baseApiInfo->defaultOutputDevice == paNoDevice) && (outStreams > 0) )
+ baseApiInfo->defaultOutputDevice = deviceCount;
+ deviceCount += outStreams;
+ }
+ }
+
+ /* Register any discovered devices */
+ if( deviceCount > 0 )
+ {
+ /* Memory allocation */
+ PA_UNLESS_( hostApi->deviceInfos = (PaDeviceInfo**) PaUtil_GroupAllocateMemory(
+ hpiHostApi->allocations, sizeof(PaDeviceInfo*) * deviceCount ),
+ paInsufficientMemory );
+ /* Allocate all device info structs in a contiguous block */
+ PA_UNLESS_( hpiDeviceList = (PaAsiHpiDeviceInfo*) PaUtil_GroupAllocateMemory(
+ hpiHostApi->allocations, sizeof(PaAsiHpiDeviceInfo) * deviceCount ),
+ paInsufficientMemory );
+
+ /* Now query devices again for information */
+ for( i=0; i < numAdapters; ++i )
+ {
+ uint16_t inStreams, outStreams;
+ uint16_t version;
+ uint32_t serial;
+ uint16_t type;
+ uint32_t idx;
+
+ hpiError = HPI_SubSysGetAdapter( NULL, i, &idx, &type );
+ if (hpiError)
+ continue;
+
+ /* Assume adapter is still open from previous round */
+ hpiError = HPI_AdapterGetInfo( NULL, idx,
+ &outStreams, &inStreams, &version, &serial, &type );
+ /* Report error and skip to next device on failure */
+ if( hpiError )
+ {
+ PA_ASIHPI_REPORT_ERROR_( hpiError );
+ continue;
+ }
+ else
+ {
+ PA_DEBUG(( "Found HPI Adapter ID=%4X Idx=%d #In=%d #Out=%d S/N=%d HWver=%c%d DSPver=%03d\n",
+ type, idx, inStreams, outStreams, serial,
+ ((version>>3)&0xf)+'A', /* Hw version major */
+ version&0x7, /* Hw version minor */
+ ((version>>13)*100)+((version>>7)&0x3f) /* DSP code version */
+ ));
+ }
+
+ /* First add all input streams as devices */
+ for( j=0; j < inStreams; ++j )
+ {
+ PaAsiHpiDeviceInfo *hpiDevice = &hpiDeviceList[deviceIndex];
+ PaDeviceInfo *baseDeviceInfo = &hpiDevice->baseDeviceInfo;
+ char srcName[72];
+ char *deviceName;
+
+ memset( hpiDevice, 0, sizeof(PaAsiHpiDeviceInfo) );
+ /* Set implementation-specific device details */
+ hpiDevice->adapterIndex = idx;
+ hpiDevice->adapterType = type;
+ hpiDevice->adapterVersion = version;
+ hpiDevice->adapterSerialNumber = serial;
+ hpiDevice->streamIndex = j;
+ hpiDevice->streamIsOutput = 0;
+ /* Set common PortAudio device stats */
+ baseDeviceInfo->structVersion = 2;
+ /* Make sure name string is owned by API info structure */
+ sprintf( srcName,
+ "Adapter %d (%4X) - Input Stream %d", i+1, type, j+1 );
+ PA_UNLESS_( deviceName = (char *) PaUtil_GroupAllocateMemory(
+ hpiHostApi->allocations, strlen(srcName) + 1 ), paInsufficientMemory );
+ strcpy( deviceName, srcName );
+ baseDeviceInfo->name = deviceName;
+ baseDeviceInfo->hostApi = hpiHostApi->hostApiIndex;
+ baseDeviceInfo->maxInputChannels = HPI_MAX_CHANNELS;
+ baseDeviceInfo->maxOutputChannels = 0;
+ /* Default latency values for interactive performance */
+ baseDeviceInfo->defaultLowInputLatency = 0.01;
+ baseDeviceInfo->defaultLowOutputLatency = -1.0;
+ /* Default latency values for robust non-interactive applications (eg. playing sound files) */
+ baseDeviceInfo->defaultHighInputLatency = 0.2;
+ baseDeviceInfo->defaultHighOutputLatency = -1.0;
+ /* HPI interface can actually handle any sampling rate to 1 Hz accuracy,
+ * so this default is as good as any */
+ baseDeviceInfo->defaultSampleRate = 44100;
+
+ /* Store device in global PortAudio list */
+ hostApi->deviceInfos[deviceIndex++] = (PaDeviceInfo *) hpiDevice;
+ }
+
+ /* Now add all output streams as devices (I know, the repetition is painful) */
+ for( j=0; j < outStreams; ++j )
+ {
+ PaAsiHpiDeviceInfo *hpiDevice = &hpiDeviceList[deviceIndex];
+ PaDeviceInfo *baseDeviceInfo = &hpiDevice->baseDeviceInfo;
+ char srcName[72];
+ char *deviceName;
+
+ memset( hpiDevice, 0, sizeof(PaAsiHpiDeviceInfo) );
+ /* Set implementation-specific device details */
+ hpiDevice->adapterIndex = idx;
+ hpiDevice->adapterType = type;
+ hpiDevice->adapterVersion = version;
+ hpiDevice->adapterSerialNumber = serial;
+ hpiDevice->streamIndex = j;
+ hpiDevice->streamIsOutput = 1;
+ /* Set common PortAudio device stats */
+ baseDeviceInfo->structVersion = 2;
+ /* Make sure name string is owned by API info structure */
+ sprintf( srcName,
+ "Adapter %d (%4X) - Output Stream %d", i+1, type, j+1 );
+ PA_UNLESS_( deviceName = (char *) PaUtil_GroupAllocateMemory(
+ hpiHostApi->allocations, strlen(srcName) + 1 ), paInsufficientMemory );
+ strcpy( deviceName, srcName );
+ baseDeviceInfo->name = deviceName;
+ baseDeviceInfo->hostApi = hpiHostApi->hostApiIndex;
+ baseDeviceInfo->maxInputChannels = 0;
+ baseDeviceInfo->maxOutputChannels = HPI_MAX_CHANNELS;
+ /* Default latency values for interactive performance. */
+ baseDeviceInfo->defaultLowInputLatency = -1.0;
+ baseDeviceInfo->defaultLowOutputLatency = 0.01;
+ /* Default latency values for robust non-interactive applications (eg. playing sound files). */
+ baseDeviceInfo->defaultHighInputLatency = -1.0;
+ baseDeviceInfo->defaultHighOutputLatency = 0.2;
+ /* HPI interface can actually handle any sampling rate to 1 Hz accuracy,
+ * so this default is as good as any */
+ baseDeviceInfo->defaultSampleRate = 44100;
+
+ /* Store device in global PortAudio list */
+ hostApi->deviceInfos[deviceIndex++] = (PaDeviceInfo *) hpiDevice;
+ }
+ }
+ }
+
+ /* Finally acknowledge checked devices */
+ baseApiInfo->deviceCount = deviceIndex;
+
+error:
+ return result;
+}
+
+
+/** Initialize host API implementation.
+ This is the only function exported beyond this file. It is called by PortAudio to initialize
+ the host API. It stores API info, finds and registers all devices, and sets up callback and
+ blocking interfaces.
+
+ @param hostApi Pointer to host API struct
+
+ @param hostApiIndex Index of current (HPI) host API
+
+ @return PortAudio error code
+ */
+PaError PaAsiHpi_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex hostApiIndex )
+{
+ PaError result = paNoError;
+ PaAsiHpiHostApiRepresentation *hpiHostApi = NULL;
+ PaHostApiInfo *baseApiInfo;
+
+ /* Try to initialize HPI subsystem */
+ if (!HPI_SubSysCreate())
+ {
+ /* the V19 development docs say that if an implementation
+ * detects that it cannot be used, it should return a NULL
+ * interface and paNoError */
+ PA_DEBUG(( "Could not open HPI interface\n" ));
+
+ *hostApi = NULL;
+ return paNoError;
+ }
+ else
+ {
+ uint32_t hpiVersion;
+ PA_ASIHPI_UNLESS_( HPI_SubSysGetVersionEx( NULL, &hpiVersion ), paUnanticipatedHostError );
+ PA_DEBUG(( "HPI interface v%d.%02d.%02d\n",
+ hpiVersion >> 16, (hpiVersion >> 8) & 0x0F, (hpiVersion & 0x0F) ));
+ }
+
+ /* Allocate host API structure */
+ PA_UNLESS_( hpiHostApi = (PaAsiHpiHostApiRepresentation*) PaUtil_AllocateMemory(
+ sizeof(PaAsiHpiHostApiRepresentation) ), paInsufficientMemory );
+ PA_UNLESS_( hpiHostApi->allocations = PaUtil_CreateAllocationGroup(), paInsufficientMemory );
+
+ hpiHostApi->hostApiIndex = hostApiIndex;
+
+ *hostApi = &hpiHostApi->baseHostApiRep;
+ baseApiInfo = &((*hostApi)->info);
+ /* Fill in common API details */
+ baseApiInfo->structVersion = 1;
+ baseApiInfo->type = paAudioScienceHPI;
+ baseApiInfo->name = "AudioScience HPI";
+ baseApiInfo->deviceCount = 0;
+ baseApiInfo->defaultInputDevice = paNoDevice;
+ baseApiInfo->defaultOutputDevice = paNoDevice;
+
+ PA_ENSURE_( PaAsiHpi_BuildDeviceList( hpiHostApi ) );
+
+ (*hostApi)->Terminate = Terminate;
+ (*hostApi)->OpenStream = OpenStream;
+ (*hostApi)->IsFormatSupported = IsFormatSupported;
+
+ PaUtil_InitializeStreamInterface( &hpiHostApi->callbackStreamInterface, CloseStream, StartStream,
+ StopStream, AbortStream, IsStreamStopped, IsStreamActive,
+ GetStreamTime, GetStreamCpuLoad,
+ PaUtil_DummyRead, PaUtil_DummyWrite,
+ PaUtil_DummyGetReadAvailable, PaUtil_DummyGetWriteAvailable );
+
+ PaUtil_InitializeStreamInterface( &hpiHostApi->blockingStreamInterface, CloseStream, StartStream,
+ StopStream, AbortStream, IsStreamStopped, IsStreamActive,
+ GetStreamTime, PaUtil_DummyGetCpuLoad,
+ ReadStream, WriteStream, GetStreamReadAvailable, GetStreamWriteAvailable );
+
+ /* Store identity of main thread */
+ PA_ENSURE_( PaUnixThreading_Initialize() );
+
+ return result;
+error:
+ if (hpiHostApi)
+ PaUtil_FreeMemory( hpiHostApi );
+ return result;
+}
+
+
+/** Terminate host API implementation.
+ This closes all HPI adapters and frees the HPI subsystem. It also frees the host API struct
+ memory. It should be called once for every PaAsiHpi_Initialize call.
+
+ @param Pointer to host API struct
+ */
+static void Terminate( struct PaUtilHostApiRepresentation *hostApi )
+{
+ PaAsiHpiHostApiRepresentation *hpiHostApi = (PaAsiHpiHostApiRepresentation*)hostApi;
+ int i;
+ PaError result = paNoError;
+
+ if( hpiHostApi )
+ {
+ /* Get rid of HPI-specific structures */
+ uint16_t lastAdapterIndex = HPI_MAX_ADAPTERS;
+ /* Iterate through device list and close adapters */
+ for( i=0; i < hostApi->info.deviceCount; ++i )
+ {
+ PaAsiHpiDeviceInfo *hpiDevice = (PaAsiHpiDeviceInfo *) hostApi->deviceInfos[ i ];
+ /* Close adapter only if it differs from previous one */
+ if( hpiDevice->adapterIndex != lastAdapterIndex )
+ {
+ /* Ignore errors (report only during debugging) */
+ PA_ASIHPI_UNLESS_( HPI_AdapterClose( NULL,
+ hpiDevice->adapterIndex ), paNoError );
+ lastAdapterIndex = hpiDevice->adapterIndex;
+ }
+ }
+ /* Finally dismantle HPI subsystem */
+ HPI_SubSysFree( NULL );
+
+ if( hpiHostApi->allocations )
+ {
+ PaUtil_FreeAllAllocations( hpiHostApi->allocations );
+ PaUtil_DestroyAllocationGroup( hpiHostApi->allocations );
+ }
+
+ PaUtil_FreeMemory( hpiHostApi );
+ }
+error:
+ return;
+}
+
+
+/** Converts PortAudio sample format to equivalent HPI format.
+
+ @param paFormat PortAudio sample format
+
+ @return HPI sample format
+ */
+static uint16_t PaAsiHpi_PaToHpiFormat( PaSampleFormat paFormat )
+{
+ /* Ignore interleaving flag */
+ switch( paFormat & ~paNonInterleaved )
+ {
+ case paFloat32:
+ return HPI_FORMAT_PCM32_FLOAT;
+
+ case paInt32:
+ return HPI_FORMAT_PCM32_SIGNED;
+
+ case paInt24:
+ return HPI_FORMAT_PCM24_SIGNED;
+
+ case paInt16:
+ return HPI_FORMAT_PCM16_SIGNED;
+
+ case paUInt8:
+ return HPI_FORMAT_PCM8_UNSIGNED;
+
+ /* Default is 16-bit signed */
+ case paInt8:
+ default:
+ return HPI_FORMAT_PCM16_SIGNED;
+ }
+}
+
+
+/** Converts HPI sample format to equivalent PortAudio format.
+
+ @param paFormat HPI sample format
+
+ @return PortAudio sample format
+ */
+static PaSampleFormat PaAsiHpi_HpiToPaFormat( uint16_t hpiFormat )
+{
+ switch( hpiFormat )
+ {
+ case HPI_FORMAT_PCM32_FLOAT:
+ return paFloat32;
+
+ case HPI_FORMAT_PCM32_SIGNED:
+ return paInt32;
+
+ case HPI_FORMAT_PCM24_SIGNED:
+ return paInt24;
+
+ case HPI_FORMAT_PCM16_SIGNED:
+ return paInt16;
+
+ case HPI_FORMAT_PCM8_UNSIGNED:
+ return paUInt8;
+
+ /* Default is custom format (e.g. for HPI MP3 format) */
+ default:
+ return paCustomFormat;
+ }
+}
+
+
+/** Creates HPI format struct based on PortAudio parameters.
+ This also does some checks to see whether the desired format is valid, and whether
+ the device allows it. This only checks the format of one half (input or output) of the
+ PortAudio stream.
+
+ @param hostApi Pointer to host API struct
+
+ @param parameters Pointer to stream parameter struct
+
+ @param sampleRate Desired sample rate
+
+ @param hpiDevice Pointer to HPI device struct
+
+ @param hpiFormat Resulting HPI format returned here
+
+ @return PortAudio error code (typically indicating a problem with stream format)
+ */
+static PaError PaAsiHpi_CreateFormat( struct PaUtilHostApiRepresentation *hostApi,
+ const PaStreamParameters *parameters, double sampleRate,
+ PaAsiHpiDeviceInfo **hpiDevice, struct hpi_format *hpiFormat )
+{
+ int maxChannelCount = 0;
+ PaSampleFormat hostSampleFormat = 0;
+ hpi_err_t hpiError = 0;
+
+ /* Unless alternate device specification is supported, reject the use of
+ paUseHostApiSpecificDeviceSpecification */
+ if( parameters->device == paUseHostApiSpecificDeviceSpecification )
+ return paInvalidDevice;
+ else
+ {
+ assert( parameters->device < hostApi->info.deviceCount );
+ *hpiDevice = (PaAsiHpiDeviceInfo*) hostApi->deviceInfos[ parameters->device ];
+ }
+
+ /* Validate streamInfo - this implementation doesn't use custom stream info */
+ if( parameters->hostApiSpecificStreamInfo )
+ return paIncompatibleHostApiSpecificStreamInfo;
+
+ /* Check that device can support channel count */
+ if( (*hpiDevice)->streamIsOutput )
+ {
+ maxChannelCount = (*hpiDevice)->baseDeviceInfo.maxOutputChannels;
+ }
+ else
+ {
+ maxChannelCount = (*hpiDevice)->baseDeviceInfo.maxInputChannels;
+ }
+ if( (maxChannelCount == 0) || (parameters->channelCount > maxChannelCount) )
+ return paInvalidChannelCount;
+
+ /* All standard sample formats are supported by the buffer adapter,
+ and this implementation doesn't support any custom sample formats */
+ if( parameters->sampleFormat & paCustomFormat )
+ return paSampleFormatNotSupported;
+
+ /* Switch to closest HPI native format */
+ hostSampleFormat = PaUtil_SelectClosestAvailableFormat(PA_ASIHPI_AVAILABLE_FORMATS_,
+ parameters->sampleFormat );
+ /* Setup format + info objects */
+ hpiError = HPI_FormatCreate( hpiFormat, (uint16_t)parameters->channelCount,
+ PaAsiHpi_PaToHpiFormat( hostSampleFormat ),
+ (uint32_t)sampleRate, 0, 0 );
+ if( hpiError )
+ {
+ PA_ASIHPI_REPORT_ERROR_( hpiError );
+ switch( hpiError )
+ {
+ case HPI_ERROR_INVALID_FORMAT:
+ return paSampleFormatNotSupported;
+
+ case HPI_ERROR_INVALID_SAMPLERATE:
+ case HPI_ERROR_INCOMPATIBLE_SAMPLERATE:
+ return paInvalidSampleRate;
+
+ case HPI_ERROR_INVALID_CHANNELS:
+ return paInvalidChannelCount;
+ }
+ }
+
+ return paNoError;
+}
+
+
+/** Open HPI input stream with given format.
+ This attempts to open HPI input stream with desired format. If the format is not supported
+ or the device is unavailable, the stream is closed and a PortAudio error code is returned.
+
+ @param hostApi Pointer to host API struct
+
+ @param hpiDevice Pointer to HPI device struct
+
+ @param hpiFormat Pointer to HPI format struct
+
+ @return PortAudio error code (typically indicating a problem with stream format or device)
+*/
+static PaError PaAsiHpi_OpenInput( struct PaUtilHostApiRepresentation *hostApi,
+ const PaAsiHpiDeviceInfo *hpiDevice, const struct hpi_format *hpiFormat,
+ hpi_handle_t *hpiStream )
+{
+ PaAsiHpiHostApiRepresentation *hpiHostApi = (PaAsiHpiHostApiRepresentation*)hostApi;
+ PaError result = paNoError;
+ hpi_err_t hpiError = 0;
+
+ /* Catch misplaced output devices, as they typically have 0 input channels */
+ PA_UNLESS_( !hpiDevice->streamIsOutput, paInvalidChannelCount );
+ /* Try to open input stream */
+ PA_ASIHPI_UNLESS_( HPI_InStreamOpen( NULL, hpiDevice->adapterIndex,
+ hpiDevice->streamIndex, hpiStream ), paDeviceUnavailable );
+ /* Set input format (checking it in the process) */
+ /* Could also use HPI_InStreamQueryFormat, but this economizes the process */
+ hpiError = HPI_InStreamSetFormat( NULL, *hpiStream, (struct hpi_format*)hpiFormat );
+ if( hpiError )
+ {
+ PA_ASIHPI_REPORT_ERROR_( hpiError );
+ PA_ASIHPI_UNLESS_( HPI_InStreamClose( NULL, *hpiStream ), paNoError );
+ switch( hpiError )
+ {
+ case HPI_ERROR_INVALID_FORMAT:
+ return paSampleFormatNotSupported;
+
+ case HPI_ERROR_INVALID_SAMPLERATE:
+ case HPI_ERROR_INCOMPATIBLE_SAMPLERATE:
+ return paInvalidSampleRate;
+
+ case HPI_ERROR_INVALID_CHANNELS:
+ return paInvalidChannelCount;
+
+ default:
+ /* In case anything else went wrong */
+ return paInvalidDevice;
+ }
+ }
+
+error:
+ return result;
+}
+
+
+/** Open HPI output stream with given format.
+ This attempts to open HPI output stream with desired format. If the format is not supported
+ or the device is unavailable, the stream is closed and a PortAudio error code is returned.
+
+ @param hostApi Pointer to host API struct
+
+ @param hpiDevice Pointer to HPI device struct
+
+ @param hpiFormat Pointer to HPI format struct
+
+ @return PortAudio error code (typically indicating a problem with stream format or device)
+*/
+static PaError PaAsiHpi_OpenOutput( struct PaUtilHostApiRepresentation *hostApi,
+ const PaAsiHpiDeviceInfo *hpiDevice, const struct hpi_format *hpiFormat,
+ hpi_handle_t *hpiStream )
+{
+ PaAsiHpiHostApiRepresentation *hpiHostApi = (PaAsiHpiHostApiRepresentation*)hostApi;
+ PaError result = paNoError;
+ hpi_err_t hpiError = 0;
+
+ /* Catch misplaced input devices, as they typically have 0 output channels */
+ PA_UNLESS_( hpiDevice->streamIsOutput, paInvalidChannelCount );
+ /* Try to open output stream */
+ PA_ASIHPI_UNLESS_( HPI_OutStreamOpen( NULL, hpiDevice->adapterIndex,
+ hpiDevice->streamIndex, hpiStream ), paDeviceUnavailable );
+
+ /* Check output format (format is set on first write to output stream) */
+ hpiError = HPI_OutStreamQueryFormat( NULL, *hpiStream, (struct hpi_format*)hpiFormat );
+ if( hpiError )
+ {
+ PA_ASIHPI_REPORT_ERROR_( hpiError );
+ PA_ASIHPI_UNLESS_( HPI_OutStreamClose( NULL, *hpiStream ), paNoError );
+ switch( hpiError )
+ {
+ case HPI_ERROR_INVALID_FORMAT:
+ return paSampleFormatNotSupported;
+
+ case HPI_ERROR_INVALID_SAMPLERATE:
+ case HPI_ERROR_INCOMPATIBLE_SAMPLERATE:
+ return paInvalidSampleRate;
+
+ case HPI_ERROR_INVALID_CHANNELS:
+ return paInvalidChannelCount;
+
+ default:
+ /* In case anything else went wrong */
+ return paInvalidDevice;
+ }
+ }
+
+error:
+ return result;
+}
+
+
+/** Checks whether the desired stream formats and devices are supported
+ (for both input and output).
+ This is done by actually opening the appropriate HPI streams and closing them again.
+
+ @param hostApi Pointer to host API struct
+
+ @param inputParameters Pointer to stream parameter struct for input side of stream
+
+ @param outputParameters Pointer to stream parameter struct for output side of stream
+
+ @param sampleRate Desired sample rate
+
+ @return PortAudio error code (paFormatIsSupported on success)
+ */
+static PaError IsFormatSupported( struct PaUtilHostApiRepresentation *hostApi,
+ const PaStreamParameters *inputParameters,
+ const PaStreamParameters *outputParameters,
+ double sampleRate )
+{
+ PaError result = paFormatIsSupported;
+ PaAsiHpiHostApiRepresentation *hpiHostApi = (PaAsiHpiHostApiRepresentation*)hostApi;
+ PaAsiHpiDeviceInfo *hpiDevice = NULL;
+ struct hpi_format hpiFormat;
+
+ /* Input stream */
+ if( inputParameters )
+ {
+ hpi_handle_t hpiStream;
+ PA_DEBUG(( "%s: Checking input params: dev=%d, sr=%d, chans=%d, fmt=%d\n",
+ __FUNCTION__, inputParameters->device, (int)sampleRate,
+ inputParameters->channelCount, inputParameters->sampleFormat ));
+ /* Create and validate format */
+ PA_ENSURE_( PaAsiHpi_CreateFormat( hostApi, inputParameters, sampleRate,
+ &hpiDevice, &hpiFormat ) );
+ /* Open stream to further check format */
+ PA_ENSURE_( PaAsiHpi_OpenInput( hostApi, hpiDevice, &hpiFormat, &hpiStream ) );
+ /* Close stream again */
+ PA_ASIHPI_UNLESS_( HPI_InStreamClose( NULL, hpiStream ), paNoError );
+ }
+
+ /* Output stream */
+ if( outputParameters )
+ {
+ hpi_handle_t hpiStream;
+ PA_DEBUG(( "%s: Checking output params: dev=%d, sr=%d, chans=%d, fmt=%d\n",
+ __FUNCTION__, outputParameters->device, (int)sampleRate,
+ outputParameters->channelCount, outputParameters->sampleFormat ));
+ /* Create and validate format */
+ PA_ENSURE_( PaAsiHpi_CreateFormat( hostApi, outputParameters, sampleRate,
+ &hpiDevice, &hpiFormat ) );
+ /* Open stream to further check format */
+ PA_ENSURE_( PaAsiHpi_OpenOutput( hostApi, hpiDevice, &hpiFormat, &hpiStream ) );
+ /* Close stream again */
+ PA_ASIHPI_UNLESS_( HPI_OutStreamClose( NULL, hpiStream ), paNoError );
+ }
+
+error:
+ return result;
+}
+
+/* ---------------------------- Stream Interface ---------------------------- */
+
+/** Obtain HPI stream information.
+ This obtains info such as stream state and available data/space in buffers. It also
+ estimates whether an underflow or overflow occurred.
+
+ @param streamComp Pointer to stream component (input or output) to query
+
+ @param info Pointer to stream info struct that will contain result
+
+ @return PortAudio error code (either paNoError, paDeviceUnavailable or paUnanticipatedHostError)
+ */
+static PaError PaAsiHpi_GetStreamInfo( PaAsiHpiStreamComponent *streamComp, PaAsiHpiStreamInfo *info )
+{
+ PaError result = paDeviceUnavailable;
+ uint16_t state;
+ uint32_t bufferSize, dataSize, frameCounter, auxDataSize, threshold;
+ uint32_t hwBufferSize, hwDataSize;
+
+ assert( streamComp );
+ assert( info );
+
+ /* First blank the stream info struct, in case something goes wrong below.
+ This saves the caller from initializing the struct. */
+ info->state = 0;
+ info->bufferSize = 0;
+ info->dataSize = 0;
+ info->frameCounter = 0;
+ info->auxDataSize = 0;
+ info->totalBufferedData = 0;
+ info->availableFrames = 0;
+ info->underflow = 0;
+ info->overflow = 0;
+
+ if( streamComp->hpiDevice && streamComp->hpiStream )
+ {
+ /* Obtain detailed stream info (either input or output) */
+ if( streamComp->hpiDevice->streamIsOutput )
+ {
+ PA_ASIHPI_UNLESS_( HPI_OutStreamGetInfoEx( NULL,
+ streamComp->hpiStream,
+ &state, &bufferSize, &dataSize, &frameCounter,
+ &auxDataSize ), paUnanticipatedHostError );
+ }
+ else
+ {
+ PA_ASIHPI_UNLESS_( HPI_InStreamGetInfoEx( NULL,
+ streamComp->hpiStream,
+ &state, &bufferSize, &dataSize, &frameCounter,
+ &auxDataSize ), paUnanticipatedHostError );
+ }
+ /* Load stream info */
+ info->state = state;
+ info->bufferSize = bufferSize;
+ info->dataSize = dataSize;
+ info->frameCounter = frameCounter;
+ info->auxDataSize = auxDataSize;
+ /* Determine total buffered data */
+ info->totalBufferedData = dataSize;
+ if( streamComp->hostBufferSize > 0 )
+ info->totalBufferedData += auxDataSize;
+ info->totalBufferedData /= streamComp->bytesPerFrame;
+ /* Determine immediately available frames */
+ info->availableFrames = streamComp->hpiDevice->streamIsOutput ?
+ bufferSize - dataSize : dataSize;
+ info->availableFrames /= streamComp->bytesPerFrame;
+ /* Minimum space/data required in buffers */
+ threshold = PA_MIN( streamComp->tempBufferSize,
+ streamComp->bytesPerFrame * PA_ASIHPI_MIN_FRAMES_ );
+ /* Obtain hardware buffer stats first, to simplify things */
+ hwBufferSize = streamComp->hardwareBufferSize;
+ hwDataSize = streamComp->hostBufferSize > 0 ? auxDataSize : dataSize;
+ /* Underflow is a bit tricky */
+ info->underflow = streamComp->hpiDevice->streamIsOutput ?
+ /* Stream seems to start in drained state sometimes, so ignore initial underflow */
+ (frameCounter > 0) && ( (state == HPI_STATE_DRAINED) || (hwDataSize == 0) ) :
+ /* Input streams check the first-level (host) buffer for underflow */
+ (state != HPI_STATE_STOPPED) && (dataSize < threshold);
+ /* Check for overflow in second-level (hardware) buffer for both input and output */
+ info->overflow = (state != HPI_STATE_STOPPED) && (hwBufferSize - hwDataSize < threshold);
+
+ return paNoError;
+ }
+
+error:
+ return result;
+}
+
+
+/** Display stream component information for debugging purposes.
+
+ @param streamComp Pointer to stream component (input or output) to query
+
+ @param stream Pointer to stream struct which contains the component above
+ */
+static void PaAsiHpi_StreamComponentDump( PaAsiHpiStreamComponent *streamComp,
+ PaAsiHpiStream *stream )
+{
+ PaAsiHpiStreamInfo streamInfo;
+
+ assert( streamComp );
+ assert( stream );
+
+ /* Name of soundcard/device used by component */
+ PA_DEBUG(( "device: %s\n", streamComp->hpiDevice->baseDeviceInfo.name ));
+ /* Unfortunately some overlap between input and output here */
+ if( streamComp->hpiDevice->streamIsOutput )
+ {
+ /* Settings on the user side (as experienced by user callback) */
+ PA_DEBUG(( "user: %d-bit, %d ",
+ 8*stream->bufferProcessor.bytesPerUserOutputSample,
+ stream->bufferProcessor.outputChannelCount));
+ if( stream->bufferProcessor.userOutputIsInterleaved )
+ {
+ PA_DEBUG(( "interleaved channels, " ));
+ }
+ else
+ {
+ PA_DEBUG(( "non-interleaved channels, " ));
+ }
+ PA_DEBUG(( "%d frames/buffer, latency = %5.1f ms\n",
+ stream->bufferProcessor.framesPerUserBuffer,
+ 1000*stream->baseStreamRep.streamInfo.outputLatency ));
+ /* Settings on the host side (internal to PortAudio host API) */
+ PA_DEBUG(( "host: %d-bit, %d interleaved channels, %d frames/buffer ",
+ 8*stream->bufferProcessor.bytesPerHostOutputSample,
+ stream->bufferProcessor.outputChannelCount,
+ stream->bufferProcessor.framesPerHostBuffer ));
+ }
+ else
+ {
+ /* Settings on the user side (as experienced by user callback) */
+ PA_DEBUG(( "user: %d-bit, %d ",
+ 8*stream->bufferProcessor.bytesPerUserInputSample,
+ stream->bufferProcessor.inputChannelCount));
+ if( stream->bufferProcessor.userInputIsInterleaved )
+ {
+ PA_DEBUG(( "interleaved channels, " ));
+ }
+ else
+ {
+ PA_DEBUG(( "non-interleaved channels, " ));
+ }
+ PA_DEBUG(( "%d frames/buffer, latency = %5.1f ms\n",
+ stream->bufferProcessor.framesPerUserBuffer,
+ 1000*stream->baseStreamRep.streamInfo.inputLatency ));
+ /* Settings on the host side (internal to PortAudio host API) */
+ PA_DEBUG(( "host: %d-bit, %d interleaved channels, %d frames/buffer ",
+ 8*stream->bufferProcessor.bytesPerHostInputSample,
+ stream->bufferProcessor.inputChannelCount,
+ stream->bufferProcessor.framesPerHostBuffer ));
+ }
+ switch( stream->bufferProcessor.hostBufferSizeMode )
+ {
+ case paUtilFixedHostBufferSize:
+ PA_DEBUG(( "[fixed] " ));
+ break;
+ case paUtilBoundedHostBufferSize:
+ PA_DEBUG(( "[bounded] " ));
+ break;
+ case paUtilUnknownHostBufferSize:
+ PA_DEBUG(( "[unknown] " ));
+ break;
+ case paUtilVariableHostBufferSizePartialUsageAllowed:
+ PA_DEBUG(( "[variable] " ));
+ break;
+ }
+ PA_DEBUG(( "(%d max)\n", streamComp->tempBufferSize / streamComp->bytesPerFrame ));
+ /* HPI hardware settings */
+ PA_DEBUG(( "HPI: adapter %d stream %d, %d-bit, %d-channel, %d Hz\n",
+ streamComp->hpiDevice->adapterIndex, streamComp->hpiDevice->streamIndex,
+ 8 * streamComp->bytesPerFrame / streamComp->hpiFormat.wChannels,
+ streamComp->hpiFormat.wChannels,
+ streamComp->hpiFormat.dwSampleRate ));
+ /* Stream state and buffer levels */
+ PA_DEBUG(( "HPI: " ));
+ PaAsiHpi_GetStreamInfo( streamComp, &streamInfo );
+ switch( streamInfo.state )
+ {
+ case HPI_STATE_STOPPED:
+ PA_DEBUG(( "[STOPPED] " ));
+ break;
+ case HPI_STATE_PLAYING:
+ PA_DEBUG(( "[PLAYING] " ));
+ break;
+ case HPI_STATE_RECORDING:
+ PA_DEBUG(( "[RECORDING] " ));
+ break;
+ case HPI_STATE_DRAINED:
+ PA_DEBUG(( "[DRAINED] " ));
+ break;
+ default:
+ PA_DEBUG(( "[unknown state] " ));
+ break;
+ }
+ if( streamComp->hostBufferSize )
+ {
+ PA_DEBUG(( "host = %d/%d B, ", streamInfo.dataSize, streamComp->hostBufferSize ));
+ PA_DEBUG(( "hw = %d/%d (%d) B, ", streamInfo.auxDataSize,
+ streamComp->hardwareBufferSize, streamComp->outputBufferCap ));
+ }
+ else
+ {
+ PA_DEBUG(( "hw = %d/%d B, ", streamInfo.dataSize, streamComp->hardwareBufferSize ));
+ }
+ PA_DEBUG(( "count = %d", streamInfo.frameCounter ));
+ if( streamInfo.overflow )
+ {
+ PA_DEBUG(( " [overflow]" ));
+ }
+ else if( streamInfo.underflow )
+ {
+ PA_DEBUG(( " [underflow]" ));
+ }
+ PA_DEBUG(( "\n" ));
+}
+
+
+/** Display stream information for debugging purposes.
+
+ @param stream Pointer to stream to query
+ */
+static void PaAsiHpi_StreamDump( PaAsiHpiStream *stream )
+{
+ assert( stream );
+
+ PA_DEBUG(( "\n------------------------- STREAM INFO FOR %p ---------------------------\n", stream ));
+ /* General stream info (input+output) */
+ if( stream->baseStreamRep.streamCallback )
+ {
+ PA_DEBUG(( "[callback] " ));
+ }
+ else
+ {
+ PA_DEBUG(( "[blocking] " ));
+ }
+ PA_DEBUG(( "sr=%d Hz, poll=%d ms, max %d frames/buf ",
+ (int)stream->baseStreamRep.streamInfo.sampleRate,
+ stream->pollingInterval, stream->maxFramesPerHostBuffer ));
+ switch( stream->state )
+ {
+ case paAsiHpiStoppedState:
+ PA_DEBUG(( "[stopped]\n" ));
+ break;
+ case paAsiHpiActiveState:
+ PA_DEBUG(( "[active]\n" ));
+ break;
+ case paAsiHpiCallbackFinishedState:
+ PA_DEBUG(( "[cb fin]\n" ));
+ break;
+ default:
+ PA_DEBUG(( "[unknown state]\n" ));
+ break;
+ }
+ if( stream->callbackMode )
+ {
+ PA_DEBUG(( "cb info: thread=%p, cbAbort=%d, cbFinished=%d\n",
+ stream->thread.thread, stream->callbackAbort, stream->callbackFinished ));
+ }
+
+ PA_DEBUG(( "----------------------------------- Input ------------------------------------\n" ));
+ if( stream->input )
+ {
+ PaAsiHpi_StreamComponentDump( stream->input, stream );
+ }
+ else
+ {
+ PA_DEBUG(( "*none*\n" ));
+ }
+
+ PA_DEBUG(( "----------------------------------- Output ------------------------------------\n" ));
+ if( stream->output )
+ {
+ PaAsiHpi_StreamComponentDump( stream->output, stream );
+ }
+ else
+ {
+ PA_DEBUG(( "*none*\n" ));
+ }
+ PA_DEBUG(( "-------------------------------------------------------------------------------\n\n" ));
+
+}
+
+
+/** Determine buffer sizes and allocate appropriate stream buffers.
+ This attempts to allocate a BBM (host) buffer for the HPI stream component (either input
+ or output, as both have similar buffer needs). Not all AudioScience adapters support BBM,
+ in which case the hardware buffer has to suffice. The size of the HPI host buffer is chosen
+ as a multiple of framesPerPaHostBuffer, and also influenced by the suggested latency and the
+ estimated minimum polling interval. The HPI host and hardware buffer sizes are stored, and an
+ appropriate cap for the hardware buffer is also calculated. Finally, the temporary stream
+ buffer which serves as the PortAudio host buffer for this implementation is allocated.
+ This buffer contains an integer number of user buffers, to simplify buffer adaption in the
+ buffer processor. The function returns paBufferTooBig if the HPI interface cannot allocate
+ an HPI host buffer of the desired size.
+
+ @param streamComp Pointer to stream component struct
+
+ @param pollingInterval Polling interval for stream, in milliseconds
+
+ @param framesPerPaHostBuffer Size of PortAudio host buffer, in frames
+
+ @param suggestedLatency Suggested latency for stream component, in seconds
+
+ @return PortAudio error code (possibly paBufferTooBig or paInsufficientMemory)
+ */
+static PaError PaAsiHpi_SetupBuffers( PaAsiHpiStreamComponent *streamComp, uint32_t pollingInterval,
+ unsigned long framesPerPaHostBuffer, PaTime suggestedLatency )
+{
+ PaError result = paNoError;
+ PaAsiHpiStreamInfo streamInfo;
+ unsigned long hpiBufferSize = 0, paHostBufferSize = 0;
+
+ assert( streamComp );
+ assert( streamComp->hpiDevice );
+
+ /* Obtain size of hardware buffer of HPI stream, since we will be activating BBM shortly
+ and afterwards the buffer size will refer to the BBM (host-side) buffer.
+ This is necessary to enable reliable detection of xruns. */
+ PA_ENSURE_( PaAsiHpi_GetStreamInfo( streamComp, &streamInfo ) );
+ streamComp->hardwareBufferSize = streamInfo.bufferSize;
+ hpiBufferSize = streamInfo.bufferSize;
+
+ /* Check if BBM (background bus mastering) is to be enabled */
+ if( PA_ASIHPI_USE_BBM_ )
+ {
+ uint32_t bbmBufferSize = 0, preLatencyBufferSize = 0;
+ hpi_err_t hpiError = 0;
+ PaTime pollingOverhead;
+
+ /* Check overhead of Pa_Sleep() call (minimum sleep duration in ms -> OS dependent) */
+ pollingOverhead = PaUtil_GetTime();
+ Pa_Sleep( 0 );
+ pollingOverhead = 1000*(PaUtil_GetTime() - pollingOverhead);
+ PA_DEBUG(( "polling overhead = %f ms (length of 0-second sleep)\n", pollingOverhead ));
+ /* Obtain minimum recommended size for host buffer (in bytes) */
+ PA_ASIHPI_UNLESS_( HPI_StreamEstimateBufferSize( &streamComp->hpiFormat,
+ pollingInterval + (uint32_t)ceil( pollingOverhead ),
+ &bbmBufferSize ), paUnanticipatedHostError );
+ /* BBM places more stringent requirements on buffer size (see description */
+ /* of HPI_StreamEstimateBufferSize in HPI API document) */
+ bbmBufferSize *= 3;
+ /* Make sure the BBM buffer contains multiple PA host buffers */
+ if( bbmBufferSize < 3 * streamComp->bytesPerFrame * framesPerPaHostBuffer )
+ bbmBufferSize = 3 * streamComp->bytesPerFrame * framesPerPaHostBuffer;
+ /* Try to honor latency suggested by user by growing buffer (no decrease possible) */
+ if( suggestedLatency > 0.0 )
+ {
+ PaTime bufferDuration = ((PaTime)bbmBufferSize) / streamComp->bytesPerFrame
+ / streamComp->hpiFormat.dwSampleRate;
+ /* Don't decrease buffer */
+ if( bufferDuration < suggestedLatency )
+ {
+ /* Save old buffer size, to be retried if new size proves too big */
+ preLatencyBufferSize = bbmBufferSize;
+ bbmBufferSize = (uint32_t)ceil( suggestedLatency * streamComp->bytesPerFrame
+ * streamComp->hpiFormat.dwSampleRate );
+ }
+ }
+ /* Choose closest memory block boundary (HPI API document states that
+ "a buffer size of Nx4096 - 20 makes the best use of memory"
+ (under the entry for HPI_StreamEstimateBufferSize)) */
+ bbmBufferSize = ((uint32_t)ceil((bbmBufferSize + 20)/4096.0))*4096 - 20;
+ streamComp->hostBufferSize = bbmBufferSize;
+ /* Allocate BBM host buffer (this enables bus mastering transfers in background) */
+ if( streamComp->hpiDevice->streamIsOutput )
+ hpiError = HPI_OutStreamHostBufferAllocate( NULL,
+ streamComp->hpiStream,
+ bbmBufferSize );
+ else
+ hpiError = HPI_InStreamHostBufferAllocate( NULL,
+ streamComp->hpiStream,
+ bbmBufferSize );
+ if( hpiError )
+ {
+ /* Indicate that BBM is disabled */
+ streamComp->hostBufferSize = 0;
+ /* Retry with smaller buffer size (transfers will still work, but not via BBM) */
+ if( hpiError == HPI_ERROR_INVALID_DATASIZE )
+ {
+ /* Retry BBM allocation with smaller size if requested latency proved too big */
+ if( preLatencyBufferSize > 0 )
+ {
+ PA_DEBUG(( "Retrying BBM allocation with smaller size (%d vs. %d bytes)\n",
+ preLatencyBufferSize, bbmBufferSize ));
+ bbmBufferSize = preLatencyBufferSize;
+ if( streamComp->hpiDevice->streamIsOutput )
+ hpiError = HPI_OutStreamHostBufferAllocate( NULL,
+ streamComp->hpiStream,
+ bbmBufferSize );
+ else
+ hpiError = HPI_InStreamHostBufferAllocate( NULL,
+ streamComp->hpiStream,
+ bbmBufferSize );
+ /* Another round of error checking */
+ if( hpiError )
+ {
+ PA_ASIHPI_REPORT_ERROR_( hpiError );
+ /* No escapes this time */
+ if( hpiError == HPI_ERROR_INVALID_DATASIZE )
+ {
+ result = paBufferTooBig;
+ goto error;
+ }
+ else if( hpiError != HPI_ERROR_INVALID_OPERATION )
+ {
+ result = paUnanticipatedHostError;
+ goto error;
+ }
+ }
+ else
+ {
+ streamComp->hostBufferSize = bbmBufferSize;
+ hpiBufferSize = bbmBufferSize;
+ }
+ }
+ else
+ {
+ result = paBufferTooBig;
+ goto error;
+ }
+ }
+ /* If BBM not supported, foreground transfers will be used, but not a show-stopper */
+ /* Anything else is an error */
+ else if (( hpiError != HPI_ERROR_INVALID_OPERATION ) &&
+ ( hpiError != HPI_ERROR_INVALID_FUNC ))
+ {
+ PA_ASIHPI_REPORT_ERROR_( hpiError );
+ result = paUnanticipatedHostError;
+ goto error;
+ }
+ }
+ else
+ {
+ hpiBufferSize = bbmBufferSize;
+ }
+ }
+
+ /* Final check of buffer size */
+ paHostBufferSize = streamComp->bytesPerFrame * framesPerPaHostBuffer;
+ if( hpiBufferSize < 3*paHostBufferSize )
+ {
+ result = paBufferTooBig;
+ goto error;
+ }
+ /* Set cap on output buffer size, based on latency suggestions */
+ if( streamComp->hpiDevice->streamIsOutput )
+ {
+ PaTime latency = suggestedLatency > 0.0 ? suggestedLatency :
+ streamComp->hpiDevice->baseDeviceInfo.defaultHighOutputLatency;
+ streamComp->outputBufferCap =
+ (uint32_t)ceil( latency * streamComp->bytesPerFrame * streamComp->hpiFormat.dwSampleRate );
+ /* The cap should not be too small, to prevent underflow */
+ if( streamComp->outputBufferCap < 4*paHostBufferSize )
+ streamComp->outputBufferCap = 4*paHostBufferSize;
+ }
+ else
+ {
+ streamComp->outputBufferCap = 0;
+ }
+ /* Temp buffer size should be multiple of PA host buffer size (or 1x, if using fixed blocks) */
+ streamComp->tempBufferSize = paHostBufferSize;
+ /* Allocate temp buffer */
+ PA_UNLESS_( streamComp->tempBuffer = (uint8_t *)PaUtil_AllocateMemory( streamComp->tempBufferSize ),
+ paInsufficientMemory );
+error:
+ return result;
+}
+
+
+/** Opens PortAudio stream.
+ This determines a suitable value for framesPerBuffer, if the user didn't specify it,
+ based on the suggested latency. It then opens each requested stream direction with the
+ appropriate stream format, and allocates the required stream buffers. It sets up the
+ various PortAudio structures dealing with streams, and estimates the stream latency.
+
+ See pa_hostapi.h for a list of validity guarantees made about OpenStream parameters.
+
+ @param hostApi Pointer to host API struct
+
+ @param s List of open streams, where successfully opened stream will go
+
+ @param inputParameters Pointer to stream parameter struct for input side of stream
+
+ @param outputParameters Pointer to stream parameter struct for output side of stream
+
+ @param sampleRate Desired sample rate
+
+ @param framesPerBuffer Desired number of frames per buffer passed to user callback
+ (or chunk size for blocking stream)
+
+ @param streamFlags Stream flags
+
+ @param streamCallback Pointer to user callback function (zero for blocking interface)
+
+ @param userData Pointer to user data that will be passed to callback function along with data
+
+ @return PortAudio error code
+*/
+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;
+ PaAsiHpiHostApiRepresentation *hpiHostApi = (PaAsiHpiHostApiRepresentation*)hostApi;
+ PaAsiHpiStream *stream = NULL;
+ unsigned long framesPerHostBuffer = framesPerBuffer;
+ int inputChannelCount = 0, outputChannelCount = 0;
+ PaSampleFormat inputSampleFormat = 0, outputSampleFormat = 0;
+ PaSampleFormat hostInputSampleFormat = 0, hostOutputSampleFormat = 0;
+ PaTime maxSuggestedLatency = 0.0;
+
+ /* Validate platform-specific flags -> none expected for HPI */
+ if( (streamFlags & paPlatformSpecificFlags) != 0 )
+ return paInvalidFlag; /* unexpected platform-specific flag */
+
+ /* Create blank stream structure */
+ PA_UNLESS_( stream = (PaAsiHpiStream *)PaUtil_AllocateMemory( sizeof(PaAsiHpiStream) ),
+ paInsufficientMemory );
+ memset( stream, 0, sizeof(PaAsiHpiStream) );
+
+ /* If the number of frames per buffer is unspecified, we have to come up with one. */
+ if( framesPerHostBuffer == paFramesPerBufferUnspecified )
+ {
+ if( inputParameters )
+ maxSuggestedLatency = inputParameters->suggestedLatency;
+ if( outputParameters && (outputParameters->suggestedLatency > maxSuggestedLatency) )
+ maxSuggestedLatency = outputParameters->suggestedLatency;
+ /* Use suggested latency if available */
+ if( maxSuggestedLatency > 0.0 )
+ framesPerHostBuffer = (unsigned long)ceil( maxSuggestedLatency * sampleRate );
+ else
+ /* AudioScience cards like BIG buffers by default */
+ framesPerHostBuffer = 4096;
+ }
+ /* Lower bounds on host buffer size, due to polling and HPI constraints */
+ if( 1000.0*framesPerHostBuffer/sampleRate < PA_ASIHPI_MIN_POLLING_INTERVAL_ )
+ framesPerHostBuffer = (unsigned long)ceil( sampleRate * PA_ASIHPI_MIN_POLLING_INTERVAL_ / 1000.0 );
+ /* if( framesPerHostBuffer < PA_ASIHPI_MIN_FRAMES_ )
+ framesPerHostBuffer = PA_ASIHPI_MIN_FRAMES_; */
+ /* Efficient if host buffer size is integer multiple of user buffer size */
+ if( framesPerBuffer > 0 )
+ framesPerHostBuffer = (unsigned long)ceil( (double)framesPerHostBuffer / framesPerBuffer ) * framesPerBuffer;
+ /* Buffer should always be a multiple of 4 bytes to facilitate 32-bit PCI transfers.
+ By keeping the frames a multiple of 4, this is ensured even for 8-bit mono sound. */
+ framesPerHostBuffer = (framesPerHostBuffer / 4) * 4;
+ /* Polling is based on time length (in milliseconds) of user-requested block size */
+ stream->pollingInterval = (uint32_t)ceil( 1000.0*framesPerHostBuffer/sampleRate );
+ assert( framesPerHostBuffer > 0 );
+
+ /* Open underlying streams, check formats and allocate buffers */
+ if( inputParameters )
+ {
+ /* Create blank stream component structure */
+ PA_UNLESS_( stream->input = (PaAsiHpiStreamComponent *)PaUtil_AllocateMemory( sizeof(PaAsiHpiStreamComponent) ),
+ paInsufficientMemory );
+ memset( stream->input, 0, sizeof(PaAsiHpiStreamComponent) );
+ /* Create/validate format */
+ PA_ENSURE_( PaAsiHpi_CreateFormat( hostApi, inputParameters, sampleRate,
+ &stream->input->hpiDevice, &stream->input->hpiFormat ) );
+ /* Open stream and set format */
+ PA_ENSURE_( PaAsiHpi_OpenInput( hostApi, stream->input->hpiDevice, &stream->input->hpiFormat,
+ &stream->input->hpiStream ) );
+ inputChannelCount = inputParameters->channelCount;
+ inputSampleFormat = inputParameters->sampleFormat;
+ hostInputSampleFormat = PaAsiHpi_HpiToPaFormat( stream->input->hpiFormat.wFormat );
+ stream->input->bytesPerFrame = inputChannelCount * Pa_GetSampleSize( hostInputSampleFormat );
+ assert( stream->input->bytesPerFrame > 0 );
+ /* Allocate host and temp buffers of appropriate size */
+ PA_ENSURE_( PaAsiHpi_SetupBuffers( stream->input, stream->pollingInterval,
+ framesPerHostBuffer, inputParameters->suggestedLatency ) );
+ }
+ if( outputParameters )
+ {
+ /* Create blank stream component structure */
+ PA_UNLESS_( stream->output = (PaAsiHpiStreamComponent *)PaUtil_AllocateMemory( sizeof(PaAsiHpiStreamComponent) ),
+ paInsufficientMemory );
+ memset( stream->output, 0, sizeof(PaAsiHpiStreamComponent) );
+ /* Create/validate format */
+ PA_ENSURE_( PaAsiHpi_CreateFormat( hostApi, outputParameters, sampleRate,
+ &stream->output->hpiDevice, &stream->output->hpiFormat ) );
+ /* Open stream and check format */
+ PA_ENSURE_( PaAsiHpi_OpenOutput( hostApi, stream->output->hpiDevice,
+ &stream->output->hpiFormat,
+ &stream->output->hpiStream ) );
+ outputChannelCount = outputParameters->channelCount;
+ outputSampleFormat = outputParameters->sampleFormat;
+ hostOutputSampleFormat = PaAsiHpi_HpiToPaFormat( stream->output->hpiFormat.wFormat );
+ stream->output->bytesPerFrame = outputChannelCount * Pa_GetSampleSize( hostOutputSampleFormat );
+ /* Allocate host and temp buffers of appropriate size */
+ PA_ENSURE_( PaAsiHpi_SetupBuffers( stream->output, stream->pollingInterval,
+ framesPerHostBuffer, outputParameters->suggestedLatency ) );
+ }
+
+ /* Determine maximum frames per host buffer (least common denominator of input/output) */
+ if( inputParameters && outputParameters )
+ {
+ stream->maxFramesPerHostBuffer = PA_MIN( stream->input->tempBufferSize / stream->input->bytesPerFrame,
+ stream->output->tempBufferSize / stream->output->bytesPerFrame );
+ }
+ else
+ {
+ stream->maxFramesPerHostBuffer = inputParameters ? stream->input->tempBufferSize / stream->input->bytesPerFrame
+ : stream->output->tempBufferSize / stream->output->bytesPerFrame;
+ }
+ assert( stream->maxFramesPerHostBuffer > 0 );
+ /* Initialize various other stream parameters */
+ stream->neverDropInput = streamFlags & paNeverDropInput;
+ stream->state = paAsiHpiStoppedState;
+
+ /* Initialize either callback or blocking interface */
+ if( streamCallback )
+ {
+ PaUtil_InitializeStreamRepresentation( &stream->baseStreamRep,
+ &hpiHostApi->callbackStreamInterface,
+ streamCallback, userData );
+ stream->callbackMode = 1;
+ }
+ else
+ {
+ PaUtil_InitializeStreamRepresentation( &stream->baseStreamRep,
+ &hpiHostApi->blockingStreamInterface,
+ streamCallback, userData );
+ /* Pre-allocate non-interleaved user buffer pointers for blocking interface */
+ PA_UNLESS_( stream->blockingUserBufferCopy =
+ PaUtil_AllocateMemory( sizeof(void *) * PA_MAX( inputChannelCount, outputChannelCount ) ),
+ paInsufficientMemory );
+ stream->callbackMode = 0;
+ }
+ PaUtil_InitializeCpuLoadMeasurer( &stream->cpuLoadMeasurer, sampleRate );
+
+ /* Following pa_linux_alsa's lead, we operate with fixed host buffer size by default, */
+ /* since other modes will invariably lead to block adaption (maybe Bounded better?) */
+ PA_ENSURE_( PaUtil_InitializeBufferProcessor( &stream->bufferProcessor,
+ inputChannelCount, inputSampleFormat, hostInputSampleFormat,
+ outputChannelCount, outputSampleFormat, hostOutputSampleFormat,
+ sampleRate, streamFlags,
+ framesPerBuffer, framesPerHostBuffer, paUtilFixedHostBufferSize,
+ streamCallback, userData ) );
+
+ stream->baseStreamRep.streamInfo.structVersion = 1;
+ stream->baseStreamRep.streamInfo.sampleRate = sampleRate;
+ /* Determine input latency from buffer processor and buffer sizes */
+ if( stream->input )
+ {
+ PaTime bufferDuration = ( stream->input->hostBufferSize + stream->input->hardwareBufferSize )
+ / sampleRate / stream->input->bytesPerFrame;
+ stream->baseStreamRep.streamInfo.inputLatency =
+ bufferDuration +
+ ((PaTime)PaUtil_GetBufferProcessorInputLatencyFrames( &stream->bufferProcessor ) -
+ stream->maxFramesPerHostBuffer) / sampleRate;
+ assert( stream->baseStreamRep.streamInfo.inputLatency > 0.0 );
+ }
+ /* Determine output latency from buffer processor and buffer sizes */
+ if( stream->output )
+ {
+ PaTime bufferDuration = ( stream->output->hostBufferSize + stream->output->hardwareBufferSize )
+ / sampleRate / stream->output->bytesPerFrame;
+ /* Take buffer size cap into account (see PaAsiHpi_WaitForFrames) */
+ if( !stream->input && (stream->output->outputBufferCap > 0) )
+ {
+ bufferDuration = PA_MIN( bufferDuration,
+ stream->output->outputBufferCap / sampleRate / stream->output->bytesPerFrame );
+ }
+ stream->baseStreamRep.streamInfo.outputLatency =
+ bufferDuration +
+ ((PaTime)PaUtil_GetBufferProcessorOutputLatencyFrames( &stream->bufferProcessor ) -
+ stream->maxFramesPerHostBuffer) / sampleRate;
+ assert( stream->baseStreamRep.streamInfo.outputLatency > 0.0 );
+ }
+
+ /* Report stream info, for debugging purposes */
+ PaAsiHpi_StreamDump( stream );
+
+ /* Save initialized stream to PA stream list */
+ *s = (PaStream*)stream;
+ return result;
+
+error:
+ CloseStream( (PaStream*)stream );
+ return result;
+}
+
+
+/** Close PortAudio stream.
+ When CloseStream() is called, the multi-api layer ensures that the stream has already
+ been stopped or aborted. This closes the underlying HPI streams and deallocates stream
+ buffers and structs.
+
+ @param s Pointer to PortAudio stream
+
+ @return PortAudio error code
+*/
+static PaError CloseStream( PaStream *s )
+{
+ PaError result = paNoError;
+ PaAsiHpiStream *stream = (PaAsiHpiStream*)s;
+
+ /* If stream is already gone, all is well */
+ if( stream == NULL )
+ return paNoError;
+
+ /* Generic stream cleanup */
+ PaUtil_TerminateBufferProcessor( &stream->bufferProcessor );
+ PaUtil_TerminateStreamRepresentation( &stream->baseStreamRep );
+
+ /* Implementation-specific details - close internal streams */
+ if( stream->input )
+ {
+ /* Close HPI stream (freeing BBM host buffer in the process, if used) */
+ if( stream->input->hpiStream )
+ {
+ PA_ASIHPI_UNLESS_( HPI_InStreamClose( NULL,
+ stream->input->hpiStream ), paUnanticipatedHostError );
+ }
+ /* Free temp buffer and stream component */
+ PaUtil_FreeMemory( stream->input->tempBuffer );
+ PaUtil_FreeMemory( stream->input );
+ }
+ if( stream->output )
+ {
+ /* Close HPI stream (freeing BBM host buffer in the process, if used) */
+ if( stream->output->hpiStream )
+ {
+ PA_ASIHPI_UNLESS_( HPI_OutStreamClose( NULL,
+ stream->output->hpiStream ), paUnanticipatedHostError );
+ }
+ /* Free temp buffer and stream component */
+ PaUtil_FreeMemory( stream->output->tempBuffer );
+ PaUtil_FreeMemory( stream->output );
+ }
+
+ PaUtil_FreeMemory( stream->blockingUserBufferCopy );
+ PaUtil_FreeMemory( stream );
+
+error:
+ return result;
+}
+
+
+/** Prime HPI output stream with silence.
+ This resets the output stream and uses PortAudio helper routines to fill the
+ temp buffer with silence. It then writes two host buffers to the stream. This is supposed
+ to be called before the stream is started. It has no effect on input-only streams.
+
+ @param stream Pointer to stream struct
+
+ @return PortAudio error code
+ */
+static PaError PaAsiHpi_PrimeOutputWithSilence( PaAsiHpiStream *stream )
+{
+ PaError result = paNoError;
+ PaAsiHpiStreamComponent *out;
+ PaUtilZeroer *zeroer;
+ PaSampleFormat outputFormat;
+ assert( stream );
+ out = stream->output;
+ /* Only continue if stream has output channels */
+ if( !out )
+ return result;
+ assert( out->tempBuffer );
+
+ /* Clear all existing data in hardware playback buffer */
+ PA_ASIHPI_UNLESS_( HPI_OutStreamReset( NULL,
+ out->hpiStream ), paUnanticipatedHostError );
+ /* Fill temp buffer with silence */
+ outputFormat = PaAsiHpi_HpiToPaFormat( out->hpiFormat.wFormat );
+ zeroer = PaUtil_SelectZeroer( outputFormat );
+ zeroer(out->tempBuffer, 1, out->tempBufferSize / Pa_GetSampleSize(outputFormat) );
+ /* Write temp buffer to hardware fifo twice, to get started */
+ PA_ASIHPI_UNLESS_( HPI_OutStreamWriteBuf( NULL, out->hpiStream,
+ out->tempBuffer, out->tempBufferSize, &out->hpiFormat),
+ paUnanticipatedHostError );
+ PA_ASIHPI_UNLESS_( HPI_OutStreamWriteBuf( NULL, out->hpiStream,
+ out->tempBuffer, out->tempBufferSize, &out->hpiFormat),
+ paUnanticipatedHostError );
+error:
+ return result;
+}
+
+
+/** Start HPI streams (both input + output).
+ This starts all HPI streams in the PortAudio stream. Output streams are first primed with
+ silence, if required. After this call the PA stream is in the Active state.
+
+ @todo Implement priming via the user callback
+
+ @param stream Pointer to stream struct
+
+ @param outputPrimed True if output is already primed (if false, silence will be loaded before starting)
+
+ @return PortAudio error code
+ */
+static PaError PaAsiHpi_StartStream( PaAsiHpiStream *stream, int outputPrimed )
+{
+ PaError result = paNoError;
+
+ if( stream->input )
+ {
+ PA_ASIHPI_UNLESS_( HPI_InStreamStart( NULL,
+ stream->input->hpiStream ), paUnanticipatedHostError );
+ }
+ if( stream->output )
+ {
+ if( !outputPrimed )
+ {
+ /* Buffer isn't primed, so load stream with silence */
+ PA_ENSURE_( PaAsiHpi_PrimeOutputWithSilence( stream ) );
+ }
+ PA_ASIHPI_UNLESS_( HPI_OutStreamStart( NULL,
+ stream->output->hpiStream ), paUnanticipatedHostError );
+ }
+ stream->state = paAsiHpiActiveState;
+ stream->callbackFinished = 0;
+
+ /* Report stream info for debugging purposes */
+ /* PaAsiHpi_StreamDump( stream ); */
+
+error:
+ return result;
+}
+
+
+/** Start PortAudio stream.
+ If the stream has a callback interface, this starts a helper thread to feed the user callback.
+ The thread will then take care of starting the HPI streams, and this function will block
+ until the streams actually start. In the case of a blocking interface, the HPI streams
+ are simply started.
+
+ @param s Pointer to PortAudio stream
+
+ @return PortAudio error code
+*/
+static PaError StartStream( PaStream *s )
+{
+ PaError result = paNoError;
+ PaAsiHpiStream *stream = (PaAsiHpiStream*)s;
+
+ assert( stream );
+
+ /* Ready the processor */
+ PaUtil_ResetBufferProcessor( &stream->bufferProcessor );
+
+ if( stream->callbackMode )
+ {
+ /* Create and start callback engine thread */
+ /* Also waits 1 second for stream to be started by engine thread (otherwise aborts) */
+ PA_ENSURE_( PaUnixThread_New( &stream->thread, &CallbackThreadFunc, stream, 1., 0 /*rtSched*/ ) );
+ }
+ else
+ {
+ PA_ENSURE_( PaAsiHpi_StartStream( stream, 0 ) );
+ }
+
+error:
+ return result;
+}
+
+
+/** Stop HPI streams (input + output), either softly or abruptly.
+ If abort is false, the function blocks until the output stream is drained, otherwise it
+ stops immediately and discards data in the stream hardware buffers.
+
+ This function is safe to call from the callback engine thread as well as the main thread.
+
+ @param stream Pointer to stream struct
+
+ @param abort True if samples in output buffer should be discarded (otherwise blocks until stream is done)
+
+ @return PortAudio error code
+
+ */
+static PaError PaAsiHpi_StopStream( PaAsiHpiStream *stream, int abort )
+{
+ PaError result = paNoError;
+
+ assert( stream );
+
+ /* Input channels */
+ if( stream->input )
+ {
+ PA_ASIHPI_UNLESS_( HPI_InStreamReset( NULL,
+ stream->input->hpiStream ), paUnanticipatedHostError );
+ }
+ /* Output channels */
+ if( stream->output )
+ {
+ if( !abort )
+ {
+ /* Wait until HPI output stream is drained */
+ while( 1 )
+ {
+ PaAsiHpiStreamInfo streamInfo;
+ PaTime timeLeft;
+
+ /* Obtain number of samples waiting to be played */
+ PA_ENSURE_( PaAsiHpi_GetStreamInfo( stream->output, &streamInfo ) );
+ /* Check if stream is drained */
+ if( (streamInfo.state != HPI_STATE_PLAYING) &&
+ (streamInfo.dataSize < stream->output->bytesPerFrame * PA_ASIHPI_MIN_FRAMES_) )
+ break;
+ /* Sleep amount of time represented by remaining samples */
+ timeLeft = 1000.0 * streamInfo.dataSize / stream->output->bytesPerFrame
+ / stream->baseStreamRep.streamInfo.sampleRate;
+ Pa_Sleep( (long)ceil( timeLeft ) );
+ }
+ }
+ PA_ASIHPI_UNLESS_( HPI_OutStreamReset( NULL,
+ stream->output->hpiStream ), paUnanticipatedHostError );
+ }
+
+ /* Report stream info for debugging purposes */
+ /* PaAsiHpi_StreamDump( stream ); */
+
+error:
+ return result;
+}
+
+
+/** Stop or abort PortAudio stream.
+
+ This function is used to explicitly stop the PortAudio stream (via StopStream/AbortStream),
+ as opposed to the situation when the callback finishes with a result other than paContinue.
+ If a stream is in callback mode we will have to inspect whether the background thread has
+ finished, or we will have to take it out. In either case we join the thread before returning.
+ In blocking mode, we simply tell HPI to stop abruptly (abort) or finish buffers (drain).
+ The PortAudio stream will be in the Stopped state after a call to this function.
+
+ Don't call this from the callback engine thread!
+
+ @param stream Pointer to stream struct
+
+ @param abort True if samples in output buffer should be discarded (otherwise blocks until stream is done)
+
+ @return PortAudio error code
+*/
+static PaError PaAsiHpi_ExplicitStop( PaAsiHpiStream *stream, int abort )
+{
+ PaError result = paNoError;
+
+ /* First deal with the callback thread, cancelling and/or joining it if necessary */
+ if( stream->callbackMode )
+ {
+ PaError threadRes;
+ stream->callbackAbort = abort;
+ if( abort )
+ {
+ PA_DEBUG(( "Aborting callback\n" ));
+ }
+ else
+ {
+ PA_DEBUG(( "Stopping callback\n" ));
+ }
+ PA_ENSURE_( PaUnixThread_Terminate( &stream->thread, !abort, &threadRes ) );
+ if( threadRes != paNoError )
+ {
+ PA_DEBUG(( "Callback thread returned: %d\n", threadRes ));
+ }
+ }
+ else
+ {
+ PA_ENSURE_( PaAsiHpi_StopStream( stream, abort ) );
+ }
+
+ stream->state = paAsiHpiStoppedState;
+
+error:
+ return result;
+}
+
+
+/** Stop PortAudio stream.
+ This blocks until the output buffers are drained.
+
+ @param s Pointer to PortAudio stream
+
+ @return PortAudio error code
+*/
+static PaError StopStream( PaStream *s )
+{
+ return PaAsiHpi_ExplicitStop( (PaAsiHpiStream *) s, 0 );
+}
+
+
+/** Abort PortAudio stream.
+ This discards any existing data in output buffers and stops the stream immediately.
+
+ @param s Pointer to PortAudio stream
+
+ @return PortAudio error code
+*/
+static PaError AbortStream( PaStream *s )
+{
+ return PaAsiHpi_ExplicitStop( (PaAsiHpiStream * ) s, 1 );
+}
+
+
+/** Determine whether the stream is stopped.
+ A stream is considered to be stopped prior to a successful call to StartStream and after
+ a successful call to StopStream or AbortStream. If a stream callback returns a value other
+ than paContinue the stream is NOT considered to be stopped (it is in CallbackFinished state).
+
+ @param s Pointer to PortAudio stream
+
+ @return Returns one (1) when the stream is stopped, zero (0) when the stream is running, or
+ a PaErrorCode (which are always negative) if PortAudio is not initialized or an
+ error is encountered.
+*/
+static PaError IsStreamStopped( PaStream *s )
+{
+ PaAsiHpiStream *stream = (PaAsiHpiStream*)s;
+
+ assert( stream );
+ return stream->state == paAsiHpiStoppedState ? 1 : 0;
+}
+
+
+/** Determine whether the stream is active.
+ A stream is active after a successful call to StartStream(), until it becomes inactive either
+ as a result of a call to StopStream() or AbortStream(), or as a result of a return value
+ other than paContinue from the stream callback. In the latter case, the stream is considered
+ inactive after the last buffer has finished playing.
+
+ @param s Pointer to PortAudio stream
+
+ @return Returns one (1) when the stream is active (i.e. playing or recording audio),
+ zero (0) when not playing, or a PaErrorCode (which are always negative)
+ if PortAudio is not initialized or an error is encountered.
+*/
+static PaError IsStreamActive( PaStream *s )
+{
+ PaAsiHpiStream *stream = (PaAsiHpiStream*)s;
+
+ assert( stream );
+ return stream->state == paAsiHpiActiveState ? 1 : 0;
+}
+
+
+/** Returns current stream time.
+ This corresponds to the system clock. The clock should run continuously while the stream
+ is open, i.e. between calls to OpenStream() and CloseStream(), therefore a frame counter
+ is not good enough.
+
+ @param s Pointer to PortAudio stream
+
+ @return Stream time, in seconds
+ */
+static PaTime GetStreamTime( PaStream *s )
+{
+ return PaUtil_GetTime();
+}
+
+
+/** Returns CPU load.
+
+ @param s Pointer to PortAudio stream
+
+ @return CPU load (0.0 if blocking interface is used)
+ */
+static double GetStreamCpuLoad( PaStream *s )
+{
+ PaAsiHpiStream *stream = (PaAsiHpiStream*)s;
+
+ return stream->callbackMode ? PaUtil_GetCpuLoad( &stream->cpuLoadMeasurer ) : 0.0;
+}
+
+/* --------------------------- Callback Interface --------------------------- */
+
+/** Exit routine which is called when callback thread quits.
+ This takes care of stopping the HPI streams (either waiting for output to finish, or
+ abruptly). It also calls the user-supplied StreamFinished callback, and sets the
+ stream state to CallbackFinished if it was reached via a non-paContinue return from
+ the user callback function.
+
+ @param userData A pointer to an open stream previously created with Pa_OpenStream
+ */
+static void PaAsiHpi_OnThreadExit( void *userData )
+{
+ PaAsiHpiStream *stream = (PaAsiHpiStream *) userData;
+
+ assert( stream );
+
+ PaUtil_ResetCpuLoadMeasurer( &stream->cpuLoadMeasurer );
+
+ PA_DEBUG(( "%s: Stopping HPI streams\n", __FUNCTION__ ));
+ PaAsiHpi_StopStream( stream, stream->callbackAbort );
+ PA_DEBUG(( "%s: Stoppage\n", __FUNCTION__ ));
+
+ /* Eventually notify user all buffers have played */
+ if( stream->baseStreamRep.streamFinishedCallback )
+ {
+ stream->baseStreamRep.streamFinishedCallback( stream->baseStreamRep.userData );
+ }
+
+ /* Unfortunately both explicit calls to Stop/AbortStream (leading to Stopped state)
+ and implicit stops via paComplete/paAbort (leading to CallbackFinished state)
+ end up here - need another flag to remind us which is the case */
+ if( stream->callbackFinished )
+ stream->state = paAsiHpiCallbackFinishedState;
+}
+
+
+/** Wait until there is enough frames to fill a host buffer.
+ The routine attempts to sleep until at least a full host buffer can be retrieved from the
+ input HPI stream and passed to the output HPI stream. It will first sleep until enough
+ output space is available, as this is usually easily achievable. If it is an output-only
+ stream, it will also sleep if the hardware buffer is too full, thereby throttling the
+ filling of the output buffer and reducing output latency. The routine then blocks until
+ enough input samples are available, unless this will cause an output underflow. In the
+ process, input overflows and output underflows are indicated.
+
+ @param stream Pointer to stream struct
+
+ @param framesAvail Returns the number of available frames
+
+ @param cbFlags Overflows and underflows indicated in here
+
+ @return PortAudio error code (only paUnanticipatedHostError expected)
+ */
+static PaError PaAsiHpi_WaitForFrames( PaAsiHpiStream *stream, unsigned long *framesAvail,
+ PaStreamCallbackFlags *cbFlags )
+{
+ PaError result = paNoError;
+ double sampleRate;
+ unsigned long framesTarget;
+ uint32_t outputData = 0, outputSpace = 0, inputData = 0, framesLeft = 0;
+
+ assert( stream );
+ assert( stream->input || stream->output );
+
+ sampleRate = stream->baseStreamRep.streamInfo.sampleRate;
+ /* We have to come up with this much frames on both input and output */
+ framesTarget = stream->bufferProcessor.framesPerHostBuffer;
+ assert( framesTarget > 0 );
+
+ while( 1 )
+ {
+ PaAsiHpiStreamInfo info;
+ /* Check output first, as this takes priority in the default full-duplex mode */
+ if( stream->output )
+ {
+ PA_ENSURE_( PaAsiHpi_GetStreamInfo( stream->output, &info ) );
+ /* Wait until enough space is available in output buffer to receive a full block */
+ if( info.availableFrames < framesTarget )
+ {
+ framesLeft = framesTarget - info.availableFrames;
+ Pa_Sleep( (long)ceil( 1000 * framesLeft / sampleRate ) );
+ continue;
+ }
+ /* Wait until the data in hardware buffer has dropped to a sensible level.
+ Without this, the hardware buffer quickly fills up in the absence of an input
+ stream to regulate its data rate (if data generation is fast). This leads to
+ large latencies, as the AudioScience hardware buffers are humongous.
+ This is similar to the default "Hardware Buffering=off" option in the
+ AudioScience WAV driver. */
+ if( !stream->input && (stream->output->outputBufferCap > 0) &&
+ ( info.totalBufferedData > stream->output->outputBufferCap / stream->output->bytesPerFrame ) )
+ {
+ framesLeft = info.totalBufferedData - stream->output->outputBufferCap / stream->output->bytesPerFrame;
+ Pa_Sleep( (long)ceil( 1000 * framesLeft / sampleRate ) );
+ continue;
+ }
+ outputData = info.totalBufferedData;
+ outputSpace = info.availableFrames;
+ /* Report output underflow to callback */
+ if( info.underflow )
+ {
+ *cbFlags |= paOutputUnderflow;
+ }
+ }
+
+ /* Now check input side */
+ if( stream->input )
+ {
+ PA_ENSURE_( PaAsiHpi_GetStreamInfo( stream->input, &info ) );
+ /* If a full block of samples hasn't been recorded yet, wait for it if possible */
+ if( info.availableFrames < framesTarget )
+ {
+ framesLeft = framesTarget - info.availableFrames;
+ /* As long as output is not disrupted in the process, wait for a full
+ block of input samples */
+ if( !stream->output || (outputData > framesLeft) )
+ {
+ Pa_Sleep( (long)ceil( 1000 * framesLeft / sampleRate ) );
+ continue;
+ }
+ }
+ inputData = info.availableFrames;
+ /** @todo The paInputOverflow flag should be set in the callback containing the
+ first input sample following the overflow. That means the block currently sitting
+ at the fore-front of recording, i.e. typically the one containing the newest (last)
+ sample in the HPI buffer system. This is most likely not the same as the current
+ block of data being passed to the callback. The current overflow should ideally
+ be noted in an overflow list of sorts, with an indication of when it should be
+ reported. The trouble starts if there are several separate overflow incidents,
+ given a big input buffer. Oh well, something to try out later... */
+ if( info.overflow )
+ {
+ *cbFlags |= paInputOverflow;
+ }
+ }
+ break;
+ }
+ /* Full-duplex stream */
+ if( stream->input && stream->output )
+ {
+ if( outputSpace >= framesTarget )
+ *framesAvail = outputSpace;
+ /* If input didn't make the target, keep the output count instead (input underflow) */
+ if( (inputData >= framesTarget) && (inputData < outputSpace) )
+ *framesAvail = inputData;
+ }
+ else
+ {
+ *framesAvail = stream->input ? inputData : outputSpace;
+ }
+
+error:
+ return result;
+}
+
+
+/** Obtain recording, current and playback timestamps of stream.
+ The current time is determined by the system clock. This "now" timestamp occurs at the
+ forefront of recording (and playback in the full-duplex case), which happens later than the
+ input timestamp by an amount equal to the total number of recorded frames in the input buffer.
+ The output timestamp indicates when the next generated sample will actually be played. This
+ happens after all the samples currently in the output buffer are played. The output timestamp
+ therefore follows the current timestamp by an amount equal to the number of frames yet to be
+ played back in the output buffer.
+
+ If the current timestamp is the present, the input timestamp is in the past and the output
+ timestamp is in the future.
+
+ @param stream Pointer to stream struct
+
+ @param timeInfo Pointer to timeInfo struct that will contain timestamps
+ */
+static void PaAsiHpi_CalculateTimeInfo( PaAsiHpiStream *stream, PaStreamCallbackTimeInfo *timeInfo )
+{
+ PaAsiHpiStreamInfo streamInfo;
+ double sampleRate;
+
+ assert( stream );
+ assert( timeInfo );
+ sampleRate = stream->baseStreamRep.streamInfo.sampleRate;
+
+ /* The current time ("now") is at the forefront of both recording and playback */
+ timeInfo->currentTime = GetStreamTime( (PaStream *)stream );
+ /* The last sample in the input buffer was recorded just now, so the first sample
+ happened (number of recorded samples)/sampleRate ago */
+ timeInfo->inputBufferAdcTime = timeInfo->currentTime;
+ if( stream->input )
+ {
+ PaAsiHpi_GetStreamInfo( stream->input, &streamInfo );
+ timeInfo->inputBufferAdcTime -= streamInfo.totalBufferedData / sampleRate;
+ }
+ /* The first of the outgoing samples will be played after all the samples in the output
+ buffer is done */
+ timeInfo->outputBufferDacTime = timeInfo->currentTime;
+ if( stream->output )
+ {
+ PaAsiHpi_GetStreamInfo( stream->output, &streamInfo );
+ timeInfo->outputBufferDacTime += streamInfo.totalBufferedData / sampleRate;
+ }
+}
+
+
+/** Read from HPI input stream and register buffers.
+ This reads data from the HPI input stream (if it exists) and registers the temp stream
+ buffers of both input and output streams with the buffer processor. In the process it also
+ handles input underflows in the full-duplex case.
+
+ @param stream Pointer to stream struct
+
+ @param numFrames On entrance the number of available frames, on exit the number of
+ received frames
+
+ @param cbFlags Indicates overflows and underflows
+
+ @return PortAudio error code
+ */
+static PaError PaAsiHpi_BeginProcessing( PaAsiHpiStream *stream, unsigned long *numFrames,
+ PaStreamCallbackFlags *cbFlags )
+{
+ PaError result = paNoError;
+
+ assert( stream );
+ if( *numFrames > stream->maxFramesPerHostBuffer )
+ *numFrames = stream->maxFramesPerHostBuffer;
+
+ if( stream->input )
+ {
+ PaAsiHpiStreamInfo info;
+
+ uint32_t framesToGet = *numFrames;
+
+ /* Check for overflows and underflows yet again */
+ PA_ENSURE_( PaAsiHpi_GetStreamInfo( stream->input, &info ) );
+ if( info.overflow )
+ {
+ *cbFlags |= paInputOverflow;
+ }
+ /* Input underflow if less than expected number of samples pitch up */
+ if( framesToGet > info.availableFrames )
+ {
+ PaUtilZeroer *zeroer;
+ PaSampleFormat inputFormat;
+
+ /* Never call an input-only stream with InputUnderflow set */
+ if( stream->output )
+ *cbFlags |= paInputUnderflow;
+ framesToGet = info.availableFrames;
+ /* Fill temp buffer with silence (to make up for missing input samples) */
+ inputFormat = PaAsiHpi_HpiToPaFormat( stream->input->hpiFormat.wFormat );
+ zeroer = PaUtil_SelectZeroer( inputFormat );
+ zeroer(stream->input->tempBuffer, 1,
+ stream->input->tempBufferSize / Pa_GetSampleSize(inputFormat) );
+ }
+
+ /* Read block of data into temp buffer */
+ PA_ASIHPI_UNLESS_( HPI_InStreamReadBuf( NULL,
+ stream->input->hpiStream,
+ stream->input->tempBuffer,
+ framesToGet * stream->input->bytesPerFrame),
+ paUnanticipatedHostError );
+ /* Register temp buffer with buffer processor (always FULL buffer) */
+ PaUtil_SetInputFrameCount( &stream->bufferProcessor, *numFrames );
+ /* HPI interface only allows interleaved channels */
+ PaUtil_SetInterleavedInputChannels( &stream->bufferProcessor,
+ 0, stream->input->tempBuffer,
+ stream->input->hpiFormat.wChannels );
+ }
+ if( stream->output )
+ {
+ /* Register temp buffer with buffer processor */
+ PaUtil_SetOutputFrameCount( &stream->bufferProcessor, *numFrames );
+ /* HPI interface only allows interleaved channels */
+ PaUtil_SetInterleavedOutputChannels( &stream->bufferProcessor,
+ 0, stream->output->tempBuffer,
+ stream->output->hpiFormat.wChannels );
+ }
+
+error:
+ return result;
+}
+
+
+/** Flush output buffers to HPI output stream.
+ This completes the processing cycle by writing the temp buffer to the HPI interface.
+ Additional output underflows are caught before data is written to the stream, as this
+ action typically remedies the underflow and hides it in the process.
+
+ @param stream Pointer to stream struct
+
+ @param numFrames The number of frames to write to the output stream
+
+ @param cbFlags Indicates overflows and underflows
+ */
+static PaError PaAsiHpi_EndProcessing( PaAsiHpiStream *stream, unsigned long numFrames,
+ PaStreamCallbackFlags *cbFlags )
+{
+ PaError result = paNoError;
+
+ assert( stream );
+
+ if( stream->output )
+ {
+ PaAsiHpiStreamInfo info;
+ /* Check for underflows after the (potentially time-consuming) callback */
+ PA_ENSURE_( PaAsiHpi_GetStreamInfo( stream->output, &info ) );
+ if( info.underflow )
+ {
+ *cbFlags |= paOutputUnderflow;
+ }
+
+ /* Write temp buffer to HPI stream */
+ PA_ASIHPI_UNLESS_( HPI_OutStreamWriteBuf( NULL,
+ stream->output->hpiStream,
+ stream->output->tempBuffer,
+ numFrames * stream->output->bytesPerFrame,
+ &stream->output->hpiFormat),
+ paUnanticipatedHostError );
+ }
+
+error:
+ return result;
+}
+
+
+/** Main callback engine.
+ This function runs in a separate thread and does all the work of fetching audio data from
+ the AudioScience card via the HPI interface, feeding it to the user callback via the buffer
+ processor, and delivering the resulting output data back to the card via HPI calls.
+ It is started and terminated when the PortAudio stream is started and stopped, and starts
+ the HPI streams on startup.
+
+ @param userData A pointer to an open stream previously created with Pa_OpenStream.
+*/
+static void *CallbackThreadFunc( void *userData )
+{
+ PaError result = paNoError;
+ PaAsiHpiStream *stream = (PaAsiHpiStream *) userData;
+ int callbackResult = paContinue;
+
+ assert( stream );
+
+ /* Cleanup routine stops streams on thread exit */
+ pthread_cleanup_push( &PaAsiHpi_OnThreadExit, stream );
+
+ /* Start HPI streams and notify parent when we're done */
+ PA_ENSURE_( PaUnixThread_PrepareNotify( &stream->thread ) );
+ /* Buffer will be primed with silence */
+ PA_ENSURE_( PaAsiHpi_StartStream( stream, 0 ) );
+ PA_ENSURE_( PaUnixThread_NotifyParent( &stream->thread ) );
+
+ /* MAIN LOOP */
+ while( 1 )
+ {
+ PaStreamCallbackFlags cbFlags = 0;
+ unsigned long framesAvail, framesGot;
+
+ pthread_testcancel();
+
+ /** @concern StreamStop if the main thread has requested a stop and the stream has not
+ * been effectively stopped we signal this condition by modifying callbackResult
+ * (we'll want to flush buffered output). */
+ if( PaUnixThread_StopRequested( &stream->thread ) && (callbackResult == paContinue) )
+ {
+ PA_DEBUG(( "Setting callbackResult to paComplete\n" ));
+ callbackResult = paComplete;
+ }
+
+ /* Start winding down thread if requested */
+ if( callbackResult != paContinue )
+ {
+ stream->callbackAbort = (callbackResult == paAbort);
+ if( stream->callbackAbort ||
+ /** @concern BlockAdaption: Go on if adaption buffers are empty */
+ PaUtil_IsBufferProcessorOutputEmpty( &stream->bufferProcessor ) )
+ {
+ goto end;
+ }
+ PA_DEBUG(( "%s: Flushing buffer processor\n", __FUNCTION__ ));
+ /* There is still buffered output that needs to be processed */
+ }
+
+ /* SLEEP */
+ /* Wait for data (or buffer space) to become available. This basically sleeps and
+ polls the HPI interface until a full block of frames can be moved. */
+ PA_ENSURE_( PaAsiHpi_WaitForFrames( stream, &framesAvail, &cbFlags ) );
+
+ /* Consume buffer space. Once we have a number of frames available for consumption we
+ must retrieve the data from the HPI interface and pass it to the PA buffer processor.
+ We should be prepared to process several chunks successively. */
+ while( framesAvail > 0 )
+ {
+ PaStreamCallbackTimeInfo timeInfo = {0, 0, 0};
+
+ pthread_testcancel();
+
+ framesGot = framesAvail;
+ if( stream->bufferProcessor.hostBufferSizeMode == paUtilFixedHostBufferSize )
+ {
+ /* We've committed to a fixed host buffer size, stick to that */
+ framesGot = framesGot >= stream->maxFramesPerHostBuffer ? stream->maxFramesPerHostBuffer : 0;
+ }
+ else
+ {
+ /* We've committed to an upper bound on the size of host buffers */
+ assert( stream->bufferProcessor.hostBufferSizeMode == paUtilBoundedHostBufferSize );
+ framesGot = PA_MIN( framesGot, stream->maxFramesPerHostBuffer );
+ }
+
+ /* Obtain buffer timestamps */
+ PaAsiHpi_CalculateTimeInfo( stream, &timeInfo );
+ PaUtil_BeginBufferProcessing( &stream->bufferProcessor, &timeInfo, cbFlags );
+ /* CPU load measurement should include processing activivity external to the stream callback */
+ PaUtil_BeginCpuLoadMeasurement( &stream->cpuLoadMeasurer );
+ if( framesGot > 0 )
+ {
+ /* READ FROM HPI INPUT STREAM */
+ PA_ENSURE_( PaAsiHpi_BeginProcessing( stream, &framesGot, &cbFlags ) );
+ /* Input overflow in a full-duplex stream makes for interesting times */
+ if( stream->input && stream->output && (cbFlags & paInputOverflow) )
+ {
+ /* Special full-duplex paNeverDropInput mode */
+ if( stream->neverDropInput )
+ {
+ PaUtil_SetNoOutput( &stream->bufferProcessor );
+ cbFlags |= paOutputOverflow;
+ }
+ }
+ /* CALL USER CALLBACK WITH INPUT DATA, AND OBTAIN OUTPUT DATA */
+ PaUtil_EndBufferProcessing( &stream->bufferProcessor, &callbackResult );
+ /* Clear overflow and underflow information (but PaAsiHpi_EndProcessing might
+ still show up output underflow that will carry over to next round) */
+ cbFlags = 0;
+ /* WRITE TO HPI OUTPUT STREAM */
+ PA_ENSURE_( PaAsiHpi_EndProcessing( stream, framesGot, &cbFlags ) );
+ /* Advance frame counter */
+ framesAvail -= framesGot;
+ }
+ PaUtil_EndCpuLoadMeasurement( &stream->cpuLoadMeasurer, framesGot );
+
+ if( framesGot == 0 )
+ {
+ /* Go back to polling for more frames */
+ break;
+
+ }
+ if( callbackResult != paContinue )
+ break;
+ }
+ }
+
+ /* This code is unreachable, but important to include regardless because it
+ * is possibly a macro with a closing brace to match the opening brace in
+ * pthread_cleanup_push() above. The documentation states that they must
+ * always occur in pairs. */
+ pthread_cleanup_pop( 1 );
+
+end:
+ /* Indicates normal exit of callback, as opposed to the thread getting killed explicitly */
+ stream->callbackFinished = 1;
+ PA_DEBUG(( "%s: Thread %d exiting (callbackResult = %d)\n ",
+ __FUNCTION__, pthread_self(), callbackResult ));
+ /* Exit from thread and report any PortAudio error in the process */
+ PaUnixThreading_EXIT( result );
+error:
+ goto end;
+}
+
+/* --------------------------- Blocking Interface --------------------------- */
+
+/* As separate stream interfaces are used for blocking and callback streams, the following
+ functions can be guaranteed to only be called for blocking streams. */
+
+/** Read data from input stream.
+ This reads the indicated number of frames into the supplied buffer from an input stream,
+ and blocks until this is done.
+
+ @param s Pointer to PortAudio stream
+
+ @param buffer Pointer to buffer that will receive interleaved data (or an array of pointers
+ to a buffer for each non-interleaved channel)
+
+ @param frames Number of frames to read from stream
+
+ @return PortAudio error code (also indicates overflow via paInputOverflowed)
+ */
+static PaError ReadStream( PaStream *s,
+ void *buffer,
+ unsigned long frames )
+{
+ PaError result = paNoError;
+ PaAsiHpiStream *stream = (PaAsiHpiStream*)s;
+ PaAsiHpiStreamInfo info;
+ void *userBuffer;
+
+ assert( stream );
+ PA_UNLESS_( stream->input, paCanNotReadFromAnOutputOnlyStream );
+
+ /* Check for input overflow since previous call to ReadStream */
+ PA_ENSURE_( PaAsiHpi_GetStreamInfo( stream->input, &info ) );
+ if( info.overflow )
+ {
+ result = paInputOverflowed;
+ }
+
+ /* NB Make copy of user buffer pointers, since they are advanced by buffer processor */
+ if( stream->bufferProcessor.userInputIsInterleaved )
+ {
+ userBuffer = buffer;
+ }
+ else
+ {
+ /* Copy channels into local array */
+ userBuffer = stream->blockingUserBufferCopy;
+ memcpy( userBuffer, buffer, sizeof (void *) * stream->input->hpiFormat.wChannels );
+ }
+
+ while( frames > 0 )
+ {
+ unsigned long framesGot, framesAvail;
+ PaStreamCallbackFlags cbFlags = 0;
+
+ PA_ENSURE_( PaAsiHpi_WaitForFrames( stream, &framesAvail, &cbFlags ) );
+ framesGot = PA_MIN( framesAvail, frames );
+ PA_ENSURE_( PaAsiHpi_BeginProcessing( stream, &framesGot, &cbFlags ) );
+
+ if( framesGot > 0 )
+ {
+ framesGot = PaUtil_CopyInput( &stream->bufferProcessor, &userBuffer, framesGot );
+ PA_ENSURE_( PaAsiHpi_EndProcessing( stream, framesGot, &cbFlags ) );
+ /* Advance frame counter */
+ frames -= framesGot;
+ }
+ }
+
+error:
+ return result;
+}
+
+
+/** Write data to output stream.
+ This writes the indicated number of frames from the supplied buffer to an output stream,
+ and blocks until this is done.
+
+ @param s Pointer to PortAudio stream
+
+ @param buffer Pointer to buffer that provides interleaved data (or an array of pointers
+ to a buffer for each non-interleaved channel)
+
+ @param frames Number of frames to write to stream
+
+ @return PortAudio error code (also indicates underflow via paOutputUnderflowed)
+ */
+static PaError WriteStream( PaStream *s,
+ const void *buffer,
+ unsigned long frames )
+{
+ PaError result = paNoError;
+ PaAsiHpiStream *stream = (PaAsiHpiStream*)s;
+ PaAsiHpiStreamInfo info;
+ const void *userBuffer;
+
+ assert( stream );
+ PA_UNLESS_( stream->output, paCanNotWriteToAnInputOnlyStream );
+
+ /* Check for output underflow since previous call to WriteStream */
+ PA_ENSURE_( PaAsiHpi_GetStreamInfo( stream->output, &info ) );
+ if( info.underflow )
+ {
+ result = paOutputUnderflowed;
+ }
+
+ /* NB Make copy of user buffer pointers, since they are advanced by buffer processor */
+ if( stream->bufferProcessor.userOutputIsInterleaved )
+ {
+ userBuffer = buffer;
+ }
+ else
+ {
+ /* Copy channels into local array */
+ userBuffer = stream->blockingUserBufferCopy;
+ memcpy( (void *)userBuffer, buffer, sizeof (void *) * stream->output->hpiFormat.wChannels );
+ }
+
+ while( frames > 0 )
+ {
+ unsigned long framesGot, framesAvail;
+ PaStreamCallbackFlags cbFlags = 0;
+
+ PA_ENSURE_( PaAsiHpi_WaitForFrames( stream, &framesAvail, &cbFlags ) );
+ framesGot = PA_MIN( framesAvail, frames );
+ PA_ENSURE_( PaAsiHpi_BeginProcessing( stream, &framesGot, &cbFlags ) );
+
+ if( framesGot > 0 )
+ {
+ framesGot = PaUtil_CopyOutput( &stream->bufferProcessor, &userBuffer, framesGot );
+ PA_ENSURE_( PaAsiHpi_EndProcessing( stream, framesGot, &cbFlags ) );
+ /* Advance frame counter */
+ frames -= framesGot;
+ }
+ }
+
+error:
+ return result;
+}
+
+
+/** Number of frames that can be read from input stream without blocking.
+
+ @param s Pointer to PortAudio stream
+
+ @return Number of frames, or PortAudio error code
+ */
+static signed long GetStreamReadAvailable( PaStream *s )
+{
+ PaError result = paNoError;
+ PaAsiHpiStream *stream = (PaAsiHpiStream*)s;
+ PaAsiHpiStreamInfo info;
+
+ assert( stream );
+ PA_UNLESS_( stream->input, paCanNotReadFromAnOutputOnlyStream );
+
+ PA_ENSURE_( PaAsiHpi_GetStreamInfo( stream->input, &info ) );
+ /* Round down to the nearest host buffer multiple */
+ result = (info.availableFrames / stream->maxFramesPerHostBuffer) * stream->maxFramesPerHostBuffer;
+ if( info.overflow )
+ {
+ result = paInputOverflowed;
+ }
+
+error:
+ return result;
+}
+
+
+/** Number of frames that can be written to output stream without blocking.
+
+ @param s Pointer to PortAudio stream
+
+ @return Number of frames, or PortAudio error code
+ */
+static signed long GetStreamWriteAvailable( PaStream *s )
+{
+ PaError result = paNoError;
+ PaAsiHpiStream *stream = (PaAsiHpiStream*)s;
+ PaAsiHpiStreamInfo info;
+
+ assert( stream );
+ PA_UNLESS_( stream->output, paCanNotWriteToAnInputOnlyStream );
+
+ PA_ENSURE_( PaAsiHpi_GetStreamInfo( stream->output, &info ) );
+ /* Round down to the nearest host buffer multiple */
+ result = (info.availableFrames / stream->maxFramesPerHostBuffer) * stream->maxFramesPerHostBuffer;
+ if( info.underflow )
+ {
+ result = paOutputUnderflowed;
+ }
+
+error:
+ return result;
+}