[PATCH 0/2] expand dshare to allow audio clock when not streaming data
The general idea of these changes is to be able to open the device without defined bindings. This would start the audio clock without blocking a channel. This might be useful for hardware that requires running clock early at system start and to be available even without application streaming audio data. Andreas Pape (2): alsa: pcm: add unsupported OPS alsa: dshare: allow missing bindings src/pcm/Makefile.am | 4 +- src/pcm/pcm_dshare.c | 72 +++++++++++-- src/pcm/pcm_unsupported.c | 265 ++++++++++++++++++++++++++++++++++++++++++++++ src/pcm/pcm_unsupported.h | 167 +++++++++++++++++++++++++++++ 4 files changed, 495 insertions(+), 13 deletions(-) create mode 100644 src/pcm/pcm_unsupported.c create mode 100644 src/pcm/pcm_unsupported.h -- 2.7.4
From: Andreas Pape <apape@de.adit-jv.com> Signed-off-by: Andreas Pape <apape@de.adit-jv.com> Signed-off-by: Adam Miartus <amiartus@de.adit-jv.com> --- src/pcm/Makefile.am | 4 +- src/pcm/pcm_unsupported.c | 265 ++++++++++++++++++++++++++++++++++++++++++++++ src/pcm/pcm_unsupported.h | 166 +++++++++++++++++++++++++++++ 3 files changed, 433 insertions(+), 2 deletions(-) create mode 100644 src/pcm/pcm_unsupported.c create mode 100644 src/pcm/pcm_unsupported.h diff --git a/src/pcm/Makefile.am b/src/pcm/Makefile.am index 8edbd0b..ba07869 100644 --- a/src/pcm/Makefile.am +++ b/src/pcm/Makefile.am @@ -8,7 +8,7 @@ libpcm_la_SOURCES = mask.c interval.c \ pcm_hw.c pcm_misc.c pcm_mmap.c pcm_symbols.c if BUILD_PCM_PLUGIN -libpcm_la_SOURCES += pcm_generic.c pcm_plugin.c +libpcm_la_SOURCES += pcm_generic.c pcm_plugin.c pcm_unsupported.c endif if BUILD_PCM_PLUGIN_COPY libpcm_la_SOURCES += pcm_copy.c @@ -108,7 +108,7 @@ EXTRA_DIST = pcm_dmix_i386.c pcm_dmix_x86_64.c pcm_dmix_generic.c noinst_HEADERS = pcm_local.h pcm_plugin.h mask.h mask_inline.h \ interval.h interval_inline.h plugin_ops.h ladspa.h \ pcm_direct.h pcm_dmix_i386.h pcm_dmix_x86_64.h \ - pcm_generic.h pcm_ext_parm.h + pcm_generic.h pcm_ext_parm.h pcm_unsupported.h alsadir = $(datadir)/alsa diff --git a/src/pcm/pcm_unsupported.c b/src/pcm/pcm_unsupported.c new file mode 100644 index 0000000..b7abf04 --- /dev/null +++ b/src/pcm/pcm_unsupported.c @@ -0,0 +1,265 @@ +/** + * \file pcm/pcm_unsupported.c + * \ingroup PCM + * \brief PCM Unsupported Interface + * \author Andreas Pape <apape@de.adit-jv.com> + * \date 2019 + */ +/* + * PCM - Common plugin code for unsupported operations + * Copyright (c) 2019 by Andreas Pape <apape@de.adit-jv.com> + * + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#include "pcm_local.h" +#include "pcm_unsupported.h" + +#ifndef DOC_HIDDEN + +#define PCM_UNSUPPORTED_ERR (-ENOSYS) +void snd_pcm_unsupported_dump(snd_pcm_t *pcm, snd_output_t *out) +{ + snd_output_printf(out, "unsupported\n"); +} + +int snd_pcm_unsupported_close(snd_pcm_t *pcm) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_nonblock(snd_pcm_t *pcm, int nonblock) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_async(snd_pcm_t *pcm, int sig, pid_t pid) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_poll_descriptors_count(snd_pcm_t *pcm) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_poll_descriptors(snd_pcm_t *pcm, struct pollfd *pfds, unsigned int space) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_poll_revents(snd_pcm_t *pcm, struct pollfd *pfds, unsigned int nfds, unsigned short *revents) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_info(snd_pcm_t *pcm, snd_pcm_info_t * info) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_hw_free(snd_pcm_t *pcm) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_sw_params(snd_pcm_t *pcm, snd_pcm_sw_params_t *params) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t *params) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_prepare(snd_pcm_t *pcm) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_channel_info(snd_pcm_t *pcm, snd_pcm_channel_info_t *info) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_status(snd_pcm_t *pcm, snd_pcm_status_t * status) +{ + return PCM_UNSUPPORTED_ERR; +} + +snd_pcm_state_t snd_pcm_unsupported_state(snd_pcm_t *pcm) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_hwsync(snd_pcm_t *pcm) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_reset(snd_pcm_t *pcm) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_start(snd_pcm_t *pcm) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_drop(snd_pcm_t *pcm) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_drain(snd_pcm_t *pcm) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_pause(snd_pcm_t *pcm, int enable) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_resume(snd_pcm_t *pcm) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp) +{ + return PCM_UNSUPPORTED_ERR; +} + +snd_pcm_sframes_t snd_pcm_unsupported_forwardable(snd_pcm_t *pcm) +{ + return PCM_UNSUPPORTED_ERR; +} + +snd_pcm_sframes_t snd_pcm_unsupported_forward(snd_pcm_t *pcm, snd_pcm_uframes_t frames) +{ + return PCM_UNSUPPORTED_ERR; +} + +snd_pcm_sframes_t snd_pcm_unsupported_rewindable(snd_pcm_t *pcm) +{ + return PCM_UNSUPPORTED_ERR; +} + +snd_pcm_sframes_t snd_pcm_unsupported_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t frames) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_link(snd_pcm_t *pcm1, snd_pcm_t *pcm2) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_link_slaves(snd_pcm_t *pcm, snd_pcm_t *master) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_unlink(snd_pcm_t *pcm) +{ + return PCM_UNSUPPORTED_ERR; +} + +snd_pcm_sframes_t snd_pcm_unsupported_writei(snd_pcm_t *pcm, const void *buffer, snd_pcm_uframes_t size) +{ + return PCM_UNSUPPORTED_ERR; +} + +snd_pcm_sframes_t snd_pcm_unsupported_writen(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_t size) +{ + return PCM_UNSUPPORTED_ERR; +} + +snd_pcm_sframes_t snd_pcm_unsupported_readi(snd_pcm_t *pcm, void *buffer, snd_pcm_uframes_t size) +{ + return PCM_UNSUPPORTED_ERR; +} + +snd_pcm_sframes_t snd_pcm_unsupported_readn(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_t size) +{ + return PCM_UNSUPPORTED_ERR; +} + +snd_pcm_sframes_t snd_pcm_unsupported_mmap_commit(snd_pcm_t *pcm, + snd_pcm_uframes_t offset, + snd_pcm_uframes_t size) +{ + return PCM_UNSUPPORTED_ERR; +} + +snd_pcm_sframes_t snd_pcm_unsupported_avail_update(snd_pcm_t *pcm) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_htimestamp(snd_pcm_t *pcm, snd_pcm_uframes_t *avail, + snd_htimestamp_t *tstamp) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_real_htimestamp(snd_pcm_t *pcm, snd_pcm_uframes_t *avail, + snd_htimestamp_t *tstamp) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_mmap(snd_pcm_t *pcm) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_munmap(snd_pcm_t *pcm) +{ + return PCM_UNSUPPORTED_ERR; +} + +snd_pcm_chmap_query_t **snd_pcm_unsupported_query_chmaps(snd_pcm_t *pcm) +{ + return NULL; +} + +snd_pcm_chmap_t *snd_pcm_unsupported_get_chmap(snd_pcm_t *pcm) +{ + return NULL; +} + +int snd_pcm_unsupported_set_chmap(snd_pcm_t *pcm, const snd_pcm_chmap_t *map) +{ + return PCM_UNSUPPORTED_ERR; +} + +int snd_pcm_unsupported_may_wait_for_avail_min(snd_pcm_t *pcm, snd_pcm_uframes_t avail ATTRIBUTE_UNUSED) +{ + return PCM_UNSUPPORTED_ERR; +} + + +#endif /* DOC_HIDDEN */ diff --git a/src/pcm/pcm_unsupported.h b/src/pcm/pcm_unsupported.h new file mode 100644 index 0000000..13e4d1b --- /dev/null +++ b/src/pcm/pcm_unsupported.h @@ -0,0 +1,166 @@ +/* + * PCM - Common plugin code for unsupported operations + * Copyright (c) 2017 by Andreas Pape <apape@de.adit-jv.com> + * + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + + +/* make local functions really local */ +#define snd_pcm_unsupported_dump \ + snd1_pcm_unsupported_dump +#define snd_pcm_unsupported_close \ + snd1_pcm_unsupported_close +#define snd_pcm_unsupported_nonblock \ + snd1_pcm_unsupported_nonblock +#define snd_pcm_unsupported_async \ + snd1_pcm_unsupported_async +#define snd_pcm_unsupported_poll_descriptors_count \ + snd1_pcm_unsupported_poll_descriptors_count +#define snd_pcm_unsupported_poll_descriptors \ + snd1_pcm_unsupported_poll_descriptors +#define snd_pcm_unsupported_poll_revents \ + snd1_pcm_unsupported_poll_revents +#define snd_pcm_unsupported_info \ + snd1_pcm_unsupported_info +#define snd_pcm_unsupported_hw_free \ + snd1_pcm_unsupported_hw_free +#define snd_pcm_unsupported_sw_params \ + snd1_pcm_unsupported_sw_params +#define snd_pcm_unsupported_hw_refine \ + snd1_pcm_unsupported_hw_refine +#define snd_pcm_unsupported_hw_params \ + snd1_pcm_unsupported_hw_params +#define snd_pcm_unsupported_channel_info \ + snd1_pcm_unsupported_channel_info +#define snd_pcm_unsupported_channel_info_no_buffer \ + snd1_pcm_unsupported_channel_info_no_buffer +#define snd_pcm_unsupported_status \ + snd1_pcm_unsupported_status +#define snd_pcm_unsupported_state \ + snd1_pcm_unsupported_state +#define snd_pcm_unsupported_prepare \ + snd1_pcm_unsupported_prepare +#define snd_pcm_unsupported_hwsync \ + snd1_pcm_unsupported_hwsync +#define snd_pcm_unsupported_reset \ + snd1_pcm_unsupported_reset +#define snd_pcm_unsupported_start \ + snd1_pcm_unsupported_start +#define snd_pcm_unsupported_drop \ + snd1_pcm_unsupported_drop +#define snd_pcm_unsupported_drain \ + snd1_pcm_unsupported_drain +#define snd_pcm_unsupported_pause \ + snd1_pcm_unsupported_pause +#define snd_pcm_unsupported_resume \ + snd1_pcm_unsupported_resume +#define snd_pcm_unsupported_delay \ + snd1_pcm_unsupported_delay +#define snd_pcm_unsupported_forwardable \ + snd1_pcm_unsupported_forwardable +#define snd_pcm_unsupported_forward \ + snd1_pcm_unsupported_forward +#define snd_pcm_unsupported_rewindable \ + snd1_pcm_unsupported_rewindable +#define snd_pcm_unsupported_rewind \ + snd1_pcm_unsupported_rewind +#define snd_pcm_unsupported_link \ + snd1_pcm_unsupported_link +#define snd_pcm_unsupported_link_slaves \ + snd1_pcm_unsupported_link_slaves +#define snd_pcm_unsupported_unlink \ + snd1_pcm_unsupported_unlink +#define snd_pcm_unsupported_writei \ + snd1_pcm_unsupported_writei +#define snd_pcm_unsupported_writen \ + snd1_pcm_unsupported_writen +#define snd_pcm_unsupported_readi \ + snd1_pcm_unsupported_readi +#define snd_pcm_unsupported_readn \ + snd1_pcm_unsupported_readn +#define snd_pcm_unsupported_mmap_commit \ + snd1_pcm_unsupported_mmap_commit +#define snd_pcm_unsupported_avail_update \ + snd1_pcm_unsupported_avail_update +#define snd_pcm_unsupported_htimestamp \ + snd1_pcm_unsupported_htimestamp +#define snd_pcm_unsupported_real_htimestamp \ + snd1_pcm_unsupported_real_htimestamp +#define snd_pcm_unsupported_mmap \ + snd1_pcm_unsupported_mmap +#define snd_pcm_unsupported_munmap \ + snd1_pcm_unsupported_munmap +#define snd_pcm_unsupported_query_chmaps \ + snd1_pcm_unsupported_query_chmaps +#define snd_pcm_unsupported_get_chmap \ + snd1_pcm_unsupported_get_chmap +#define snd_pcm_unsupported_set_chmap \ + snd1_pcm_unsupported_set_chmap +#define snd_pcm_unsupported_may_wait_for_avail_min \ + snd1_pcm_unsupported_may_wait_for_avail_min + +int snd_pcm_unsupported_close(snd_pcm_t *pcm); +int snd_pcm_unsupported_nonblock(snd_pcm_t *pcm, int nonblock); +int snd_pcm_unsupported_async(snd_pcm_t *pcm, int sig, pid_t pid); +int snd_pcm_unsupported_poll_descriptors_count(snd_pcm_t *pcm); +int snd_pcm_unsupported_poll_descriptors(snd_pcm_t *pcm, struct pollfd *pfds, unsigned int space); +int snd_pcm_unsupported_poll_revents(snd_pcm_t *pcm, struct pollfd *pfds, unsigned int nfds, unsigned short *revents); +int snd_pcm_unsupported_info(snd_pcm_t *pcm, snd_pcm_info_t * info); +int snd_pcm_unsupported_hw_free(snd_pcm_t *pcm); +int snd_pcm_unsupported_sw_params(snd_pcm_t *pcm, snd_pcm_sw_params_t *params); +int snd_pcm_unsupported_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params); +int snd_pcm_unsupported_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t *params); +int snd_pcm_unsupported_channel_info(snd_pcm_t *pcm, snd_pcm_channel_info_t * info); +int snd_pcm_unsupported_channel_info_no_buffer(snd_pcm_t *pcm, snd_pcm_channel_info_t * info); +int snd_pcm_unsupported_status(snd_pcm_t *pcm, snd_pcm_status_t * status); +snd_pcm_state_t snd_pcm_unsupported_state(snd_pcm_t *pcm); +int snd_pcm_unsupported_prepare(snd_pcm_t *pcm); +int snd_pcm_unsupported_hwsync(snd_pcm_t *pcm); +int snd_pcm_unsupported_reset(snd_pcm_t *pcm); +int snd_pcm_unsupported_start(snd_pcm_t *pcm); +int snd_pcm_unsupported_drop(snd_pcm_t *pcm); +int snd_pcm_unsupported_drain(snd_pcm_t *pcm); +int snd_pcm_unsupported_pause(snd_pcm_t *pcm, int enable); +int snd_pcm_unsupported_resume(snd_pcm_t *pcm); +int snd_pcm_unsupported_delay(snd_pcm_t *pcm, snd_pcm_sframes_t *delayp); +snd_pcm_sframes_t snd_pcm_unsupported_forwardable(snd_pcm_t *pcm); +snd_pcm_sframes_t snd_pcm_unsupported_forward(snd_pcm_t *pcm, snd_pcm_uframes_t frames); +snd_pcm_sframes_t snd_pcm_unsupported_rewindable(snd_pcm_t *pcm); +snd_pcm_sframes_t snd_pcm_unsupported_rewind(snd_pcm_t *pcm, snd_pcm_uframes_t frames); +int snd_pcm_unsupported_link(snd_pcm_t *pcm1, snd_pcm_t *pcm2); +int snd_pcm_unsupported_link_slaves(snd_pcm_t *pcm, snd_pcm_t *master); +int snd_pcm_unsupported_unlink(snd_pcm_t *pcm); +snd_pcm_sframes_t snd_pcm_unsupported_writei(snd_pcm_t *pcm, const void *buffer, snd_pcm_uframes_t size); +snd_pcm_sframes_t snd_pcm_unsupported_writen(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_t size); +snd_pcm_sframes_t snd_pcm_unsupported_readi(snd_pcm_t *pcm, void *buffer, snd_pcm_uframes_t size); +snd_pcm_sframes_t snd_pcm_unsupported_readn(snd_pcm_t *pcm, void **bufs, snd_pcm_uframes_t size); +snd_pcm_sframes_t snd_pcm_unsupported_mmap_commit(snd_pcm_t *pcm, + snd_pcm_uframes_t offset, + snd_pcm_uframes_t size); +snd_pcm_sframes_t snd_pcm_unsupported_avail_update(snd_pcm_t *pcm); +int snd_pcm_unsupported_htimestamp(snd_pcm_t *pcm, snd_pcm_uframes_t *avail, + snd_htimestamp_t *timestamp); +int snd_pcm_unsupported_real_htimestamp(snd_pcm_t *pcm, snd_pcm_uframes_t *avail, + snd_htimestamp_t *tstamp); +int snd_pcm_unsupported_mmap(snd_pcm_t *pcm); +int snd_pcm_unsupported_munmap(snd_pcm_t *pcm); +snd_pcm_chmap_query_t **snd_pcm_unsupported_query_chmaps(snd_pcm_t *pcm); +snd_pcm_chmap_t *snd_pcm_unsupported_get_chmap(snd_pcm_t *pcm); +int snd_pcm_unsupported_set_chmap(snd_pcm_t *pcm, const snd_pcm_chmap_t *map); +int snd_pcm_unsupported_may_wait_for_avail_min(snd_pcm_t *pcm, snd_pcm_uframes_t avail); + -- 2.7.4
From: Andreas Pape <apape@de.adit-jv.com> The general idea of this patch is to be able to open the device without defined bindings. This would start the audio clock without blocking any channel. This might be useful for hardware that requires running clock early at system start and to be available even without application streaming audio data. Signed-off-by: Andreas Pape <apape@de.adit-jv.com> Signed-off-by: Adam Miartus <amiartus@de.adit-jv.com> --- src/pcm/pcm_dshare.c | 72 +++++++++++++++++++++++++++++++++++++++-------- src/pcm/pcm_unsupported.h | 1 + 2 files changed, 62 insertions(+), 11 deletions(-) diff --git a/src/pcm/pcm_dshare.c b/src/pcm/pcm_dshare.c index b75809c..9008748 100644 --- a/src/pcm/pcm_dshare.c +++ b/src/pcm/pcm_dshare.c @@ -44,6 +44,7 @@ #include <sys/un.h> #include <sys/mman.h> #include "pcm_direct.h" +#include "pcm_unsupported.h" #ifndef PIC /* entry for static linking */ @@ -508,7 +509,8 @@ static int snd_pcm_dshare_close(snd_pcm_t *pcm) if (dshare->timer) snd_timer_close(dshare->timer); - do_silenca(pcm); + if (dshare->bindings) + do_silence(pcm); snd_pcm_direct_semaphore_down(dshare, DIRECT_IPC_SEM_CLIENT); dshare->shmptr->u.dshare.chn_mask &= ~dshare->u.dshare.chn_mask; snd_pcm_close(dshare->spcm); @@ -621,6 +623,54 @@ static void snd_pcm_dshare_dump(snd_pcm_t *pcm, snd_output_t *out) snd_pcm_dump(dshare->spcm, out); } +static const snd_pcm_ops_t snd_pcm_dshare_dummy_ops = { + .close = snd_pcm_dshare_close, + .info = snd_pcm_unsupported_info, + .hw_refine = snd_pcm_unsupported_hw_refine, + .hw_params = snd_pcm_unsupported_hw_params, + .hw_free = snd_pcm_unsupported_hw_free, + .sw_params = snd_pcm_unsupported_sw_params, + .channel_info = snd_pcm_unsupported_channel_info, + .dump = snd_pcm_unsupported_dump, + .nonblock = snd_pcm_unsupported_nonblock, + .async = snd_pcm_unsupported_async, + .mmap = snd_pcm_unsupported_mmap, + .munmap = snd_pcm_unsupported_munmap, + .get_chmap = snd_pcm_unsupported_get_chmap, + .set_chmap = snd_pcm_unsupported_set_chmap, +}; + +static const snd_pcm_fast_ops_t snd_pcm_dshare_fast_dummy_ops = { + .status = snd_pcm_unsupported_status, + .state = snd_pcm_unsupported_state, + .hwsync = snd_pcm_unsupported_hwsync, + .delay = snd_pcm_unsupported_delay, + .prepare = snd_pcm_unsupported_prepare, + .reset = snd_pcm_unsupported_reset, + .start = snd_pcm_unsupported_start, + .drop = snd_pcm_unsupported_drop, + .drain = snd_pcm_unsupported_drain, + .pause = snd_pcm_unsupported_pause, + .rewindable = snd_pcm_unsupported_rewindable, + .rewind = snd_pcm_unsupported_rewind, + .forwardable = snd_pcm_unsupported_forwardable, + .forward = snd_pcm_unsupported_forward, + .resume = snd_pcm_unsupported_resume, + .link = NULL, + .link_slaves = NULL, + .unlink = NULL, + .writei = snd_pcm_unsupported_writei, + .writen = snd_pcm_unsupported_writen, + .readi = snd_pcm_unsupported_readi, + .readn = snd_pcm_unsupported_readn, + .avail_update = snd_pcm_unsupported_avail_update, + .mmap_commit = snd_pcm_unsupported_mmap_commit, + .htimestamp = snd_pcm_unsupported_htimestamp, + .poll_descriptors = snd_pcm_unsupported_poll_descriptors, + .poll_descriptors_count = NULL, + .poll_revents = snd_pcm_unsupported_poll_revents, +}; + static const snd_pcm_ops_t snd_pcm_dshare_ops = { .close = snd_pcm_dshare_close, .info = snd_pcm_direct_info, @@ -713,12 +763,7 @@ int snd_pcm_dshare_open(snd_pcm_t **pcmp, const char *name, if (ret < 0) goto _err_nosem; - if (!dshare->bindings) { - SNDERR("dshare: specify bindings!!!"); - ret = -EINVAL; - goto _err_nosem; - } - + dshare->ipc_key = opts->ipc_key; dshare->ipc_perm = opts->ipc_perm; dshare->ipc_gid = opts->ipc_gid; @@ -751,9 +796,14 @@ int snd_pcm_dshare_open(snd_pcm_t **pcmp, const char *name, SNDERR("unable to create IPC shm instance"); goto _err; } - - pcm->ops = &snd_pcm_dshare_ops; - pcm->fast_ops = &snd_pcm_dshare_fast_ops; + + if (!dshare->bindings) { + pcm->ops = &snd_pcm_dshare_dummy_ops; + pcm->fast_ops = &snd_pcm_dshare_fast_dummy_ops; + } else { + pcm->ops = &snd_pcm_dshare_ops; + pcm->fast_ops = &snd_pcm_dshare_fast_ops; + } pcm->private_data = dshare; dshare->state = SND_PCM_STATE_OPEN; dshare->slowptr = opts->slowptr; @@ -843,7 +893,7 @@ int snd_pcm_dshare_open(snd_pcm_t **pcmp, const char *name, dshare->spcm = spcm; } - for (chn = 0; chn < dshare->channels; chn++) { + for (chn = 0; dshare->bindings && (chn < dshare->channels); chn++) { unsigned int dchn = dshare->bindings ? dshare->bindings[chn] : chn; if (dchn != UINT_MAX) dshare->u.dshare.chn_mask |= (1ULL << dchn); diff --git a/src/pcm/pcm_unsupported.h b/src/pcm/pcm_unsupported.h index 13e4d1b..5783222 100644 --- a/src/pcm/pcm_unsupported.h +++ b/src/pcm/pcm_unsupported.h @@ -114,6 +114,7 @@ #define snd_pcm_unsupported_may_wait_for_avail_min \ snd1_pcm_unsupported_may_wait_for_avail_min +void snd_pcm_unsupported_dump(snd_pcm_t *pcm, snd_output_t *out); int snd_pcm_unsupported_close(snd_pcm_t *pcm); int snd_pcm_unsupported_nonblock(snd_pcm_t *pcm, int nonblock); int snd_pcm_unsupported_async(snd_pcm_t *pcm, int sig, pid_t pid); -- 2.7.4
participants (1)
-
Adam Miartus