--- /dev/null
+/*
+ Copyright (C) 2001 CodeFactory AB
+ Copyright (C) 2001 Thomas Nyberg <thomas@codefactory.se>
+ Copyright (C) 2001 Andy Wingo <apwingo@eos.ncsu.edu>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public
+ License as published by the Free Software Foundation; either
+ version 2 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
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public
+ License along with this library; if not, write to the Free
+ Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <stdlib.h>
+#include "alsa.h"
+
+static GstElementDetails gst_alsa_sink_details = {
+ "Alsa Sink",
+ "Sink/Audio",
+ "Output to a sound card via ALSA: see plugins/alsa/README for more info",
+ VERSION,
+ "Thomas Nyberg <thomas@codefactory.se>, "
+ "Andy Wingo <apwingo@eos.ncsu.edu>",
+ "(C) 2001 "
+};
+
+static GstElementDetails gst_alsa_src_details = {
+ "Alsa Src",
+ "Source/Audio",
+ "Read from a sound card via ALSA: see plugins/alsa/README for more info",
+ VERSION,
+ "Thomas Nyberg <thomas@codefactory.se>, "
+ "Andy Wingo <apwingo@eos.ncsu.edu>"
+ "(C) 2001",
+};
+
+static GstElement *parent_class = NULL;
+
+static void gst_alsa_init(GstAlsa *this);
+static void gst_alsa_class_init(GstAlsaClass *klass);
+
+static GstPadTemplate *gst_alsa_src_pad_factory();
+static GstPadTemplate *gst_alsa_src_request_pad_factory();
+static GstPadTemplate *gst_alsa_sink_pad_factory();
+static GstPadTemplate *gst_alsa_sink_request_pad_factory();
+
+static GstPad* gst_alsa_request_new_pad (GstElement *element, GstPadTemplate *templ, const
+ gchar *name);
+
+static void gst_alsa_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
+static void gst_alsa_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
+static GstElementStateReturn gst_alsa_change_state(GstElement *element);
+static GstPadNegotiateReturn gst_alsa_negotiate(GstPad *pad, GstCaps **caps, gpointer *user_data);
+
+static GstCaps* gst_alsa_caps (GstAlsa *this);
+
+static gboolean gst_alsa_open_audio(GstAlsa *this);
+static gboolean gst_alsa_start_audio(GstAlsa *this);
+static void gst_alsa_stop_audio(GstAlsa *this);
+static void gst_alsa_close_audio(GstAlsa *this);
+
+static gboolean gst_alsa_set_params(GstAlsa *this);
+static void gst_alsa_loop (GstElement *element);
+static gboolean gst_alsa_sink_process (GstAlsa *this, snd_pcm_uframes_t frames);
+static gboolean gst_alsa_src_process (GstAlsa *this, snd_pcm_uframes_t frames);
+
+static gboolean gst_alsa_get_channel_addresses (GstAlsa *this);
+static void gst_alsa_release_channel_addresses (GstAlsa *this);
+
+static void gst_alsa_sink_silence_on_channel (GstAlsa *this, guint32 chn, guint32 nframes);
+static void memset_interleave (char *dst, char val, unsigned int bytes,
+ unsigned int unit_bytes,
+ unsigned int skip_bytes);
+
+
+enum {
+ ARG_0,
+ ARG_DEVICE,
+ ARG_FORMAT,
+ ARG_CHANNELS,
+ ARG_RATE,
+ ARG_PERIODCOUNT,
+ ARG_PERIODFRAMES
+};
+
+GType
+gst_alsa_get_type (void)
+{
+ static GType alsa_type = 0;
+
+ if (!alsa_type) {
+ static const GTypeInfo alsa_info = {
+ sizeof(GstAlsaClass),
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ sizeof(GstAlsa),
+ 0,
+ NULL,
+ };
+ alsa_type = g_type_register_static (GST_TYPE_ELEMENT, "GstAlsa", &alsa_info, 0);
+ }
+ return alsa_type;
+}
+
+GType
+gst_alsa_sink_get_type (void)
+{
+ static GType alsa_type = 0;
+
+ if (!alsa_type) {
+ static const GTypeInfo alsa_info = {
+ sizeof(GstAlsaClass),
+ NULL,
+ NULL,
+ (GClassInitFunc)gst_alsa_class_init,
+ NULL,
+ NULL,
+ sizeof(GstAlsa),
+ 0,
+ (GInstanceInitFunc)gst_alsa_init,
+ };
+ alsa_type = g_type_register_static (GST_TYPE_ALSA, "GstAlsaSink", &alsa_info, 0);
+ }
+ return alsa_type;
+}
+
+GType
+gst_alsa_src_get_type (void)
+{
+ static GType alsa_type = 0;
+
+ if (!alsa_type) {
+ static const GTypeInfo alsa_info = {
+ sizeof(GstAlsaClass),
+ NULL,
+ NULL,
+ (GClassInitFunc)gst_alsa_class_init,
+ NULL,
+ NULL,
+ sizeof(GstAlsa),
+ 0,
+ (GInstanceInitFunc)gst_alsa_init,
+ };
+ alsa_type = g_type_register_static (GST_TYPE_ALSA, "GstAlsaSrc", &alsa_info, 0);
+ }
+ return alsa_type;
+}
+
+static GstPadTemplate*
+gst_alsa_src_pad_factory(void)
+{
+ static GstPadTemplate *template = NULL;
+
+ if (!template)
+ template = gst_padtemplate_new("src", GST_PAD_SRC, GST_PAD_SOMETIMES,
+ gst_caps_new("src", "audio/raw", NULL),
+ NULL);
+
+ return template;
+}
+
+static GstPadTemplate*
+gst_alsa_src_request_pad_factory(void)
+{
+ static GstPadTemplate *template = NULL;
+
+ if (!template)
+ template = gst_padtemplate_new("src%d", GST_PAD_SRC, GST_PAD_REQUEST,
+ gst_caps_new("src", "audio/raw",
+ gst_props_new("channels", GST_PROPS_INT(1), NULL)),
+ NULL);
+
+ return template;
+}
+
+static GstPadTemplate*
+gst_alsa_sink_pad_factory(void)
+{
+ static GstPadTemplate *template = NULL;
+
+ if (!template)
+ template = gst_padtemplate_new("sink", GST_PAD_SINK, GST_PAD_SOMETIMES,
+ gst_caps_new("sink", "audio/raw", NULL),
+ NULL);
+
+ return template;
+}
+
+static GstPadTemplate*
+gst_alsa_sink_request_pad_factory(void)
+{
+ static GstPadTemplate *template = NULL;
+
+ if (!template)
+ template = gst_padtemplate_new("sink%d", GST_PAD_SINK, GST_PAD_REQUEST,
+ gst_caps_new("sink-request", "audio/raw",
+ gst_props_new("channels", GST_PROPS_INT(1), NULL)),
+ NULL);
+
+ return template;
+}
+
+static void
+gst_alsa_class_init(GstAlsaClass *klass)
+{
+ GObjectClass *object_class;
+ GstElementClass *element_class;
+
+ object_class = (GObjectClass *)klass;
+ element_class = (GstElementClass *)klass;
+
+ if (parent_class == NULL)
+ parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+
+ object_class->get_property = gst_alsa_get_property;
+ object_class->set_property = gst_alsa_set_property;
+
+ g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_DEVICE,
+ g_param_spec_string("device","device","alsa device: please see README for details",
+ "default",
+ G_PARAM_READWRITE));
+ g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_FORMAT,
+ g_param_spec_int("format","format","format",
+ 0, SND_PCM_FORMAT_LAST, SND_PCM_FORMAT_S16,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_CHANNELS,
+ g_param_spec_int("channels","channels","channels",
+ 1, 64, 1,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_RATE,
+ g_param_spec_int("rate","rate","rate",
+ 8000, 192000, 44100,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_PERIODCOUNT,
+ g_param_spec_int("period_count","period count","period count",
+ 2, 64, 2,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_PERIODFRAMES,
+ g_param_spec_int("period_frames","period frames","period frames",
+ 64, 4096, 256,
+ G_PARAM_READWRITE));
+
+ element_class->change_state = gst_alsa_change_state;
+
+ element_class->request_new_pad = gst_alsa_request_new_pad;
+}
+
+static void
+gst_alsa_init(GstAlsa *this)
+{
+ /* init values */
+ this->handle = NULL;
+
+ /* i tried to trim this down to only the essentials needed for proper
+ * functioning; we'll be setting this values 'in earnest' when caps come */
+
+ this->rate = 44100;
+ this->channels = 2;
+
+ /* i wish i could leave these to defaults, but when caps come and typically
+ * the number of channels doubles, you can't have the default count and size
+ * that alsa gives you from the pre-caps setup apply to the post-caps setup
+ * due to internal hw buffer size restrictions. these values seem to be
+ * pretty common, though, although not pushing latency limits */
+ this->period_count = 2;
+ this->period_frames = 4096;
+
+ this->device = g_strdup("default");
+
+ /* is this right? */
+ GST_FLAG_SET(this, GST_ELEMENT_THREAD_SUGGESTED);
+
+ if (G_OBJECT_TYPE(this) == GST_TYPE_ALSA_SRC) {
+ this->stream = SND_PCM_STREAM_CAPTURE;
+ this->pads = g_list_append(NULL, g_new0(GstAlsaPad, 1));
+ GST_ALSA_PAD(this->pads)->pad = gst_pad_new_from_template(gst_alsa_src_pad_factory(), "src");
+ this->process = gst_alsa_src_process;
+ this->format = SND_PCM_FORMAT_S16; /* native endian */
+ } else if (G_OBJECT_TYPE(this) == GST_TYPE_ALSA_SINK) {
+ this->stream = SND_PCM_STREAM_PLAYBACK;
+ this->pads = g_list_append(NULL, g_new0(GstAlsaPad, 1));
+ GST_ALSA_PAD(this->pads)->pad = gst_pad_new_from_template(gst_alsa_sink_pad_factory(), "sink");
+ this->process = gst_alsa_sink_process;
+ this->format = SND_PCM_FORMAT_UNKNOWN; /* we don't know until caps are
+ * set */
+ } else {
+ g_print("you cannot instantiate an object of type gstalsa. use alsasink or alsasrc instead.\n");
+ G_BREAKPOINT();
+ return;
+ }
+
+ GST_ALSA_PAD(this->pads)->channel = -1;
+
+ this->data_interleaved = TRUE;
+
+ gst_element_add_pad(GST_ELEMENT(this), GST_ALSA_PAD(this->pads)->pad);
+
+ gst_pad_set_negotiate_function(GST_ALSA_PAD(this->pads)->pad, gst_alsa_negotiate);
+ gst_element_set_loop_function(GST_ELEMENT(this), gst_alsa_loop);
+}
+
+static GstPad*
+gst_alsa_request_new_pad (GstElement *element, GstPadTemplate *templ, const gchar *name)
+{
+ GstAlsa *this;
+ gint channel;
+ gchar *newname;
+ GList *l;
+ GstAlsaPad *pad;
+
+ g_return_val_if_fail (this = GST_ALSA(element), NULL);
+
+ /* you can't request a pad if the non-request pad is connected */
+ g_return_val_if_fail (this->data_interleaved == FALSE ||
+ this->pads == NULL ||
+ GST_ALSA_PAD(this->pads) == NULL ||
+ GST_ALSA_PAD(this->pads)->pad == NULL ||
+ GST_PAD_PEER(GST_ALSA_PAD(this->pads)->pad) == NULL,
+ NULL);
+
+ if (name) {
+ if (sscanf(name, templ->name_template, &channel) != 1) {
+ g_warning("invalid pad name %s (trying to fit with %s)", name,
+ templ->name_template);
+ return NULL;
+ }
+ l = this->pads;
+ while (l) {
+ if (GST_ALSA_PAD(l)->channel == channel) {
+ g_warning("requested channel %d already in use.", channel);
+ return NULL;
+ }
+ l = l->next;
+ }
+ } else {
+ l = this->pads;
+ channel = 0;
+ while (l) {
+ if (GST_ALSA_PAD(l)->channel > channel)
+ channel = GST_ALSA_PAD(l)->channel;
+ l = l->next;
+ }
+ }
+
+ newname = g_strdup_printf (templ->name_template, channel);
+
+ pad = g_new0(GstAlsaPad, 1);
+ pad->channel = channel;
+ pad->pad = gst_pad_new_from_template (templ, newname);
+ gst_element_add_pad (GST_ELEMENT (this), pad->pad);
+ gst_pad_set_negotiate_function(pad->pad, gst_alsa_negotiate);
+
+ if (this->data_interleaved && this->pads) {
+ gst_element_remove_pad (GST_ELEMENT (this), GST_ALSA_PAD(this->pads)->pad);
+ g_free (GST_ALSA_PAD(this->pads));
+ g_list_free (this->pads);
+ this->pads = NULL;
+ }
+
+ this->pads = g_list_append(this->pads, pad);
+
+ // FIXME: allow interleaved access (for hw:N,M access on consumer hardware)
+
+ if (this->data_interleaved) {
+ this->channels = pad->channel + 1;
+ this->data_interleaved = FALSE;
+ } else {
+ this->channels = MAX(this->channels, pad->channel + 1);
+ }
+
+ return pad->pad;
+}
+
+static void
+gst_alsa_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+ GstAlsa *this;
+
+ this = (GstAlsa *)object;
+ switch (prop_id) {
+ case ARG_DEVICE:
+ if (this->device)
+ g_free (this->device);
+ this->device = g_strdup(g_value_get_string (value));
+ break;
+ case ARG_FORMAT:
+ this->format = g_value_get_int (value);
+ break;
+ case ARG_CHANNELS:
+ this->channels = g_value_get_int (value);
+ break;
+ case ARG_RATE:
+ this->rate = g_value_get_int (value);
+ break;
+ case ARG_PERIODCOUNT:
+ this->period_count = g_value_get_int (value);
+ this->buffer_frames = this->period_count * this->period_frames;
+ break;
+ case ARG_PERIODFRAMES:
+ this->period_frames = g_value_get_int (value);
+ this->buffer_frames = this->period_count * this->period_frames;
+ break;
+ default:
+ GST_DEBUG(0, "Unknown arg");
+ return;
+ }
+
+ if (GST_STATE(this) == GST_STATE_NULL)
+ return;
+
+ if (GST_FLAG_IS_SET(this, GST_ALSA_RUNNING)) {
+ gst_alsa_stop_audio(this);
+ gst_alsa_set_params(this);
+ gst_alsa_start_audio(this);
+ } else {
+ gst_alsa_set_params(this);
+ }
+}
+
+static void
+gst_alsa_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+ GstAlsa *this;
+
+ this = (GstAlsa *)object;
+
+ switch (prop_id) {
+ case ARG_DEVICE:
+ g_value_set_string (value, this->device);
+ break;
+ case ARG_FORMAT:
+ g_value_set_int (value, this->format);
+ break;
+ case ARG_CHANNELS:
+ g_value_set_int (value, this->channels);
+ break;
+ case ARG_RATE:
+ g_value_set_int (value, this->rate);
+ break;
+ case ARG_PERIODCOUNT:
+ g_value_set_int (value, this->period_count);
+ break;
+ case ARG_PERIODFRAMES:
+ g_value_set_int (value, this->period_frames);
+ break;
+ default:
+ GST_DEBUG(0, "Unknown arg");
+ break;
+ }
+}
+
+static GstElementStateReturn
+gst_alsa_change_state(GstElement *element)
+{
+ GstAlsa *this;
+ guint chn;
+
+ g_return_val_if_fail(element != NULL, FALSE);
+ this = GST_ALSA (element);
+
+ switch (GST_STATE_PENDING(element)) {
+ case GST_STATE_NULL:
+ if (GST_FLAG_IS_SET(element, GST_ALSA_RUNNING))
+ gst_alsa_stop_audio((GstAlsa *)element);
+ if (GST_FLAG_IS_SET(element, GST_ALSA_OPEN))
+ gst_alsa_close_audio((GstAlsa *)element);
+ /* FIXME: clean up bytestreams, etc */
+ break;
+
+ case GST_STATE_READY:
+ break;
+
+ case GST_STATE_PAUSED:
+ if (GST_FLAG_IS_SET(element, GST_ALSA_OPEN) == FALSE)
+ if (gst_alsa_open_audio((GstAlsa *)element) == FALSE)
+ return GST_STATE_FAILURE;
+ if (GST_FLAG_IS_SET(element, GST_ALSA_RUNNING)) {
+ if (this->stream == SND_PCM_STREAM_PLAYBACK) {
+ for (chn = 0; chn < this->channels; chn++) {
+ gst_alsa_sink_silence_on_channel (this, chn, this->avail);
+ }
+ }
+ gst_alsa_stop_audio((GstAlsa *)element);
+ }
+ break;
+
+ case GST_STATE_PLAYING:
+ if (GST_FLAG_IS_SET(element, GST_ALSA_RUNNING) == FALSE)
+ if (gst_alsa_start_audio((GstAlsa *)element) == FALSE)
+ return GST_STATE_FAILURE;
+ break;
+ }
+
+ if (GST_ELEMENT_CLASS(parent_class)->change_state)
+ return GST_ELEMENT_CLASS(parent_class)->change_state(element);
+
+ return GST_STATE_SUCCESS;
+}
+
+static gboolean
+gst_alsa_parse_caps (GstAlsa *this, GstCaps *caps)
+{
+ gint law, endianness, width, depth;
+ gboolean sign;
+ gint format = -1;
+ const gchar* format_name;
+
+ format_name = gst_caps_get_string(caps, "format");
+
+ if (format_name == NULL) {
+ return FALSE;
+ } else if (strcmp(format_name, "int")==0) {
+ width = gst_caps_get_int (caps, "width");
+ depth = gst_caps_get_int (caps, "depth");
+
+ law = gst_caps_get_int (caps, "law");
+ endianness = gst_caps_get_int (caps, "endianness");
+ sign = gst_caps_get_boolean (caps, "signed");
+
+ if (law == 0) {
+ if (width == 8) {
+ if (sign == TRUE) {
+ format = SND_PCM_FORMAT_S8;
+ } else {
+ format = SND_PCM_FORMAT_U8;
+ }
+ } else if (width == 16) {
+ if (sign == TRUE) {
+ if (endianness == G_LITTLE_ENDIAN)
+ format = SND_PCM_FORMAT_S16_LE;
+ else if (endianness == G_BIG_ENDIAN)
+ format = SND_PCM_FORMAT_S16_BE;
+ } else {
+ if (endianness == G_LITTLE_ENDIAN)
+ format = SND_PCM_FORMAT_U16_LE;
+ else if (endianness == G_BIG_ENDIAN)
+ format = SND_PCM_FORMAT_U16_BE;
+ }
+ } else if (width == 24) {
+ if (sign == TRUE) {
+ if (endianness == G_LITTLE_ENDIAN)
+ format = SND_PCM_FORMAT_S24_LE;
+ else if (endianness == G_BIG_ENDIAN)
+ format = SND_PCM_FORMAT_S24_BE;
+ } else {
+ if (endianness == G_LITTLE_ENDIAN)
+ format = SND_PCM_FORMAT_U24_LE;
+ else if (endianness == G_BIG_ENDIAN)
+ format = SND_PCM_FORMAT_U24_BE;
+ }
+ } else if (width == 32) {
+ if (sign == TRUE) {
+ if (endianness == G_LITTLE_ENDIAN)
+ format = SND_PCM_FORMAT_S32_LE;
+ else if (endianness == G_BIG_ENDIAN)
+ format = SND_PCM_FORMAT_S32_BE;
+ } else {
+ if (endianness == G_LITTLE_ENDIAN)
+ format = SND_PCM_FORMAT_U32_LE;
+ else if (endianness == G_BIG_ENDIAN)
+ format = SND_PCM_FORMAT_U32_BE;
+ }
+ }
+ } else if (law == 1) { /* mu law */
+ if (width == depth && width == 8 && sign == FALSE) {
+ format = SND_PCM_FORMAT_MU_LAW;
+ } else {
+ return FALSE;
+ }
+ } else if (law == 2) { /* a law, ug. */
+ if (width == depth && width == 8 && sign == FALSE) {
+ format = SND_PCM_FORMAT_A_LAW;
+ }
+ } else {
+ return FALSE;
+ }
+ } else if (strcmp(format_name, "float")==0) {
+ if (strcmp(gst_caps_get_string(caps, "layout"), "gfloat")==0) {
+ format = SND_PCM_FORMAT_FLOAT;
+ } else {
+ return FALSE;
+ /* if you need float64, chat w/ me on irc.gstreamer.net and i'll tell you what needs to
+ * be done. i'm 'wingo'. */
+ }
+ } else {
+ return FALSE;
+ }
+
+ this->format = format;
+ this->rate = gst_caps_get_int(caps, "rate");
+ if (this->data_interleaved)
+ this->channels = gst_caps_get_int(caps, "channels");
+ else if (gst_caps_get_int(caps, "channels") != 1)
+ return FALSE;
+
+ return TRUE;
+}
+
+/* caps are so painful sometimes. */
+static GstCaps*
+gst_alsa_caps (GstAlsa *this)
+{
+ gint law, endianness, width, depth;
+ gboolean sign;
+ GstProps *props;
+
+ g_return_val_if_fail (this != NULL && this->handle != NULL, NULL);
+
+ if (this->format == SND_PCM_FORMAT_FLOAT) {
+ props = gst_props_new ("format", GST_PROPS_STRING ("float"),
+ "layout", GST_PROPS_STRING ("gfloat"),
+ "rate", GST_PROPS_INT (this->rate),
+ "channels", GST_PROPS_INT ((this->data_interleaved ? this->channels : 1)),
+ NULL);
+ } else {
+ // we'll just have to assume int, i don't feel like checking
+ if (this->format == SND_PCM_FORMAT_MU_LAW) {
+ law = 1;
+ width = 8;
+ sign = FALSE;
+ endianness = 0;
+ } else if (this->format == SND_PCM_FORMAT_A_LAW) {
+ law = 2;
+ width = 8;
+ sign = FALSE;
+ endianness = 0;
+ } else {
+ law = 0;
+ if (this->format == SND_PCM_FORMAT_S8) {
+ width = 8;
+ sign = TRUE;
+ endianness = 0;
+ } else if (this->format == SND_PCM_FORMAT_U8) {
+ width = 8;
+ sign = FALSE;
+ endianness = 0;
+ } else if (this->format == SND_PCM_FORMAT_S16_LE) {
+ width = 16;
+ sign = TRUE;
+ endianness = G_LITTLE_ENDIAN;
+ } else if (this->format == SND_PCM_FORMAT_S16_BE) {
+ width = 16;
+ sign = TRUE;
+ endianness = G_BIG_ENDIAN;
+ } else if (this->format == SND_PCM_FORMAT_U16_LE) {
+ width = 16;
+ sign = FALSE;
+ endianness = G_LITTLE_ENDIAN;
+ } else if (this->format == SND_PCM_FORMAT_U16_BE) {
+ width = 16;
+ sign = FALSE;
+ endianness = G_BIG_ENDIAN;
+ } else if (this->format == SND_PCM_FORMAT_S24_LE) {
+ width = 24;
+ sign = TRUE;
+ endianness = G_LITTLE_ENDIAN;
+ } else if (this->format == SND_PCM_FORMAT_S24_BE) {
+ width = 24;
+ sign = TRUE;
+ endianness = G_BIG_ENDIAN;
+ } else if (this->format == SND_PCM_FORMAT_U24_LE) {
+ width = 24;
+ sign = FALSE;
+ endianness = G_LITTLE_ENDIAN;
+ } else if (this->format == SND_PCM_FORMAT_U24_BE) {
+ width = 24;
+ sign = FALSE;
+ endianness = G_BIG_ENDIAN;
+ } else if (this->format == SND_PCM_FORMAT_S32_LE) {
+ width = 32;
+ sign = TRUE;
+ endianness = G_LITTLE_ENDIAN;
+ } else if (this->format == SND_PCM_FORMAT_S32_BE) {
+ width = 32;
+ sign = TRUE;
+ endianness = G_BIG_ENDIAN;
+ } else if (this->format == SND_PCM_FORMAT_U32_LE) {
+ width = 32;
+ sign = FALSE;
+ endianness = G_LITTLE_ENDIAN;
+ } else if (this->format == SND_PCM_FORMAT_U32_BE) {
+ width = 32;
+ sign = FALSE;
+ endianness = G_BIG_ENDIAN;
+ } else {
+ g_error ("what is going on here?");
+ return NULL;
+ }
+ }
+ depth = width;
+ props = gst_props_new ("format", GST_PROPS_STRING ("int"),
+ "rate", GST_PROPS_INT (this->rate),
+ "channels", GST_PROPS_INT ((this->data_interleaved ? this->channels : 1)),
+ "law", GST_PROPS_INT (law),
+ "endianness", GST_PROPS_INT (endianness),
+ "signed", GST_PROPS_BOOLEAN (sign),
+ "width", GST_PROPS_INT (width),
+ "depth", GST_PROPS_INT (depth),
+ NULL);
+ }
+
+ return gst_caps_new ("alsasrc", "audio/raw", props);
+}
+
+/*
+ * Negotiates the caps, "borrowed" from gstosssink.c
+ */
+GstPadNegotiateReturn
+gst_alsa_negotiate(GstPad *pad, GstCaps **caps, gpointer *user_data)
+{
+ GstAlsa *this;
+ gboolean need_mmap;
+
+ g_return_val_if_fail (pad != NULL, GST_PAD_NEGOTIATE_FAIL);
+ g_return_val_if_fail (GST_IS_PAD (pad), GST_PAD_NEGOTIATE_FAIL);
+
+ this = GST_ALSA(gst_pad_get_parent(pad));
+
+ // we decide
+ if (user_data == NULL) {
+ *caps = NULL;
+ return GST_PAD_NEGOTIATE_TRY;
+ }
+ // have we got caps?
+ else if (*caps) {
+ if (this->handle == NULL)
+ return GST_PAD_NEGOTIATE_FAIL;
+
+ if (gst_alsa_parse_caps(this, *caps)) {
+ need_mmap = this->mmap_open;
+
+ /* sync the params */
+ if (GST_FLAG_IS_SET(this, GST_ALSA_RUNNING))
+ gst_alsa_stop_audio(this);
+
+ if (GST_FLAG_IS_SET(this, GST_ALSA_OPEN))
+ gst_alsa_close_audio(this);
+
+ // FIXME send out another caps if nego fails
+
+ if (!gst_alsa_open_audio(this))
+ return GST_PAD_NEGOTIATE_FAIL;
+
+ if (!gst_alsa_start_audio(this))
+ return GST_PAD_NEGOTIATE_FAIL;
+
+ if (need_mmap && !gst_alsa_get_channel_addresses(this))
+ return GST_PAD_NEGOTIATE_FAIL;
+
+ return GST_PAD_NEGOTIATE_AGREE;
+ }
+
+ return GST_PAD_NEGOTIATE_FAIL;
+ }
+
+ return GST_PAD_NEGOTIATE_FAIL;
+}
+
+/* shamelessly stolen from pbd's audioengine. thanks, paul! */
+static void
+gst_alsa_loop (GstElement *element)
+{
+ struct pollfd pfd;
+ gboolean xrun_detected;
+ guint32 i;
+ GstAlsa *this = GST_ALSA(element);
+
+ g_return_if_fail(this != NULL);
+
+ snd_pcm_poll_descriptors (this->handle, &pfd, 1);
+
+ if (this->stream == SND_PCM_STREAM_PLAYBACK) {
+ pfd.events = POLLOUT | POLLERR;
+ } else {
+ pfd.events = POLLIN | POLLERR;
+ }
+
+ do {
+ if (poll (&pfd, 1, 1000) < 0) {
+ if (errno == EINTR) {
+ /* this happens mostly when run
+ * under gdb, or when exiting due to a signal */
+ g_print ("EINTR\n");
+ continue;
+ }
+
+ g_warning("poll call failed (%s)", strerror(errno));
+ return;
+ }
+
+ if (pfd.revents & POLLERR) {
+ g_warning("alsa: poll reports error.");
+ return;
+ }
+
+ if (pfd.revents == 0) {
+ g_print ("poll on alsa %s device \"%s\" timed out\n",
+ this->stream==SND_PCM_STREAM_CAPTURE ? "capture" : "playback",
+ this->device);
+ /* timed out, such as when the device is paused */
+ continue;
+ }
+
+ xrun_detected = FALSE;
+
+ this->avail = snd_pcm_avail_update (this->handle);
+// g_print ("snd_pcm_avail_update() = %d\n", this->avail);
+
+ if (this->avail < 0) {
+ if (this->avail == -EPIPE) {
+ xrun_detected = TRUE;
+ } else {
+ g_warning("unknown ALSA avail_update return value (%d)",
+ (int)this->avail);
+ return;
+ }
+ }
+
+ /* pretty sophisticated eh? */
+ if (xrun_detected)
+ g_warning ("xrun detected");
+
+ /* we need to loop here because the available bytes might not be
+ * contiguous */
+ while (this->avail) {
+ /* changes this->avail, as a side effect */
+ if (!gst_alsa_get_channel_addresses (this) < 0) {
+ g_error("could not get channels");
+ return;
+ }
+
+ if (this->mute && this->stream == SND_PCM_STREAM_PLAYBACK) {
+ for (i = 0; i < this->channels; i++) {
+ if (this->mute & (1<<i)) {
+ gst_alsa_sink_silence_on_channel (this, i, this->buffer_frames);
+ }
+ }
+ }
+
+ if (!this->process(this, this->avail)) {
+ g_warning("alsa: something happened while processing audio");
+ return;
+ }
+
+ /* we could have released the mmap regions on a state change */
+ if (this->mmap_open)
+ gst_alsa_release_channel_addresses(this);
+ }
+ gst_element_yield (element);
+ } while (TRUE);
+}
+
+static gboolean
+gst_alsa_src_process (GstAlsa *this, snd_pcm_uframes_t frames)
+{
+ GstBuffer *buf;
+ GList *l;
+ GstAlsaPad *pad = NULL;
+ GstCaps *caps;
+ gint unit;
+// gint i=0;
+
+ static gboolean caps_set = FALSE;
+
+ if (!caps_set) {
+ /* let's get on the caps-setting merry-go-round! */
+ caps = gst_alsa_caps(this);
+ l = this->pads;
+ while (l) {
+ if (!gst_pad_set_caps (GST_ALSA_PAD(l)->pad, caps)) {
+ g_print ("DANGER WILL ROBINSON!\n");
+ sleep(1);
+ return FALSE;
+ }
+
+ l = l->next;
+ }
+ caps_set = TRUE;
+ }
+
+ unit = this->sample_bytes * (this->data_interleaved ? this->channels : 1);
+
+ while (frames) {
+// g_print ("(%d) frames to process: %d\n", i++, frames);
+ l = this->pads;
+ while (l) {
+ pad = GST_ALSA_PAD(l);
+
+ if (!pad->buf) {
+ pad->buf = g_malloc(this->period_frames * unit);
+ // g_print ("created buffer %p of size %d\n", pad->buf, this->period_frames * unit);
+ }
+ /*
+ g_print ("pad->buf = %p, offset = %d\n", pad->buf, pad->offset);
+ g_print ("about to memcpy(%p, %p, %d)\n",
+ pad->buf + pad->offset * unit,
+ pad->access_addr,
+ MIN(frames, this->period_frames - pad->offset) * unit);
+ */
+ memcpy(pad->buf + pad->offset * unit,
+ pad->access_addr,
+ MIN(frames, this->period_frames - pad->offset) * unit);
+
+ pad->offset += MIN(frames, this->period_frames - pad->offset);
+
+ if (pad->offset >= this->period_frames) {
+ if (pad->offset > this->period_frames)
+ G_BREAKPOINT();
+
+ buf = gst_buffer_new();
+ GST_BUFFER_DATA(buf) = pad->buf;
+ GST_BUFFER_SIZE(buf) = this->period_frames * unit;
+ GST_BUFFER_MAXSIZE(buf) = this->period_frames * unit;
+ gst_pad_push(pad->pad, buf);
+ pad->buf = NULL;
+ pad->offset = 0;
+ }
+ l = l->next;
+ }
+ frames -= MIN(frames, this->period_frames - pad->offset); // shouldn't
+ // matter which pad, in theory (tm)
+ }
+
+ return TRUE;
+}
+
+static gboolean
+gst_alsa_sink_process (GstAlsa *this, snd_pcm_uframes_t frames)
+{
+ guint8 *peeked;
+ guint32 len, avail;
+ GstEvent *event = NULL;
+ GList *l;
+
+ /* this is necessary because the sample_bytes will change, probably, when
+ * caps are set, which will occur after the first bytestream_peek. we
+ * underestimate the amount of data we will need by peeking 'frames' only.
+ * */
+
+ if (!this->sample_bytes) {
+ if (!GST_ALSA_PAD(this->pads)->bs)
+ GST_ALSA_PAD(this->pads)->bs = gst_bytestream_new(GST_ALSA_PAD(this->pads)->pad);
+
+ if (!(peeked = gst_bytestream_peek_bytes(GST_ALSA_PAD(this->pads)->bs, frames))) {
+ g_warning("initial pull on pad %s returned NULL", GST_OBJECT_NAME(GST_ALSA_PAD(this->pads)->pad));
+ gst_element_set_state(GST_ELEMENT(this), GST_STATE_PAUSED);
+ return FALSE;
+ }
+
+ if (!this->sample_bytes) {
+ g_critical ("alsa plugin requires a pipeline that can adequately set caps.");
+ return FALSE;
+ }
+ }
+
+ len = frames * this->channels * this->sample_bytes;
+
+ l = this->pads;
+ while (l) {
+ if (!GST_ALSA_PAD(this->pads)->bs)
+ GST_ALSA_PAD(this->pads)->bs = gst_bytestream_new(GST_ALSA_PAD(this->pads)->pad);
+
+ if (!(peeked = gst_bytestream_peek_bytes(GST_ALSA_PAD(this->pads)->bs, len))) {
+ gst_bytestream_get_status(GST_ALSA_PAD(this->pads)->bs, &avail, &event);
+ if (event) {
+ g_warning("got an event on alsasink");
+ if (GST_EVENT_TYPE(event) == GST_EVENT_EOS) {
+ /* really, we should just cut this pad out of the graph. let
+ * me know when this is needed ;)
+ * also, for sample accuracy etc, we should play avail
+ * bytes, but hey. */
+ gst_element_set_state(GST_ELEMENT(this), GST_STATE_PAUSED);
+ gst_event_free(event);
+ return TRUE;
+ }
+ } else {
+ /* the element at the top of the chain did not emit an eos
+ * event. this is a Bug(tm) */
+ g_assert_not_reached();
+ }
+ }
+
+ memcpy(GST_ALSA_PAD(this->pads)->access_addr, peeked, len);
+ gst_bytestream_flush(GST_ALSA_PAD(this->pads)->bs, len);
+
+ l=l->next;
+ }
+
+ return TRUE;
+}
+
+/* taken more or less from pbd's audioengine code */
+static gboolean
+gst_alsa_set_params (GstAlsa *this)
+{
+ snd_pcm_sw_params_t *sw_param;
+ snd_pcm_hw_params_t *hw_param;
+ snd_pcm_access_mask_t *mask;
+ gint ret;
+
+ g_return_val_if_fail(this != NULL, FALSE);
+ g_return_val_if_fail(this->handle != NULL, FALSE);
+
+ g_print("Preparing channel: %s %dHz, %d channels\n",
+ snd_pcm_format_name(this->format),
+ this->rate, this->channels);
+
+ snd_pcm_hw_params_alloca(&hw_param);
+ snd_pcm_sw_params_alloca(&sw_param);
+
+ ret = snd_pcm_hw_params_any(this->handle, hw_param);
+ if (ret < 0) {
+ g_warning("Broken configuration for this PCM: no configurations available");
+ return FALSE;
+ }
+
+ if ((ret = snd_pcm_hw_params_set_periods_integer (this->handle, hw_param)) < 0) {
+ g_warning("cannot restrict period size to integral value.");
+ return FALSE;
+ }
+
+ mask = alloca(snd_pcm_access_mask_sizeof());
+ snd_pcm_access_mask_none(mask);
+
+ if (this->data_interleaved)
+ snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
+
+ snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
+ ret = snd_pcm_hw_params_set_access_mask(this->handle, hw_param, mask);
+ if (ret < 0) {
+ g_warning("the gstreamer alsa plugin does not support your hardware.");
+ return FALSE;
+ }
+
+ if (this->format != SND_PCM_FORMAT_UNKNOWN) {
+ ret = snd_pcm_hw_params_set_format(this->handle, hw_param, this->format);
+ if (ret < 0) {
+ g_warning("Sample format (%s) not available: %s", snd_pcm_format_name(this->format), snd_strerror(ret));
+ return FALSE;
+ }
+ this->sample_bytes = snd_pcm_format_physical_width(this->format) / 8;
+ }
+
+ ret = snd_pcm_hw_params_set_channels(this->handle, hw_param, this->channels);
+ if (ret < 0) {
+ g_warning("Channels count (%d) not available: %s", this->channels, snd_strerror(ret));
+ return FALSE;
+ }
+ this->channels = snd_pcm_hw_params_get_channels(hw_param);
+
+ if (this->rate) {
+ ret = snd_pcm_hw_params_set_rate(this->handle, hw_param, this->rate, 0);
+ if (ret < 0) {
+ g_warning("error setting rate (%d): %s", this->rate, snd_strerror(ret));
+ return FALSE;
+ }
+ }
+
+ if (this->period_count) {
+ ret = snd_pcm_hw_params_set_periods (this->handle, hw_param, this->period_count, 0);
+ if (ret < 0) {
+ g_warning("error setting period count minimum (%d): %s", this->period_count, snd_strerror(ret));
+ return FALSE;
+ }
+ }
+
+ if (this->period_frames) {
+ ret = snd_pcm_hw_params_set_period_size (this->handle, hw_param, this->period_frames, 0);
+ if (ret < 0) {
+ g_warning("error setting period in frames (%d): %s", this->period_frames, snd_strerror(ret));
+ return FALSE;
+ }
+ }
+
+ if (this->buffer_frames) {
+ ret = snd_pcm_hw_params_set_buffer_size (this->handle, hw_param, this->buffer_frames);
+ if (ret < 0) {
+ g_warning("error setting buffer size (%d): %s", this->buffer_frames, snd_strerror(ret));
+ return FALSE;
+ }
+ }
+
+ ret = snd_pcm_hw_params(this->handle, hw_param);
+ if (ret < 0) {
+ g_warning("could not set hw params: %s", snd_strerror(ret));
+ snd_pcm_hw_params_dump(hw_param, this->out);
+ return FALSE;
+ }
+
+ if (!this->rate)
+ this->rate = snd_pcm_hw_params_get_rate(hw_param, 0);
+ if (!this->format)
+ this->format = snd_pcm_hw_params_get_format(hw_param);
+ if (!this->period_count)
+ this->period_count = snd_pcm_hw_params_get_periods(hw_param, 0);
+ if (!this->period_frames)
+ this->period_frames = snd_pcm_hw_params_get_period_size(hw_param, 0);
+ if (!this->buffer_frames)
+ this->buffer_frames = snd_pcm_hw_params_get_buffer_size(hw_param);
+ if (this->buffer_frames != this->period_count * this->period_frames)
+ g_critical ("buffer size != period size * number of periods, unexpected things may happen!");
+
+ snd_pcm_sw_params_current (this->handle, sw_param);
+
+ ret = snd_pcm_sw_params_set_start_threshold (this->handle, sw_param, ~0U);
+ if (ret < 0) {
+ g_warning("could not set start mode: %s", snd_strerror(ret));
+ return FALSE;
+ }
+
+ ret = snd_pcm_sw_params_set_stop_threshold (this->handle, sw_param, ~0U);
+ if (ret < 0) {
+ g_warning("could not set stop mode: %s", snd_strerror(ret));
+ return FALSE;
+ }
+
+ ret = snd_pcm_sw_params_set_silence_threshold (this->handle, sw_param, 0);
+ if (ret < 0) {
+ g_warning("could not set silence threshold: %s", snd_strerror(ret));
+ return FALSE;
+ }
+
+ ret = snd_pcm_sw_params_set_silence_size (this->handle, sw_param, this->buffer_frames);
+ if (ret < 0) {
+ g_warning("could not set silence size: %s", snd_strerror(ret));
+ return FALSE;
+ }
+
+ ret = snd_pcm_sw_params_set_avail_min (this->handle, sw_param, this->period_frames);
+ if (ret < 0) {
+ g_warning("could not set avail min: %s", snd_strerror(ret));
+ return FALSE;
+ }
+
+ ret = snd_pcm_sw_params (this->handle, sw_param);
+ if (ret < 0) {
+ g_warning("could not set sw_params: %s", snd_strerror(ret));
+ return FALSE;
+ }
+
+ snd_pcm_dump(this->handle, this->out);
+
+ this->access_interleaved = !(snd_pcm_hw_params_get_access (hw_param) ==
+ SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
+
+ if (this->access_interleaved) {
+ this->interleave_unit = this->sample_bytes;
+ this->interleave_skip = this->interleave_unit * this->channels;
+ } else {
+ this->interleave_unit = 0; /* not used */
+ this->interleave_skip = this->sample_bytes;
+ }
+
+ if (this->access_addr)
+ g_free (this->access_addr);
+ this->access_addr = g_new0 (char*, this->channels);
+
+ return TRUE;
+}
+
+static gboolean
+gst_alsa_open_audio(GstAlsa *this)
+{
+ gint ret;
+ g_assert(this != NULL);
+
+ if (this->handle)
+ gst_alsa_close_audio(this);
+
+ g_print("Opening alsa device \"%s\" for %s...\n", this->device,
+ this->stream==SND_PCM_STREAM_PLAYBACK ? "playback" : "capture");
+
+ ret = snd_output_stdio_attach(&this->out, stdout, 0);
+ if (ret < 0) {
+ g_print("error opening log output: %s", snd_strerror(ret));
+ return FALSE;
+ }
+
+ /* blocking i/o */
+ if ((ret = snd_pcm_open(&this->handle, this->device, this->stream, 0))) {
+ g_print("error opening pcm device: %s", snd_strerror(ret));
+ return FALSE;
+ }
+
+ if (gst_alsa_set_params(this) == FALSE) {
+ gst_alsa_close_audio(this);
+ return FALSE;
+ }
+
+ GST_FLAG_SET(this, GST_ALSA_OPEN);
+ return TRUE;
+}
+
+
+static gboolean
+gst_alsa_start_audio(GstAlsa *this)
+{
+ gint err;
+ guint32 chn;
+
+ g_return_val_if_fail(this != NULL, FALSE);
+ g_return_val_if_fail(this->handle != NULL, FALSE);
+
+ if ((err = snd_pcm_prepare (this->handle)) < 0) {
+ g_warning("channel prepare failed: %s", snd_strerror (err));
+ return FALSE;
+ }
+
+ this->avail = snd_pcm_avail_update (this->handle);
+
+ if (this->stream == SND_PCM_STREAM_PLAYBACK &&
+ this->avail != this->buffer_frames) {
+ g_warning ("full buffer not available at start");
+ return FALSE;
+ }
+
+ if (!gst_alsa_get_channel_addresses (this)) {
+ return FALSE;
+ }
+
+ if (this->stream == SND_PCM_STREAM_PLAYBACK) {
+ for (chn = 0; chn < this->channels; chn++) {
+ gst_alsa_sink_silence_on_channel (this, chn, this->buffer_frames);
+ }
+ }
+
+ gst_alsa_release_channel_addresses (this);
+
+ if ((err = snd_pcm_start (this->handle)) < 0) {
+ g_warning("could not start audio: %s", snd_strerror (err));
+ return FALSE;
+ }
+
+ GST_FLAG_SET(this, GST_ALSA_RUNNING);
+ return TRUE;
+}
+
+static void
+gst_alsa_stop_audio(GstAlsa *this)
+{
+ gint err;
+ g_assert(this != NULL);
+
+ g_return_if_fail(this != NULL);
+ g_return_if_fail(this->handle != NULL);
+
+ if (this->mmap_open)
+ gst_alsa_release_channel_addresses (this);
+
+ if (this->stream == SND_PCM_STREAM_PLAYBACK &&
+ (err = snd_pcm_drop (this->handle)) < 0) {
+ g_warning("channel flush failed: %s", snd_strerror (err));
+ return;
+ }
+
+ GST_FLAG_UNSET(this, GST_ALSA_RUNNING);
+}
+
+static void
+gst_alsa_close_audio(GstAlsa *this)
+{
+// gint err;
+ g_return_if_fail(this != NULL);
+ g_return_if_fail(this->handle != NULL);
+
+/* if ((err = snd_pcm_drop (this->handle)) < 0) {
+ g_warning("channel flush for failed: %s", snd_strerror (err));
+ return;
+ } */
+
+ snd_pcm_close(this->handle);
+
+ this->handle = NULL;
+
+ GST_FLAG_UNSET(this, GST_ALSA_OPEN);
+}
+
+static gboolean
+gst_alsa_get_channel_addresses (GstAlsa *this)
+{
+ guint32 err, i;
+ const snd_pcm_channel_area_t *a;
+ GList *l;
+
+ g_return_val_if_fail (this->mmap_open == FALSE, FALSE);
+
+ if ((err = snd_pcm_mmap_begin (this->handle, &this->mmap_areas, &this->offset, &this->avail)) < 0) {
+ g_warning("gstalsa: mmap failed: %s", snd_strerror(err));
+ return FALSE;
+ }
+
+ GST_DEBUG(0, "got %d mmap'd frames\n", (int)this->avail);
+
+// g_print ("snd_pcm_mmap_begin() sets avail = %d\n", this->avail);
+
+ l = this->pads;
+ while (l) {
+ a = &this->mmap_areas[GST_ALSA_PAD(l)->channel > 0 ?
+ GST_ALSA_PAD(l)->channel-1 : 0];
+ GST_ALSA_PAD(l)->access_addr = (char *) a->addr + ((a->first + a->step *
+ this->offset) / 8);
+ l = l->next;
+ }
+
+ for (i=0; i<this->channels; i++) {
+ a = &this->mmap_areas[i];
+ this->access_addr[i] = (char *) a->addr + ((a->first + a->step * this->offset) / 8);
+ }
+
+ this->mmap_open = TRUE;
+
+ return TRUE;
+}
+
+static void
+gst_alsa_release_channel_addresses (GstAlsa *this)
+{
+ guint32 err, i;
+ GList *l;
+
+ g_return_if_fail (this->mmap_open == TRUE);
+
+ GST_DEBUG(0, "releasing mmap'd data region: %d frames\n", (int)this->avail);
+
+ if ((err = snd_pcm_mmap_commit (this->handle, this->offset, this->avail)) < 0) {
+ g_warning("gstalsa: mmap commit failed: %s", snd_strerror(err));
+ return;
+ }
+
+ l = this->pads;
+ while (l) {
+ GST_ALSA_PAD(l)->access_addr = NULL;
+ l = l->next;
+ }
+
+ for (i=0; i<this->channels; i++) {
+ this->access_addr[i] = NULL;
+ }
+
+ this->mmap_open = FALSE;
+ this->avail=0;
+}
+
+static void
+gst_alsa_sink_silence_on_channel (GstAlsa *this, guint32 chn, guint32 nframes)
+{
+ if (this->access_interleaved) {
+ memset_interleave
+ (this->access_addr[chn],
+ 0, nframes * this->sample_bytes,
+ this->interleave_unit,
+ this->interleave_skip);
+ } else {
+ memset (this->access_addr[chn], 0, nframes * this->sample_bytes);
+ }
+// mark_channel_done (chn);
+}
+
+/* taken directly from paul davis' memops.cc */
+static void
+memset_interleave (char *dst, char val, unsigned int bytes,
+ unsigned int unit_bytes,
+ unsigned int skip_bytes)
+{
+ switch (unit_bytes) {
+ case 1:
+ while (bytes--) {
+ *dst = val;
+ dst += skip_bytes;
+ }
+ break;
+ case 2:
+ while (bytes) {
+ *((short *) dst) = (short) val;
+ dst += skip_bytes;
+ bytes -= 2;
+ }
+ break;
+ case 4:
+ while (bytes) {
+ *((int *) dst) = (int) val;
+ dst += skip_bytes;
+ bytes -= 4;
+ }
+ break;
+ }
+}
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+ GstElementFactory *factory;
+
+ if (!gst_library_load ("gstbytestream")) {
+ gst_info("alsa: could not load support library: 'gstbytestream'\n");
+ return FALSE;
+ }
+
+ factory = gst_elementfactory_new ("alsasrc", GST_TYPE_ALSA_SRC, &gst_alsa_src_details);
+ g_return_val_if_fail (factory != NULL, FALSE);
+ gst_elementfactory_add_padtemplate (factory, gst_alsa_src_pad_factory());
+ gst_elementfactory_add_padtemplate (factory, gst_alsa_src_request_pad_factory());
+ gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+ factory = gst_elementfactory_new ("alsasink", GST_TYPE_ALSA_SINK, &gst_alsa_sink_details);
+ g_return_val_if_fail (factory != NULL, FALSE);
+ gst_elementfactory_add_padtemplate (factory, gst_alsa_sink_pad_factory());
+ gst_elementfactory_add_padtemplate (factory, gst_alsa_sink_request_pad_factory());
+ gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+ gst_plugin_set_longname(plugin, "ALSA plugin library");
+
+ return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+ GST_VERSION_MAJOR,
+ GST_VERSION_MINOR,
+ "alsa",
+ plugin_init
+};
+
+
projects / platform / upstream / gst-plugins-base.git / commitdiff