From 986b8e338782a4c8aab83e626949ed5457eb5b69 Mon Sep 17 00:00:00 2001 From: Bhalchandra Gajare Date: Wed, 4 Sep 2019 15:32:35 -0700 Subject: tinyalsa: add support for PCM plugins Update the pcm framework to support plugins. Resolve the pcm device node to be either kernel device or virtual device and setup function pointers accordingly. Implement framework functionality for pcm_plugin.c for ease of plugin development. Plugin itself is compiled as shared object (.so) and dynamically linked from pcm_plugin.c. Signed-off-by: Bhalchandra Gajare Signed-off-by: Rohit kumar --- src/Makefile | 8 +- src/pcm.c | 121 ++++++--- src/pcm_hw.c | 118 +++++++++ src/pcm_io.h | 47 ++++ src/pcm_plugin.c | 718 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/snd_card_plugin.c | 149 +++++++++++ src/snd_card_plugin.h | 74 ++++++ 7 files changed, 1195 insertions(+), 40 deletions(-) create mode 100644 src/pcm_hw.c create mode 100644 src/pcm_io.h create mode 100644 src/pcm_plugin.c create mode 100644 src/snd_card_plugin.c create mode 100644 src/snd_card_plugin.h (limited to 'src') diff --git a/src/Makefile b/src/Makefile index aa00484..b278f47 100644 --- a/src/Makefile +++ b/src/Makefile @@ -15,7 +15,7 @@ INCLUDE_DIRS = -I ../include override CFLAGS := $(WARNINGS) $(INCLUDE_DIRS) -fPIC $(CFLAGS) VPATH = ../include/tinyalsa -OBJECTS = limits.o mixer.o pcm.o +OBJECTS = limits.o mixer.o pcm.o pcm_plugin.o pcm_hw.o snd_card_plugin.o LIBVERSION_MAJOR = $(TINYALSA_VERSION_MAJOR) LIBVERSION = $(TINYALSA_VERSION) @@ -25,10 +25,16 @@ all: libtinyalsa.a libtinyalsa.so pcm.o: pcm.c pcm.h +pcm_plugin.o: pcm_plugin.c pcm_io.h + +pcm_hw.o: pcm_hw.c pcm_io.h + limits.o: limits.c limits.h mixer.o: mixer.c mixer.h +snd_card_plugin.o: snd_card_plugin.c snd_card_plugin.h + libtinyalsa.a: $(OBJECTS) $(AR) $(ARFLAGS) $@ $^ diff --git a/src/pcm.c b/src/pcm.c index a32871e..7a8defc 100644 --- a/src/pcm.c +++ b/src/pcm.c @@ -59,6 +59,8 @@ #include #include +#include "pcm_io.h" +#include "snd_card_plugin.h" #ifndef PARAM_MAX #define PARAM_MAX SNDRV_PCM_HW_PARAM_LAST_INTERVAL @@ -68,6 +70,7 @@ #define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) #endif /* SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP */ + static inline int param_is_mask(int p) { return (p >= SNDRV_PCM_HW_PARAM_FIRST_MASK) && @@ -234,6 +237,12 @@ struct pcm { long pcm_delay; /** The subdevice corresponding to the PCM */ unsigned int subdevice; + /** Pointer to the pcm ops, either hw or plugin */ + const struct pcm_ops *ops; + /** Private data for pcm_hw or pcm_plugin */ + void *data; + /** Pointer to the pcm node from snd card definition */ + struct snd_node *snd_node; }; static int oops(struct pcm *pcm, int e, const char *fmt, ...) @@ -383,7 +392,7 @@ int pcm_set_config(struct pcm *pcm, const struct pcm_config *config) param_set_mask(¶ms, SNDRV_PCM_HW_PARAM_ACCESS, SNDRV_PCM_ACCESS_RW_INTERLEAVED); - if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_HW_PARAMS, ¶ms)) { + if (pcm->ops->ioctl(pcm->data, SNDRV_PCM_IOCTL_HW_PARAMS, ¶ms)) { int errno_copy = errno; oops(pcm, -errno, "cannot set hw params"); return -errno_copy; @@ -440,7 +449,7 @@ int pcm_set_config(struct pcm *pcm, const struct pcm_config *config) while (pcm->boundary * 2 <= INT_MAX - pcm->buffer_size) pcm->boundary *= 2; - if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_SW_PARAMS, &sparams)) { + if (pcm->ops->ioctl(pcm->data, SNDRV_PCM_IOCTL_SW_PARAMS, &sparams)) { int errno_copy = errno; oops(pcm, -errno, "cannot set sw params"); return -errno_copy; @@ -519,7 +528,8 @@ static int pcm_sync_ptr(struct pcm *pcm, int flags) } } else { pcm->sync_ptr->flags = flags; - if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_SYNC_PTR, pcm->sync_ptr) < 0) { + if (pcm->ops->ioctl(pcm->data, SNDRV_PCM_IOCTL_SYNC_PTR, + pcm->sync_ptr) < 0) { oops(pcm, errno, "failed to sync mmap ptr"); return -1; } @@ -599,19 +609,30 @@ struct pcm_params *pcm_params_get(unsigned int card, unsigned int device, unsigned int flags) { struct snd_pcm_hw_params *params; - char fn[256]; + void *snd_node = NULL, *data; + const struct pcm_ops *ops; int fd; - snprintf(fn, sizeof(fn), "/dev/snd/pcmC%uD%u%c", card, device, - flags & PCM_IN ? 'c' : 'p'); - - if (flags & PCM_NONBLOCK) - fd = open(fn, O_RDWR | O_NONBLOCK); - else - fd = open(fn, O_RDWR); + ops = &hw_ops; + fd = ops->open(card, device, flags, &data, snd_node); +#ifdef TINYALSA_USES_PLUGINS + if (fd < 0) { + int pcm_type; + snd_node = snd_utils_open_pcm(card, device); + pcm_type = snd_utils_get_node_type(snd_node); + if (!snd_node || pcm_type != SND_NODE_TYPE_PLUGIN) { + fprintf(stderr, "no device (hw/plugin) for card(%u), device(%u)", + card, device); + goto err_open; + } + ops = &plug_ops; + fd = ops->open(card, device, flags, &data, snd_node); + } +#endif if (fd < 0) { - fprintf(stderr, "cannot open device '%s': %s\n", fn, strerror(errno)); + fprintf(stderr, "cannot open card(%d) device (%d): %s\n", + card, device, strerror(errno)); goto err_open; } @@ -620,19 +641,27 @@ struct pcm_params *pcm_params_get(unsigned int card, unsigned int device, goto err_calloc; param_init(params); - if (ioctl(fd, SNDRV_PCM_IOCTL_HW_REFINE, params)) { + if (ops->ioctl(data, SNDRV_PCM_IOCTL_HW_REFINE, params)) { fprintf(stderr, "SNDRV_PCM_IOCTL_HW_REFINE error (%d)\n", errno); goto err_hw_refine; } - close(fd); +#ifdef TINYALSA_USES_PLUGINS + if (snd_node) + snd_utils_close_dev_node(snd_node); +#endif + ops->close(data); return (struct pcm_params *)params; err_hw_refine: free(params); err_calloc: - close(fd); +#ifdef TINYALSA_USES_PLUGINS + if (snd_node) + snd_utils_close_dev_node(snd_node); +#endif + ops->close(data); err_open: return NULL; } @@ -787,8 +816,8 @@ int pcm_close(struct pcm *pcm) munmap(pcm->mmap_buffer, pcm_frames_to_bytes(pcm, pcm->buffer_size)); } - if (pcm->fd >= 0) - close(pcm->fd); + snd_utils_close_dev_node(pcm->snd_node); + pcm->ops->close(pcm->data); pcm->buffer_size = 0; pcm->fd = -1; free(pcm); @@ -851,29 +880,39 @@ struct pcm *pcm_open(unsigned int card, unsigned int device, { struct pcm *pcm; struct snd_pcm_info info; - char fn[256]; int rc; pcm = calloc(1, sizeof(struct pcm)); if (!pcm) return &bad_pcm; - snprintf(fn, sizeof(fn), "/dev/snd/pcmC%uD%u%c", card, device, - flags & PCM_IN ? 'c' : 'p'); - - pcm->flags = flags; - - if (flags & PCM_NONBLOCK) - pcm->fd = open(fn, O_RDWR | O_NONBLOCK); - else - pcm->fd = open(fn, O_RDWR); + /* Default to hw_ops, attemp plugin open only if hw (/dev/snd/pcm*) open fails */ + pcm->ops = &hw_ops; + pcm->fd = pcm->ops->open(card, device, flags, &pcm->data, NULL); +#ifdef TINYALSA_USES_PLUGINS + if (pcm->fd < 0) { + int pcm_type; + pcm->snd_node = snd_utils_open_pcm(card, device); + pcm_type = snd_utils_get_node_type(pcm->snd_node); + if (!pcm->snd_node || pcm_type != SND_NODE_TYPE_PLUGIN) { + oops(pcm, -ENODEV, "no device (hw/plugin) for card(%u), device(%u)", + card, device); + return pcm; + } + pcm->ops = &plug_ops; + pcm->fd = pcm->ops->open(card, device, flags, &pcm->data, pcm->snd_node); + } +#endif if (pcm->fd < 0) { - oops(pcm, errno, "cannot open device '%s'", fn); + oops(pcm, errno, "cannot open device (%u) for card (%u)", + device, card); return pcm; } - if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_INFO, &info)) { + pcm->flags = flags; + + if (pcm->ops->ioctl(pcm->data, SNDRV_PCM_IOCTL_INFO, &info)) { oops(pcm, errno, "cannot get info"); goto fail_close; } @@ -891,7 +930,7 @@ struct pcm *pcm_open(unsigned int card, unsigned int device, #ifdef SNDRV_PCM_IOCTL_TTSTAMP if (pcm->flags & PCM_MONOTONIC) { int arg = SNDRV_PCM_TSTAMP_TYPE_MONOTONIC; - rc = ioctl(pcm->fd, SNDRV_PCM_IOCTL_TTSTAMP, &arg); + rc = pcm->ops->ioctl(pcm->data, SNDRV_PCM_IOCTL_TTSTAMP, &arg); if (rc < 0) { oops(pcm, rc, "cannot set timestamp type"); goto fail; @@ -911,7 +950,11 @@ fail: if (flags & PCM_MMAP) munmap(pcm->mmap_buffer, pcm_frames_to_bytes(pcm, pcm->buffer_size)); fail_close: - close(pcm->fd); +#ifdef TINYALSA_USES_PLUGINS + if (pcm->snd_node) + snd_utils_close_dev_node(pcm->snd_node); +#endif + pcm->ops->close(pcm->data); pcm->fd = -1; return pcm; } @@ -970,7 +1013,7 @@ int pcm_unlink(struct pcm *pcm) */ int pcm_prepare(struct pcm *pcm) { - if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_PREPARE) < 0) + if (pcm->ops->ioctl(pcm->data, SNDRV_PCM_IOCTL_PREPARE) < 0) return oops(pcm, errno, "cannot prepare channel"); /* get appl_ptr and avail_min from kernel */ @@ -991,7 +1034,7 @@ int pcm_start(struct pcm *pcm) return -1; if (pcm->mmap_status->state != PCM_STATE_RUNNING) { - if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_START) < 0) + if (pcm->ops->ioctl(pcm->data, SNDRV_PCM_IOCTL_START) < 0) return oops(pcm, errno, "cannot start channel"); } @@ -1005,7 +1048,7 @@ int pcm_start(struct pcm *pcm) */ int pcm_stop(struct pcm *pcm) { - if (ioctl(pcm->fd, SNDRV_PCM_IOCTL_DROP) < 0) + if (pcm->ops->ioctl(pcm->data, SNDRV_PCM_IOCTL_DROP) < 0) return oops(pcm, errno, "cannot stop channel"); return 0; @@ -1288,7 +1331,7 @@ int pcm_mmap_transfer(struct pcm *pcm, void *buffer, unsigned int frames) */ if (!is_playback && state == PCM_STATE_PREPARED && frames >= pcm->config.start_threshold) { - err = ioctl(pcm->fd, SNDRV_PCM_IOCTL_START); + err = pcm->ops->ioctl(pcm->data, SNDRV_PCM_IOCTL_START); if (err == -1) return -1; /* state = PCM_STATE_RUNNING */ @@ -1326,7 +1369,7 @@ int pcm_mmap_transfer(struct pcm *pcm, void *buffer, unsigned int frames) /* start playback if written >= start_threshold */ if (is_playback && state == PCM_STATE_PREPARED && pcm->buffer_size - avail >= pcm->config.start_threshold) { - err = ioctl(pcm->fd, SNDRV_PCM_IOCTL_START); + err = pcm->ops->ioctl(pcm->data, SNDRV_PCM_IOCTL_START); if (err == -1) break; } @@ -1365,9 +1408,9 @@ static int pcm_rw_transfer(struct pcm *pcm, void *data, unsigned int frames) transfer.frames = frames; transfer.result = 0; - res = ioctl(pcm->fd, is_playback - ? SNDRV_PCM_IOCTL_WRITEI_FRAMES - : SNDRV_PCM_IOCTL_READI_FRAMES, &transfer); + res = pcm->ops->ioctl(pcm->data, is_playback + ? SNDRV_PCM_IOCTL_WRITEI_FRAMES + : SNDRV_PCM_IOCTL_READI_FRAMES, &transfer); return res == 0 ? (int) transfer.result : -1; } diff --git a/src/pcm_hw.c b/src/pcm_hw.c new file mode 100644 index 0000000..1e67e9b --- /dev/null +++ b/src/pcm_hw.c @@ -0,0 +1,118 @@ +/* pcm_hw.c +** Copyright (c) 2019, The Linux Foundation. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above +** copyright notice, this list of conditions and the following +** disclaimer in the documentation and/or other materials provided +** with the distribution. +** * Neither the name of The Linux Foundation nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED +** WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT +** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS +** BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR +** BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +** WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +** OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN +** IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +**/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "pcm_io.h" + +struct pcm_hw_data { + /** Card number of the pcm device */ + unsigned int card; + /** Device number for the pcm device */ + unsigned int device; + /** File descriptor to the pcm device file node */ + unsigned int fd; + /** Pointer to the pcm node from snd card definiton */ + struct snd_node *node; +}; + +static void pcm_hw_close(void *data) +{ + struct pcm_hw_data *hw_data = data; + + if (hw_data->fd > 0) + close(hw_data->fd); + + free(hw_data); +} + +static int pcm_hw_ioctl(void *data, unsigned int cmd, ...) +{ + struct pcm_hw_data *hw_data = data; + va_list ap; + void *arg; + + va_start(ap, cmd); + arg = va_arg(ap, void *); + va_end(ap); + + return ioctl(hw_data->fd, cmd, arg); +} + +static int pcm_hw_open(unsigned int card, unsigned int device, + unsigned int flags, void **data, struct snd_node *node) +{ + struct pcm_hw_data *hw_data; + char fn[256]; + int fd; + + hw_data = calloc(1, sizeof(*hw_data)); + if (!hw_data) { + return -ENOMEM; + } + + snprintf(fn, sizeof(fn), "/dev/snd/pcmC%uD%u%c", card, device, + flags & PCM_IN ? 'c' : 'p'); + if (flags & PCM_NONBLOCK) + fd = open(fn, O_RDWR|O_NONBLOCK); + else + fd = open(fn, O_RDWR); + + if (fd < 0) { + return fd; + } + + hw_data->card = card; + hw_data->device = device; + hw_data->fd = fd; + hw_data->node = node; + + *data = hw_data; + + return fd; +} + +const struct pcm_ops hw_ops = { + .open = pcm_hw_open, + .close = pcm_hw_close, + .ioctl = pcm_hw_ioctl, +}; + diff --git a/src/pcm_io.h b/src/pcm_io.h new file mode 100644 index 0000000..1b68ac8 --- /dev/null +++ b/src/pcm_io.h @@ -0,0 +1,47 @@ +/* pcm_io.h +** Copyright (c) 2019, The Linux Foundation. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above +** copyright notice, this list of conditions and the following +** disclaimer in the documentation and/or other materials provided +** with the distribution. +** * Neither the name of The Linux Foundation nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED +** WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT +** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS +** BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR +** BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +** WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +** OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN +** IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +**/ + +#ifndef TINYALSA_SRC_PCM_IO_H +#define TINYALSA_SRC_PCM_IO_H + +#include + +struct snd_node; + +struct pcm_ops { + int (*open) (unsigned int card, unsigned int device, + unsigned int flags, void **data, struct snd_node *node); + void (*close) (void *data); + int (*ioctl) (void *data, unsigned int cmd, ...); +}; + +extern const struct pcm_ops hw_ops; +extern const struct pcm_ops plug_ops; + +#endif /* TINYALSA_SRC_PCM_IO_H */ diff --git a/src/pcm_plugin.c b/src/pcm_plugin.c new file mode 100644 index 0000000..695ad2c --- /dev/null +++ b/src/pcm_plugin.c @@ -0,0 +1,718 @@ +/* pcm_plugin.c +** Copyright (c) 2019, The Linux Foundation. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above +** copyright notice, this list of conditions and the following +** disclaimer in the documentation and/or other materials provided +** with the distribution. +** * Neither the name of The Linux Foundation nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED +** WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT +** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS +** BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR +** BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +** WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +** OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN +** IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +**/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "pcm_io.h" +#include "snd_card_plugin.h" + +/* 2 words of uint32_t = 64 bits of mask */ +#define PCM_MASK_SIZE (2) +#define ARRAY_SIZE(a) \ + (sizeof(a) / sizeof(a[0])) + +#define PCM_PARAM_GET_MASK(p, n) \ + &p->masks[n - SNDRV_PCM_HW_PARAM_FIRST_MASK]; + +enum { + PCM_PLUG_HW_PARAM_SELECT_MIN, + PCM_PLUG_HW_PARAM_SELECT_MAX, + PCM_PLUG_HW_PARAM_SELECT_VAL, +}; + +enum { + PCM_PLUG_STATE_OPEN, + PCM_PLUG_STATE_SETUP, + PCM_PLUG_STATE_PREPARED, + PCM_PLUG_STATE_RUNNING, +}; + +struct pcm_plug_data { + unsigned int card; + unsigned int device; + unsigned int fd; + unsigned int flags; + + void *dl_hdl; + /** pointer to plugin operation */ + const struct pcm_plugin_ops *ops; + struct pcm_plugin *plugin; + void *dev_node; +}; + +static unsigned int param_list[] = { + SNDRV_PCM_HW_PARAM_SAMPLE_BITS, + SNDRV_PCM_HW_PARAM_CHANNELS, + SNDRV_PCM_HW_PARAM_RATE, + SNDRV_PCM_HW_PARAM_PERIOD_SIZE, + SNDRV_PCM_HW_PARAM_PERIODS, +}; + +static void pcm_plug_close(void *data) +{ + struct pcm_plug_data *plug_data = data; + struct pcm_plugin *plugin = plug_data->plugin; + + plug_data->ops->close(plugin); + dlclose(plug_data->dl_hdl); + + free(plug_data); +} + +static int pcm_plug_info(struct pcm_plug_data *plug_data, + struct snd_pcm_info *info) +{ + int stream = SNDRV_PCM_STREAM_PLAYBACK; + int ret = 0, val = -1; + char *name; + + memset(info, 0, sizeof(*info)); + + if (plug_data->flags & PCM_IN) { + stream = SNDRV_PCM_STREAM_CAPTURE; + ret = snd_utils_get_int(plug_data->dev_node, "capture", &val); + if (ret || !val) { + fprintf(stderr, "%s: not a capture device\n", __func__); + return -EINVAL; + } + } else { + stream = SNDRV_PCM_STREAM_PLAYBACK; + ret = snd_utils_get_int(plug_data->dev_node, "playback", &val); + if (ret || !val) { + fprintf(stderr, "%s: not a playback device\n", __func__); + return -EINVAL; + } + } + + info->stream = stream; + info->card = plug_data->card; + info->device = plug_data->device; + + ret = snd_utils_get_str(plug_data->dev_node, "name", &name); + if (ret) { + fprintf(stderr, "%s: failed to get pcm device name\n", __func__); + return ret; + } + + strncpy((char *)info->id, name, sizeof(info->id)); + strncpy((char *)info->name, name, sizeof(info->name)); + strncpy((char *)info->subname, name, sizeof(info->subname)); + + info->subdevices_count = 1; + + return ret; +} + +static void pcm_plug_set_mask(struct snd_pcm_hw_params *p, int n, uint64_t v) +{ + struct snd_mask *mask; + + mask = PCM_PARAM_GET_MASK(p, n); + + mask->bits[0] |= (v & 0xFFFFFFFF); + mask->bits[1] |= ((v >> 32) & 0xFFFFFFFF); + /* + * currently only supporting 64 bits, may need to update to support + * more than 64 bits + */ +} + +static void pcm_plug_set_interval(struct snd_pcm_hw_params *params, + int p, struct pcm_plugin_min_max *v, int is_integer) +{ + struct snd_interval *i; + + i = ¶ms->intervals[p - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL]; + + i->min = v->min; + i->max = v->max; + + if (is_integer) + i->integer = 1; +} + +static int pcm_plug_frames_to_bytes(unsigned int frames, + unsigned int frame_bits) +{ + return (frames * (frame_bits / 8)); +} + +static int pcm_plug_bytes_to_frames(unsigned int size, + unsigned int frame_bits) +{ + return (size * 8) / frame_bits; +} + +static int pcm_plug_get_params(struct pcm_plugin *plugin, + struct snd_pcm_hw_params *params) +{ + struct pcm_plugin_min_max bw, ch, pb, periods; + struct pcm_plugin_min_max val; + struct pcm_plugin_min_max frame_bits, buffer_bytes; + + /* + * populate the struct snd_pcm_hw_params structure + * using the hw_param constraints provided by plugin + * via the plugin->constraints + */ + + /* Set the mask params */ + pcm_plug_set_mask(params, SNDRV_PCM_HW_PARAM_ACCESS, + plugin->constraints->access); + pcm_plug_set_mask(params, SNDRV_PCM_HW_PARAM_FORMAT, + plugin->constraints->format); + pcm_plug_set_mask(params, SNDRV_PCM_HW_PARAM_SUBFORMAT, + SNDRV_PCM_SUBFORMAT_STD); + + /* Set the standard interval params */ + pcm_plug_set_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS, + &plugin->constraints->bit_width, 1); + pcm_plug_set_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS, + &plugin->constraints->channels, 1); + pcm_plug_set_interval(params, SNDRV_PCM_HW_PARAM_RATE, + &plugin->constraints->rate, 1); + pcm_plug_set_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, + &plugin->constraints->period_bytes, 0); + pcm_plug_set_interval(params, SNDRV_PCM_HW_PARAM_PERIODS, + &plugin->constraints->periods, 1); + + /* set the calculated interval params */ + + bw.min = plugin->constraints->bit_width.min; + bw.max = plugin->constraints->bit_width.max; + + ch.min = plugin->constraints->channels.min; + ch.max = plugin->constraints->channels.max; + + pb.min = plugin->constraints->period_bytes.min; + pb.max = plugin->constraints->period_bytes.max; + + periods.min = plugin->constraints->periods.min; + periods.max = plugin->constraints->periods.max; + + /* Calculate and set frame bits */ + frame_bits.min = bw.min * ch.min; + frame_bits.max = bw.max * ch.max; + pcm_plug_set_interval(params, SNDRV_PCM_HW_PARAM_FRAME_BITS, + &frame_bits, 1); + + + /* Calculate and set period_size in frames */ + val.min = pcm_plug_bytes_to_frames(pb.min, frame_bits.min); + val.max = pcm_plug_bytes_to_frames(pb.max, frame_bits.min); + pcm_plug_set_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, + &val, 1); + + /* Calculate and set buffer_bytes */ + buffer_bytes.min = pb.min * periods.min; + buffer_bytes.max = pb.max * periods.max; + pcm_plug_set_interval(params, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, + &buffer_bytes, 1); + + /* Calculate and set buffer_size in frames */ + val.min = pcm_plug_bytes_to_frames(buffer_bytes.min, frame_bits.min); + val.max = pcm_plug_bytes_to_frames(buffer_bytes.max, frame_bits.min); + pcm_plug_set_interval(params, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, + &val, 1); + return 0; +} + +static int pcm_plug_masks_refine(struct snd_pcm_hw_params *p, + struct snd_pcm_hw_params *c) +{ + struct snd_mask *req_mask; + struct snd_mask *con_mask; + unsigned int idx, i, masks; + + masks = SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK; + + for (idx = 0; idx <= masks; idx++) { + + if (!(p->rmask & (1 << (idx + SNDRV_PCM_HW_PARAM_FIRST_MASK)))) + continue; + + req_mask = PCM_PARAM_GET_MASK(p, idx); + con_mask = PCM_PARAM_GET_MASK(c, idx); + + /* + * set the changed mask if requested mask value is not the same as + * constrained mask value + */ + if (memcmp(req_mask, con_mask, PCM_MASK_SIZE * sizeof(uint32_t))) + p->cmask |= 1 << (idx + SNDRV_PCM_HW_PARAM_FIRST_MASK); + + /* Actually change the requested mask to constrained mask */ + for (i = 0; i < PCM_MASK_SIZE; i++) + req_mask->bits[i] &= con_mask->bits[i]; + } + + return 0; +} + +static int pcm_plug_interval_refine(struct snd_pcm_hw_params *p, + struct snd_pcm_hw_params *c) +{ + struct snd_interval *ri; + struct snd_interval *ci; + unsigned int idx; + unsigned int intervals; + int changed = 0; + + intervals = SNDRV_PCM_HW_PARAM_LAST_INTERVAL - + SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; + + for (idx = 0; idx <= intervals; idx++) { + ri = &p->intervals[idx]; + ci = &c->intervals[idx]; + + if (!(p->rmask & (1 << (idx + SNDRV_PCM_HW_PARAM_FIRST_INTERVAL)) )) + continue; + + if (ri->min < ci->min) { + ri->min = ci->min; + ri->openmin = ci->openmin; + changed = 1; + } else if (ri->min == ci->min && !ri->openmin && ci->openmin) { + ri->openmin = 1; + changed = 1; + } + + if (ri->max > ci->max) { + ri->max = ci->max; + ri->openmax = ci->openmax; + changed = 1; + } else if (ri->max == ci->max && !ri->openmax && ci->openmax) { + ri->openmax = 1; + changed = 1; + }; + + if (!ri->integer && ci->integer) { + ri->integer = 1; + changed = 1; + } + + if (ri->integer) { + if (ri->openmin) { + ri->min++; + ri->openmin = 0; + } + if (ri->openmax) { + ri->max--; + ri->openmax = 0; + } + } else if (!ri->openmin && !ri->openmax && ri->min == ri->max) { + ri->integer = 1; + } + + /* Set the changed mask */ + if (changed) + p->cmask |= (1 << (idx + SNDRV_PCM_HW_PARAM_FIRST_INTERVAL)); + } + + return 0; +} + + +static int pcm_plug_hw_params_refine(struct snd_pcm_hw_params *p, + struct snd_pcm_hw_params *c) +{ + int rc; + + rc = pcm_plug_masks_refine(p, c); + if (rc) { + fprintf(stderr, "%s: masks refine failed %d\n", __func__, rc); + return rc; + } + + rc = pcm_plug_interval_refine(p, c); + if (rc) { + fprintf(stderr, "%s: interval refine failed %d\n", __func__, rc); + return rc; + } + + /* clear the requested params */ + p->rmask = 0; + + return rc; +} + +static int __pcm_plug_hrefine(struct pcm_plug_data *plug_data, + struct snd_pcm_hw_params *params) +{ + struct pcm_plugin *plugin = plug_data->plugin; + struct snd_pcm_hw_params plug_params; + int rc; + + memset(&plug_params, 0, sizeof(plug_params)); + rc = pcm_plug_get_params(plugin, &plug_params); + if (rc) { + fprintf(stderr, "%s: pcm_plug_get_params failed %d\n", + __func__, rc); + return -EINVAL; + } + + return pcm_plug_hw_params_refine(params, &plug_params); + +} + +static int pcm_plug_hrefine(struct pcm_plug_data *plug_data, + struct snd_pcm_hw_params *params) +{ + return __pcm_plug_hrefine(plug_data, params); +} + +static int pcm_plug_interval_select(struct snd_pcm_hw_params *p, + unsigned int param, unsigned int select, unsigned int val) +{ + struct snd_interval *i; + + if (param < SNDRV_PCM_HW_PARAM_FIRST_INTERVAL || + param > SNDRV_PCM_HW_PARAM_LAST_INTERVAL) + return -EINVAL; + + i = &p->intervals[param - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL]; + + if (!i->min) + return -EINVAL; + + switch (select) { + + case PCM_PLUG_HW_PARAM_SELECT_MIN: + i->max = i->min; + break; + + case PCM_PLUG_HW_PARAM_SELECT_MAX: + i->min = i->max; + break; + + case PCM_PLUG_HW_PARAM_SELECT_VAL: + i->min = i->max = val; + break; + + default: + return -EINVAL; + } + + return 0; +} + +static void pcm_plug_hw_params_set(struct snd_pcm_hw_params *p) +{ + unsigned int i, select; + unsigned int bw, ch, period_sz, periods; + unsigned int val1, val2, offset; + + offset = SNDRV_PCM_HW_PARAM_FIRST_INTERVAL; + + /* Select the min values first */ + select = PCM_PLUG_HW_PARAM_SELECT_MIN; + for (i = 0; i < ARRAY_SIZE(param_list); i++) + pcm_plug_interval_select(p, param_list[i], select, 0); + + /* Select calculated values */ + select = PCM_PLUG_HW_PARAM_SELECT_VAL; + bw = (p->intervals[SNDRV_PCM_HW_PARAM_SAMPLE_BITS - offset]).min; + ch = (p->intervals[SNDRV_PCM_HW_PARAM_CHANNELS - offset]).min; + period_sz = (p->intervals[SNDRV_PCM_HW_PARAM_PERIOD_SIZE - offset]).min; + periods = (p->intervals[SNDRV_PCM_HW_PARAM_PERIODS - offset]).min; + + val1 = bw * ch; // frame_bits; + pcm_plug_interval_select(p, SNDRV_PCM_HW_PARAM_FRAME_BITS, select, val1); + + val2 = pcm_plug_frames_to_bytes(period_sz, val1); // period_bytes; + pcm_plug_interval_select(p, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, select, + val2); + + val2 = period_sz * periods; //buffer_size; + pcm_plug_interval_select(p, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, select, val2); + + val2 = pcm_plug_frames_to_bytes(period_sz * periods, val1); //buffer_bytes; + pcm_plug_interval_select(p, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, select, val2); +} + +static int pcm_plug_hparams(struct pcm_plug_data *plug_data, + struct snd_pcm_hw_params *params) +{ + struct pcm_plugin *plugin = plug_data->plugin; + int rc; + + if (plugin->state != PCM_PLUG_STATE_OPEN) + return -EBADFD; + + params->rmask = ~0U; + + rc = __pcm_plug_hrefine(plug_data, params); + if (rc) { + fprintf(stderr, "%s: __pcm_plug_hrefine failed %d\n", + __func__, rc); + return rc; + } + + pcm_plug_hw_params_set(params); + + rc = plug_data->ops->hw_params(plugin, params); + if (!rc) + plugin->state = PCM_PLUG_STATE_SETUP; + + return rc; +} + +static int pcm_plug_sparams(struct pcm_plug_data *plug_data, + struct snd_pcm_sw_params *params) +{ + struct pcm_plugin *plugin = plug_data->plugin; + + if (plugin->state != PCM_PLUG_STATE_SETUP) + return -EBADFD; + + return plug_data->ops->sw_params(plugin, params); +} + +static int pcm_plug_sync_ptr(struct pcm_plug_data *plug_data, + struct snd_pcm_sync_ptr *sync_ptr) +{ + struct pcm_plugin *plugin = plug_data->plugin; + + return plug_data->ops->sync_ptr(plugin, sync_ptr); +} + +static int pcm_plug_writei_frames(struct pcm_plug_data *plug_data, + struct snd_xferi *x) +{ + struct pcm_plugin *plugin = plug_data->plugin; + + if (plugin->state != PCM_PLUG_STATE_PREPARED && + plugin->state != PCM_PLUG_STATE_RUNNING) + return -EBADFD; + + return plug_data->ops->writei_frames(plugin, x); +} + +static int pcm_plug_readi_frames(struct pcm_plug_data *plug_data, + struct snd_xferi *x) +{ + struct pcm_plugin *plugin = plug_data->plugin; + + if (plugin->state != PCM_PLUG_STATE_RUNNING) + return -EBADFD; + + return plug_data->ops->readi_frames(plugin, x); +} + +static int pcm_plug_ttstamp(struct pcm_plug_data *plug_data, + int *tstamp) +{ + struct pcm_plugin *plugin = plug_data->plugin; + + if (plugin->state != PCM_PLUG_STATE_RUNNING) + return -EBADFD; + + return plug_data->ops->ttstamp(plugin, tstamp); +} + +static int pcm_plug_prepare(struct pcm_plug_data *plug_data) +{ + struct pcm_plugin *plugin = plug_data->plugin; + int rc; + + if (plugin->state != PCM_PLUG_STATE_SETUP) + return -EBADFD; + + rc = plug_data->ops->prepare(plugin); + if (!rc) + plugin->state = PCM_PLUG_STATE_PREPARED; + + return rc; +} + +static int pcm_plug_start(struct pcm_plug_data *plug_data) +{ + struct pcm_plugin *plugin = plug_data->plugin; + int rc; + + if (plugin->state != PCM_PLUG_STATE_PREPARED) + return -EBADFD; + + rc = plug_data->ops->start(plugin); + if (!rc) + plugin->state = PCM_PLUG_STATE_RUNNING; + + return rc; +} + +static int pcm_plug_drop(struct pcm_plug_data *plug_data) +{ + struct pcm_plugin *plugin = plug_data->plugin; + int rc; + + rc = plug_data->ops->drop(plugin); + if (!rc) + plugin->state = PCM_PLUG_STATE_SETUP; + + return rc; +} + +static int pcm_plug_ioctl(void *data, unsigned int cmd, ...) +{ + struct pcm_plug_data *plug_data = data; + struct pcm_plugin *plugin = plug_data->plugin; + int ret; + va_list ap; + void *arg; + + va_start(ap, cmd); + arg = va_arg(ap, void *); + va_end(ap); + + switch (cmd) { + case SNDRV_PCM_IOCTL_INFO: + ret = pcm_plug_info(plug_data, arg); + break; + case SNDRV_PCM_IOCTL_TTSTAMP: + ret = pcm_plug_ttstamp(plug_data, arg); + break; + case SNDRV_PCM_IOCTL_HW_REFINE: + ret = pcm_plug_hrefine(plug_data, arg); + break; + case SNDRV_PCM_IOCTL_HW_PARAMS: + ret = pcm_plug_hparams(plug_data, arg); + break; + case SNDRV_PCM_IOCTL_SW_PARAMS: + ret = pcm_plug_sparams(plug_data, arg); + break; + case SNDRV_PCM_IOCTL_SYNC_PTR: + ret = pcm_plug_sync_ptr(plug_data, arg); + break; + case SNDRV_PCM_IOCTL_PREPARE: + ret = pcm_plug_prepare(plug_data); + break; + case SNDRV_PCM_IOCTL_START: + ret = pcm_plug_start(plug_data); + break; + case SNDRV_PCM_IOCTL_DROP: + ret = pcm_plug_drop(plug_data); + break; + case SNDRV_PCM_IOCTL_WRITEI_FRAMES: + ret = pcm_plug_writei_frames(plug_data, arg); + break; + case SNDRV_PCM_IOCTL_READI_FRAMES: + ret = pcm_plug_readi_frames(plug_data, arg); + break; + default: + ret = plug_data->ops->ioctl(plugin, cmd, arg); + break; + } + + return ret; +} + +static int pcm_plug_open(unsigned int card, unsigned int device, + unsigned int flags, void **data, struct snd_node *pcm_node) +{ + struct pcm_plug_data *plug_data; + void *dl_hdl; + int rc = 0; + char *so_name; + + plug_data = calloc(1, sizeof(*plug_data)); + if (!plug_data) { + return -ENOMEM; + } + + rc = snd_utils_get_str(pcm_node, "so-name", &so_name); + if (rc) { + fprintf(stderr, "%s: failed to get plugin lib name\n", __func__); + goto err_get_lib; + } + + dl_hdl = dlopen(so_name, RTLD_NOW); + if (!dl_hdl) { + fprintf(stderr, "%s: unable to open %s\n", __func__, so_name); + goto err_dl_open; + } else { + fprintf(stderr, "%s: dlopen successful for %s\n", __func__, so_name); + } + + dlerror(); + + plug_data->ops = dlsym(dl_hdl, "pcm_plugin_ops"); + if (!plug_data->ops) { + fprintf(stderr, "%s: dlsym to open fn failed, err = '%s'\n", + __func__, dlerror()); + goto err_dlsym; + } + + rc = plug_data->ops->open(&plug_data->plugin, card, device, flags); + if (rc) { + fprintf(stderr, "%s: failed to open plugin\n", __func__); + goto err_open; + } + + plug_data->dl_hdl = dl_hdl; + plug_data->card = card; + plug_data->device = device; + plug_data->dev_node = pcm_node; + plug_data->flags = flags; + + *data = plug_data; + + plug_data->plugin->state = PCM_PLUG_STATE_OPEN; + + return 0; + +err_open: +err_dlsym: + dlclose(dl_hdl); +err_get_lib: +err_dl_open: + free(plug_data); + + return rc; +} + +const struct pcm_ops plug_ops = { + .open = pcm_plug_open, + .close = pcm_plug_close, + .ioctl = pcm_plug_ioctl, +}; diff --git a/src/snd_card_plugin.c b/src/snd_card_plugin.c new file mode 100644 index 0000000..17912a2 --- /dev/null +++ b/src/snd_card_plugin.c @@ -0,0 +1,149 @@ +/* snd_card_plugin.c +** Copyright (c) 2019, The Linux Foundation. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above +** copyright notice, this list of conditions and the following +** disclaimer in the documentation and/or other materials provided +** with the distribution. +** * Neither the name of The Linux Foundation nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED +** WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT +** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS +** BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR +** BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +** WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +** OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN +** IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +**/ + +#include "snd_card_plugin.h" + +#include +#include +#include + +#define SND_DLSYM(h, p, s, err) \ +do { \ + err = 0; \ + p = dlsym(h, s); \ + if (!p) \ + err = -ENODEV; \ +} while(0) + +int snd_utils_get_int(struct snd_node *node, const char *prop, int *val) +{ + if (!node || !node->card_node || !node->dev_node) + return SND_NODE_TYPE_HW; + + return node->ops->get_int(node->dev_node, prop, val); +} + +int snd_utils_get_str(struct snd_node *node, const char *prop, char **val) +{ + if (!node || !node->card_node || !node->dev_node) + return SND_NODE_TYPE_HW; + + return node->ops->get_str(node->dev_node, prop, val); +} + +void snd_utils_close_dev_node(struct snd_node *node) +{ + if (!node) + return; + + if (node->card_node) + node->ops->close_card(node->card_node); + + if (node->dl_hdl) + dlclose(node->dl_hdl); + + free(node); +} + +enum snd_node_type snd_utils_get_node_type(struct snd_node *node) +{ + int val = SND_NODE_TYPE_HW; + + if (!node || !node->card_node || !node->dev_node) + return SND_NODE_TYPE_HW; + + node->ops->get_int(node->dev_node, "type", &val); + + return val; +}; + +static int snd_utils_resolve_symbols(struct snd_node *node) +{ + void *dl = node->dl_hdl; + int err; + SND_DLSYM(dl, node->ops, "snd_card_ops", err); + return err; +} + +static struct snd_node *snd_utils_open_dev_node(unsigned int card, + unsigned int device, + int dev_type) +{ + struct snd_node *node; + int rc = 0; + + node = calloc(1, sizeof(*node)); + if (!node) + return NULL; + + node->dl_hdl = dlopen("libsndcardparser.so", RTLD_NOW); + if (!node->dl_hdl) { + goto err_dl_open; + } + + rc = snd_utils_resolve_symbols(node); + if (rc < 0) + goto err_resolve_symbols; + + node->card_node = node->ops->open_card(card); + if (!node->card_node) + goto err_resolve_symbols; + + if (dev_type == NODE_PCM) { + node->dev_node = node->ops->get_pcm(node->card_node, device); + } else { + node->dev_node = node->ops->get_mixer(node->card_node); + } + + if (!node->dev_node) + goto err_get_node; + + return node; + +err_get_node: + node->ops->close_card(node->card_node); + +err_resolve_symbols: + dlclose(node->dl_hdl); + +err_dl_open: + free(node); + return NULL; +} + +struct snd_node* snd_utils_open_pcm(unsigned int card, + unsigned int device) +{ + return snd_utils_open_dev_node(card, device, NODE_PCM); +} + +struct snd_node* snd_utils_open_mixer(unsigned int card) +{ + return snd_utils_open_dev_node(card, 0, NODE_MIXER); +} diff --git a/src/snd_card_plugin.h b/src/snd_card_plugin.h new file mode 100644 index 0000000..b80695e --- /dev/null +++ b/src/snd_card_plugin.h @@ -0,0 +1,74 @@ +/* snd_utils.h +** Copyright (c) 2019, The Linux Foundation. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above +** copyright notice, this list of conditions and the following +** disclaimer in the documentation and/or other materials provided +** with the distribution. +** * Neither the name of The Linux Foundation nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED +** WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT +** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS +** BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR +** BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +** WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +** OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN +** IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +**/ + +#ifndef TINYALSA_SRC_SND_CARD_UTILS_H +#define TINYALSA_SRC_SND_CARD_UTILS_H + +#include + +#include + +/** Encapsulates the pcm device definition from + * the sound card definition configuration file. + */ +struct snd_node { + /** Pointer the card definition */ + void *card_node; + /** Pointer to device definition, either PCM or MIXER device */ + void *dev_node; + /** Pointer to the sound card parser library */ + void *dl_hdl; + /** A pointer to the operations structure. */ + const struct snd_node_ops* ops; +}; + +enum snd_node_type { + SND_NODE_TYPE_HW = 0, + SND_NODE_TYPE_PLUGIN, + SND_NODE_TYPE_INVALID, +}; + +enum { + NODE_PCM, + NODE_MIXER +}; + +struct snd_node *snd_utils_open_pcm(unsigned int card, unsigned int device); + +struct snd_node *snd_utils_open_mixer(unsigned int card); + +void snd_utils_close_dev_node(struct snd_node *node); + +enum snd_node_type snd_utils_get_node_type(struct snd_node *node); + +int snd_utils_get_int(struct snd_node *node, const char *prop, int *val); + +int snd_utils_get_str(struct snd_node *node, const char *prop, char **val); + +#endif /* end of TINYALSA_SRC_SND_CARD_UTILS_H */ -- cgit v1.2.3