Corrected and completed encapsulation for PCM and rawmidi. Remove SND_PCM_HW_PARAM_* and use functions. Separated rawmidi info between streams

src/rawmidi/Makefile.am

@@ -1,6 +1,6 @@
 EXTRA_LTLIBRARIES=librawmidi.la
 
-librawmidi_la_SOURCES = rawmidi.c rawmidi_hw.c
+librawmidi_la_SOURCES = rawmidi.c rawmidi_m4.c rawmidi_hw.c
 noinst_HEADERS = rawmidi_local.h
 
 all: librawmidi.la

src/rawmidi/rawmidi.c

@@ -28,6 +28,14 @@
 #include <dlfcn.h>
 #include "rawmidi_local.h"
 
+static inline int snd_rawmidi_stream_ok(snd_rawmidi_t *rmidi, snd_rawmidi_stream_t stream)
+{
+	assert(rmidi);
+	assert(stream == SND_RAWMIDI_STREAM_INPUT || 
+	       stream == SND_RAWMIDI_STREAM_OUTPUT);
+	return rmidi->streams & (1 << (snd_enum_to_int(stream)));
+}
+
 int snd_rawmidi_close(snd_rawmidi_t *rmidi)
 {
 	int err;
@@ -40,22 +48,19 @@ int snd_rawmidi_close(snd_rawmidi_t *rmidi)
 	return 0;
 }
 
-int snd_rawmidi_card(snd_rawmidi_t *rmidi)
+int snd_rawmidi_poll_descriptor(snd_rawmidi_t *rmidi,
+				snd_rawmidi_stream_t stream ATTRIBUTE_UNUSED)
 {
-	assert(rmidi);
-	return rmidi->ops->card(rmidi);
-}
-
-int snd_rawmidi_poll_descriptor(snd_rawmidi_t *rmidi)
-{
-	assert(rmidi);
+	assert(snd_rawmidi_stream_ok(rmidi, stream));
 	return rmidi->poll_fd;
 }
 
-int snd_rawmidi_nonblock(snd_rawmidi_t *rmidi, int nonblock)
+int snd_rawmidi_nonblock(snd_rawmidi_t *rmidi, 
+			 snd_rawmidi_stream_t stream ATTRIBUTE_UNUSED,
+			 int nonblock)
 {
 	int err;
-	assert(rmidi);
+	assert(snd_rawmidi_stream_ok(rmidi, stream));
 	assert(!(rmidi->mode & SND_RAWMIDI_APPEND));
 	if ((err = rmidi->ops->nonblock(rmidi, nonblock)) < 0)
 		return err;
@@ -66,64 +71,59 @@ int snd_rawmidi_nonblock(snd_rawmidi_t *rmidi, int nonblock)
 	return 0;
 }
 
-int snd_rawmidi_info(snd_rawmidi_t *rmidi, snd_rawmidi_info_t * info)
+int snd_rawmidi_info(snd_rawmidi_t *rmidi,
+		     snd_rawmidi_stream_t stream,
+		     snd_rawmidi_info_t * info)
 {
-	assert(rmidi && info);
+	assert(snd_rawmidi_stream_ok(rmidi, stream));
+	assert(info);
+	info->stream = snd_enum_to_int(stream);
 	return rmidi->ops->info(rmidi, info);
 }
 
-int snd_rawmidi_params(snd_rawmidi_t *rmidi, snd_rawmidi_params_t * params)
+int snd_rawmidi_params(snd_rawmidi_t *rmidi, 
+		       snd_rawmidi_stream_t stream,
+		       snd_rawmidi_params_t * params)
 {
-	assert(rmidi && params);
+	assert(snd_rawmidi_stream_ok(rmidi, stream));
+	assert(params);
+	params->stream = snd_enum_to_int(stream);
 	return rmidi->ops->params(rmidi, params);
 }
 
-int snd_rawmidi_status(snd_rawmidi_t *rmidi, snd_rawmidi_status_t * status)
+int snd_rawmidi_status(snd_rawmidi_t *rmidi,
+		       snd_rawmidi_stream_t stream,
+		       snd_rawmidi_status_t * status)
 {
-	assert(rmidi && status);
+	assert(snd_rawmidi_stream_ok(rmidi, stream));
+	assert(status);
+	status->stream = snd_enum_to_int(stream);
 	return rmidi->ops->status(rmidi, status);
 }
 
-int snd_rawmidi_drop(snd_rawmidi_t *rmidi, int str)
+int snd_rawmidi_drop(snd_rawmidi_t *rmidi, snd_rawmidi_stream_t stream)
 {
-	assert(rmidi);
-	assert(str >= 0 && str <= 1);
-	assert(rmidi->streams & (1 << str));
-	return rmidi->ops->drop(rmidi, str);
+	assert(snd_rawmidi_stream_ok(rmidi, stream));
+	return rmidi->ops->drop(rmidi, stream);
 }
 
-int snd_rawmidi_output_drop(snd_rawmidi_t *rmidi)
+int snd_rawmidi_drain(snd_rawmidi_t *rmidi, snd_rawmidi_stream_t stream)
 {
-	return snd_rawmidi_drop(rmidi, SND_RAWMIDI_STREAM_OUTPUT);
-}
-
-int snd_rawmidi_drain(snd_rawmidi_t *rmidi, int str)
-{
-	assert(rmidi);
-	assert(str >= 0 && str <= 1);
-	assert(rmidi->streams & (1 << str));
-	return rmidi->ops->drain(rmidi, str);
-}
-
-int snd_rawmidi_output_drain(snd_rawmidi_t *rmidi)
-{
-	return snd_rawmidi_drain(rmidi, SND_RAWMIDI_STREAM_OUTPUT);
-}
-
-int snd_rawmidi_input_drain(snd_rawmidi_t *rmidi)
-{
-	return snd_rawmidi_drain(rmidi, SND_RAWMIDI_STREAM_INPUT);
+	assert(snd_rawmidi_stream_ok(rmidi, stream));
+	return rmidi->ops->drain(rmidi, stream);
 }
 
 ssize_t snd_rawmidi_write(snd_rawmidi_t *rmidi, const void *buffer, size_t size)
 {
-	assert(rmidi && (buffer || size == 0));
+	assert(snd_rawmidi_stream_ok(rmidi, SND_RAWMIDI_STREAM_OUTPUT));
+	assert(buffer || size == 0);
 	return rmidi->ops->write(rmidi, buffer, size);
 }
 
 ssize_t snd_rawmidi_read(snd_rawmidi_t *rmidi, void *buffer, size_t size)
 {
-	assert(rmidi && (buffer || size == 0));
+	assert(snd_rawmidi_stream_ok(rmidi, SND_RAWMIDI_STREAM_INPUT));
+	assert(buffer || size == 0);
 	return rmidi->ops->read(rmidi, buffer, size);
 }
 

src/rawmidi/rawmidi_hw.c

@@ -49,12 +49,6 @@ static int snd_rawmidi_hw_close(snd_rawmidi_t *rmidi)
 	return 0;
 }
 
-static int snd_rawmidi_hw_card(snd_rawmidi_t *rmidi)
-{
-	snd_rawmidi_hw_t *hw = rmidi->private;
-	return hw->card;
-}
-
 static int snd_rawmidi_hw_nonblock(snd_rawmidi_t *rmidi, int nonblock)
 {
 	snd_rawmidi_hw_t *hw = rmidi->private;
@@ -105,7 +99,7 @@ static int snd_rawmidi_hw_status(snd_rawmidi_t *rmidi, snd_rawmidi_status_t * st
 	return 0;
 }
 
-static int snd_rawmidi_hw_drop(snd_rawmidi_t *rmidi, int stream)
+static int snd_rawmidi_hw_drop(snd_rawmidi_t *rmidi, snd_rawmidi_stream_t stream)
 {
 	snd_rawmidi_hw_t *hw = rmidi->private;
 	if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_DROP, &stream) < 0) {
@@ -115,7 +109,7 @@ static int snd_rawmidi_hw_drop(snd_rawmidi_t *rmidi, int stream)
 	return 0;
 }
 
-static int snd_rawmidi_hw_drain(snd_rawmidi_t *rmidi, int stream)
+static int snd_rawmidi_hw_drain(snd_rawmidi_t *rmidi, snd_rawmidi_stream_t stream)
 {
 	snd_rawmidi_hw_t *hw = rmidi->private;
 	if (ioctl(hw->fd, SNDRV_RAWMIDI_IOCTL_DRAIN, &stream) < 0) {
@@ -147,7 +141,6 @@ static ssize_t snd_rawmidi_hw_read(snd_rawmidi_t *rmidi, void *buffer, size_t si
 
 snd_rawmidi_ops_t snd_rawmidi_hw_ops = {
 	close: snd_rawmidi_hw_close,
-	card: snd_rawmidi_hw_card,
 	nonblock: snd_rawmidi_hw_nonblock,
 	info: snd_rawmidi_hw_info,
 	params: snd_rawmidi_hw_params,

src/rawmidi/rawmidi_local.h

@@ -28,13 +28,12 @@
 
 typedef struct {
 	int (*close)(snd_rawmidi_t *rawmidi);
-	int (*card)(snd_rawmidi_t *rawmidi);
 	int (*nonblock)(snd_rawmidi_t *rawmidi, int nonblock);
 	int (*info)(snd_rawmidi_t *rawmidi, snd_rawmidi_info_t *info);
 	int (*params)(snd_rawmidi_t *rawmidi, snd_rawmidi_params_t *params);
 	int (*status)(snd_rawmidi_t *rawmidi, snd_rawmidi_status_t *status);
-	int (*drop)(snd_rawmidi_t *rawmidi, int stream);
-	int (*drain)(snd_rawmidi_t *rawmidi, int stream);
+	int (*drop)(snd_rawmidi_t *rawmidi, snd_rawmidi_stream_t stream);
+	int (*drain)(snd_rawmidi_t *rawmidi, snd_rawmidi_stream_t stream);
 	ssize_t (*write)(snd_rawmidi_t *rawmidi, const void *buffer, size_t size);
 	ssize_t (*read)(snd_rawmidi_t *rawmidi, void *buffer, size_t size);
 } snd_rawmidi_ops_t;

src/rawmidi/rawmidi_m4.c

@@ -0,0 +1,238 @@
+/*
+ *  Rawmidi - Automatically generated functions
+ *  Copyright (c) 2001 by Abramo Bagnara <abramo@alsa-project.org>
+ *
+ *
+ *   This library is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this library; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+  
+#include "rawmidi_local.h"
+
+size_t snd_rawmidi_params_sizeof()
+{
+	return sizeof(snd_rawmidi_params_t);
+}
+
+int snd_rawmidi_params_malloc(snd_rawmidi_params_t **ptr)
+{
+	assert(ptr);
+	*ptr = malloc(sizeof(snd_rawmidi_params_t));
+	if (!*ptr)
+		return -ENOMEM;
+	return 0;
+}
+
+void snd_rawmidi_params_free(snd_rawmidi_params_t *obj)
+{
+	free(obj);
+}
+
+void snd_rawmidi_params_copy(snd_rawmidi_params_t *dst, const snd_rawmidi_params_t *src)
+{
+	assert(dst && src);
+	*dst = *src;
+}
+
+int snd_rawmidi_params_set_buffer_size(snd_rawmidi_t *rmidi ATTRIBUTE_UNUSED, snd_rawmidi_params_t *params, size_t val)
+{
+	assert(rmidi && params);
+	assert(val > params->avail_min);
+	params->buffer_size = val;
+	return 0;
+}
+
+size_t snd_rawmidi_params_get_buffer_size(const snd_rawmidi_params_t *params)
+{
+	assert(params);
+	return params->buffer_size;
+}
+
+
+int snd_rawmidi_params_set_avail_min(snd_rawmidi_t *rmidi ATTRIBUTE_UNUSED, snd_rawmidi_params_t *params, size_t val)
+{
+	assert(rmidi && params);
+	assert(val < params->buffer_size);
+	params->avail_min = val;
+	return 0;
+}
+
+size_t snd_rawmidi_params_get_avail_min(const snd_rawmidi_params_t *params)
+{
+	assert(params);
+	return params->avail_min;
+}
+
+
+int snd_rawmidi_params_set_no_active_sensing(snd_rawmidi_t *rmidi ATTRIBUTE_UNUSED, snd_rawmidi_params_t *params, int val)
+{
+	assert(rmidi && params);
+	params->no_active_sensing = val;
+	return 0;
+}
+
+int snd_rawmidi_params_get_no_active_sensing(const snd_rawmidi_params_t *params)
+{
+	assert(params);
+	return params->no_active_sensing;
+}
+
+
+size_t snd_rawmidi_info_sizeof()
+{
+	return sizeof(snd_rawmidi_info_t);
+}
+
+int snd_rawmidi_info_malloc(snd_rawmidi_info_t **ptr)
+{
+	assert(ptr);
+	*ptr = malloc(sizeof(snd_rawmidi_info_t));
+	if (!*ptr)
+		return -ENOMEM;
+	return 0;
+}
+
+void snd_rawmidi_info_free(snd_rawmidi_info_t *obj)
+{
+	free(obj);
+}
+
+void snd_rawmidi_info_copy(snd_rawmidi_info_t *dst, const snd_rawmidi_info_t *src)
+{
+	assert(dst && src);
+	*dst = *src;
+}
+
+unsigned int snd_rawmidi_info_get_device(const snd_rawmidi_info_t *obj)
+{
+	assert(obj);
+	return obj->device;
+}
+
+unsigned int snd_rawmidi_info_get_subdevice(const snd_rawmidi_info_t *obj)
+{
+	assert(obj);
+	return obj->subdevice;
+}
+
+snd_rawmidi_stream_t snd_rawmidi_info_get_stream(const snd_rawmidi_info_t *obj)
+{
+	assert(obj);
+	return snd_int_to_enum(obj->stream);
+}
+
+int snd_rawmidi_info_get_card(const snd_rawmidi_info_t *obj)
+{
+	assert(obj);
+	return obj->card;
+}
+
+unsigned int snd_rawmidi_info_get_flags(const snd_rawmidi_info_t *obj)
+{
+	assert(obj);
+	return obj->flags;
+}
+
+const char * snd_rawmidi_info_get_id(const snd_rawmidi_info_t *obj)
+{
+	assert(obj);
+	return obj->id;
+}
+
+const char * snd_rawmidi_info_get_name(const snd_rawmidi_info_t *obj)
+{
+	assert(obj);
+	return obj->name;
+}
+
+const char * snd_rawmidi_info_get_subdevice_name(const snd_rawmidi_info_t *obj)
+{
+	assert(obj);
+	return obj->subname;
+}
+
+unsigned int snd_rawmidi_info_get_subdevices_count(const snd_rawmidi_info_t *obj)
+{
+	assert(obj);
+	return obj->subdevices_count;
+}
+
+unsigned int snd_rawmidi_info_get_subdevices_avail(const snd_rawmidi_info_t *obj)
+{
+	assert(obj);
+	return obj->subdevices_avail;
+}
+
+void snd_rawmidi_info_set_device(snd_rawmidi_info_t *obj, unsigned int val)
+{
+	assert(obj);
+	obj->device = val;
+}
+
+void snd_rawmidi_info_set_subdevice(snd_rawmidi_info_t *obj, unsigned int val)
+{
+	assert(obj);
+	obj->subdevice = val;
+}
+
+void snd_rawmidi_info_set_stream(snd_rawmidi_info_t *obj, snd_rawmidi_stream_t val)
+{
+	assert(obj);
+	obj->stream = snd_enum_to_int(val);
+}
+
+size_t snd_rawmidi_status_sizeof()
+{
+	return sizeof(snd_rawmidi_status_t);
+}
+
+int snd_rawmidi_status_malloc(snd_rawmidi_status_t **ptr)
+{
+	assert(ptr);
+	*ptr = malloc(sizeof(snd_rawmidi_status_t));
+	if (!*ptr)
+		return -ENOMEM;
+	return 0;
+}
+
+void snd_rawmidi_status_free(snd_rawmidi_status_t *obj)
+{
+	free(obj);
+}
+
+void snd_rawmidi_status_copy(snd_rawmidi_status_t *dst, const snd_rawmidi_status_t *src)
+{
+	assert(dst && src);
+	*dst = *src;
+}
+
+void snd_rawmidi_status_get_tstamp(const snd_rawmidi_status_t *obj, snd_timestamp_t *ptr)
+{
+	assert(obj && ptr);
+	*ptr = obj->tstamp;
+}
+
+size_t snd_rawmidi_status_get_avail(const snd_rawmidi_status_t *obj)
+{
+	assert(obj);
+	return obj->avail;
+}
+
+size_t snd_rawmidi_status_get_avail_max(const snd_rawmidi_status_t *obj)
+{
+	assert(obj);
+	return obj->xruns;
+}
+