+/**
+ * \file pcm/pcm_alaw.c
+ * \ingroup PCM_Plugins
+ * \brief PCM A-Law Conversion Plugin Interface
+ * \author Abramo Bagnara <abramo@alsa-project.org>
+ * \date 2000-2001
+ */
/*
* PCM - A-Law conversion
* Copyright (c) 2000 by Abramo Bagnara <abramo@alsa-project.org>
*
*
* This library is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Library General Public License as
- * published by the Free Software Foundation; either version 2 of
+ * 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 Library General Public License for more details.
+ * GNU Lesser General Public License for more details.
*
- * You should have received a copy of the GNU Library General Public
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
-#include <byteswap.h>
+#include "bswap.h"
#include "pcm_local.h"
#include "pcm_plugin.h"
+#include "plugin_ops.h"
+
+#ifndef PIC
+/* entry for static linking */
+const char *_snd_module_pcm_alaw = "";
+#endif
+
+#ifndef DOC_HIDDEN
+
typedef void (*alaw_f)(const snd_pcm_channel_area_t *dst_areas,
snd_pcm_uframes_t dst_offset,
const snd_pcm_channel_area_t *src_areas,
snd_pcm_format_t sformat;
} snd_pcm_alaw_t;
+#endif
+
static inline int val_seg(int val)
{
int r = 1;
return ((a_val & 0x80) ? t : -t);
}
+#ifndef DOC_HIDDEN
+
void snd_pcm_alaw_decode(const snd_pcm_channel_area_t *dst_areas,
snd_pcm_uframes_t dst_offset,
const snd_pcm_channel_area_t *src_areas,
}
}
+#endif /* DOC_HIDDEN */
+
static int snd_pcm_alaw_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
{
snd_pcm_alaw_t *alaw = pcm->private_data;
snd_pcm_alaw_hw_refine_cchange,
snd_pcm_alaw_hw_refine_sprepare,
snd_pcm_alaw_hw_refine_schange,
- snd_pcm_plugin_hw_refine_slave);
+ snd_pcm_generic_hw_refine);
}
static int snd_pcm_alaw_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t * params)
{
snd_pcm_alaw_t *alaw = pcm->private_data;
+ snd_pcm_format_t format;
int err = snd_pcm_hw_params_slave(pcm, params,
snd_pcm_alaw_hw_refine_cchange,
snd_pcm_alaw_hw_refine_sprepare,
snd_pcm_alaw_hw_refine_schange,
- snd_pcm_plugin_hw_params_slave);
+ snd_pcm_generic_hw_params);
if (err < 0)
return err;
+ err = INTERNAL(snd_pcm_hw_params_get_format)(params, &format);
+ if (err < 0)
+ return err;
+
if (pcm->stream == SND_PCM_STREAM_PLAYBACK) {
if (alaw->sformat == SND_PCM_FORMAT_A_LAW) {
- alaw->getput_idx = snd_pcm_linear_get_index(snd_pcm_hw_params_get_format(params), SND_PCM_FORMAT_S16);
+ alaw->getput_idx = snd_pcm_linear_get_index(format, SND_PCM_FORMAT_S16);
alaw->func = snd_pcm_alaw_encode;
} else {
alaw->getput_idx = snd_pcm_linear_put_index(SND_PCM_FORMAT_S16, alaw->sformat);
}
} else {
if (alaw->sformat == SND_PCM_FORMAT_A_LAW) {
- alaw->getput_idx = snd_pcm_linear_put_index(SND_PCM_FORMAT_S16, snd_pcm_hw_params_get_format(params));
+ alaw->getput_idx = snd_pcm_linear_put_index(SND_PCM_FORMAT_S16, format);
alaw->func = snd_pcm_alaw_decode;
} else {
alaw->getput_idx = snd_pcm_linear_get_index(alaw->sformat, SND_PCM_FORMAT_S16);
snd_pcm_dump_setup(pcm, out);
}
snd_output_printf(out, "Slave: ");
- snd_pcm_dump(alaw->plug.slave, out);
+ snd_pcm_dump(alaw->plug.gen.slave, out);
}
-snd_pcm_ops_t snd_pcm_alaw_ops = {
- close: snd_pcm_plugin_close,
- info: snd_pcm_plugin_info,
- hw_refine: snd_pcm_alaw_hw_refine,
- hw_params: snd_pcm_alaw_hw_params,
- hw_free: snd_pcm_plugin_hw_free,
- sw_params: snd_pcm_plugin_sw_params,
- channel_info: snd_pcm_plugin_channel_info,
- dump: snd_pcm_alaw_dump,
- nonblock: snd_pcm_plugin_nonblock,
- async: snd_pcm_plugin_async,
- mmap: snd_pcm_plugin_mmap,
- munmap: snd_pcm_plugin_munmap,
+static const snd_pcm_ops_t snd_pcm_alaw_ops = {
+ .close = snd_pcm_generic_close,
+ .info = snd_pcm_generic_info,
+ .hw_refine = snd_pcm_alaw_hw_refine,
+ .hw_params = snd_pcm_alaw_hw_params,
+ .hw_free = snd_pcm_generic_hw_free,
+ .sw_params = snd_pcm_generic_sw_params,
+ .channel_info = snd_pcm_generic_channel_info,
+ .dump = snd_pcm_alaw_dump,
+ .nonblock = snd_pcm_generic_nonblock,
+ .async = snd_pcm_generic_async,
+ .mmap = snd_pcm_generic_mmap,
+ .munmap = snd_pcm_generic_munmap,
+ .query_chmaps = snd_pcm_generic_query_chmaps,
+ .get_chmap = snd_pcm_generic_get_chmap,
+ .set_chmap = snd_pcm_generic_set_chmap,
};
+/**
+ * \brief Creates a new A-Law conversion PCM
+ * \param pcmp Returns created PCM handle
+ * \param name Name of PCM
+ * \param sformat Slave (destination) format
+ * \param slave Slave PCM handle
+ * \param close_slave When set, the slave PCM handle is closed with copy PCM
+ * \retval zero on success otherwise a negative error code
+ * \warning Using of this function might be dangerous in the sense
+ * of compatibility reasons. The prototype might be freely
+ * changed in future.
+ */
int snd_pcm_alaw_open(snd_pcm_t **pcmp, const char *name, snd_pcm_format_t sformat, snd_pcm_t *slave, int close_slave)
{
snd_pcm_t *pcm;
snd_pcm_alaw_t *alaw;
+ int err;
assert(pcmp && slave);
if (snd_pcm_format_linear(sformat) != 1 &&
sformat != SND_PCM_FORMAT_A_LAW)
if (!alaw) {
return -ENOMEM;
}
+ snd_pcm_plugin_init(&alaw->plug);
alaw->sformat = sformat;
alaw->plug.read = snd_pcm_alaw_read_areas;
alaw->plug.write = snd_pcm_alaw_write_areas;
- alaw->plug.slave = slave;
- alaw->plug.close_slave = close_slave;
+ alaw->plug.undo_read = snd_pcm_plugin_undo_read_generic;
+ alaw->plug.undo_write = snd_pcm_plugin_undo_write_generic;
+ alaw->plug.gen.slave = slave;
+ alaw->plug.gen.close_slave = close_slave;
- pcm = calloc(1, sizeof(snd_pcm_t));
- if (!pcm) {
+ err = snd_pcm_new(&pcm, SND_PCM_TYPE_ALAW, name, slave->stream, slave->mode);
+ if (err < 0) {
free(alaw);
- return -ENOMEM;
+ return err;
}
- if (name)
- pcm->name = strdup(name);
- pcm->type = SND_PCM_TYPE_ALAW;
- pcm->stream = slave->stream;
- pcm->mode = slave->mode;
pcm->ops = &snd_pcm_alaw_ops;
- pcm->op_arg = pcm;
pcm->fast_ops = &snd_pcm_plugin_fast_ops;
- pcm->fast_op_arg = pcm;
pcm->private_data = alaw;
pcm->poll_fd = slave->poll_fd;
- pcm->hw_ptr = &alaw->plug.hw_ptr;
- pcm->appl_ptr = &alaw->plug.appl_ptr;
+ pcm->poll_events = slave->poll_events;
+ pcm->tstamp_type = slave->tstamp_type;
+ snd_pcm_set_hw_ptr(pcm, &alaw->plug.hw_ptr, -1, 0);
+ snd_pcm_set_appl_ptr(pcm, &alaw->plug.appl_ptr, -1, 0);
*pcmp = pcm;
return 0;
}
+/*! \page pcm_plugins
+
+\section pcm_plugins_alaw Plugin: A-Law
+
+This plugin converts A-Law samples to linear or linear to A-Law samples
+from master A-Law conversion PCM to given slave PCM. The channel count,
+format and rate must match for both of them.
+
+\code
+pcm.name {
+ type alaw # A-Law conversion PCM
+ slave STR # Slave name
+ # or
+ slave { # Slave definition
+ pcm STR # Slave PCM name
+ # or
+ pcm { } # Slave PCM definition
+ format STR # Slave format
+ }
+}
+\endcode
+
+\subsection pcm_plugins_alaw_funcref Function reference
+
+<UL>
+ <LI>snd_pcm_alaw_open()
+ <LI>_snd_pcm_alaw_open()
+</UL>
+
+*/
+
+/**
+ * \brief Creates a new A-Law conversion PCM
+ * \param pcmp Returns created PCM handle
+ * \param name Name of PCM
+ * \param root Root configuration node
+ * \param conf Configuration node with copy PCM description
+ * \param stream Stream type
+ * \param mode Stream mode
+ * \retval zero on success otherwise a negative error code
+ * \warning Using of this function might be dangerous in the sense
+ * of compatibility reasons. The prototype might be freely
+ * changed in future.
+ */
int _snd_pcm_alaw_open(snd_pcm_t **pcmp, const char *name,
- snd_config_t *conf,
- snd_pcm_stream_t stream, int mode)
+ snd_config_t *root, snd_config_t *conf,
+ snd_pcm_stream_t stream, int mode)
{
snd_config_iterator_t i, next;
- const char *sname = NULL;
int err;
snd_pcm_t *spcm;
- snd_config_t *slave = NULL;
+ snd_config_t *slave = NULL, *sconf;
snd_pcm_format_t sformat;
snd_config_for_each(i, next, conf) {
snd_config_t *n = snd_config_iterator_entry(i);
- const char *id = snd_config_get_id(n);
- if (strcmp(id, "comment") == 0)
+ const char *id;
+ if (snd_config_get_id(n, &id) < 0)
continue;
- if (strcmp(id, "type") == 0)
+ if (snd_pcm_conf_generic_id(id))
continue;
if (strcmp(id, "slave") == 0) {
slave = n;
SNDERR("slave is not defined");
return -EINVAL;
}
- err = snd_pcm_slave_conf(slave, &sname, 1,
- SND_PCM_HW_PARAM_FORMAT, 1, &sformat);
+ err = snd_pcm_slave_conf(root, slave, &sconf, 1,
+ SND_PCM_HW_PARAM_FORMAT, SCONF_MANDATORY, &sformat);
if (err < 0)
return err;
if (snd_pcm_format_linear(sformat) != 1 &&
sformat != SND_PCM_FORMAT_A_LAW) {
+ snd_config_delete(sconf);
SNDERR("invalid slave format");
return -EINVAL;
}
- /* This is needed cause snd_config_update may destroy config */
- sname = strdup(sname);
- if (!sname)
- return -ENOMEM;
- err = snd_pcm_open(&spcm, sname, stream, mode);
- free((void *) sname);
+ err = snd_pcm_open_slave(&spcm, root, sconf, stream, mode, conf);
+ snd_config_delete(sconf);
if (err < 0)
return err;
err = snd_pcm_alaw_open(pcmp, name, sformat, spcm, 1);
snd_pcm_close(spcm);
return err;
}
-
-
+#ifndef DOC_HIDDEN
+SND_DLSYM_BUILD_VERSION(_snd_pcm_alaw_open, SND_PCM_DLSYM_VERSION);
+#endif