... more changes to try to upload 0.38 test 5 to CVS

svn path=/trunk/; revision=2011

3 files changed, 1310 insertions, 0 deletions

diff --git a/pd/portaudio/pa_unix_oss/low_latency_tip.txt b/pd/portaudio/pa_unix_oss/low_latency_tip.txt
new file mode 100644
index 00000000..2d982b79
--- /dev/null
+++ b/pd/portaudio/pa_unix_oss/low_latency_tip.txt
diff --git a/pd/portaudio/pa_unix_oss/pa_unix_oss.c b/pd/portaudio/pa_unix_oss/pa_unix_oss.c
new file mode 100644
index 00000000..b2e6d5a4
--- /dev/null
+++ b/pd/portaudio/pa_unix_oss/pa_unix_oss.c
@@ -0,0 +1,1196 @@
+/*
+ * $Id: pa_unix_oss.c,v 1.6.2.7 2003/09/23 21:17:22 rossbencina Exp $
+ * PortAudio Portable Real-Time Audio Library
+ * Latest Version at: http://www.portaudio.com
+ * OSS implementation by:
+ *   Douglas Repetto
+ *   Phil Burk
+ *   Dominic Mazzoni
+ *
+ * Based on the Open Source API proposed by Ross Bencina
+ * Copyright (c) 1999-2002 Ross Bencina, Phil Burk
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ *
+ * 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.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <pthread.h>
+
+#ifdef __linux__
+# include <linux/soundcard.h>
+# define DEVICE_NAME_BASE            "/dev/dsp"
+#else
+# include <machine/soundcard.h> /* JH20010905 */
+# define DEVICE_NAME_BASE            "/dev/audio"
+#endif
+
+#include "portaudio.h"
+#include "pa_util.h"
+#include "pa_allocation.h"
+#include "pa_hostapi.h"
+#include "pa_stream.h"
+#include "pa_cpuload.h"
+#include "pa_process.h"
+
+/* TODO: add error text handling
+#define PA_UNIX_OSS_ERROR( errorCode, errorText ) \
+    PaUtil_SetLastHostErrorInfo( paInDevelopment, errorCode, errorText )
+*/
+
+#define PRINT(x)   { printf x; fflush(stdout); }
+#define DBUG(x)    /* PRINT(x) */
+
+/* PaOSSHostApiRepresentation - host api datastructure specific to this implementation */
+
+typedef struct
+{
+    PaUtilHostApiRepresentation inheritedHostApiRep;
+    PaUtilStreamInterface callbackStreamInterface;
+    PaUtilStreamInterface blockingStreamInterface;
+
+    PaUtilAllocationGroup *allocations;
+
+    PaHostApiIndex hostApiIndex;
+}
+PaOSSHostApiRepresentation;
+
+typedef struct PaOSS_DeviceList {
+    PaDeviceInfo *deviceInfo;
+    struct PaOSS_DeviceList *next;
+}
+PaOSS_DeviceList;
+
+/* prototypes for functions declared in this file */
+
+PaError PaOSS_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex hostApiIndex );
+static void Terminate( struct PaUtilHostApiRepresentation *hostApi );
+static PaError IsFormatSupported( struct PaUtilHostApiRepresentation *hostApi,
+                                  const PaStreamParameters *inputParameters,
+                                  const PaStreamParameters *outputParameters,
+                                  double sampleRate );
+static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,
+                           PaStream** s,
+                           const PaStreamParameters *inputParameters,
+                           const PaStreamParameters *outputParameters,
+                           double sampleRate,
+                           unsigned long framesPerBuffer,
+                           PaStreamFlags streamFlags,
+                           PaStreamCallback *streamCallback,
+                           void *userData );
+static PaError CloseStream( PaStream* stream );
+static PaError StartStream( PaStream *stream );
+static PaError StopStream( PaStream *stream );
+static PaError AbortStream( PaStream *stream );
+static PaError IsStreamStopped( PaStream *s );
+static PaError IsStreamActive( PaStream *stream );
+static PaTime GetStreamTime( PaStream *stream );
+static double GetStreamCpuLoad( PaStream* stream );
+static PaError ReadStream( PaStream* stream, void *buffer, unsigned long frames );
+static PaError WriteStream( PaStream* stream, const void *buffer, unsigned long frames );
+static signed long GetStreamReadAvailable( PaStream* stream );
+static signed long GetStreamWriteAvailable( PaStream* stream );
+static PaError BuildDeviceList( PaOSSHostApiRepresentation *hostApi );
+
+
+PaError PaOSS_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex hostApiIndex )
+{
+    PaError result = paNoError;
+    PaOSSHostApiRepresentation *ossHostApi;
+
+    DBUG(("PaOSS_Initialize\n"));
+
+    ossHostApi = (PaOSSHostApiRepresentation*)PaUtil_AllocateMemory( sizeof(PaOSSHostApiRepresentation) );
+    if( !ossHostApi )
+    {
+        result = paInsufficientMemory;
+        goto error;
+    }
+
+    ossHostApi->allocations = PaUtil_CreateAllocationGroup();
+    if( !ossHostApi->allocations )
+    {
+        result = paInsufficientMemory;
+        goto error;
+    }
+
+    *hostApi = &ossHostApi->inheritedHostApiRep;
+    (*hostApi)->info.structVersion = 1;
+    (*hostApi)->info.type = paOSS;
+    (*hostApi)->info.name = "OSS";
+    ossHostApi->hostApiIndex = hostApiIndex;
+
+    BuildDeviceList( ossHostApi );
+
+    (*hostApi)->Terminate = Terminate;
+    (*hostApi)->OpenStream = OpenStream;
+    (*hostApi)->IsFormatSupported = IsFormatSupported;
+
+    PaUtil_InitializeStreamInterface( &ossHostApi->callbackStreamInterface, CloseStream, StartStream,
+                                      StopStream, AbortStream, IsStreamStopped, IsStreamActive,
+                                      GetStreamTime, GetStreamCpuLoad,
+                                      PaUtil_DummyRead, PaUtil_DummyWrite,
+                                      PaUtil_DummyGetReadAvailable,
+                                      PaUtil_DummyGetWriteAvailable );
+
+    PaUtil_InitializeStreamInterface( &ossHostApi->blockingStreamInterface, CloseStream, StartStream,
+                                      StopStream, AbortStream, IsStreamStopped, IsStreamActive,
+                                      GetStreamTime, PaUtil_DummyGetCpuLoad,
+                                      ReadStream, WriteStream, GetStreamReadAvailable, GetStreamWriteAvailable );
+
+    return result;
+
+error:
+    if( ossHostApi )
+    {
+        if( ossHostApi->allocations )
+        {
+            PaUtil_FreeAllAllocations( ossHostApi->allocations );
+            PaUtil_DestroyAllocationGroup( ossHostApi->allocations );
+        }
+                
+        PaUtil_FreeMemory( ossHostApi );
+    }
+    return result;
+}
+
+#ifndef AFMT_S16_NE
+#define AFMT_S16_NE  Get_AFMT_S16_NE()
+/*********************************************************************
+ * Some versions of OSS do not define AFMT_S16_NE. So check CPU.
+ * PowerPC is Big Endian. X86 is Little Endian.
+ */
+static int Get_AFMT_S16_NE( void )
+{
+    long testData = 1; 
+    char *ptr = (char *) &testData;
+    int isLittle = ( *ptr == 1 ); /* Does address point to least significant byte? */
+    return isLittle ? AFMT_S16_LE : AFMT_S16_BE;
+}
+#endif
+
+PaError PaOSS_SetFormat(const char *callingFunctionName, int deviceHandle,
+                        char *deviceName, int inputChannelCount, int outputChannelCount,
+                        double *sampleRate)
+{
+    int format;
+    int rate;
+    int temp;
+
+    /* Attempt to set format to 16-bit */
+    
+    format = AFMT_S16_NE;
+    if (ioctl(deviceHandle, SNDCTL_DSP_SETFMT, &format) == -1) {
+       DBUG(("%s: could not set format: %s\n", callingFunctionName, deviceName ));
+       return paSampleFormatNotSupported;
+    }
+    if (format != AFMT_S16_NE) {
+       DBUG(("%s: device does not support AFMT_S16_NE: %s\n", callingFunctionName, deviceName ));
+       return paSampleFormatNotSupported;
+    }
+
+    /* try to set the number of channels */
+
+    if (inputChannelCount > 0) {
+       temp = inputChannelCount;
+       
+       if( ioctl(deviceHandle, SNDCTL_DSP_CHANNELS, &temp) < 0 ) {
+          DBUG(("%s: Couldn't set device %s to %d channels\n", callingFunctionName, deviceName, inputChannelCount ));
+          return paSampleFormatNotSupported;
+       }
+    }
+    
+    if (outputChannelCount > 0) {
+       temp = outputChannelCount;
+       
+       if( ioctl(deviceHandle, SNDCTL_DSP_CHANNELS, &temp) < 0 ) {
+          DBUG(("%s: Couldn't set device %s to %d channels\n", callingFunctionName, deviceName, outputChannelCount ));          
+          return paSampleFormatNotSupported;
+       }
+    }
+
+    /* try to set the sample rate */
+
+    rate = (int)(*sampleRate);
+    if (ioctl(deviceHandle, SNDCTL_DSP_SPEED, &rate) == -1)
+    {
+        DBUG(("%s: Device %s, couldn't set sample rate to %d\n",
+              callingFunctionName, deviceName, (int)*sampleRate ));
+        return paInvalidSampleRate;
+    }
+
+    /* reject if there's no sample rate within 1% of the one requested */
+    if ((fabs(*sampleRate - rate) / *sampleRate) > 0.01)
+    {
+        DBUG(("%s: Device %s, wanted %d, closest sample rate was %d\n",
+              callingFunctionName, deviceName, (int)*sampleRate, rate ));                 
+        return paInvalidSampleRate;
+    }
+
+    *sampleRate = rate;
+
+    return paNoError;
+}
+
+static PaError PaOSS_QueryDevice(char *deviceName, PaDeviceInfo *deviceInfo)
+{
+    PaError result = paNoError;
+    int tempDevHandle;
+    int numChannels, maxNumChannels;
+    int sampleRate;
+    int format;
+
+    /* douglas:
+       we have to do this querying in a slightly different order. apparently
+       some sound cards will give you different info based on their settins. 
+       e.g. a card might give you stereo at 22kHz but only mono at 44kHz.
+       the correct order for OSS is: format, channels, sample rate
+    */
+
+    if ( (tempDevHandle = open(deviceName,O_WRONLY|O_NONBLOCK))  == -1 )
+    {
+        DBUG(("PaOSS_QueryDevice: could not open %s\n", deviceName ));
+        return paDeviceUnavailable;
+    }
+
+    /* Attempt to set format to 16-bit */
+    format = AFMT_S16_NE;
+    if (ioctl(tempDevHandle, SNDCTL_DSP_SETFMT, &format) == -1) {
+       DBUG(("PaOSS_QueryDevice: could not set format: %s\n", deviceName ));
+       result = paSampleFormatNotSupported;
+       goto error;
+    }
+    if (format != AFMT_S16_NE) {
+       DBUG(("PaOSS_QueryDevice: device does not support AFMT_S16_NE: %s\n", deviceName ));
+       result = paSampleFormatNotSupported;
+       goto error;
+    }
+
+    /* Negotiate for the maximum number of channels for this device. PLB20010927
+     * Consider up to 16 as the upper number of channels.
+     * Variable maxNumChannels should contain the actual upper limit after the call.
+     * Thanks to John Lazzaro and Heiko Purnhagen for suggestions.
+     */
+    maxNumChannels = 0;
+    for( numChannels = 1; numChannels <= 16; numChannels++ )
+    {
+        int temp = numChannels;
+        DBUG(("PaOSS_QueryDevice: use SNDCTL_DSP_CHANNELS, numChannels = %d\n", numChannels ))
+        if(ioctl(tempDevHandle, SNDCTL_DSP_CHANNELS, &temp) < 0 )
+        {
+            /* ioctl() failed so bail out if we already have stereo */
+            if( numChannels > 2 ) break;
+        }
+        else
+        {
+            /* ioctl() worked but bail out if it does not support numChannels.
+             * We don't want to leave gaps in the numChannels supported.
+             */
+            if( (numChannels > 2) && (temp != numChannels) ) break;
+            DBUG(("PaOSS_QueryDevice: temp = %d\n", temp ))
+            if( temp > maxNumChannels ) maxNumChannels = temp; /* Save maximum. */
+        }
+    }
+
+    /* The above negotiation may fail for an old driver so try this older technique. */
+    if( maxNumChannels < 1 )
+    {
+        int stereo = 1;
+        if(ioctl(tempDevHandle, SNDCTL_DSP_STEREO, &stereo) < 0)
+        {
+            maxNumChannels = 1;
+        }
+        else
+        {
+            maxNumChannels = (stereo) ? 2 : 1;
+        }
+        DBUG(("PaOSS_QueryDevice: use SNDCTL_DSP_STEREO, maxNumChannels = %d\n", maxNumChannels ))
+    }
+
+    DBUG(("PaOSS_QueryDevice: maxNumChannels = %d\n", maxNumChannels))
+
+    deviceInfo->maxOutputChannels = maxNumChannels;
+    /* FIXME - for now, assume maxInputChannels = maxOutputChannels.
+     *    Eventually do separate queries for O_WRONLY and O_RDONLY
+    */
+    deviceInfo->maxInputChannels = deviceInfo->maxOutputChannels;
+
+    /* During channel negotiation, the last ioctl() may have failed. This can
+     * also cause sample rate negotiation to fail. Hence the following, to return
+     * to a supported number of channels. SG20011005 */
+    {
+        int temp = maxNumChannels;
+        if( temp > 2 ) temp = 2; /* use most reasonable default value */
+        ioctl(tempDevHandle, SNDCTL_DSP_CHANNELS, &temp);
+    }
+
+    /* Get supported sample rate closest to 44100 Hz */
+    sampleRate = 44100;
+    if (ioctl(tempDevHandle, SNDCTL_DSP_SPEED, &sampleRate) == -1)
+    {
+        result = paUnanticipatedHostError;
+        goto error;
+    }
+
+    deviceInfo->defaultSampleRate = sampleRate;
+
+    deviceInfo->structVersion = 2;
+
+    /* TODO */
+    deviceInfo->defaultLowInputLatency = 128.0 / sampleRate;
+    deviceInfo->defaultLowOutputLatency = 128.0 / sampleRate;
+    deviceInfo->defaultHighInputLatency = 16384.0 / sampleRate;
+    deviceInfo->defaultHighOutputLatency = 16384.0 / sampleRate;
+
+    result = paNoError;
+
+error:
+    /* We MUST close the handle here or we won't be able to reopen it later!!!  */
+    close(tempDevHandle);
+
+    return result;
+}
+
+static PaError BuildDeviceList( PaOSSHostApiRepresentation *ossApi )
+{
+    PaUtilHostApiRepresentation *commonApi = &ossApi->inheritedHostApiRep;
+    PaOSS_DeviceList *head = NULL, *tail = NULL, *entry;
+    int i;
+    int numDevices;
+
+    /* Find devices by calling PaOSS_QueryDevice on each
+       potential device names.  When we find a valid one,
+       add it to a linked list. */
+
+    for(i=0; i<10; i++) {
+       char deviceName[32];
+       PaDeviceInfo deviceInfo;
+       int testResult;
+
+       if (i==0)
+          sprintf(deviceName, "%s", DEVICE_NAME_BASE);
+       else
+          sprintf(deviceName, "%s%d", DEVICE_NAME_BASE, i);
+
+       DBUG(("PaOSS BuildDeviceList: trying device %s\n", deviceName ));
+       testResult = PaOSS_QueryDevice(deviceName, &deviceInfo);
+       DBUG(("PaOSS BuildDeviceList: PaOSS_QueryDevice returned %d\n", testResult ));
+
+       if (testResult == paNoError) {
+          DBUG(("PaOSS BuildDeviceList: Adding device %s to list\n", deviceName));
+          deviceInfo.hostApi = ossApi->hostApiIndex;
+          deviceInfo.name = PaUtil_GroupAllocateMemory(
+              ossApi->allocations, strlen(deviceName)+1);
+          strcpy((char *)deviceInfo.name, deviceName);
+          entry = (PaOSS_DeviceList *)PaUtil_AllocateMemory(sizeof(PaOSS_DeviceList));
+          entry->deviceInfo = (PaDeviceInfo*)PaUtil_GroupAllocateMemory(
+              ossApi->allocations, sizeof(PaDeviceInfo) );
+          entry->next = NULL;
+          memcpy(entry->deviceInfo, &deviceInfo, sizeof(PaDeviceInfo));
+          if (tail)
+             tail->next = entry;
+          else {
+             head = entry;
+             tail = entry;
+          }
+       }
+    }
+
+    /* Make an array of PaDeviceInfo pointers out of the linked list */
+
+    numDevices = 0;
+    entry = head;
+    while(entry) {
+       numDevices++;
+       entry = entry->next;
+    }
+
+    DBUG(("PaOSS BuildDeviceList: Total number of devices found: %d\n", numDevices));
+
+    commonApi->deviceInfos = (PaDeviceInfo**)PaUtil_GroupAllocateMemory(
+        ossApi->allocations, sizeof(PaDeviceInfo*) *numDevices );
+
+    entry = head;
+    i = 0;
+    while(entry) {
+       commonApi->deviceInfos[i] = entry->deviceInfo;
+       i++;
+       entry = entry->next;
+    }
+
+    commonApi->info.deviceCount = numDevices;
+    commonApi->info.defaultInputDevice = 0;
+    commonApi->info.defaultOutputDevice = 0;
+
+    return paNoError;
+}
+
+static void Terminate( struct PaUtilHostApiRepresentation *hostApi )
+{
+    PaOSSHostApiRepresentation *ossHostApi = (PaOSSHostApiRepresentation*)hostApi;
+
+    if( ossHostApi->allocations )
+    {
+        PaUtil_FreeAllAllocations( ossHostApi->allocations );
+        PaUtil_DestroyAllocationGroup( ossHostApi->allocations );
+    }
+
+    PaUtil_FreeMemory( ossHostApi );
+}
+
+static PaError IsFormatSupported( struct PaUtilHostApiRepresentation *hostApi,
+                                  const PaStreamParameters *inputParameters,
+                                  const PaStreamParameters *outputParameters,
+                                  double sampleRate )
+{
+    PaDeviceIndex device;
+    PaDeviceInfo *deviceInfo;
+    PaError result = paNoError;
+    char *deviceName;
+    int inputChannelCount, outputChannelCount;
+    int tempDevHandle = 0;
+    int flags;
+    PaSampleFormat inputSampleFormat, outputSampleFormat;
+    
+    if( inputParameters )
+    {
+        inputChannelCount = inputParameters->channelCount;
+        inputSampleFormat = inputParameters->sampleFormat;
+
+        /* unless alternate device specification is supported, reject the use of
+            paUseHostApiSpecificDeviceSpecification */
+
+        if( inputParameters->device == paUseHostApiSpecificDeviceSpecification )
+            return paInvalidDevice;
+
+        /* check that input device can support inputChannelCount */
+        if( inputChannelCount > hostApi->deviceInfos[ inputParameters->device ]->maxInputChannels )
+            return paInvalidChannelCount;
+
+        /* validate inputStreamInfo */
+        if( inputParameters->hostApiSpecificStreamInfo )
+            return paIncompatibleHostApiSpecificStreamInfo; /* this implementation doesn't use custom stream info */
+    }
+    else
+    {
+        inputChannelCount = 0;
+    }
+
+    if( outputParameters )
+    {
+        outputChannelCount = outputParameters->channelCount;
+        outputSampleFormat = outputParameters->sampleFormat;
+        
+        /* unless alternate device specification is supported, reject the use of
+            paUseHostApiSpecificDeviceSpecification */
+
+        if( outputParameters->device == paUseHostApiSpecificDeviceSpecification )
+            return paInvalidDevice;
+
+        /* check that output device can support inputChannelCount */
+        if( outputChannelCount > hostApi->deviceInfos[ outputParameters->device ]->maxOutputChannels )
+            return paInvalidChannelCount;
+
+        /* validate outputStreamInfo */
+        if( outputParameters->hostApiSpecificStreamInfo )
+            return paIncompatibleHostApiSpecificStreamInfo; /* this implementation doesn't use custom stream info */
+    }
+    else
+    {
+        outputChannelCount = 0;
+    }
+
+    if (inputChannelCount == 0 && outputChannelCount == 0)
+        return paInvalidChannelCount;
+
+    /* if full duplex, make sure that they're the same device */
+
+    if (inputChannelCount > 0 && outputChannelCount > 0 &&
+        inputParameters->device != outputParameters->device)
+        return paInvalidDevice;
+
+    /* if full duplex, also make sure that they're the same number of channels */
+
+    if (inputChannelCount > 0 && outputChannelCount > 0 &&
+        inputChannelCount != outputChannelCount)
+       return paInvalidChannelCount;
+
+    /* open the device so we can do more tests */
+    
+    if (inputChannelCount > 0) {
+        result = PaUtil_DeviceIndexToHostApiDeviceIndex(&device, inputParameters->device, hostApi);
+        if (result != paNoError)
+            return result;
+    }
+    else {
+        result = PaUtil_DeviceIndexToHostApiDeviceIndex(&device, outputParameters->device, hostApi);
+        if (result != paNoError)
+            return result;
+    }
+
+    deviceInfo = hostApi->deviceInfos[device];
+    deviceName = (char *)deviceInfo->name;
+    
+    flags = O_NONBLOCK;
+    if (inputChannelCount > 0 && outputChannelCount > 0)
+       flags |= O_RDWR;
+    else if (inputChannelCount > 0)
+       flags |= O_RDONLY;
+    else
+       flags |= O_WRONLY;
+
+    if ( (tempDevHandle = open(deviceInfo->name, flags))  == -1 )
+    {
+        DBUG(("PaOSS IsFormatSupported: could not open %s\n", deviceName ));
+        return paDeviceUnavailable;
+    }
+
+    /* PaOSS_SetFormat will do the rest of the checking for us */
+
+    if ((result = PaOSS_SetFormat("PaOSS IsFormatSupported", tempDevHandle,
+                                  deviceName, inputChannelCount, outputChannelCount,
+                                  &sampleRate)) != paNoError)
+    {
+       goto error;
+    }
+
+    /* everything succeeded! */
+
+    close(tempDevHandle);             
+
+    return paFormatIsSupported;
+
+ error:
+    if (tempDevHandle)
+        close(tempDevHandle);         
+
+    return paSampleFormatNotSupported;
+}
+
+/* PaOSSStream - a stream data structure specifically for this implementation */
+
+typedef struct PaOSSStream
+{
+    PaUtilStreamRepresentation streamRepresentation;
+    PaUtilCpuLoadMeasurer cpuLoadMeasurer;
+    PaUtilBufferProcessor bufferProcessor;
+
+    int deviceHandle;
+
+    int stopSoon;
+    int stopNow;
+    int isActive;
+
+    int inputChannelCount;
+    int outputChannelCount;
+
+    pthread_t thread;
+
+    void *inputBuffer;
+    void *outputBuffer;
+
+    int lastPosPtr;
+    double lastStreamBytes;
+
+    int framesProcessed;
+
+    double sampleRate;
+
+    unsigned long framesPerHostCallback;
+}
+PaOSSStream;
+
+/* see pa_hostapi.h for a list of validity guarantees made about OpenStream parameters */
+
+static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,
+                           PaStream** s,
+                           const PaStreamParameters *inputParameters,
+                           const PaStreamParameters *outputParameters,
+                           double sampleRate,
+                           unsigned long framesPerBuffer,
+                           PaStreamFlags streamFlags,
+                           PaStreamCallback *streamCallback,
+                           void *userData )
+{
+    PaError result = paNoError;
+    PaOSSHostApiRepresentation *ossHostApi = (PaOSSHostApiRepresentation*)hostApi;
+    PaOSSStream *stream = 0;
+    PaDeviceIndex device;
+    PaDeviceInfo *deviceInfo;
+    audio_buf_info bufinfo;
+    int bytesPerHostBuffer;
+    int flags;
+    int deviceHandle = 0;
+    char *deviceName;
+    unsigned long framesPerHostBuffer;
+    int inputChannelCount, outputChannelCount;
+    PaSampleFormat inputSampleFormat = paInt16, outputSampleFormat = paInt16;
+    PaSampleFormat hostInputSampleFormat = paInt16, hostOutputSampleFormat = paInt16;
+
+    if( inputParameters )
+    {
+        inputChannelCount = inputParameters->channelCount;
+        inputSampleFormat = inputParameters->sampleFormat;
+
+        /* unless alternate device specification is supported, reject the use of
+            paUseHostApiSpecificDeviceSpecification */
+
+        if( inputParameters->device == paUseHostApiSpecificDeviceSpecification )
+            return paInvalidDevice;
+
+        /* check that input device can support inputChannelCount */
+        if( inputChannelCount > hostApi->deviceInfos[ inputParameters->device ]->maxInputChannels )
+            return paInvalidChannelCount;
+
+        /* validate inputStreamInfo */
+        if( inputParameters->hostApiSpecificStreamInfo )
+            return paIncompatibleHostApiSpecificStreamInfo; /* this implementation doesn't use custom stream info */
+
+        hostInputSampleFormat =
+            PaUtil_SelectClosestAvailableFormat( paInt16, inputSampleFormat );
+    }
+    else
+    {
+        inputChannelCount = 0;
+    }
+
+    if( outputParameters )
+    {
+        outputChannelCount = outputParameters->channelCount;
+        outputSampleFormat = outputParameters->sampleFormat;
+        
+        /* unless alternate device specification is supported, reject the use of
+            paUseHostApiSpecificDeviceSpecification */
+
+        if( outputParameters->device == paUseHostApiSpecificDeviceSpecification )
+            return paInvalidDevice;
+
+        /* check that output device can support inputChannelCount */
+        if( outputChannelCount > hostApi->deviceInfos[ outputParameters->device ]->maxOutputChannels )
+            return paInvalidChannelCount;
+
+        /* validate outputStreamInfo */
+        if( outputParameters->hostApiSpecificStreamInfo )
+            return paIncompatibleHostApiSpecificStreamInfo; /* this implementation doesn't use custom stream info */
+
+        hostOutputSampleFormat =
+            PaUtil_SelectClosestAvailableFormat( paInt16, outputSampleFormat );
+    }
+    else
+    {
+        outputChannelCount = 0;
+    }
+
+    if( inputChannelCount == 0 && outputChannelCount == 0 )
+    {
+        DBUG(("Both inputChannelCount and outputChannelCount are zero!\n"));
+        return paUnanticipatedHostError;
+    }
+
+    /* validate platform specific flags */
+    if( (streamFlags & paPlatformSpecificFlags) != 0 )
+        return paInvalidFlag; /* unexpected platform specific flag */
+
+    /*
+     * open the device and set parameters here
+     */
+
+    if (inputChannelCount == 0 && outputChannelCount == 0)
+        return paInvalidChannelCount;
+
+    /* if full duplex, make sure that they're the same device */
+
+    if (inputChannelCount > 0 && outputChannelCount > 0 &&
+        inputParameters->device != outputParameters->device)
+        return paInvalidDevice;
+
+    /* if full duplex, also make sure that they're the same number of channels */
+
+    if (inputChannelCount > 0 && outputChannelCount > 0 &&
+        inputChannelCount != outputChannelCount)
+       return paInvalidChannelCount;
+
+    /* note that inputParameters and outputParameters device indicies are
+     * already in host format */
+    device = (inputChannelCount > 0 )
+            ? inputParameters->device
+            : outputParameters->device;
+
+    deviceInfo = hostApi->deviceInfos[device];
+    deviceName = (char *)deviceInfo->name;
+
+    flags = O_NONBLOCK;
+    if (inputChannelCount > 0 && outputChannelCount > 0)
+       flags |= O_RDWR;
+    else if (inputChannelCount > 0)
+       flags |= O_RDONLY;
+    else
+       flags |= O_WRONLY;
+
+    /* open first in nonblocking mode, in case it's busy... */
+    if ( (deviceHandle = open(deviceInfo->name, flags))  == -1 )
+    {
+        DBUG(("PaOSS OpenStream: could not open %s\n", deviceName ));
+        return paDeviceUnavailable;
+    }
+
+    /* if that succeeded, immediately open it again in blocking mode */
+    close(deviceHandle);
+    flags -= O_NONBLOCK;
+    if ( (deviceHandle = open(deviceInfo->name, flags))  == -1 )
+    {
+        DBUG(("PaOSS OpenStream: could not open %s in blocking mode\n", deviceName ));
+        return paDeviceUnavailable;
+    }
+
+    if ((result = PaOSS_SetFormat("PaOSS OpenStream", deviceHandle,
+                                  deviceName, inputChannelCount, outputChannelCount,
+                                  &sampleRate)) != paNoError)
+    {
+       goto error;
+    }
+
+    /* Compute number of frames per host buffer - if we can't retrieve the
+     * value, use the user's value instead 
+     */
+    
+    if ( ioctl(deviceHandle, SNDCTL_DSP_GETBLKSIZE, &bytesPerHostBuffer) == 0)
+    {
+        framesPerHostBuffer = bytesPerHostBuffer / 2 / (inputChannelCount>0? inputChannelCount: outputChannelCount);
+    }
+    else
+        framesPerHostBuffer = framesPerBuffer;
+
+    /* Allocate stream and fill in structure */
+
+    stream = (PaOSSStream*)PaUtil_AllocateMemory( sizeof(PaOSSStream) );
+    if( !stream )
+    {
+        result = paInsufficientMemory;
+        goto error;
+    }
+
+    if( streamCallback )
+    {
+        PaUtil_InitializeStreamRepresentation( &stream->streamRepresentation,
+                                               &ossHostApi->callbackStreamInterface, streamCallback, userData );
+    }
+    else
+    {
+        PaUtil_InitializeStreamRepresentation( &stream->streamRepresentation,
+                                               &ossHostApi->blockingStreamInterface, streamCallback, userData );
+    }    
+
+    stream->streamRepresentation.streamInfo.inputLatency = 0.;
+    stream->streamRepresentation.streamInfo.outputLatency = 0.;
+
+    if (inputChannelCount > 0) {
+        if (ioctl( deviceHandle, SNDCTL_DSP_GETISPACE, &bufinfo) == 0)
+            stream->streamRepresentation.streamInfo.inputLatency =
+                (bufinfo.fragsize * bufinfo.fragstotal) / sampleRate;
+    }
+
+    if (outputChannelCount > 0) {
+        if (ioctl( deviceHandle, SNDCTL_DSP_GETOSPACE, &bufinfo) == 0)
+            stream->streamRepresentation.streamInfo.outputLatency =
+                (bufinfo.fragsize * bufinfo.fragstotal) / sampleRate;
+    }    
+
+    stream->streamRepresentation.streamInfo.sampleRate = sampleRate;
+
+    PaUtil_InitializeCpuLoadMeasurer( &stream->cpuLoadMeasurer, sampleRate );
+
+    /* we assume a fixed host buffer size in this example, but the buffer processor
+        can also support bounded and unknown host buffer sizes by passing 
+        paUtilBoundedHostBufferSize or paUtilUnknownHostBufferSize instead of
+        paUtilFixedHostBufferSize below. */
+        
+    result =  PaUtil_InitializeBufferProcessor( &stream->bufferProcessor,
+              inputChannelCount, inputSampleFormat, hostInputSampleFormat,
+              outputChannelCount, outputSampleFormat, hostOutputSampleFormat,
+              sampleRate, streamFlags, framesPerBuffer,
+              framesPerHostBuffer, paUtilFixedHostBufferSize,
+              streamCallback, userData );
+    if( result != paNoError )
+        goto error;
+
+    stream->framesPerHostCallback = framesPerHostBuffer;
+
+    stream->stopSoon = 0;
+    stream->stopNow = 0;
+    stream->isActive = 0;
+    stream->thread = 0;
+    stream->lastPosPtr = 0;
+    stream->lastStreamBytes = 0;
+    stream->sampleRate = sampleRate;
+    stream->framesProcessed = 0;
+    stream->deviceHandle = deviceHandle;
+
+    if (inputChannelCount > 0)
+        stream->inputBuffer = PaUtil_AllocateMemory( 2 * framesPerHostBuffer * inputChannelCount );
+    else
+        stream->inputBuffer = NULL;
+
+    if (outputChannelCount > 0)
+        stream->outputBuffer = PaUtil_AllocateMemory( 2 * framesPerHostBuffer * outputChannelCount );
+    else
+        stream->outputBuffer = NULL;
+
+    stream->inputChannelCount = inputChannelCount;
+    stream->outputChannelCount = outputChannelCount;
+
+    *s = (PaStream*)stream;
+
+    result = paNoError;
+
+    return result;
+
+error:
+    if( stream )
+        PaUtil_FreeMemory( stream );
+
+    if( deviceHandle )
+        close( deviceHandle );
+
+    return result;
+}
+
+static void *PaOSS_AudioThreadProc(void *userData)
+{
+    PaOSSStream *stream = (PaOSSStream*)userData;
+
+    DBUG(("PaOSS AudioThread: %d in, %d out\n", stream->inputChannelCount, stream->outputChannelCount));
+
+    while( (stream->stopNow == 0) && (stream->stopSoon == 0) ) {
+        PaStreamCallbackTimeInfo timeInfo = {0,0,0}; /* TODO: IMPLEMENT ME */
+        int callbackResult;
+        unsigned long framesProcessed;
+        int bytesRequested;
+        int bytesRead, bytesWritten;
+        int delta;
+        int result;
+        count_info info;
+
+        PaUtil_BeginCpuLoadMeasurement( &stream->cpuLoadMeasurer );
+    
+        PaUtil_BeginBufferProcessing( &stream->bufferProcessor, &timeInfo,
+                0 /* @todo pass underflow/overflow flags when necessary */ );
+        
+        /*
+          depending on whether the host buffers are interleaved, non-interleaved
+          or a mixture, you will want to call PaUtil_SetInterleaved*Channels(),
+          PaUtil_SetNonInterleaved*Channel() or PaUtil_Set*Channel() here.
+        */
+
+        if ( stream->inputChannelCount > 0 )
+        {
+            bytesRequested = stream->framesPerHostCallback * 2 * stream->inputChannelCount;
+            bytesRead = read( stream->deviceHandle, stream->inputBuffer, bytesRequested );
+            
+            PaUtil_SetInputFrameCount( &stream->bufferProcessor, bytesRead/(2*stream->inputChannelCount));
+            PaUtil_SetInterleavedInputChannels( &stream->bufferProcessor,
+                                                0, /* first channel of inputBuffer is channel 0 */
+                                                stream->inputBuffer,
+                                                0 ); /* 0 - use inputChannelCount passed to init buffer processor */
+        }
+
+        if ( stream->outputChannelCount > 0 )
+        {
+           PaUtil_SetOutputFrameCount( &stream->bufferProcessor, 0 /* default to host buffer size */ );
+           PaUtil_SetInterleavedOutputChannels( &stream->bufferProcessor,
+                                                0, /* first channel of outputBuffer is channel 0 */
+                                                stream->outputBuffer,
+                                                0 ); /* 0 - use outputChannelCount passed to init buffer processor */
+        }
+
+        callbackResult = paContinue;
+        framesProcessed = PaUtil_EndBufferProcessing( &stream->bufferProcessor, &callbackResult );
+
+        PaUtil_EndCpuLoadMeasurement( &stream->cpuLoadMeasurer, framesProcessed );
+        
+        if( callbackResult == paContinue )
+        {
+           /* nothing special to do */
+        }
+        else if( callbackResult == paAbort )
+        {
+            /* once finished, call the finished callback */
+            if( stream->streamRepresentation.streamFinishedCallback != 0 )
+                stream->streamRepresentation.streamFinishedCallback( stream->streamRepresentation.userData );
+
+            return NULL; /* return from the loop */
+        }
+        else if ( callbackResult == paComplete )
+        {
+            /* User callback has asked us to stop with paComplete or other non-zero value */
+           
+            /* once finished, call the finished callback */
+            if( stream->streamRepresentation.streamFinishedCallback != 0 )
+                stream->streamRepresentation.streamFinishedCallback( stream->streamRepresentation.userData );
+
+            stream->stopSoon = 1;
+        }
+
+        if ( stream->outputChannelCount > 0 ) {
+            /* write output samples AFTER we've checked the callback result code */
+
+            bytesRequested = stream->framesPerHostCallback * 2 * stream->outputChannelCount;
+            bytesWritten = write( stream->deviceHandle, stream->outputBuffer, bytesRequested );
+
+            /* TODO: handle bytesWritten != bytesRequested (slippage?) */
+        }
+
+        /* Update current stream time (using a double so that
+           we don't wrap around like info.bytes does) */
+        if( stream->outputChannelCount > 0 )
+            result = ioctl( stream->deviceHandle, SNDCTL_DSP_GETOPTR, &info);
+        else
+            result = ioctl( stream->deviceHandle, SNDCTL_DSP_GETIPTR, &info);
+
+        if (result == 0) {
+            delta = ( info.bytes - stream->lastPosPtr ) & 0x000FFFFF;
+            stream->lastStreamBytes += delta;
+            stream->lastPosPtr = info.bytes;
+        }
+
+        stream->framesProcessed += stream->framesPerHostCallback;
+    }
+
+    return NULL;
+}
+
+/*
+    When CloseStream() is called, the multi-api layer ensures that
+    the stream has already been stopped or aborted.
+*/
+static PaError CloseStream( PaStream* s )
+{
+    PaError result = paNoError;
+    PaOSSStream *stream = (PaOSSStream*)s;
+
+    close(stream->deviceHandle);
+
+    if ( stream->inputBuffer )
+        PaUtil_FreeMemory( stream->inputBuffer );
+    if ( stream->outputBuffer )
+        PaUtil_FreeMemory( stream->outputBuffer );
+
+    PaUtil_TerminateBufferProcessor( &stream->bufferProcessor );
+    PaUtil_TerminateStreamRepresentation( &stream->streamRepresentation );
+    PaUtil_FreeMemory( stream );
+
+    return result;
+}
+
+
+static PaError StartStream( PaStream *s )
+{
+    PaError result = paNoError;
+    PaOSSStream *stream = (PaOSSStream*)s;
+    int presult;
+
+    stream->isActive = 1;
+    stream->lastPosPtr = 0;
+    stream->lastStreamBytes = 0;
+    stream->framesProcessed = 0;
+
+    DBUG(("PaOSS StartStream\n"));
+
+    /* only use the thread for callback streams */
+    if( stream->bufferProcessor.streamCallback ) {
+            presult = pthread_create(&stream->thread,
+                             NULL /*pthread_attr_t * attr*/,
+                             (void*)PaOSS_AudioThreadProc, (void *)stream);
+    }
+    
+    return result;
+}
+
+
+static PaError StopStream( PaStream *s )
+{
+    PaError result = paNoError;
+    PaOSSStream *stream = (PaOSSStream*)s;
+
+    stream->stopSoon = 1;
+
+    /* only use the thread for callback streams */
+    if( stream->bufferProcessor.streamCallback )
+        pthread_join( stream->thread, NULL );
+
+    stream->stopSoon = 0;
+    stream->stopNow = 0;
+    stream->isActive = 0;
+
+    DBUG(("PaOSS StopStream: Stopped stream\n"));
+
+    return result;
+}
+
+
+static PaError AbortStream( PaStream *s )
+{
+    PaError result = paNoError;
+    PaOSSStream *stream = (PaOSSStream*)s;
+
+    stream->stopNow = 1;
+
+    /* only use the thread for callback streams */
+    if( stream->bufferProcessor.streamCallback )
+        pthread_join( stream->thread, NULL );
+
+    stream->stopSoon = 0;
+    stream->stopNow = 0;
+    stream->isActive = 0;
+
+    DBUG(("PaOSS AbortStream: Stopped stream\n"));
+
+    return result;
+}
+
+
+static PaError IsStreamStopped( PaStream *s )
+{
+    PaOSSStream *stream = (PaOSSStream*)s;
+
+    return (!stream->isActive);
+}
+
+
+static PaError IsStreamActive( PaStream *s )
+{
+    PaOSSStream *stream = (PaOSSStream*)s;
+
+    return (stream->isActive);
+}
+
+
+static PaTime GetStreamTime( PaStream *s )
+{
+    PaOSSStream *stream = (PaOSSStream*)s;
+    count_info info;
+    int delta;
+
+    if( stream->outputChannelCount > 0 ) {
+        if (ioctl( stream->deviceHandle, SNDCTL_DSP_GETOPTR, &info) == 0) {
+            delta = ( info.bytes - stream->lastPosPtr ) & 0x000FFFFF;
+            return ( stream->lastStreamBytes + delta) / ( stream->outputChannelCount * 2 ) / stream->sampleRate;
+        }
+    }
+    else {
+        if (ioctl( stream->deviceHandle, SNDCTL_DSP_GETIPTR, &info) == 0) {
+            delta = (info.bytes - stream->lastPosPtr) & 0x000FFFFF;
+            return ( stream->lastStreamBytes + delta) / ( stream->inputChannelCount * 2 ) / stream->sampleRate;
+        }
+    }
+
+    /* the ioctl failed, but we can still give a coarse estimate */
+
+    return stream->framesProcessed / stream->sampleRate;
+}
+
+
+static double GetStreamCpuLoad( PaStream* s )
+{
+    PaOSSStream *stream = (PaOSSStream*)s;
+
+    return PaUtil_GetCpuLoad( &stream->cpuLoadMeasurer );
+}
+
+
+/*
+    As separate stream interfaces are used for blocking and callback
+    streams, the following functions can be guaranteed to only be called
+    for blocking streams.
+*/
+
+
+static PaError ReadStream( PaStream* s,
+                           void *buffer,
+                           unsigned long frames )
+{
+    PaOSSStream *stream = (PaOSSStream*)s;
+    int bytesRequested, bytesRead;
+
+    bytesRequested = frames * 2 * stream->inputChannelCount;
+    bytesRead = read( stream->deviceHandle, stream->inputBuffer, bytesRequested );
+
+    if ( bytesRequested != bytesRead )
+        return paUnanticipatedHostError;
+    else
+        return paNoError;
+}
+
+
+static PaError WriteStream( PaStream* s,
+                            const void *buffer,
+                            unsigned long frames )
+{
+    PaOSSStream *stream = (PaOSSStream*)s;
+    int bytesRequested, bytesWritten;
+
+    bytesRequested = frames * 2 * stream->outputChannelCount;
+    bytesWritten = write( stream->deviceHandle, buffer, bytesRequested );
+
+    if ( bytesRequested != bytesWritten )
+        return paUnanticipatedHostError;
+    else
+        return paNoError;
+}
+
+
+static signed long GetStreamReadAvailable( PaStream* s )
+{
+    PaOSSStream *stream = (PaOSSStream*)s;
+    audio_buf_info info;
+
+    if ( ioctl(stream->deviceHandle, SNDCTL_DSP_GETISPACE, &info) == 0)
+    {
+        int bytesAvailable = info.fragments * info.fragsize;
+        return ( bytesAvailable / 2 / stream->inputChannelCount );
+    }
+    else
+        return 0; /* TODO: is this right for "don't know"? */
+}
+
+
+static signed long GetStreamWriteAvailable( PaStream* s )
+{
+    PaOSSStream *stream = (PaOSSStream*)s;
+
+    audio_buf_info info;
+
+    if ( ioctl(stream->deviceHandle, SNDCTL_DSP_GETOSPACE, &info) == 0)
+    {
+        int bytesAvailable = info.fragments * info.fragsize;
+        return ( bytesAvailable / 2 / stream->outputChannelCount );
+    }
+    else
+        return 0; /* TODO: is this right for "don't know"? */
+}
+
diff --git a/pd/portaudio/pa_unix_oss/recplay.c b/pd/portaudio/pa_unix_oss/recplay.c
new file mode 100644
index 00000000..9d4c78cf
--- /dev/null
+++ b/pd/portaudio/pa_unix_oss/recplay.c
@@ -0,0 +1,114 @@
+/*
+ * recplay.c
+ * Phil Burk
+ * Minimal record and playback test.
+ * 
+ */
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#ifndef __STDC__
+/* #include <getopt.h> */
+#endif /* __STDC__ */
+#include <fcntl.h>
+#ifdef __STDC__
+#include <string.h>
+#else /* __STDC__ */
+#include <strings.h>
+#endif /* __STDC__ */
+#include <sys/soundcard.h>
+
+#define NUM_BYTES   (64*1024)
+#define BLOCK_SIZE   (4*1024)
+
+#define AUDIO "/dev/dsp"
+
+char buffer[NUM_BYTES];
+
+int audioDev = 0;
+
+main (int argc, char *argv[])
+{
+    int   numLeft;
+    char *ptr;
+    int   num;
+    int   samplesize;
+
+    /********** RECORD ********************/
+    /* Open audio device. */
+    audioDev = open (AUDIO, O_RDONLY, 0);
+    if (audioDev == -1)
+    {
+        perror (AUDIO);
+        exit (-1);
+    }
+
+    /* Set to 16 bit samples. */
+    samplesize = 16;
+    ioctl(audioDev, SNDCTL_DSP_SAMPLESIZE, &samplesize);
+    if (samplesize != 16)
+    {
+        perror("Unable to set the sample size.");
+        exit(-1);
+    }
+
+    /* Record in blocks */
+    printf("Begin recording.\n");
+    numLeft = NUM_BYTES;
+    ptr = buffer;
+    while( numLeft >= BLOCK_SIZE )
+    {
+        if ( (num = read (audioDev, ptr, BLOCK_SIZE)) < 0 )
+        {
+            perror (AUDIO);
+            exit (-1);
+        }
+        else
+        {
+            printf("Read %d bytes\n", num);
+            ptr += num;
+            numLeft -= num;
+        }
+    }
+
+    close( audioDev );
+
+    /********** PLAYBACK ********************/
+    /* Open audio device for writing. */
+    audioDev = open (AUDIO, O_WRONLY, 0);
+    if (audioDev == -1)
+    {
+        perror (AUDIO);
+        exit (-1);
+    }
+
+    /* Set to 16 bit samples. */
+    samplesize = 16;
+    ioctl(audioDev, SNDCTL_DSP_SAMPLESIZE, &samplesize);
+    if (samplesize != 16)
+    {
+        perror("Unable to set the sample size.");
+        exit(-1);
+    }
+
+    /* Play in blocks */
+    printf("Begin playing.\n");
+    numLeft = NUM_BYTES;
+    ptr = buffer;
+    while( numLeft >= BLOCK_SIZE )
+    {
+        if ( (num = write (audioDev, ptr, BLOCK_SIZE)) < 0 )
+        {
+            perror (AUDIO);
+            exit (-1);
+        }
+        else
+        {
+            printf("Wrote %d bytes\n", num);
+            ptr += num;
+            numLeft -= num;
+        }
+    }
+
+    close( audioDev );
+}