From: Jaroslav Kysela Date: Tue, 20 Mar 2001 16:46:45 +0000 (+0000) Subject: Merged rawmidi M4 files into the main ones. X-Git-Tag: v1.0.3~917 X-Git-Url: https://git.alsa-project.org/?a=commitdiff_plain;h=e8a01ea4ed5b86b776bab7334a49adc4b4010d62;p=alsa-lib.git Merged rawmidi M4 files into the main ones. The first attempt to create documentation for the RawMidi API. --- diff --git a/doc/doxygen.cfg b/doc/doxygen.cfg index 95920377..5f9e93e6 100644 --- a/doc/doxygen.cfg +++ b/doc/doxygen.cfg @@ -2,12 +2,32 @@ PROJECT_NAME = "ALSA project - the C library reference" OUTPUT_DIRECTORY = doxygen GENERATE_LATEX = NO GENERATE_MAN = NO +GENERATE_RTF = NO + +CASE_SENSE_NAMES = NO INPUT = ../../alsa-driver/include/asound.h ../include/asoundlib.h ../src +EXCLUDE = ../src/control/control_local.h \ + ../src/pcm/atomic.h \ + ../src/pcm/interval.h \ + ../src/pcm/interval_inline.h \ + ../src/pcm/mask.h \ + ../src/pcm/mask_inline.h \ + ../src/pcm/pcm_local.h \ + ../src/pcm/pcm_meter.h \ + ../src/pcm/pcm_plugin.h \ + ../src/pcm/plugin_ops.h \ + ../src/mixer/mixer_local.h \ + ../src/rawmidi/rawmidi_local.h \ + ../src/seq/seq_local.h +RECURSIVE = YES FILE_PATTERNS = *.c *.h #EXAMPLE_PATH = example_test.cpp -QUIET = NO +QUIET = YES -EXTRACT_ALL = YES -EXTRACT_STATIC = YES -RECURSIVE = YES -PREDEFINED = DOC_PUBLIC +EXTRACT_ALL = NO +EXTRACT_STATIC = NO +JAVADOC_AUTOBRIEF = NO +INHERIT_DOCS = YES +ENABLED_SECTIONS = "static" + +OPTIMIZE_OUTPUT_FOR_C = YES # doxygen 1.2.6 option diff --git a/include/Makefile.am b/include/Makefile.am index 7a5ca8cc..6d8c362d 100644 --- a/include/Makefile.am +++ b/include/Makefile.am @@ -4,7 +4,7 @@ sysinclude_HEADERS = asoundlib.h # This is the order they will be concatenated into asoundlib.h! # header_files=header.h version.h global.h input.h output.h error.h \ - pcm.h pcm_m4.h rawmidi.h rawmidi_m4.h timer.h \ + pcm.h pcm_m4.h rawmidi.h timer.h \ hwdep.h hwdep_m4.h control.h control_m4.h \ mixer.h mixer_m4.h \ seq.h seqmid.h seq_midi_event.h \ diff --git a/include/header.h b/include/header.h index 6bcca906..044c6ddb 100644 --- a/include/header.h +++ b/include/header.h @@ -1,7 +1,11 @@ -/* - * Application interface library for the ALSA driver - * Copyright (c) by Jaroslav Kysela - * Abramo Bagnara +/** + * \file asoundlib.h + * \author Jaroslav Kysela + * \author Abramo Bagnara + * \author Takashi Iwai + * \date 1998-2001 + * + * Application interface library for the ALSA driver * * * This library is free software; you can redistribute it and/or modify diff --git a/include/rawmidi.h b/include/rawmidi.h index 535d3b08..d7296e7d 100644 --- a/include/rawmidi.h +++ b/include/rawmidi.h @@ -50,8 +50,46 @@ int snd_rawmidi_close(snd_rawmidi_t *rmidi); int snd_rawmidi_poll_descriptors_count(snd_rawmidi_t *rmidi); int snd_rawmidi_poll_descriptors(snd_rawmidi_t *rmidi, struct pollfd *pfds, unsigned int space); int snd_rawmidi_nonblock(snd_rawmidi_t *rmidi, int nonblock); +size_t snd_rawmidi_info_sizeof(); +#define snd_rawmidi_info_alloca(ptr) do { assert(ptr); *ptr = (snd_rawmidi_info_t *) alloca(snd_rawmidi_info_sizeof()); memset(*ptr, 0, snd_rawmidi_info_sizeof()); } while (0) +int snd_rawmidi_info_malloc(snd_rawmidi_info_t **ptr); +void snd_rawmidi_info_free(snd_rawmidi_info_t *obj); +void snd_rawmidi_info_copy(snd_rawmidi_info_t *dst, const snd_rawmidi_info_t *src); +unsigned int snd_rawmidi_info_get_device(const snd_rawmidi_info_t *obj); +unsigned int snd_rawmidi_info_get_subdevice(const snd_rawmidi_info_t *obj); +snd_rawmidi_stream_t snd_rawmidi_info_get_stream(const snd_rawmidi_info_t *obj); +int snd_rawmidi_info_get_card(const snd_rawmidi_info_t *obj); +unsigned int snd_rawmidi_info_get_flags(const snd_rawmidi_info_t *obj); +const char *snd_rawmidi_info_get_id(const snd_rawmidi_info_t *obj); +const char *snd_rawmidi_info_get_name(const snd_rawmidi_info_t *obj); +const char *snd_rawmidi_info_get_subdevice_name(const snd_rawmidi_info_t *obj); +unsigned int snd_rawmidi_info_get_subdevices_count(const snd_rawmidi_info_t *obj); +unsigned int snd_rawmidi_info_get_subdevices_avail(const snd_rawmidi_info_t *obj); +void snd_rawmidi_info_set_device(snd_rawmidi_info_t *obj, unsigned int val); +void snd_rawmidi_info_set_subdevice(snd_rawmidi_info_t *obj, unsigned int val); +void snd_rawmidi_info_set_stream(snd_rawmidi_info_t *obj, snd_rawmidi_stream_t val); int snd_rawmidi_info(snd_rawmidi_t *rmidi, snd_rawmidi_info_t * info); +size_t snd_rawmidi_params_sizeof(); +#define snd_rawmidi_params_alloca(ptr) do { assert(ptr); *ptr = (snd_rawmidi_params_t *) alloca(snd_rawmidi_params_sizeof()); memset(*ptr, 0, snd_rawmidi_params_sizeof()); } while (0) +int snd_rawmidi_params_malloc(snd_rawmidi_params_t **ptr); +void snd_rawmidi_params_free(snd_rawmidi_params_t *obj); +void snd_rawmidi_params_copy(snd_rawmidi_params_t *dst, const snd_rawmidi_params_t *src); +int snd_rawmidi_params_set_buffer_size(snd_rawmidi_t *rmidi, snd_rawmidi_params_t *params, size_t val); +size_t snd_rawmidi_params_get_buffer_size(const snd_rawmidi_params_t *params); +int snd_rawmidi_params_set_avail_min(snd_rawmidi_t *rmidi, snd_rawmidi_params_t *params, size_t val); +size_t snd_rawmidi_params_get_avail_min(const snd_rawmidi_params_t *params); +int snd_rawmidi_params_set_no_active_sensing(snd_rawmidi_t *rmidi, snd_rawmidi_params_t *params, int val); +int snd_rawmidi_params_get_no_active_sensing(const snd_rawmidi_params_t *params); int snd_rawmidi_params(snd_rawmidi_t *rmidi, snd_rawmidi_params_t * params); +int snd_rawmidi_params_current(snd_rawmidi_t *rmidi, snd_rawmidi_params_t *params); +size_t snd_rawmidi_status_sizeof(); +#define snd_rawmidi_status_alloca(ptr) do { assert(ptr); *ptr = (snd_rawmidi_status_t *) alloca(snd_rawmidi_status_sizeof()); memset(*ptr, 0, snd_rawmidi_status_sizeof()); } while (0) +int snd_rawmidi_status_malloc(snd_rawmidi_status_t **ptr); +void snd_rawmidi_status_free(snd_rawmidi_status_t *obj); +void snd_rawmidi_status_copy(snd_rawmidi_status_t *dst, const snd_rawmidi_status_t *src); +void snd_rawmidi_status_get_tstamp(const snd_rawmidi_status_t *obj, snd_timestamp_t *ptr); +size_t snd_rawmidi_status_get_avail(const snd_rawmidi_status_t *obj); +size_t snd_rawmidi_status_get_avail_max(const snd_rawmidi_status_t *obj); int snd_rawmidi_status(snd_rawmidi_t *rmidi, snd_rawmidi_status_t * status); int snd_rawmidi_drain(snd_rawmidi_t *rmidi); int snd_rawmidi_drop(snd_rawmidi_t *rmidi); @@ -60,8 +98,6 @@ ssize_t snd_rawmidi_read(snd_rawmidi_t *rmidi, void *buffer, size_t size); const char *snd_rawmidi_name(snd_rawmidi_t *rmidi); snd_rawmidi_type_t snd_rawmidi_type(snd_rawmidi_t *rmidi); -int snd_rawmidi_params_current(snd_rawmidi_t *rmidi, snd_rawmidi_params_t *params); - #ifdef __cplusplus } #endif diff --git a/include/rawmidi_m4.h b/include/rawmidi_m4.h deleted file mode 100644 index 9db9fcce..00000000 --- a/include/rawmidi_m4.h +++ /dev/null @@ -1,67 +0,0 @@ -#ifdef __cplusplus -extern "C" { -#endif - -size_t snd_rawmidi_params_sizeof(); -#define snd_rawmidi_params_alloca(ptr) do { assert(ptr); *ptr = (snd_rawmidi_params_t *) alloca(snd_rawmidi_params_sizeof()); memset(*ptr, 0, snd_rawmidi_params_sizeof()); } while (0) -int snd_rawmidi_params_malloc(snd_rawmidi_params_t **ptr); -void snd_rawmidi_params_free(snd_rawmidi_params_t *obj); -void snd_rawmidi_params_copy(snd_rawmidi_params_t *dst, const snd_rawmidi_params_t *src); - -int snd_rawmidi_params_set_buffer_size(snd_rawmidi_t *rmidi, snd_rawmidi_params_t *params, size_t val); -size_t snd_rawmidi_params_get_buffer_size(const snd_rawmidi_params_t *params); - -int snd_rawmidi_params_set_avail_min(snd_rawmidi_t *rmidi, snd_rawmidi_params_t *params, size_t val); -size_t snd_rawmidi_params_get_avail_min(const snd_rawmidi_params_t *params); - -int snd_rawmidi_params_set_no_active_sensing(snd_rawmidi_t *rmidi, snd_rawmidi_params_t *params, int val); -int snd_rawmidi_params_get_no_active_sensing(const snd_rawmidi_params_t *params); - -size_t snd_rawmidi_info_sizeof(); -#define snd_rawmidi_info_alloca(ptr) do { assert(ptr); *ptr = (snd_rawmidi_info_t *) alloca(snd_rawmidi_info_sizeof()); memset(*ptr, 0, snd_rawmidi_info_sizeof()); } while (0) -int snd_rawmidi_info_malloc(snd_rawmidi_info_t **ptr); -void snd_rawmidi_info_free(snd_rawmidi_info_t *obj); -void snd_rawmidi_info_copy(snd_rawmidi_info_t *dst, const snd_rawmidi_info_t *src); - -unsigned int snd_rawmidi_info_get_device(const snd_rawmidi_info_t *obj); - -unsigned int snd_rawmidi_info_get_subdevice(const snd_rawmidi_info_t *obj); - -snd_rawmidi_stream_t snd_rawmidi_info_get_stream(const snd_rawmidi_info_t *obj); - -int snd_rawmidi_info_get_card(const snd_rawmidi_info_t *obj); - -unsigned int snd_rawmidi_info_get_flags(const snd_rawmidi_info_t *obj); - -const char *snd_rawmidi_info_get_id(const snd_rawmidi_info_t *obj); - -const char *snd_rawmidi_info_get_name(const snd_rawmidi_info_t *obj); - -const char *snd_rawmidi_info_get_subdevice_name(const snd_rawmidi_info_t *obj); - -unsigned int snd_rawmidi_info_get_subdevices_count(const snd_rawmidi_info_t *obj); - -unsigned int snd_rawmidi_info_get_subdevices_avail(const snd_rawmidi_info_t *obj); - -void snd_rawmidi_info_set_device(snd_rawmidi_info_t *obj, unsigned int val); - -void snd_rawmidi_info_set_subdevice(snd_rawmidi_info_t *obj, unsigned int val); - -void snd_rawmidi_info_set_stream(snd_rawmidi_info_t *obj, snd_rawmidi_stream_t val); - -size_t snd_rawmidi_status_sizeof(); -#define snd_rawmidi_status_alloca(ptr) do { assert(ptr); *ptr = (snd_rawmidi_status_t *) alloca(snd_rawmidi_status_sizeof()); memset(*ptr, 0, snd_rawmidi_status_sizeof()); } while (0) -int snd_rawmidi_status_malloc(snd_rawmidi_status_t **ptr); -void snd_rawmidi_status_free(snd_rawmidi_status_t *obj); -void snd_rawmidi_status_copy(snd_rawmidi_status_t *dst, const snd_rawmidi_status_t *src); - -void snd_rawmidi_status_get_tstamp(const snd_rawmidi_status_t *obj, snd_timestamp_t *ptr); - -size_t snd_rawmidi_status_get_avail(const snd_rawmidi_status_t *obj); - -size_t snd_rawmidi_status_get_avail_max(const snd_rawmidi_status_t *obj); - - -#ifdef __cplusplus -} -#endif diff --git a/src/error.c b/src/error.c index 8e87cdff..4b547139 100644 --- a/src/error.c +++ b/src/error.c @@ -1,4 +1,4 @@ -/*! +/** * \file error.c * Error code handling routines. */ @@ -30,13 +30,17 @@ #include #include "local.h" +/** + * \if static + * Array of error codes in US ASCII. + * \endif + */ static const char *snd_error_codes[] = { "Sound protocol is not compatible" }; -/*! - * \fn const char * snd_strerror(int errnum) +/** * \brief Get the error string. * \param errnum The error code number. * @@ -54,9 +58,8 @@ const char *snd_strerror(int errnum) return snd_error_codes[errnum]; } -#ifndef DOC_PUBLIC -/*! - * \fn static void snd_lib_error_default(const char *file, int line, const char *function, int err, const char *fmt, ...) +/** + * \if static * \brief The default error handler function. * \param file The filename where the error was hit. * \param line The line number. @@ -66,6 +69,7 @@ const char *snd_strerror(int errnum) * \param ... Optional arguments. * * Prints the error message including location to stderr. + * \endif */ static void snd_lib_error_default(const char *file, int line, const char *function, int err, const char *fmt, ...) { @@ -78,18 +82,13 @@ static void snd_lib_error_default(const char *file, int line, const char *functi putc('\n', stderr); va_end(arg); } -#endif /* !DOC_PUBLIC */ -#ifndef DOC_PUBLIC -/*! - * \var snd_lib_error_handler_t *snd_lib_error; +/** * Pointer to the error handler function. */ snd_lib_error_handler_t *snd_lib_error = snd_lib_error_default; -#endif /* !DOC_PUBLIC */ -/*! - * \fn int snd_lib_error_set_handler(snd_lib_error_handler_t *handler) +/** * \brief Set the error handler. * \param handler The pointer to the new error handler function. * diff --git a/src/rawmidi/Makefile.am b/src/rawmidi/Makefile.am index 32b5051e..7b374de4 100644 --- a/src/rawmidi/Makefile.am +++ b/src/rawmidi/Makefile.am @@ -1,6 +1,6 @@ EXTRA_LTLIBRARIES=librawmidi.la -librawmidi_la_SOURCES = rawmidi.c rawmidi_m4.c rawmidi_hw.c +librawmidi_la_SOURCES = rawmidi.c rawmidi_hw.c noinst_HEADERS = rawmidi_local.h all: librawmidi.la diff --git a/src/rawmidi/rawmidi.c b/src/rawmidi/rawmidi.c index 698fdc5c..02242c97 100644 --- a/src/rawmidi/rawmidi.c +++ b/src/rawmidi/rawmidi.c @@ -1,7 +1,24 @@ +/** + * \file rawmidi/rawmidi.c + * \author Jaroslav Kysela + * \author Abramo Bagnara + * \date 2000-2001 + * + * RawMidi Interface is designed to write or read raw (unchanged) MIDI + * data over the MIDI line. MIDI stands Musical Instrument Digital Interface + * and more information about this standard can be found at + * http://www.midi.org. + * + * RawMidi devices are opened exclusively for a selected direction. + * While more than one process may not open a given MIDI device in the same + * direction simultaneously, seperate processes may open a single MIDI device + * in different directions (i.e. process one opens a MIDI device in write + * direction and process two opens the same device in read direction). MIDI + * devices return EBUSY error to applications when other applications have + * already opened the requested direction (nonblock behaviour) or wait + * until the device is not available (block behaviour). + */ /* - * RawMIDI Interface - main file - * Copyright (c) 2000 by Jaroslav Kysela - * Abramo Bagnara * * This library is free software; you can redistribute it and/or modify * it under the terms of the GNU Library General Public License as @@ -27,144 +44,17 @@ #include #include "rawmidi_local.h" -const char *snd_rawmidi_name(snd_rawmidi_t *rawmidi) -{ - assert(rawmidi); - return rawmidi->name; -} - -snd_rawmidi_type_t snd_rawmidi_type(snd_rawmidi_t *rawmidi) -{ - assert(rawmidi); - return rawmidi->type; -} - -int snd_rawmidi_close(snd_rawmidi_t *rmidi) -{ - int err; - assert(rmidi); - if ((err = rmidi->ops->close(rmidi)) < 0) - return err; - if (rmidi->name) - free(rmidi->name); - free(rmidi); - return 0; -} - -int _snd_rawmidi_poll_descriptor(snd_rawmidi_t *rmidi) -{ - assert(rmidi); - return rmidi->poll_fd; -} - -int snd_rawmidi_poll_descriptors_count(snd_rawmidi_t *rmidi) -{ - assert(rmidi); - return 1; -} - -int snd_rawmidi_poll_descriptors(snd_rawmidi_t *rmidi, struct pollfd *pfds, unsigned int space) -{ - assert(rmidi); - if (space >= 1) { - pfds->fd = rmidi->poll_fd; - pfds->events = rmidi->stream == SND_RAWMIDI_STREAM_OUTPUT ? POLLOUT : POLLIN; - return 1; - } - return 0; -} - - -int snd_rawmidi_nonblock(snd_rawmidi_t *rmidi, int nonblock) -{ - int err; - assert(rmidi); - assert(!(rmidi->mode & SND_RAWMIDI_APPEND)); - if ((err = rmidi->ops->nonblock(rmidi, nonblock)) < 0) - return err; - if (nonblock) - rmidi->mode |= SND_RAWMIDI_NONBLOCK; - else - rmidi->mode &= ~SND_RAWMIDI_NONBLOCK; - return 0; -} - -int snd_rawmidi_info(snd_rawmidi_t *rmidi, snd_rawmidi_info_t * info) -{ - assert(rmidi); - assert(info); - return rmidi->ops->info(rmidi, info); -} - -int snd_rawmidi_params(snd_rawmidi_t *rmidi, snd_rawmidi_params_t * params) -{ - int err; - assert(rmidi); - assert(params); - err = rmidi->ops->params(rmidi, params); - if (err < 0) - return err; - rmidi->buffer_size = params->buffer_size; - rmidi->avail_min = params->avail_min; - rmidi->no_active_sensing = params->no_active_sensing; - return 0; -} - -int snd_rawmidi_status(snd_rawmidi_t *rmidi, snd_rawmidi_status_t * status) -{ - assert(rmidi); - assert(status); - return rmidi->ops->status(rmidi, status); -} - -int snd_rawmidi_drop(snd_rawmidi_t *rmidi) -{ - assert(rmidi); - return rmidi->ops->drop(rmidi); -} - -int snd_rawmidi_drain(snd_rawmidi_t *rmidi) -{ - assert(rmidi); - return rmidi->ops->drain(rmidi); -} - -ssize_t snd_rawmidi_write(snd_rawmidi_t *rmidi, const void *buffer, size_t size) -{ - assert(rmidi); - assert(rmidi->stream == 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); - assert(rmidi->stream == SND_RAWMIDI_STREAM_INPUT); - assert(buffer || size == 0); - return rmidi->ops->read(rmidi, buffer, size); -} - -int snd_rawmidi_params_current(snd_rawmidi_t *rmidi, snd_rawmidi_params_t *params) -{ - assert(rmidi); - assert(params); - params->buffer_size = rmidi->buffer_size; - params->avail_min = rmidi->avail_min; - params->no_active_sensing = rmidi->no_active_sensing; - return 0; -} - -int snd_rawmidi_params_default(snd_rawmidi_t *rmidi, snd_rawmidi_params_t *params) -{ - assert(rmidi); - assert(params); - params->buffer_size = page_size(); - params->avail_min = 1; - params->no_active_sensing = 0; - return 0; -} - +/** + * \brief Opens a new connection to the RawMidi interface. + * \param inputp Returned input handle + * \param outputp Returned output handle + * \param name ASCII identifier of the RawMidi stream + * \param mode Open mode + * \return a negative error code on failure or zero on success + * + * Opens a new connection to the RawMidi interface specified with + * an ASCII identifier and mode. + */ int snd_rawmidi_open(snd_rawmidi_t **inputp, snd_rawmidi_t **outputp, const char *name, int mode) { @@ -270,3 +160,631 @@ int snd_rawmidi_open(snd_rawmidi_t **inputp, snd_rawmidi_t **outputp, return 0; } +/** + * \brief close rawmidi handle + * \param rmidi rawmidi handle + * \return zero if success otherwise a negative error code + * + * Closes the specified rawmidi handle and frees all associated + * resources. + */ +int snd_rawmidi_close(snd_rawmidi_t *rmidi) +{ + int err; + assert(rmidi); + if ((err = rmidi->ops->close(rmidi)) < 0) + return err; + if (rmidi->name) + free(rmidi->name); + free(rmidi); + return 0; +} + +/** + * \brief get identifier of rawmidi handle + * \param rawmidi a rawmidi handle + * \return ascii identifier of rawmidi handle + * + * Returns the ASCII identifier of given rawmidi handle. It's the same + * identifier as for snd_rawmidi_open(). + */ +const char *snd_rawmidi_name(snd_rawmidi_t *rawmidi) +{ + assert(rawmidi); + return rawmidi->name; +} + +/** + * \brief get type of rawmidi handle + * \param rawmidi a rawmidi handle + * \return type of rawmidi handle + * + * Returns the type #snd_rawmidi_type_t of given rawmidi handle. + */ +snd_rawmidi_type_t snd_rawmidi_type(snd_rawmidi_t *rawmidi) +{ + assert(rawmidi); + return rawmidi->type; +} + +/** + * \brief get count of poll descriptors for rawmidi handle + * \param rmidi rawmidi handle + * \return count of poll descriptors + */ +int snd_rawmidi_poll_descriptors_count(snd_rawmidi_t *rmidi) +{ + assert(rmidi); + return 1; +} + +/** + * \brief get poll descriptors + * \param rmidi rawmidi handle + * \param pfds array of poll descriptors + * \param space space in the poll descriptor array + * \return count of filled descriptors + */ +int snd_rawmidi_poll_descriptors(snd_rawmidi_t *rmidi, struct pollfd *pfds, unsigned int space) +{ + assert(rmidi); + if (space >= 1) { + pfds->fd = rmidi->poll_fd; + pfds->events = rmidi->stream == SND_RAWMIDI_STREAM_OUTPUT ? POLLOUT : POLLIN; + return 1; + } + return 0; +} + +/** + * \brief set nonblock mode + * \param rmidi rawmidi handle + * \param nonblock 0 = block, 1 = nonblock mode + * \return zero if success otherwise a negative error code + */ +int snd_rawmidi_nonblock(snd_rawmidi_t *rmidi, int nonblock) +{ + int err; + assert(rmidi); + assert(!(rmidi->mode & SND_RAWMIDI_APPEND)); + if ((err = rmidi->ops->nonblock(rmidi, nonblock)) < 0) + return err; + if (nonblock) + rmidi->mode |= SND_RAWMIDI_NONBLOCK; + else + rmidi->mode &= ~SND_RAWMIDI_NONBLOCK; + return 0; +} + +/** + * \brief get size of the snd_rawmidi_info_t structure in bytes + * \return size of the snd_rawmidi_info_t structure in bytes + */ +size_t snd_rawmidi_info_sizeof() +{ + return sizeof(snd_rawmidi_info_t); +} + +/** + * \brief allocate a new snd_rawmidi_info_t structure + * \param ptr returned pointer + * \return zero if success or a negative error code if fails + * + * Allocates a new snd_rawmidi_params_t structure using the standard + * malloc C library function. + */ +int snd_rawmidi_info_malloc(snd_rawmidi_info_t **info) +{ + assert(info); + *info = calloc(1, sizeof(snd_rawmidi_info_t)); + if (!*info) + return -ENOMEM; + return 0; +} + +/** + * \brief frees the snd_rawmidi_info_t structure + * \param params pointer to the snd_rawmidi_info_t structure to free + * + * Frees the given snd_rawmidi_params_t structure using the standard + * free C library function. + */ +void snd_rawmidi_info_free(snd_rawmidi_info_t *info) +{ + assert(info); + free(info); +} + +/** + * \brief copy one snd_rawmidi_info_t structure to another + * \param dst destination snd_rawmidi_info_t structure + * \param src source snd_rawmidi_info_t structure + */ +void snd_rawmidi_info_copy(snd_rawmidi_info_t *dst, const snd_rawmidi_info_t *src) +{ + assert(dst && src); + *dst = *src; +} + +/** + * \brief get rawmidi device number + * \param info pointer to a snd_rawmidi_info_t structure + * \return rawmidi device number + */ +unsigned int snd_rawmidi_info_get_device(const snd_rawmidi_info_t *info) +{ + assert(info); + return info->device; +} + +/** + * \brief get rawmidi subdevice number + * \param info pointer to a snd_rawmidi_info_t structure + * \return rawmidi subdevice number + */ +unsigned int snd_rawmidi_info_get_subdevice(const snd_rawmidi_info_t *info) +{ + assert(info); + return info->subdevice; +} + +/** + * \brief get rawmidi stream identification + * \param info pointer to a snd_rawmidi_info_t structure + * \return rawmidi stream identification + */ +snd_rawmidi_stream_t snd_rawmidi_info_get_stream(const snd_rawmidi_info_t *info) +{ + assert(info); + return snd_int_to_enum(info->stream); +} + +/** + * \brief get rawmidi card number + * \param info pointer to a snd_rawmidi_info_t structure + * \return rawmidi card number + */ +int snd_rawmidi_info_get_card(const snd_rawmidi_info_t *info) +{ + assert(info); + return info->card; +} + +/** + * \brief get rawmidi flags + * \param info pointer to a snd_rawmidi_info_t structure + * \return rawmidi flags + */ +unsigned int snd_rawmidi_info_get_flags(const snd_rawmidi_info_t *info) +{ + assert(info); + return info->flags; +} + +/** + * \brief get rawmidi hardware driver identifier + * \param info pointer to a snd_rawmidi_info_t structure + * \return rawmidi hardware driver identifier + */ +const char *snd_rawmidi_info_get_id(const snd_rawmidi_info_t *info) +{ + assert(info); + return info->id; +} + +/** + * \brief get rawmidi hardware driver name + * \param info pointer to a snd_rawmidi_info_t structure + * \return rawmidi hardware driver name + */ +const char *snd_rawmidi_info_get_name(const snd_rawmidi_info_t *info) +{ + assert(info); + return info->name; +} + +/** + * \brief get rawmidi subdevice name + * \param info pointer to a snd_rawmidi_info_t structure + * \return rawmidi subdevice name + */ +const char *snd_rawmidi_info_get_subdevice_name(const snd_rawmidi_info_t *info) +{ + assert(info); + return info->subname; +} + +/** + * \brief get rawmidi count of subdevices + * \param info pointer to a snd_rawmidi_info_t structure + * \return rawmidi count of subdevices + */ +unsigned int snd_rawmidi_info_get_subdevices_count(const snd_rawmidi_info_t *info) +{ + assert(info); + return info->subdevices_count; +} + +/** + * \brief get rawmidi available count of subdevices + * \param info pointer to a snd_rawmidi_info_t structure + * \return rawmidi available count of subdevices + */ +unsigned int snd_rawmidi_info_get_subdevices_avail(const snd_rawmidi_info_t *info) +{ + assert(info); + return info->subdevices_avail; +} + +/** + * \brief set rawmidi device number + * \param info pointer to a snd_rawmidi_info_t structure + * \param val device number + */ +void snd_rawmidi_info_set_device(snd_rawmidi_info_t *info, unsigned int val) +{ + assert(info); + info->device = val; +} + +/** + * \brief set rawmidi subdevice number + * \param info pointer to a snd_rawmidi_info_t structure + * \param val subdevice number + */ +void snd_rawmidi_info_set_subdevice(snd_rawmidi_info_t *info, unsigned int val) +{ + assert(info); + info->subdevice = val; +} + +/** + * \brief set rawmidi stream identifier + * \param info pointer to a snd_rawmidi_info_t structure + * \param val rawmidi stream identifier + */ +void snd_rawmidi_info_set_stream(snd_rawmidi_info_t *info, snd_rawmidi_stream_t val) +{ + assert(info); + info->stream = snd_enum_to_int(val); +} + +/** + * \brief get information about rawmidi handle + * \param rmidi rawmidi handle + * \param info pointer to a snd_rawmidi_info_t structure to be filled + * \return zero if success otherwise a negative error code + */ +int snd_rawmidi_info(snd_rawmidi_t *rmidi, snd_rawmidi_info_t * info) +{ + assert(rmidi); + assert(info); + return rmidi->ops->info(rmidi, info); +} + +/** + * \brief get size of the snd_rawmidi_params_t structure in bytes + * \return size of the snd_rawmidi_params_t structure in bytes + */ +size_t snd_rawmidi_params_sizeof() +{ + return sizeof(snd_rawmidi_params_t); +} + +/** + * \brief allocate the snd_rawmidi_params_t structure + * \param ptr returned pointer + * \return zero if success or a negative error code if fails + * + * Allocates a new snd_rawmidi_params_t structure using the standard + * malloc C library function. + */ +int snd_rawmidi_params_malloc(snd_rawmidi_params_t **params) +{ + assert(params); + *params = calloc(1, sizeof(snd_rawmidi_params_t)); + if (!*params) + return -ENOMEM; + return 0; +} + +/** + * \brief frees the snd_rawmidi_params_t structure + * \param params pointer to the #snd_rawmidi_params_t structure to free + * + * Frees the given snd_rawmidi_params_t structure using the standard + * free C library function. + */ +void snd_rawmidi_params_free(snd_rawmidi_params_t *params) +{ + assert(params); + free(params); +} + +/** + * \brief copy one snd_rawmidi_params_t structure to another + * \param dst destination snd_rawmidi_params_t structure + * \param src source snd_rawmidi_params_t structure + */ +void snd_rawmidi_params_copy(snd_rawmidi_params_t *dst, const snd_rawmidi_params_t *src) +{ + assert(dst && src); + *dst = *src; +} + +/** + * \brief setup the default parameters + * \param rmidi rawmidi handle + * \param params pointer to a snd_rawmidi_params_t structure + * \return zero if success otherwise a negative error code + */ +int snd_rawmidi_params_default(snd_rawmidi_t *rmidi, snd_rawmidi_params_t *params) +{ + assert(rmidi); + assert(params); + params->buffer_size = page_size(); + params->avail_min = 1; + params->no_active_sensing = 0; + return 0; +} + +/** + * \brief set rawmidi I/O ring buffer size + * \param rmidi rawmidi handle + * \param params pointer to a snd_rawmidi_params_t structure + * \param val size in bytes + * \return zero if success otherwise a negative error code + */ +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; +} + +/** + * \brief get rawmidi I/O ring buffer size + * \param params pointer to a snd_rawmidi_params_t structure + * \return size of rawmidi I/O ring buffer in bytes + */ +size_t snd_rawmidi_params_get_buffer_size(const snd_rawmidi_params_t *params) +{ + assert(params); + return params->buffer_size; +} + +/** + * \brief set minimum available bytes in rawmidi I/O ring buffer for wakeup + * \param rmidi rawmidi handle + * \param params pointer to a snd_rawmidi_params_t structure + * \param val desired value + */ +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; +} + +/** + * \brief get minimum available bytes in rawmidi I/O ring buffer for wakeup + * \param params pointer to snd_rawmidi_params_t structure + * \return minimum available bytes + */ +size_t snd_rawmidi_params_get_avail_min(const snd_rawmidi_params_t *params) +{ + assert(params); + return params->avail_min; +} + +/** + * \brief set no-active-sensing action on snd_rawmidi_close() + * \param rmidi rawmidi handle + * \param params pointer to snd_rawmidi_params_t structure + * \param val value: 0 = enable to send the active sensing message, 1 = disable + * \return zero if success otherwise a negative error code + */ +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; +} + +/** + * \brief get no-active-sensing action status + * \param params pointer to snd_rawmidi_params_t structure + * \return the current status (0 = enable, 1 = disable the active sensing message) + */ +int snd_rawmidi_params_get_no_active_sensing(const snd_rawmidi_params_t *params) +{ + assert(params); + return params->no_active_sensing; +} + +/** + * \brief get parameters about rawmidi stream + * \param rmidi rawmidi handle + * \param params pointer to a snd_rawmidi_params_t structure to be filled + * \return zero if success otherwise a negative error code + */ +int snd_rawmidi_params(snd_rawmidi_t *rmidi, snd_rawmidi_params_t * params) +{ + int err; + assert(rmidi); + assert(params); + err = rmidi->ops->params(rmidi, params); + if (err < 0) + return err; + rmidi->buffer_size = params->buffer_size; + rmidi->avail_min = params->avail_min; + rmidi->no_active_sensing = params->no_active_sensing; + return 0; +} + +/** + * \brief get current parameters about rawmidi stream + * \param rmidi rawmidi handle + * \param params pointer to a snd_rawmidi_params_t structure to be filled + * \return zero if success otherwise a negative error code + */ +int snd_rawmidi_params_current(snd_rawmidi_t *rmidi, snd_rawmidi_params_t *params) +{ + assert(rmidi); + assert(params); + params->buffer_size = rmidi->buffer_size; + params->avail_min = rmidi->avail_min; + params->no_active_sensing = rmidi->no_active_sensing; + return 0; +} + +/** + * \brief get size of the snd_rawmidi_status_t structure in bytes + * \return size of the snd_rawmidi_status_t structure in bytes + */ +size_t snd_rawmidi_status_sizeof() +{ + return sizeof(snd_rawmidi_status_t); +} + +/** + * \brief allocate the snd_rawmidi_status_t structure + * \param ptr returned pointer + * \return zero if success or a negative error code if fails + * + * Allocates a new snd_rawmidi_status_t structure using the standard + * malloc C library function. + */ +int snd_rawmidi_status_malloc(snd_rawmidi_status_t **ptr) +{ + assert(ptr); + *ptr = calloc(1, sizeof(snd_rawmidi_status_t)); + if (!*ptr) + return -ENOMEM; + return 0; +} + +/** + * \brief frees the snd_rawmidi_status_t structure + * \param status pointer to the snd_rawmidi_status_t structure to free + * + * Frees the given snd_rawmidi_status_t structure using the standard + * free C library function. + */ +void snd_rawmidi_status_free(snd_rawmidi_status_t *status) +{ + assert(status); + free(status); +} + +/** + * \brief copy one snd_rawmidi_status_t structure to another + * \param dst destination snd_rawmidi_status_t structure + * \param src source snd_rawmidi_status_t structure + */ +void snd_rawmidi_status_copy(snd_rawmidi_status_t *dst, const snd_rawmidi_status_t *src) +{ + assert(dst && src); + *dst = *src; +} + +/** + * \brief get the start timestamp + * \param status pointer to a snd_rawmidi_status_t structure + * \param tstamp returned timestamp value + */ +void snd_rawmidi_status_get_tstamp(const snd_rawmidi_status_t *status, snd_timestamp_t *tstamp) +{ + assert(status && tstamp); + *tstamp = status->tstamp; +} + +/** + * \brief get current available bytes in the rawmidi I/O ring buffer + * \param status pointer to a snd_rawmidi_status_t structure + * \return current available bytes in the rawmidi I/O ring buffer + */ +size_t snd_rawmidi_status_get_avail(const snd_rawmidi_status_t *status) +{ + assert(status); + return status->avail; +} + +/** + * \brief get count of xruns + * \param status pointer to a snd_rawmidi_status_t structure + * \return count of xruns + */ +size_t snd_rawmidi_status_get_xruns(const snd_rawmidi_status_t *status) +{ + assert(status); + return status->xruns; +} + +/** + * \brief get status of rawmidi stream + * \param rmidi rawmidi handle + * \param status pointer to a snd_rawmidi_status_t structure to be filled + * \return zero if success otherwise a negative error code + */ +int snd_rawmidi_status(snd_rawmidi_t *rmidi, snd_rawmidi_status_t * status) +{ + assert(rmidi); + assert(status); + return rmidi->ops->status(rmidi, status); +} + +/** + * \brief drop all bytes in the rawmidi I/O ring buffer immediately + * \param rmidi rawmidi handle + * \return zero if success otherwise a negative error code + */ +int snd_rawmidi_drop(snd_rawmidi_t *rmidi) +{ + assert(rmidi); + return rmidi->ops->drop(rmidi); +} + +/** + * \brief drain all bytes in the rawmidi I/O ring buffer + * \param rmidi rawmidi handle + * \return zero if success otherwise a negative error code + * + * Waits until all MIDI bytes are not drained (sent) to the + * hardware device. + */ +int snd_rawmidi_drain(snd_rawmidi_t *rmidi) +{ + assert(rmidi); + return rmidi->ops->drain(rmidi); +} + +/** + * \brief write MIDI bytes to MIDI stream + * \param rmidi rawmidi handle + * \param buffer buffer containing MIDI bytes + * \param size output buffer size in bytes + */ +ssize_t snd_rawmidi_write(snd_rawmidi_t *rmidi, const void *buffer, size_t size) +{ + assert(rmidi); + assert(rmidi->stream == SND_RAWMIDI_STREAM_OUTPUT); + assert(buffer || size == 0); + return rmidi->ops->write(rmidi, buffer, size); +} + +/** + * \brief read MIDI bytes from MIDI stream + * \param rmidi rawmidi handle + * \param buffer buffer to store the input MIDI bytes + * \param size input buffer size in bytes + */ +ssize_t snd_rawmidi_read(snd_rawmidi_t *rmidi, void *buffer, size_t size) +{ + assert(rmidi); + assert(rmidi->stream == SND_RAWMIDI_STREAM_INPUT); + assert(buffer || size == 0); + return rmidi->ops->read(rmidi, buffer, size); +} diff --git a/src/rawmidi/rawmidi_local.h b/src/rawmidi/rawmidi_local.h index 581b0110..26039a3f 100644 --- a/src/rawmidi/rawmidi_local.h +++ b/src/rawmidi/rawmidi_local.h @@ -36,8 +36,6 @@ typedef struct { ssize_t (*read)(snd_rawmidi_t *rawmidi, void *buffer, size_t size); } snd_rawmidi_ops_t; - - struct _snd_rawmidi { char *name; snd_rawmidi_type_t type; @@ -54,4 +52,3 @@ struct _snd_rawmidi { int snd_rawmidi_hw_open(snd_rawmidi_t **input, snd_rawmidi_t **output, const char *name, int card, int device, int subdevice, int mode); - diff --git a/src/rawmidi/rawmidi_m4.c b/src/rawmidi/rawmidi_m4.c deleted file mode 100644 index e88c8721..00000000 --- a/src/rawmidi/rawmidi_m4.c +++ /dev/null @@ -1,238 +0,0 @@ -/* - * Rawmidi - Automatically generated functions - * Copyright (c) 2001 by Abramo Bagnara - * - * - * 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 = calloc(1, 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 = calloc(1, 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 = calloc(1, 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; -} -