diff options
Diffstat (limited to 'portaudio/src/hostapi/asihpi')
| -rw-r--r-- | portaudio/src/hostapi/asihpi/pa_linux_asihpi.c | 2893 |
1 files changed, 0 insertions, 2893 deletions
diff --git a/portaudio/src/hostapi/asihpi/pa_linux_asihpi.c b/portaudio/src/hostapi/asihpi/pa_linux_asihpi.c deleted file mode 100644 index 79eb1d7..0000000 --- a/portaudio/src/hostapi/asihpi/pa_linux_asihpi.c +++ /dev/null @@ -1,2893 +0,0 @@ -/* - * $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; -} |