Subject: [linux-audio-dev] [PATCH] oss driver for jack 0.90.0 - the actual patch :)
From: Jussi Laako (jussi.laako_AT_pp.inet.fi)
Date: Mon Nov 17 2003 - 01:04:33 EET
Looks like I forgot to attach the patch...
-- Jussi Laako <jussi.laako_AT_pp.inet.fi>
--- jack-audio-connection-kit-0.90.0/configure.in 2003-11-16 00:39:16.000000000 +0200 +++ jackit.mod/configure.in 2003-11-16 22:50:17.000000000 +0200 @@ -116,8 +116,8 @@ JACK_CORE_CFLAGS="-I\$(top_srcdir) -D_REENTRANT -D_POSIX_PTHREAD_SEMANTICS -Wall" -JACK_CFLAGS="$JACK_CORE_CFLAGS -g" -JACK_OPT_CFLAGS="$JACK_CORE_CFLAGS -O3 -march=$target_cpu -fomit-frame-pointer -ffast-math -fstrength-reduce -funroll-loops -fmove-all-movables" +JACK_CFLAGS="$JACK_CORE_CFLAGS -g $CFLAGS" +JACK_OPT_CFLAGS="$JACK_CORE_CFLAGS -march=pentium2 -mcpu=pentium4 -O3 -ffast-math -funroll-loops -fprefetch-loop-arrays" AC_ARG_ENABLE(optimize, [ --enable-optimize ask the compiler for its best optimizations], @@ -317,6 +317,7 @@ drivers/alsa/Makefile drivers/dummy/Makefile drivers/portaudio/Makefile +drivers/oss/Makefile example-clients/Makefile doc/Makefile doc/reference.doxygen --- jack-audio-connection-kit-0.90.0/drivers/Makefile.am 2003-09-26 01:37:02.000000000 +0300 +++ jackit.mod/drivers/Makefile.am 2003-11-16 21:42:49.000000000 +0200 @@ -12,6 +12,6 @@ PA_DIR = endif -SUBDIRS = dummy $(ALSA_DIR) $(PA_DIR) +SUBDIRS = dummy $(ALSA_DIR) $(PA_DIR) oss -DIST_SUBDIRS = dummy alsa portaudio +DIST_SUBDIRS = dummy alsa portaudio oss diff -urN jack-audio-connection-kit-0.90.0/drivers/oss/Makefile.am jackit.mod/drivers/oss/Makefile.am --- jack-audio-connection-kit-0.90.0/drivers/oss/Makefile.am 1970-01-01 02:00:00.000000000 +0200 +++ jackit.mod/drivers/oss/Makefile.am 2003-11-16 22:51:39.000000000 +0200 @@ -0,0 +1,13 @@ +MAINTAINCLEANFILES = Makefile.in + +AM_CFLAGS = $(JACK_CFLAGS) -I/opt/oss/include +AM_LDFLAGS = $(JACK_LDFLAGS) -lpthread + +plugindir = $(ADDON_DIR) + +plugin_LTLIBRARIES = jack_oss.la + +jack_oss_la_LDFLAGS = -module -avoid-version +jack_oss_la_SOURCES = oss_driver.c oss_driver.h + +noinst_HEADERS = oss_driver.h diff -urN jack-audio-connection-kit-0.90.0/drivers/oss/oss_driver.c jackit.mod/drivers/oss/oss_driver.c --- jack-audio-connection-kit-0.90.0/drivers/oss/oss_driver.c 1970-01-01 02:00:00.000000000 +0200 +++ jackit.mod/drivers/oss/oss_driver.c 2003-11-17 00:18:17.000000000 +0200 @@ -0,0 +1,918 @@ +/* + + OSS driver for Jack + Copyright (C) 2003 Jussi Laako <jussi_AT_sonarnerd.net> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, + MA 02111-1307 USA + +*/ + + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <fcntl.h> +#include <errno.h> +#include <math.h> +#include <float.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/ioctl.h> +#include <sys/soundcard.h> +#include <stdarg.h> +#include <getopt.h> +#include <pthread.h> + +#include <jack/types.h> +#include <jack/internal.h> +#include <jack/engine.h> +#include <jack/time.h> + +#include "oss_driver.h" + + +#define OSS_DRIVER_N_PARAMS 8 +const static jack_driver_param_desc_t oss_params[OSS_DRIVER_N_PARAMS] = { + { "samplerate", + 's', + optional_argument, + JackDriverParamUInt, + { .ui = OSS_DRIVER_DEF_FS }, + "sample rate", + "sample rate" + }, + { "periodsize", + 'b', + optional_argument, + JackDriverParamUInt, + { .ui = OSS_DRIVER_DEF_BLKSIZE }, + "period size", + "period size" + }, + { "wordlength", + 'w', + optional_argument, + JackDriverParamInt, + { .i = OSS_DRIVER_DEF_BITS }, + "word length", + "word length" + }, + { "capturech", + 'c', + optional_argument, + JackDriverParamUInt, + { .ui = OSS_DRIVER_DEF_INS }, + "capture channels", + "capture channels" + }, + { "playbackch", + 'p', + optional_argument, + JackDriverParamUInt, + { .ui = OSS_DRIVER_DEF_OUTS }, + "playback channels", + "playback channels" + }, + { "inputdev", + 'i', + optional_argument, + JackDriverParamString, + { .str[0] = '\0' }, + "input device", + "input device" + }, + { "outputdev", + 'o', + optional_argument, + JackDriverParamString, + { .str[0] = '\0' }, + "output device", + "output device" + }, + { "help", + 'h', + optional_argument, + JackDriverParamBool, + { }, + "help", + "help" + } +}; + + + +/* internal functions */ + + +static void copy_and_convert_in (jack_sample_t *dst, void *src, + size_t nframes, int channel, int chcount, int bits) +{ + int srcidx; + int dstidx; + signed short *s16src = (signed short *) src; + signed int *s32src = (signed int *) src; + double *f64src = (double *) src; + jack_sample_t scale; + + srcidx = channel; + switch (bits) + { + case 16: + scale = 1.0f / 0x7fff; + for (dstidx = 0; dstidx < nframes; dstidx++) + { + dst[dstidx] = (jack_sample_t) + s16src[srcidx] * scale; + srcidx += chcount; + } + break; + case 24: + scale = 1.0f / 0x7fffff; + for (dstidx = 0; dstidx < nframes; dstidx++) + { + dst[dstidx] = (jack_sample_t) + s32src[srcidx] * scale; + srcidx += chcount; + } + break; + case 32: + scale = 1.0f / 0x7fffffff; + for (dstidx = 0; dstidx < nframes; dstidx++) + { + dst[dstidx] = (jack_sample_t) + s32src[srcidx] * scale; + srcidx += chcount; + } + break; + case 64: + for (dstidx = 0; dstidx < nframes; dstidx++) + { + dst[dstidx] = (jack_sample_t) f64src[srcidx]; + srcidx += chcount; + } + break; + } +} + + +static void copy_and_convert_out (void *dst, jack_sample_t *src, + size_t nframes, int channel, int chcount, int bits) +{ + int srcidx; + int dstidx; + signed short *s16dst = (signed short *) dst; + signed int *s32dst = (signed int *) dst; + double *f64dst = (double *) dst; + jack_sample_t scale; + + dstidx = channel; + switch (bits) + { + case 16: + scale = 0x7fff; + for (srcidx = 0; srcidx < nframes; srcidx++) + { + s16dst[dstidx] = (signed short) + (src[srcidx] * scale + 0.5f); + dstidx += chcount; + } + break; + case 24: + scale = 0x7fffff; + for (srcidx = 0; srcidx < nframes; srcidx++) + { + s32dst[dstidx] = (signed int) + (src[srcidx] * scale + 0.5f); + dstidx += chcount; + } + break; + case 32: + scale = 0x7fffffff; + for (srcidx = 0; srcidx < nframes; srcidx++) + { + s32dst[dstidx] = (signed int) + (src[srcidx] * scale + 0.5f); + dstidx += chcount; + } + break; + case 64: + for (srcidx = 0; srcidx < nframes; srcidx++) + { + f64dst[dstidx] = (double) src[srcidx]; + dstidx += chcount; + } + break; + } +} + + +static void set_fragment (int fd, int fragsize, int fragcount) +{ + int fragsize_2p; + int fragments; + + fragsize_2p = (int) (log(fragsize) / log(2.0) + 0.5); + fragments = ((fragcount << 16) | (fragsize_2p & 0xffff)); + if (ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &fragments) < 0) + { + jack_error("OSS: failed to set fragment size: %s@%i", + __FILE__, __LINE__); + } +} + + +static int get_fragment (int fd) +{ + int fragsize; + + if (ioctl(fd, SNDCTL_DSP_GETBLKSIZE, &fragsize) < 0) + { + jack_error("OSS: failed to get fragment size: %s@%i", + __FILE__, __LINE__); + return 0; + } + return fragsize; +} + + +static void *io_thread (void *); + + +/* jack driver interface */ + + +static int oss_driver_attach (oss_driver_t *driver, jack_engine_t *engine) +{ + int port_flags; + unsigned int channel; + char channel_name[64]; + jack_port_t *port; + + driver->engine = engine; + + engine->set_buffer_size(engine, driver->period_size); + engine->set_sample_rate(engine, driver->sample_rate); + + port_flags = JackPortIsOutput|JackPortIsPhysical|JackPortIsTerminal; + for (channel = 0; channel < driver->capture_channels; channel++) + { + snprintf(channel_name, sizeof(channel_name), + "capture_%u", channel + 1); + port = jack_port_register(driver->client, channel_name, + JACK_DEFAULT_AUDIO_TYPE, port_flags, 0); + if (port == NULL) + { + jack_error("OSS: cannot register port for %s: %s@%i", + channel_name, __FILE__, __LINE__); + break; + } + driver->capture_ports = + jack_slist_append(driver->capture_ports, port); + } + + port_flags = JackPortIsInput|JackPortIsPhysical|JackPortIsTerminal; + for (channel = 0; channel < driver->playback_channels; channel++) + { + snprintf(channel_name, sizeof(channel_name), + "playback_%u", channel + 1); + port = jack_port_register(driver->client, channel_name, + JACK_DEFAULT_AUDIO_TYPE, port_flags, 0); + if (port == NULL) + { + jack_error("OSS: cannot register port for %s: %s@%i", + channel_name, __FILE__, __LINE__); + break; + } + driver->playback_ports = + jack_slist_append(driver->playback_ports, port); + } + + jack_activate(driver->client); + + return 0; +} + + +static int oss_driver_detach (oss_driver_t *driver, jack_engine_t *engine) +{ + JSList *node; + + if (driver->engine == NULL) + return -1; + + node = driver->capture_ports; + while (node != NULL) + { + jack_port_unregister(driver->client, + ((jack_port_t *) node->data)); + node = jack_slist_next(node); + } + jack_slist_free(driver->capture_ports); + driver->capture_ports = NULL; + + node = driver->playback_ports; + while (node != NULL) + { + jack_port_unregister(driver->client, + ((jack_port_t *) node->data)); + node = jack_slist_next(node); + } + jack_slist_free(driver->playback_ports); + driver->playback_ports = NULL; + + driver->engine = NULL; + + return 0; +} + + +static int oss_driver_start (oss_driver_t *driver) +{ + int format; + int channels; + int samplerate; + int infd = driver->infd; + int outfd = driver->outfd; + size_t samplesize; + size_t fragsize; + const char *indev = driver->indev; + const char *outdev = driver->outdev; + + switch (driver->bits) + { + case 0: + samplesize = sizeof(unsigned int); + break; + case 24: + case 32: + samplesize = sizeof(int); + break; + case 64: + samplesize = sizeof(double); + break; + case 16: + default: + samplesize = sizeof(short); + break; + } + if (strcmp(indev, outdev) != 0) + { + if (driver->capture_channels > 0) + { + infd = open(indev, O_RDONLY); + if (infd < 0) + { + jack_error( + "OSS: failed to open input device %s: %s@%i", + indev, __FILE__, __LINE__); + } + fragsize = driver->period_size * + driver->capture_channels * samplesize; + //set_fragment(infd, fragsize, 0xffff / fragsize); + set_fragment(infd, fragsize, 2); + } + else infd = -1; + + if (driver->playback_channels > 0) + { + outfd = open(outdev, O_WRONLY); + if (outfd < 0) + { + jack_error( + "OSS: failed to open output device %s: %s@%i", + outdev, __FILE__, __LINE__); + } + fragsize = driver->period_size * + driver->playback_channels * samplesize; + //set_fragment(outfd, fragsize, 0xffff / fragsize); + set_fragment(outfd, fragsize, 2); + } + else outfd = -1; + } + else + { + if (driver->capture_channels != 0 && + driver->playback_channels == 0) + { + infd = open(indev, O_RDWR); + outfd = -1; + if (infd < 0) + { + jack_error( + "OSS: failed to open device %s: %s@%i", + indev, __FILE__, __LINE__); + return -1; + } + } + else if (driver->capture_channels == 0 && + driver->playback_channels != 0) + { + infd = -1; + outfd = open(outdev, O_RDWR); + if (outfd < 0) + { + jack_error( + "OSS: failed to open device %s: %s@%i", + outdev, __FILE__, __LINE__); + return -1; + } + } + else + { + infd = outfd = open(indev, O_RDWR); + if (infd < 0) + { + jack_error( + "OSS: failed to open device %s: %s@%i", + indev, __FILE__, __LINE__); + return -1; + } + } + if (infd >= 0 && outfd >= 0) + { + if (ioctl(infd, SNDCTL_DSP_SETDUPLEX, 0) < 0) + { + jack_error( + "OSS: failed to enable full duplex for %s: %s@%i", + indev, __FILE__, __LINE__); + } + } + if (infd >= 0) + { + fragsize = driver->period_size * + driver->capture_channels * samplesize; + //set_fragment(infd, fragsize, 0xffff / fragsize); + set_fragment(infd, fragsize, 2); + } + if (outfd >= 0 && infd < 0) + { + fragsize = driver->period_size * + driver->playback_channels * samplesize; + //set_fragment(outfd, fragsize, 0xffff / fragsize); + set_fragment(outfd, fragsize, 2); + } + } + driver->infd = infd; + driver->outfd = outfd; + + if (infd >= 0) + { + format = driver->format; + if (ioctl(infd, SNDCTL_DSP_SETFMT, &format) < 0) + jack_error( + "OSS: failed to set format for %s: %s@%i", + indev, __FILE__, __LINE__); + channels = driver->capture_channels; + if (ioctl(infd, SNDCTL_DSP_CHANNELS, &channels) < 0) + jack_error( + "OSS: failed to set channels for %s: %s@%i", + indev, __FILE__, __LINE__); + samplerate = driver->sample_rate; + if (ioctl(infd, SNDCTL_DSP_SPEED, &samplerate) < 0) + jack_error( + "OSS: failed to set samplerate for %s: %s@%i", + indev, __FILE__, __LINE__); + printf("oss_driver: %s : 0x%x/%i/%i (%i)\n", indev, + format, channels, samplerate, get_fragment(infd)); + } + + if (outfd >= 0 && infd != outfd) + { + format = driver->format; + if (ioctl(outfd, SNDCTL_DSP_SETFMT, &format) < 0) + jack_error( + "OSS: failed to set format for %s: %s@%i", + outdev, __FILE__, __LINE__); + channels = driver->playback_channels; + if (ioctl(outfd, SNDCTL_DSP_CHANNELS, &channels) < 0) + jack_error( + "OSS: failed to set channels for %s: %s@%i", + outdev, __FILE__, __LINE__); + samplerate = driver->sample_rate; + if (ioctl(outfd, SNDCTL_DSP_SPEED, &samplerate) < 0) + jack_error( + "OSS: failed to set samplerate for %s: %s@%i", + outdev, __FILE__, __LINE__); + printf("oss_driver: %s : 0x%x/%i/%i (%i)\n", outdev, + format, channels, samplerate, + get_fragment(outfd)); + } + + if (driver->capture_channels > 0) + { + driver->indevbufsize = driver->period_size * + driver->capture_channels * samplesize; + driver->indevbuf = malloc(driver->indevbufsize); + if (driver->indevbuf == NULL) + { + jack_error( "OSS: malloc() failed: %s@%i", + __FILE__, __LINE__); + return -1; + } + memset(driver->indevbuf, 0x00, driver->indevbufsize); + } + else + { + driver->indevbufsize = 0; + driver->indevbuf = NULL; + } + + if (driver->playback_channels > 0) + { + driver->outdevbufsize = driver->period_size * + driver->playback_channels * samplesize; + driver->outdevbuf = malloc(driver->outdevbufsize); + if (driver->outdevbuf == NULL) + { + jack_error("OSS: malloc() failed: %s@%i", + __FILE__, __LINE__); + return -1; + } + memset(driver->outdevbuf, 0x00, driver->outdevbufsize); + } + else + { + driver->outdevbufsize = 0; + driver->outdevbuf = NULL; + } + + printf("oss_driver: indevbuf %u B, outdevbuf %u B\n", + driver->indevbufsize, driver->outdevbufsize); + + driver->run = 1; + if (pthread_create(&driver->thread_io, NULL, io_thread, driver) < 0) + { + jack_error("OSS: pthread_create() failed: %s@%i", + __FILE__, __LINE__); + return -1; + } + + return 0; +} + + +static int oss_driver_stop (oss_driver_t *driver) +{ + void *retval; + + driver->run = 0; + if (pthread_join(driver->thread_io, &retval) < 0) + { + jack_error("OSS: pthread_join() failed: %s@%i", + __FILE__, __LINE__); + return -1; + } + + if (driver->outfd >= 0 && driver->outfd != driver->infd) + { + close(driver->outfd); + driver->outfd = -1; + } + if (driver->infd >= 0) + { + close(driver->infd); + driver->infd = -1; + } + + if (driver->indevbuf != NULL) + { + free(driver->indevbuf); + driver->indevbuf = NULL; + } + if (driver->outdevbuf != NULL) + { + free(driver->outdevbuf); + driver->outdevbuf = NULL; + } + + return 0; +} + + +static int oss_driver_read (oss_driver_t *driver, jack_nframes_t nframes) +{ + int channel; + jack_sample_t *portbuf; + JSList *node; + jack_port_t *port; + + if (nframes != driver->period_size) + { + jack_error( + "OSS: read failed nframes != period_size (%u/%u): %s@%i", + nframes, driver->period_size, __FILE__, __LINE__); + return -1; + } + + node = driver->capture_ports; + channel = 0; + while (node != NULL) + { + port = (jack_port_t *) node->data; + + if (jack_port_connected(port)) + { + portbuf = jack_port_get_buffer(port, nframes); + copy_and_convert_in(portbuf, driver->indevbuf, + nframes, channel, + driver->capture_channels, + driver->bits); + } + + node = jack_slist_next(node); + channel++; + } + + return 0; +} + + +static int oss_driver_write (oss_driver_t *driver, jack_nframes_t nframes) +{ + int channel; + jack_sample_t *portbuf; + JSList *node; + jack_port_t *port; + + if (nframes != driver->period_size) + { + jack_error( + "OSS: write failed nframes != period_size (%u/%u): %s@%i", + nframes, driver->period_size, __FILE__, __LINE__); + return -1; + } + + node = driver->playback_ports; + channel = 0; + while (node != NULL) + { + port = (jack_port_t *) node->data; + + if (jack_port_connected(port)) + { + portbuf = jack_port_get_buffer(port, nframes); + copy_and_convert_out(driver->outdevbuf, portbuf, + nframes, channel, + driver->playback_channels, + driver->bits); + } + + node = jack_slist_next(node); + channel++; + } + + return 0; +} + + +static int oss_driver_null_cycle (oss_driver_t *driver, jack_nframes_t nframes) +{ + return 0; +} + + +static jack_nframes_t oss_driver_wait (oss_driver_t *driver, int *status, + float *delayed_usecs) +{ + *status = 0; + *delayed_usecs = 0; + + if (driver->playback_channels > 0) + { + if (write(driver->outfd, driver->outdevbuf, + driver->outdevbufsize) < (ssize_t) + driver->outdevbufsize) + { + /*jack_error("OSS: write() failed: %s@%i", + __FILE__, __LINE__);*/ + oss_driver_stop(driver); + *status = 1; + } + } + + if (driver->capture_channels > 0) + { + if (read(driver->infd, driver->indevbuf, + driver->indevbufsize) < (ssize_t) + driver->indevbufsize) + { + /*jack_error("OSS: read() failed: %s@%i", + __FILE__, __LINE__);*/ + oss_driver_stop(driver); + *status = 1; + } + } + + driver->last_wait_ust = jack_get_microseconds(); + + return driver->period_size; +} + + +static int oss_driver_bufsize (oss_driver_t *driver, jack_nframes_t nframes) +{ + driver->period_size = nframes; + driver->period_usecs = + ((double) driver->period_size / + (double) driver->sample_rate) * 1e6; + + return 0; +} + + +/* internal driver thread */ + + +static void *io_thread (void *param) +{ + int status; + float delay; + jack_nframes_t nframes; + oss_driver_t *driver = (oss_driver_t *) param; + + while (driver->run) + { + nframes = oss_driver_wait(driver, &status, &delay); + if (status == 0) + driver->engine->run_cycle(driver->engine, nframes, + delay); + } + + return NULL; +} + + +/* jack driver published interface */ + + +const char driver_client_name[] = "oss"; + + +void driver_finish (jack_driver_t *); + + +jack_driver_desc_t * driver_get_descriptor () +{ + jack_driver_desc_t *desc; + jack_driver_param_desc_t *params; + + desc = (jack_driver_desc_t *) calloc(1, sizeof(jack_driver_desc_t)); + if (desc == NULL) + { + printf("oss_driver: malloc() failed: %s@%i\n", + __FILE__, __LINE__); + return NULL; + } + strcpy(desc->name, driver_client_name); + desc->nparams = 8; + + params = calloc(desc->nparams, sizeof(jack_driver_param_desc_t)); + memcpy(params, oss_params, + OSS_DRIVER_N_PARAMS * sizeof(jack_driver_param_desc_t)); + desc->params = params; + + return desc; +} + + +jack_driver_t * driver_initialize (jack_client_t *client, + JSList * params) +{ + int bits = OSS_DRIVER_DEF_BITS; + jack_nframes_t sample_rate = OSS_DRIVER_DEF_FS; + jack_nframes_t period_size = OSS_DRIVER_DEF_BLKSIZE; + unsigned int capture_channels = OSS_DRIVER_DEF_INS; + unsigned int playback_channels = OSS_DRIVER_DEF_OUTS; + const JSList *pnode; + const jack_driver_param_t *param; + oss_driver_t *driver; + + driver = (oss_driver_t *) malloc(sizeof(oss_driver_t)); + if (driver == NULL) + { + jack_error("OSS: malloc() failed: %s@%i", __FILE__, __LINE__); + return NULL; + } + jack_driver_init((jack_driver_t *) driver); + + driver->attach = (JackDriverAttachFunction) oss_driver_attach; + driver->detach = (JackDriverDetachFunction) oss_driver_detach; + driver->start = (JackDriverStartFunction) oss_driver_start; + driver->stop = (JackDriverStopFunction) oss_driver_stop; + driver->read = (JackDriverReadFunction) oss_driver_read; + driver->write = (JackDriverWriteFunction) oss_driver_write; + driver->null_cycle = (JackDriverNullCycleFunction) + oss_driver_null_cycle; + driver->bufsize = (JackDriverBufSizeFunction) oss_driver_bufsize; + + driver->indev = NULL; + driver->outdev = NULL; + + pnode = params; + while (pnode != NULL) + { + param = (const jack_driver_param_t *) pnode->data; + + switch (param->character) + { + case 's': + sample_rate = param->value.ui; + case 'b': + period_size = param->value.ui; + case 'w': + bits = param->value.i; + case 'c': + capture_channels = param->value.ui; + case 'p': + playback_channels = param->value.ui; + case 'i': + driver->indev = strdup(param->value.str); + case 'o': + driver->outdev = strdup(param->value.str); + case 'h': + puts("-s <fs>\tsample rate"); + puts("-b <size>\tperiod size"); + puts("-w <bits>\tword length"); + puts("-c <chs>\tcapture channels"); + puts("-p <chs>\tplayback channels"); + puts("-i <dev>\tcapture device"); + puts("-o <dev>\tplayback device"); + puts("-h\tthis help"); + break; + } + pnode = jack_slist_next(pnode); + } + + driver->sample_rate = sample_rate; + driver->period_size = period_size; + driver->bits = bits; + driver->capture_channels = capture_channels; + driver->playback_channels = playback_channels; + + driver->period_usecs = + ((double) period_size / (double) sample_rate) * 1e6; + driver->last_wait_ust = 0; + + driver->finish = driver_finish; + + if (driver->indev == NULL) + driver->indev = strdup("/dev/dsp"); + if (driver->outdev == NULL) + driver->outdev = strdup(driver->indev); + driver->infd = -1; + driver->outfd = -1; + switch (driver->bits) + { +# ifdef OPEN_SOUND_SYSTEM + case 0: + driver->format = AFMT_SPDIF_RAW; + break; + case 24: + driver->format = AFMT_S24_NE; + break; + case 32: + driver->format = AFMT_S32_NE; + break; + case 64: + driver->format = AFMT_FLOAT; + break; +# endif + case 16: + default: + driver->format = AFMT_S16_NE; + break; + } + + driver->indevbuf = driver->outdevbuf = NULL; + + driver->capture_ports = NULL; + driver->playback_ports = NULL; + + driver->engine = NULL; + driver->client = client; + + return ((jack_driver_t *) driver); +} + + +void driver_finish (jack_driver_t *driver) +{ + free(((oss_driver_t *) driver)->indev); + free(((oss_driver_t *) driver)->outdev); + free(driver); +} + diff -urN jack-audio-connection-kit-0.90.0/drivers/oss/oss_driver.h jackit.mod/drivers/oss/oss_driver.h --- jack-audio-connection-kit-0.90.0/drivers/oss/oss_driver.h 1970-01-01 02:00:00.000000000 +0200 +++ jackit.mod/drivers/oss/oss_driver.h 2003-11-16 22:49:30.000000000 +0200 @@ -0,0 +1,78 @@ +/* + + OSS driver for Jack + Copyright (C) 2003 Jussi Laako <jussi_AT_sonarnerd.net> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, + MA 02111-1307 USA + +*/ + + +#ifndef __JACK_OSS_DRIVER_H__ +#define __JACK_OSS_DRIVER_H__ + +#include <pthread.h> + +#include <jack/types.h> +#include <jack/jslist.h> +#include <jack/driver.h> +#include <jack/jack.h> + + +#define OSS_DRIVER_DEF_FS 44100 +#define OSS_DRIVER_DEF_BLKSIZE 1024 +#define OSS_DRIVER_DEF_BITS 16 +#define OSS_DRIVER_DEF_INS 2 +#define OSS_DRIVER_DEF_OUTS 2 + + +typedef jack_default_audio_sample_t jack_sample_t; + +typedef struct _oss_driver +{ + JACK_DRIVER_DECL + + jack_nframes_t sample_rate; + jack_nframes_t period_size; + int bits; + unsigned int capture_channels; + unsigned int playback_channels; + + char *indev; + char *outdev; + int infd; + int outfd; + int format; + + size_t indevbufsize; + size_t outdevbufsize; + size_t portbufsize; + void *indevbuf; + void *outdevbuf; + + JSList *capture_ports; + JSList *playback_ports; + + jack_engine_t *engine; + jack_client_t *client; + + volatile int run; + pthread_t thread_io; +} oss_driver_t; + + +#endif +
This archive was generated by hypermail 2b28 : Mon Nov 17 2003 - 01:03:44 EET