MASTER_SITES=	http://www.portaudio.com/archives/

DISTNAME=	pa_stable_v190600_20161030

SUB_FILES=	pkg-message

	cd ${WRKSRC} && ${INSTALL_DATA} README.txt index.html ${STAGEDIR}${DOCSDIR}

/*

 * Copyright (c) 2009 Alexandre Ratchov <alex@caoua.org>

 *

 * Permission to use, copy, modify, and distribute this software for any

 * purpose with or without fee is hereby granted, provided that the above

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 */

#include <sys/types.h>

#include <pthread.h>

#include <poll.h>

#include <errno.h>

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#include <sndio.h>

#include "pa_util.h"

#include "pa_hostapi.h"

#include "pa_stream.h"

#include "pa_process.h"

#include "pa_allocation.h"

#if 0

#define DPR(...) do { fprintf(stderr, __VA_ARGS__); } while (0)

#else

#define DPR(...) do {} while (0)

#endif

/*

 * per-stream data

 */

typedef struct PaSndioStream

{

	PaUtilStreamRepresentation base;

	PaUtilBufferProcessor bufproc;	/* format conversion */

	struct sio_hdl *hdl;		/* handle for device i/o */

	struct sio_par par;		/* current device parameters */	

	unsigned mode;			/* SIO_PLAY, SIO_REC or both */

	int stopped;			/* stop requested or not started */

	int active;			/* thread is running */

	unsigned long long realpos;	/* frame number h/w is processing */

	char *rbuf, *wbuf;		/* bounce buffers for conversions */

	unsigned long long rpos, wpos;	/* bytes read/written */

	pthread_t thread;		/* thread of the callback interface */

} PaSndioStream;

/*

 * api "class" data, common to all streams

 */

typedef struct PaSndioHostApiRepresentation

{

	PaUtilHostApiRepresentation base;

	PaUtilStreamInterface callback;

	PaUtilStreamInterface blocking;

	/*

	 * sndio has no device discovery mechanism and PortAudio has

	 * no way of accepting raw device strings from users.

	 * Normally we just expose the default device, which can be

	 * changed via the AUDIODEVICE environment variable, but we

	 * also allow specifying a list of up to 16 devices via the

	 * PA_SNDIO_AUDIODEVICES environment variable.

	 *

	 * Example:

	 * PA_SNDIO_AUDIODEVICES=default:snd/0.monitor:snd@remote/0

	 */

#define PA_SNDIO_AUDIODEVICES_MAX	16

	PaDeviceInfo device_info[PA_SNDIO_AUDIODEVICES_MAX];

	PaDeviceInfo *infos[PA_SNDIO_AUDIODEVICES_MAX];

	char *audiodevices;

} PaSndioHostApiRepresentation;

/*

 * callback invoked when blocks are processed by the hardware

 */

static void

sndioOnMove(void *addr, int delta)

{

	PaSndioStream *s = (PaSndioStream *)addr;

	s->realpos += delta;

}

/*

 * convert PA encoding to sndio encoding, return true on success

 */

static int

sndioSetFmt(struct sio_par *sio, PaSampleFormat fmt)

{

	switch (fmt & ~paNonInterleaved) {

	case paInt32:

		sio->sig = 1;

		sio->bits = 32;

		break;

	case paInt24:

		sio->sig = 1;

		sio->bits = 24;

		sio->bps = 3;	/* paInt24 is packed format */

		break;

	case paInt16:

	case paFloat32:

		sio->sig = 1;

		sio->bits = 16;

		break;

	case paInt8:

		sio->sig = 1;

		sio->bits = 8;

		break;

	case paUInt8:

		sio->sig = 0;

		sio->bits = 8;

		break;

	default:

		DPR("sndioSetFmt: %x: unsupported\n", fmt);

		return 0;

	}

	sio->le = SIO_LE_NATIVE;

	return 1;

}

/*

 * convert sndio encoding to PA encoding, return true on success

 */

static int

sndioGetFmt(struct sio_par *sio, PaSampleFormat *fmt)

{

	if ((sio->bps * 8 != sio->bits && !sio->msb) ||

	    (sio->bps > 1 && sio->le != SIO_LE_NATIVE)) {

		DPR("sndioGetFmt: bits = %u, le = %u, msb = %u, bps = %u\n",

		    sio->bits, sio->le, sio->msb, sio->bps);

		return 0;

	}

	switch (sio->bits) {

	case 32:

		if (!sio->sig)

			return 0;

		*fmt = paInt32;

		break;

	case 24:

		if (!sio->sig)

			return 0;

		*fmt = (sio->bps == 3) ? paInt24 : paInt32;

		break;

	case 16:

		if (!sio->sig)

			return 0;

		*fmt = paInt16;

		break;

	case 8:

		*fmt = sio->sig ? paInt8 : paUInt8;

		break;

	default:

		DPR("sndioGetFmt: %u: unsupported\n", sio->bits);

		return 0;

	}

	return 1;

}

/*

 * I/O loop for callback interface

 */

static void *

sndioThread(void *arg)

{

	PaSndioStream *s = (PaSndioStream *)arg;

	PaStreamCallbackTimeInfo ti;

	unsigned char *data;

	unsigned todo, rblksz, wblksz;

	int n, result;

	rblksz = s->par.round * s->par.rchan * s->par.bps;

	wblksz = s->par.round * s->par.pchan * s->par.bps;

	DPR("sndioThread: mode = %x, round = %u, rblksz = %u, wblksz = %u\n",

	    s->mode, s->par.round, rblksz, wblksz);

	while (!s->stopped) {

		if (s->mode & SIO_REC) {

			todo = rblksz;

			data = s->rbuf;

			while (todo > 0) {

				n = sio_read(s->hdl, data, todo);

				if (n == 0) {

					DPR("sndioThread: sio_read failed\n");

					goto failed;

				}

				todo -= n;

				data += n;

			}

			s->rpos += s->par.round;

			ti.inputBufferAdcTime = 

			    (double)s->realpos / s->par.rate;

		}

		if (s->mode & SIO_PLAY) {

			ti.outputBufferDacTime =

			    (double)(s->realpos + s->par.bufsz) / s->par.rate;

		}

		ti.currentTime = s->realpos / (double)s->par.rate;

		PaUtil_BeginBufferProcessing(&s->bufproc, &ti, 0);

		if (s->mode & SIO_PLAY) {

			PaUtil_SetOutputFrameCount(&s->bufproc, s->par.round);

			PaUtil_SetInterleavedOutputChannels(&s->bufproc,

			    0, s->wbuf, s->par.pchan);

		}

		if (s->mode & SIO_REC) {

			PaUtil_SetInputFrameCount(&s->bufproc, s->par.round);

			PaUtil_SetInterleavedInputChannels(&s->bufproc,

			    0, s->rbuf, s->par.rchan);

		}

		result = paContinue;

		n = PaUtil_EndBufferProcessing(&s->bufproc, &result);

		if (n != s->par.round) {

			DPR("sndioThread: %d < %u frames, result = %d\n",

			    n, s->par.round, result);

		}

		if (result != paContinue) {

			break;

		}

		if (s->mode & SIO_PLAY) {

			n = sio_write(s->hdl, s->wbuf, wblksz);

			if (n < wblksz) {

				DPR("sndioThread: sio_write failed\n");

				goto failed;

			}

			s->wpos += s->par.round;

		}

	}

 failed:

	s->active = 0;

	DPR("sndioThread: done\n");

}

static PaError

OpenStream(struct PaUtilHostApiRepresentation *hostApi,

    PaStream **stream,

    const PaStreamParameters *inputPar,

    const PaStreamParameters *outputPar,

    double sampleRate,

    unsigned long framesPerBuffer,

    PaStreamFlags streamFlags,

    PaStreamCallback *streamCallback,

    void *userData)

{

	PaSndioHostApiRepresentation *sndioHostApi = (PaSndioHostApiRepresentation *)hostApi;

	PaSndioStream *s;

	PaError err;

	struct sio_hdl *hdl;

	struct sio_par par;

	unsigned mode;

	int inch, onch;

	PaSampleFormat ifmt, ofmt, siofmt;

	const char *dev;

	DPR("OpenStream:\n");

	mode = 0;

	inch = onch = 0;

	ifmt = ofmt = 0;

	sio_initpar(&par);

	if (outputPar && outputPar->channelCount > 0) {

		if (outputPar->device >= sndioHostApi->base.info.deviceCount) {

			DPR("OpenStream: %d: bad output device\n", outputPar->device);

			return paInvalidDevice;

		}

		if (outputPar->hostApiSpecificStreamInfo) {

			DPR("OpenStream: output specific info\n");

			return paIncompatibleHostApiSpecificStreamInfo;

		}

		if (!sndioSetFmt(&par, outputPar->sampleFormat)) {

			return paSampleFormatNotSupported;

		}

		ofmt = outputPar->sampleFormat;

		onch = par.pchan = outputPar->channelCount;

		mode |= SIO_PLAY;

	}

	if (inputPar && inputPar->channelCount > 0) {

		if (inputPar->device >= sndioHostApi->base.info.deviceCount) {

			DPR("OpenStream: %d: bad input device\n", inputPar->device);

			return paInvalidDevice;

		}

		if (inputPar->hostApiSpecificStreamInfo) {

			DPR("OpenStream: input specific info\n");

			return paIncompatibleHostApiSpecificStreamInfo;

		}

		if (!sndioSetFmt(&par, inputPar->sampleFormat)) {

			return paSampleFormatNotSupported;

		}

		ifmt = inputPar->sampleFormat;

		inch = par.rchan = inputPar->channelCount;

		mode |= SIO_REC;

	}

	par.rate = sampleRate;

	if (framesPerBuffer != paFramesPerBufferUnspecified)

		par.round = framesPerBuffer;

	DPR("OpenStream: mode = %x, trying rate = %u\n", mode, par.rate);

	if (outputPar) {

		dev = sndioHostApi->device_info[outputPar->device].name;

	} else if (inputPar) {

		dev = sndioHostApi->device_info[inputPar->device].name;

	} else {

		return paUnanticipatedHostError;

	}

	hdl = sio_open(dev, mode, 0);

	if (hdl == NULL)

		return paUnanticipatedHostError;

	if (!sio_setpar(hdl, &par)) {

		sio_close(hdl);

		return paUnanticipatedHostError;

	}

	if (!sio_getpar(hdl, &par)) {

		sio_close(hdl);

		return paUnanticipatedHostError;

	}

	if (!sndioGetFmt(&par, &siofmt)) {

		sio_close(hdl);

		return paSampleFormatNotSupported;

	}

	if ((mode & SIO_REC) && par.rchan != inputPar->channelCount) {

		DPR("OpenStream: rchan(%u) != %d\n", par.rchan, inputPar->channelCount);

		sio_close(hdl);

		return paInvalidChannelCount;

	}

	if ((mode & SIO_PLAY) && par.pchan != outputPar->channelCount) {

		DPR("OpenStream: pchan(%u) != %d\n", par.pchan, outputPar->channelCount);

		sio_close(hdl);

		return paInvalidChannelCount;

	}

	if ((double)par.rate < sampleRate * 0.995 ||

	    (double)par.rate > sampleRate * 1.005) {

		DPR("OpenStream: rate(%u) != %g\n", par.rate, sampleRate);

		sio_close(hdl);

		return paInvalidSampleRate;

	}

	s = (PaSndioStream *)PaUtil_AllocateMemory(sizeof(PaSndioStream));

	if (s == NULL) {

		sio_close(hdl);

		return paInsufficientMemory;

	}

	PaUtil_InitializeStreamRepresentation(&s->base, 

	    streamCallback ? &sndioHostApi->callback : &sndioHostApi->blocking,

	    streamCallback, userData);

	DPR("inch = %d, onch = %d, ifmt = %x, ofmt = %x\n", 

	    inch, onch, ifmt, ofmt);

	err = PaUtil_InitializeBufferProcessor(&s->bufproc,

	    inch, ifmt, siofmt,

	    onch, ofmt, siofmt,

	    sampleRate,

	    streamFlags,

	    framesPerBuffer,

	    par.round,

	    paUtilFixedHostBufferSize, 

	    streamCallback, userData);

	if (err) {

		DPR("OpenStream: PaUtil_InitializeBufferProcessor failed\n");

		PaUtil_FreeMemory(s);

		sio_close(hdl);

		return err;

	}

	if (mode & SIO_REC) {

		s->rbuf = malloc(par.round * par.rchan * par.bps);

		if (s->rbuf == NULL) {

			DPR("OpenStream: failed to allocate rbuf\n");

			PaUtil_FreeMemory(s);

			sio_close(hdl);

			return paInsufficientMemory;

		}

	}

	if (mode & SIO_PLAY) {

		s->wbuf = malloc(par.round * par.pchan * par.bps);

		if (s->wbuf == NULL) {

			DPR("OpenStream: failed to allocate wbuf\n");

			free(s->rbuf);

			PaUtil_FreeMemory(s);

			sio_close(hdl);

			return paInsufficientMemory;

		}

	}	

	s->base.streamInfo.inputLatency = 0;

	s->base.streamInfo.outputLatency = (mode & SIO_PLAY) ?

	    (double)(par.bufsz + PaUtil_GetBufferProcessorOutputLatencyFrames(&s->bufproc)) / (double)par.rate : 0;

	s->base.streamInfo.sampleRate = par.rate;

	s->active = 0;

	s->stopped = 1;

	s->mode = mode;

	s->hdl = hdl;

	s->par = par;

	*stream = s;	

	DPR("OpenStream: done\n");

	return paNoError;

}

static PaError

BlockingReadStream(PaStream *stream, void *data, unsigned long numFrames)

{

	PaSndioStream *s = (PaSndioStream *)stream;

	unsigned n, res, todo;

	void *buf;

	while (numFrames > 0) {

		n = s->par.round;

		if (n > numFrames)

			n = numFrames;

		buf = s->rbuf;

		todo = n * s->par.rchan * s->par.bps;

		while (todo > 0) {

			res = sio_read(s->hdl, buf, todo);

			if (res == 0)

				return paUnanticipatedHostError;

			buf = (char *)buf + res;

			todo -= res;

		}

		s->rpos += n;

		PaUtil_SetInputFrameCount(&s->bufproc, n);

		PaUtil_SetInterleavedInputChannels(&s->bufproc, 0, s->rbuf, s->par.rchan);

		res = PaUtil_CopyInput(&s->bufproc, &data, n);

		if (res != n) {

			DPR("BlockingReadStream: copyInput: %u != %u\n");

			return paUnanticipatedHostError;

		}

		numFrames -= n;

	}

	return paNoError;

}

static PaError

BlockingWriteStream(PaStream* stream, const void *data, unsigned long numFrames)

{

	PaSndioStream *s = (PaSndioStream *)stream;

	unsigned n, res;

	while (numFrames > 0) {

		n = s->par.round;

		if (n > numFrames)

			n = numFrames;

		PaUtil_SetOutputFrameCount(&s->bufproc, n);

		PaUtil_SetInterleavedOutputChannels(&s->bufproc, 0, s->wbuf, s->par.pchan);

		res = PaUtil_CopyOutput(&s->bufproc, &data, n);

		if (res != n) {

			DPR("BlockingWriteStream: copyOutput: %u != %u\n");

			return paUnanticipatedHostError;

		}

		res = sio_write(s->hdl, s->wbuf, n * s->par.pchan * s->par.bps);

		if (res == 0)

			return paUnanticipatedHostError;		

		s->wpos += n;

		numFrames -= n;

	}

	return paNoError;

}

static signed long

BlockingGetStreamReadAvailable(PaStream *stream)

{

	PaSndioStream *s = (PaSndioStream *)stream;

	struct pollfd pfd;

	int n, events;

	n = sio_pollfd(s->hdl, &pfd, POLLIN);

	while (poll(&pfd, n, 0) < 0) {

		if (errno == EINTR)

			continue;

		perror("poll");

		abort();

	}

	events = sio_revents(s->hdl, &pfd);

	if (!(events & POLLIN))

		return 0;

	return s->realpos - s->rpos;

}

static signed long

BlockingGetStreamWriteAvailable(PaStream *stream)

{

	PaSndioStream *s = (PaSndioStream *)stream;

	struct pollfd pfd;

	int n, events;

	n = sio_pollfd(s->hdl, &pfd, POLLOUT);

	while (poll(&pfd, n, 0) < 0) {

		if (errno == EINTR)

			continue;

		perror("poll");

		abort();

	}

	events = sio_revents(s->hdl, &pfd);

	if (!(events & POLLOUT))

		return 0;

	return s->par.bufsz - (s->wpos - s->realpos);

}

static PaError

BlockingWaitEmpty( PaStream *stream )

{

	PaSndioStream *s = (PaSndioStream *)stream;

	/*

	 * drain playback buffers; sndio always does it in background

	 * and there is no way to wait for completion

	 */

	DPR("BlockingWaitEmpty: s=%d, a=%d\n", s->stopped, s->active);

	return paNoError;

}

static PaError

StartStream(PaStream *stream)

{

	PaSndioStream *s = (PaSndioStream *)stream;

	unsigned primes, wblksz;

	int err;

	DPR("StartStream: s=%d, a=%d\n", s->stopped, s->active);

	if (!s->stopped) {

		DPR("StartStream: already started\n");

		return paNoError;

	}

	s->stopped = 0;

	s->active = 1;

	s->realpos = 0;

	s->wpos = 0;

	s->rpos = 0;

	PaUtil_ResetBufferProcessor(&s->bufproc);

	if (!sio_start(s->hdl))

		return paUnanticipatedHostError;

	/*

	 * send a complete buffer of silence

	 */

	if (s->mode & SIO_PLAY) {

		wblksz = s->par.round * s->par.pchan * s->par.bps;

		memset(s->wbuf, 0, wblksz);

		for (primes = s->par.bufsz / s->par.round; primes > 0; primes--)

			s->wpos += sio_write(s->hdl, s->wbuf, wblksz);

	}

	if (s->base.streamCallback) {

		err = pthread_create(&s->thread, NULL, sndioThread, s);

		if (err) {

			DPR("SndioStartStream: couldn't create thread\n");

			return paUnanticipatedHostError;

		}

		DPR("StartStream: started...\n");

	}

	return paNoError;

}

static PaError

StopStream(PaStream *stream)

{

	PaSndioStream *s = (PaSndioStream *)stream;

	void *ret;

	int err;

	DPR("StopStream: s=%d, a=%d\n", s->stopped, s->active);

	if (s->stopped) {

		DPR("StartStream: already started\n");

		return paNoError;

	}

	s->stopped = 1;

	if (s->base.streamCallback) {

		err = pthread_join(s->thread, &ret);

		if (err) {

			DPR("SndioStop: couldn't join thread\n");

			return paUnanticipatedHostError;

		}

	}

	if (!sio_stop(s->hdl))

		return paUnanticipatedHostError;

	return paNoError;

}

static PaError

CloseStream(PaStream *stream)

{

	PaSndioStream *s = (PaSndioStream *)stream;

	DPR("CloseStream:\n");

	if (!s->stopped)

		StopStream(stream);

	if (s->mode & SIO_REC)

		free(s->rbuf);

	if (s->mode & SIO_PLAY)

		free(s->wbuf);

	sio_close(s->hdl);

        PaUtil_TerminateStreamRepresentation(&s->base);

	PaUtil_TerminateBufferProcessor(&s->bufproc);

	PaUtil_FreeMemory(s);

	return paNoError;

}

static PaError

AbortStream(PaStream *stream)

{

	DPR("AbortStream:\n");

	return StopStream(stream);

}

static PaError

IsStreamStopped(PaStream *stream)

{

	PaSndioStream *s = (PaSndioStream *)stream;

	//DPR("IsStreamStopped: s=%d, a=%d\n", s->stopped, s->active);

	return s->stopped;

}

static PaError

IsStreamActive(PaStream *stream)

{

	PaSndioStream *s = (PaSndioStream *)stream;

	//DPR("IsStreamActive: s=%d, a=%d\n", s->stopped, s->active);

	return s->active;

}

static PaTime

GetStreamTime(PaStream *stream)

{

	PaSndioStream *s = (PaSndioStream *)stream;

	return (double)s->realpos / s->base.streamInfo.sampleRate;

}

static PaError

IsFormatSupported(struct PaUtilHostApiRepresentation *hostApi,

    const PaStreamParameters *inputPar,

    const PaStreamParameters *outputPar,

    double sampleRate)

{

	return paFormatIsSupported;

}

static void

Terminate(struct PaUtilHostApiRepresentation *hostApi)

{

	PaSndioHostApiRepresentation *sndioHostApi;

	sndioHostApi = (PaSndioHostApiRepresentation *)hostApi;

	free(sndioHostApi->audiodevices);

	PaUtil_FreeMemory(hostApi);

}

static void

InitDeviceInfo(PaDeviceInfo *info, PaHostApiIndex hostApiIndex, const char *name)

{

	info->structVersion = 2;

	info->name = name;

	info->hostApi = hostApiIndex;

	info->maxInputChannels = 128;

	info->maxOutputChannels = 128;

	info->defaultLowInputLatency = 0.01;

	info->defaultLowOutputLatency = 0.01;

	info->defaultHighInputLatency = 0.5;

	info->defaultHighOutputLatency = 0.5;

	info->defaultSampleRate = 48000;

}

PaError

PaSndio_Initialize(PaUtilHostApiRepresentation **hostApi, PaHostApiIndex hostApiIndex)

{

	PaSndioHostApiRepresentation *sndioHostApi;

	PaDeviceInfo *info;

	struct sio_hdl *hdl;

	char *audiodevices;

	char *device;

	size_t deviceCount;

	DPR("PaSndio_Initialize: initializing...\n");

	/* unusable APIs should return paNoError and a NULL hostApi */

	*hostApi = NULL;

	sndioHostApi = PaUtil_AllocateMemory(sizeof(PaSndioHostApiRepresentation));

	if (sndioHostApi == NULL)

		return paNoError;

	// Add default device

	info = &sndioHostApi->device_info[0];

	InitDeviceInfo(info, hostApiIndex, SIO_DEVANY);

	sndioHostApi->infos[0] = info;

	deviceCount = 1;

	// Add additional devices as specified in the PA_SNDIO_AUDIODEVICES

	// environment variable as a colon separated list

	sndioHostApi->audiodevices = NULL;

	audiodevices = getenv("PA_SNDIO_AUDIODEVICES");

	if (audiodevices != NULL) {

		sndioHostApi->audiodevices = strdup(audiodevices);

		if (sndioHostApi->audiodevices == NULL)

			return paNoError;

		audiodevices = sndioHostApi->audiodevices;

		while ((device = strsep(&audiodevices, ":")) != NULL &&

			deviceCount < PA_SNDIO_AUDIODEVICES_MAX) {

			if (*device == '\0')

				continue;

			info = &sndioHostApi->device_info[deviceCount];

			InitDeviceInfo(info, hostApiIndex, device);

			sndioHostApi->infos[deviceCount] = info;

			deviceCount++;

		}

	}

	*hostApi = &sndioHostApi->base;

	(*hostApi)->info.structVersion = 1;

	(*hostApi)->info.type = paSndio;

	(*hostApi)->info.name = "sndio";

	(*hostApi)->info.deviceCount = deviceCount;

	(*hostApi)->info.defaultInputDevice = 0;

	(*hostApi)->info.defaultOutputDevice = 0;

	(*hostApi)->deviceInfos = sndioHostApi->infos;

	(*hostApi)->Terminate = Terminate;

	(*hostApi)->OpenStream = OpenStream;

	(*hostApi)->IsFormatSupported = IsFormatSupported;

	PaUtil_InitializeStreamInterface(&sndioHostApi->blocking,

	    CloseStream,

	    StartStream,

	    StopStream,

	    AbortStream,

	    IsStreamStopped,

	    IsStreamActive,

	    GetStreamTime,

	    PaUtil_DummyGetCpuLoad,

	    BlockingReadStream,

	    BlockingWriteStream,

	    BlockingGetStreamReadAvailable,

	    BlockingGetStreamWriteAvailable);

	PaUtil_InitializeStreamInterface(&sndioHostApi->callback,

	    CloseStream,

	    StartStream,

	    StopStream,

	    AbortStream,

	    IsStreamStopped,

	    IsStreamActive,

	    GetStreamTime,

	    PaUtil_DummyGetCpuLoad,

	    PaUtil_DummyRead,

	    PaUtil_DummyWrite,

	    PaUtil_DummyGetReadAvailable,

	    PaUtil_DummyGetWriteAvailable);

	DPR("PaSndio_Initialize: done\n");

	return paNoError;

}

#ifndef PA_UNIX_OSS_H

#define PA_UNIX_OSS_H

/*

 * $Id: portaudio.patch,v 1.10 2009-06-30 04:52:59 llucius Exp $

 * PortAudio Portable Real-Time Audio Library

 * OSS-specific extensions

 *

 * Copyright (c) 1999-2000 Ross Bencina and 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.

 *

 */

/** @file

 * OSS-specific PortAudio API extension header file.

 */

#ifdef __cplusplus

extern "C" {

#endif

const char *PaOSS_GetStreamInputDevice( PaStream *s );

const char *PaOSS_GetStreamOutputDevice( PaStream *s );

#ifdef __cplusplus

}

#endif

#endif

$OpenBSD: patch-Makefile_in,v 1.4 2013/03/12 00:59:50 brad Exp $

--- Makefile.in.orig	2016-06-22 08:28:31 UTC

+++ Makefile.in

@@ -146,6 +146,7 @@ SRC_DIRS = \

 	src/hostapi/dsound \

 	src/hostapi/jack \

 	src/hostapi/oss \

+	src/hostapi/sndio \

 	src/hostapi/wasapi \

 	src/hostapi/wdmks \

 	src/hostapi/wmme \

$OpenBSD: patch-configure_in,v 1.4 2014/09/13 04:56:28 bentley Exp $

--- configure.in.orig	2016-06-22 08:28:31 UTC

+++ configure.in

@@ -24,6 +24,10 @@ AC_ARG_WITH(alsa,

             AS_HELP_STRING([--with-alsa], [Enable support for ALSA @<:@autodetect@:>@]),

             [with_alsa=$withval])

+AC_ARG_WITH(sndio,

+            AS_HELP_STRING([--with-sndio], [Enable support for sndio @<:@autodetect@:>@]),

+            [with_sndio=$withval])

+

 AC_ARG_WITH(jack,

             AS_HELP_STRING([--with-jack], [Enable support for JACK @<:@autodetect@:>@]),

             [with_jack=$withval])

@@ -120,6 +124,10 @@ have_alsa=no

 if test "x$with_alsa" != "xno"; then

     AC_CHECK_LIB(asound, snd_pcm_open, have_alsa=yes, have_alsa=no)

 fi

+have_sndio=no

+if test "x$with_sndio" != "xno"; then

+    AC_CHECK_LIB(sndio, sio_open, have_sndio=yes, have_sndio=no)

+fi

 have_asihpi=no

 if test "x$with_asihpi" != "xno"; then

     AC_CHECK_LIB(hpi, HPI_SubSysCreate, have_asihpi=yes, have_asihpi=no, -lm)

@@ -397,6 +405,13 @@ case "${host_os}" in

            AC_DEFINE(PA_USE_ALSA,1)

         fi

+        if [[ "$have_sndio" = "yes" -a "$with_sndio" != "no" ]] ; then

+           DLL_LIBS="$DLL_LIBS -lsndio"

+           LIBS="$LIBS -lsndio"

+           OTHER_OBJS="$OTHER_OBJS src/hostapi/sndio/pa_sndio.o"

+           AC_DEFINE(PA_USE_SNDIO,1)

+        fi

+

         if [[ "$have_jack" = "yes" ] && [ "$with_jack" != "no" ]] ; then

            DLL_LIBS="$DLL_LIBS $JACK_LIBS"

            CFLAGS="$CFLAGS $JACK_CFLAGS"

@@ -500,6 +515,7 @@ case "$target_os" in

         ;;

      *)

 	AC_MSG_RESULT([

+  Sndio ....................... $have_sndio

   OSS ......................... $have_oss

   JACK ........................ $have_jack

 ])

$OpenBSD: patch-include_portaudio_h,v 1.2 2013/03/12 00:59:50 brad Exp $

--- include/portaudio.h.orig	2018-07-17 06:55:08 UTC

+++ include/portaudio.h

@@ -236,7 +236,8 @@ typedef enum PaHostApiTypeId

     paWDMKS=11,

     paJACK=12,

     paWASAPI=13,

-    paAudioScienceHPI=14

+    paAudioScienceHPI=14,

+    paSndio=15

 } PaHostApiTypeId;

@@ -1144,6 +1145,15 @@ signed long Pa_GetStreamReadAvailable( PaStream* strea

  error is encountered.

 */

 signed long Pa_GetStreamWriteAvailable( PaStream* stream );

+

+

+/** Retrieve the host type handling an open stream.

+

+ @return Returns a non-negative value representing the host API type

+ handling an open stream or, a PaErrorCode (which are always negative)

+ if PortAudio is not initialized or an error is encountered.

+*/

+PaHostApiTypeId Pa_GetStreamHostApiType( PaStream* stream );

 /* Miscellaneous utilities */

--- src/common/pa_front.c.orig	2018-07-17 06:44:39 UTC

+++ src/common/pa_front.c

@@ -1216,8 +1216,10 @@ PaError Pa_OpenStream( PaStream** stream,

                                   hostApiInputParametersPtr, hostApiOutputParametersPtr,

                                   sampleRate, framesPerBuffer, streamFlags, streamCallback, userData );

-    if( result == paNoError )

+    if( result == paNoError ) {

         AddOpenStream( *stream );

+        PA_STREAM_REP(*stream)->hostApiType = hostApi->info.type;

+    }

     PA_LOGAPI(("Pa_OpenStream returned:\n" ));

@@ -1729,6 +1731,32 @@ signed long Pa_GetStreamWriteAvailable( PaStream* stre

     return result;

 }

+PaHostApiTypeId Pa_GetStreamHostApiType( PaStream* stream )

+{

+    PaError error = PaUtil_ValidateStreamPointer( stream );

+    PaHostApiTypeId result;

+

+#ifdef PA_LOG_API_CALLS

+    PaUtil_DebugPrint("Pa_GetStreamHostApiType called:\n" );

+    PaUtil_DebugPrint("\tPaStream* stream: 0x%p\n", stream );

+#endif

+

+    if( error == paNoError )

+    {

+        result = PA_STREAM_REP(stream)->hostApiType;

+    }

+    else

+    {

+        result = (PaHostApiTypeId) error;

+    }

+

+#ifdef PA_LOG_API_CALLS

+    PaUtil_DebugPrint("Pa_GetStreamHostApiType returned:\n" );

+    PaUtil_DebugPrint("\tPaError: %d ( %s )\n\n", result, Pa_GetErrorText( result ) );

+#endif

+

+    return result;

+}

 PaError Pa_GetSampleSize( PaSampleFormat format )

 {

--- src/common/pa_stream.c.orig	2018-07-17 06:44:39 UTC

+++ src/common/pa_stream.c

@@ -93,6 +93,8 @@ void PaUtil_InitializeStreamRepresentation( PaUtilStre

     streamRepresentation->streamInfo.inputLatency = 0.;

     streamRepresentation->streamInfo.outputLatency = 0.;

     streamRepresentation->streamInfo.sampleRate = 0.;

+

+    streamRepresentation->hostApiType = 0;

 }

--- src/common/pa_stream.h.orig	2018-07-17 06:44:39 UTC

+++ src/common/pa_stream.h

@@ -152,6 +152,7 @@ typedef struct PaUtilStreamRepresentation {

     PaStreamFinishedCallback *streamFinishedCallback;

     void *userData;

     PaStreamInfo streamInfo;

+    PaHostApiTypeId hostApiType;

 } PaUtilStreamRepresentation;

$OpenBSD: patch-src_os_unix_pa_unix_hostapis_c,v 1.2 2013/03/12 00:59:50 brad Exp $

Difference to OpenBSD patch: PA_USE_SNDIO has been moved before

PA_USE_OSS, so that portaudio prefers the sndio output.

--- src/os/unix/pa_unix_hostapis.c.orig	2018-07-17 07:08:09 UTC

+++ src/os/unix/pa_unix_hostapis.c

@@ -44,6 +44,7 @@

 PaError PaJack_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index );

 PaError PaAlsa_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index );

+PaError PaSndio_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index );

 PaError PaOSS_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index );

 /* Added for IRIX, Pieter, oct 2, 2003: */

 PaError PaSGI_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index );

@@ -68,6 +69,10 @@ PaUtilHostApiInitializer *paHostApiInitializers[] =

 #endif

 #else   /* __linux__ */

+

+#ifdef PA_USE_SNDIO

+	PaSndio_Initialize,

+#endif

 #if PA_USE_OSS

         PaOSS_Initialize,

lib/libportaudio.so.2.0.0

lib/libportaudiocpp.a

lib/libportaudiocpp.so

lib/libportaudiocpp.so.0

lib/libportaudiocpp.so.0.0.12

libdata/pkgconfig/portaudiocpp.pc