text: /*
   * $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 = 3;
                  /* 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;
                  baseDeviceInfo->connectionId = PaUtil_MakeDeviceConnectionId();
  
                  /* 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 = 3;
                  /* 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;
                  baseDeviceInfo->connectionId = PaUtil_MakeDeviceConnectionId();
  
                  /* 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;
      (*hostApi)->ScanDeviceInfos = 0;
      (*hostApi)->CommitDeviceInfos = 0;
      (*hostApi)->DisposeDeviceInfos = 0;
  
      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;
  }
  