SV platform dependency builds

/*

 * $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;