mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-27 20:21:24 +00:00
Code Issues 1 Projects Releases Wiki Activity

+ got the alsa mixer implementation to work !

Browse source 
Original commit message from CVS:
+ got the alsa mixer implementation to work !
This commit is contained in:
Leif Johnson 2003-12-06 00:02:20 +00:00
parent 80fece4f4b
commit ba2b9bd9d1
8 changed files with 731 additions and 440 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
ext/alsa/Makefile.am
View file

@ -2,13 +2,16 @@
plugin_LTLIBRARIES = libgstalsa.la plugin_LTLIBRARIES = libgstalsa.la
libgstalsa_la_SOURCES = gstalsaplugin.c \ libgstalsa_la_SOURCES = gstalsaplugin.c \
gstalsa.c gstalsaclock.c gstalsasink.c gstalsasrc.c gstalsamixer.c gstalsa.c gstalsaclock.c gstalsasink.c gstalsasrc.c \
gstalsamixer.c gstalsamixertrack.c
libgstalsa_la_CFLAGS = $(GST_CFLAGS) $(ALSA_CFLAGS) libgstalsa_la_CFLAGS = $(GST_CFLAGS) $(ALSA_CFLAGS)
libgstalsa_la_LIBADD = $(ALSA_LIBS)
libgstalsa_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) libgstalsa_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
libgstalsa_la_LIBADD = $(ALSA_LIBS) \
-L${top_builddir}/gst-libs/gst -lgstinterfaces-@GST_MAJORMINOR@
noinst_HEADERS = \ noinst_HEADERS = \
gstalsa.h gstalsaclock.h gstalsasink.h gstalsasrc.h gstalsamixer.h gstalsa.h gstalsaclock.h gstalsasink.h gstalsasrc.h \
gstalsamixer.h gstalsamixertrack.h
EXTRA_DIST = README EXTRA_DIST = README

461
ext/alsa/gstalsa.c
View file

@ -27,6 +27,7 @@
#include "gstalsa.h" #include "gstalsa.h"
#include "gstalsaclock.h" #include "gstalsaclock.h"
#include "gstalsamixer.h"
/* GObject functions */ /* GObject functions */
static void gst_alsa_class_init (gpointer g_class, static void gst_alsa_class_init (gpointer g_class,
@ -42,15 +43,28 @@ static void gst_alsa_get_property (GObject * object,
GValue * value, GValue * value,
GParamSpec * pspec); GParamSpec * pspec);
/* GStreamer functions for pads, queries, conversions and state changing */ /* GStreamer functions for pads and state changing */
static GstPad * gst_alsa_request_new_pad (GstElement * element, static GstPad * gst_alsa_request_new_pad (GstElement * element,
GstPadTemplate * templ, GstPadTemplate * templ,
const gchar * name); const gchar * name);
static GstElementStateReturn gst_alsa_change_state (GstElement * element); static GstElementStateReturn gst_alsa_change_state (GstElement * element);
static const GstFormat * gst_alsa_get_formats (GstPad * pad);
static GstClock * gst_alsa_get_clock (GstElement * element); static GstClock * gst_alsa_get_clock (GstElement * element);
static void gst_alsa_set_clock (GstElement * element, static void gst_alsa_set_clock (GstElement * element,
GstClock * clock); GstClock * clock);
/* ALSA setup / start / stop functions */
static gboolean gst_alsa_probe_hw_params (GstAlsa * this,
GstAlsaFormat * format);
static gboolean gst_alsa_set_hw_params (GstAlsa * this);
static gboolean gst_alsa_set_sw_params (GstAlsa * this);
static gboolean gst_alsa_open_audio (GstAlsa * this);
static gboolean gst_alsa_start_audio (GstAlsa * this);
static gboolean gst_alsa_drain_audio (GstAlsa * this);
static gboolean gst_alsa_stop_audio (GstAlsa * this);
static gboolean gst_alsa_close_audio (GstAlsa * this);
/* GStreamer querying, conversion, and format functions */
static const GstFormat * gst_alsa_get_formats (GstPad * pad);
static gboolean gst_alsa_convert (GstAlsa * this, static gboolean gst_alsa_convert (GstAlsa * this,
GstFormat src_format, GstFormat src_format,
gint64 src_value, gint64 src_value,
@ -75,18 +89,6 @@ static gboolean gst_alsa_pad_query (GstPad * pad,
GstFormat * format, GstFormat * format,
gint64 * value); gint64 * value);
/* alsa setup / start / stop functions */
static gboolean gst_alsa_probe_hw_params (GstAlsa * this,
GstAlsaFormat * format);
static gboolean gst_alsa_set_hw_params (GstAlsa * this);
static gboolean gst_alsa_set_sw_params (GstAlsa * this);
static gboolean gst_alsa_open_audio (GstAlsa * this);
static gboolean gst_alsa_start_audio (GstAlsa * this);
static gboolean gst_alsa_drain_audio (GstAlsa * this);
static gboolean gst_alsa_stop_audio (GstAlsa * this);
static gboolean gst_alsa_close_audio (GstAlsa * this);
/*** TYPE FUNCTIONS ***********************************************************/ /*** TYPE FUNCTIONS ***********************************************************/
GType GType
@ -109,6 +111,7 @@ gst_alsa_get_type (void)
alsa_type = g_type_register_static (GST_TYPE_ELEMENT, "GstAlsa", &alsa_info, 0); alsa_type = g_type_register_static (GST_TYPE_ELEMENT, "GstAlsa", &alsa_info, 0);
} }
return alsa_type; return alsa_type;
} }
@ -147,25 +150,32 @@ gst_alsa_class_init (gpointer g_class, gpointer class_data)
object_class->set_property = gst_alsa_set_property; object_class->set_property = gst_alsa_set_property;
g_object_class_install_property (object_class, ARG_DEVICE, g_object_class_install_property (object_class, ARG_DEVICE,
g_param_spec_string ("device", "Device", "Alsa device, as defined in an asoundrc", g_param_spec_string ("device", "Device",
"default", G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); "ALSA device, as defined in an asoundrc",
"default", G_PARAM_READWRITE));
g_object_class_install_property (object_class, ARG_PERIODCOUNT, g_object_class_install_property (object_class, ARG_PERIODCOUNT,
g_param_spec_int ("period-count", "Period count", "Number of hardware buffers to use", g_param_spec_int ("period-count", "Period count",
"Number of hardware buffers to use",
2, 64, 2, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); 2, 64, 2, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, ARG_PERIODSIZE, g_object_class_install_property (object_class, ARG_PERIODSIZE,
g_param_spec_int ("period-size", "Period size", "Number of frames (samples on each channel) in one hardware period", g_param_spec_int ("period-size", "Period size",
"Number of frames (samples on each channel) in one hardware period",
2, 8192, 8192, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); 2, 8192, 8192, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, ARG_BUFFERSIZE, g_object_class_install_property (object_class, ARG_BUFFERSIZE,
g_param_spec_int ("buffer-size", "Buffer size", "Number of frames the hardware buffer can hold", g_param_spec_int ("buffer-size", "Buffer size",
"Number of frames the hardware buffer can hold",
4, 65536, 16384, G_PARAM_READWRITE)); 4, 65536, 16384, G_PARAM_READWRITE));
g_object_class_install_property (object_class, ARG_AUTORECOVER, g_object_class_install_property (object_class, ARG_AUTORECOVER,
g_param_spec_boolean ("autorecover", "Automatic xrun recovery", "When TRUE tries to reduce processor load on xruns", g_param_spec_boolean ("autorecover", "Automatic xrun recovery",
"When TRUE tries to reduce processor load on xruns",
TRUE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); TRUE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, ARG_MMAP, g_object_class_install_property (object_class, ARG_MMAP,
g_param_spec_boolean ("mmap", "Use mmap'ed access", "Wether to use mmap (faster) or standard read/write (more compatible)", g_param_spec_boolean ("mmap", "Use mmap'ed access",
"Wether to use mmap (faster) or standard read/write (more compatible)",
TRUE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); TRUE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
g_object_class_install_property (object_class, ARG_MAXDISCONT, g_object_class_install_property (object_class, ARG_MAXDISCONT,
g_param_spec_uint64 ("max-discont", "Maximum Discontinuity", "GStreamer timeunits before the timestamp syncing starts dropping/insertting samples", g_param_spec_uint64 ("max-discont", "Maximum Discontinuity",
"GStreamer timeunits before the timestamp syncing starts dropping/inserting samples",
/* rounding errors */ 1000, GST_SECOND, GST_ALSA_DEFAULT_DISCONT, G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); /* rounding errors */ 1000, GST_SECOND, GST_ALSA_DEFAULT_DISCONT, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
element_class->change_state = GST_DEBUG_FUNCPTR (gst_alsa_change_state); element_class->change_state = GST_DEBUG_FUNCPTR (gst_alsa_change_state);
@ -178,22 +188,27 @@ gst_alsa_class_init (gpointer g_class, gpointer class_data)
static void static void
gst_alsa_init (GstAlsa *this) gst_alsa_init (GstAlsa *this)
{ {
this->device = g_strdup("default");
GST_FLAG_SET (this, GST_ELEMENT_EVENT_AWARE); GST_FLAG_SET (this, GST_ELEMENT_EVENT_AWARE);
GST_FLAG_SET (this, GST_ELEMENT_THREAD_SUGGESTED); GST_FLAG_SET (this, GST_ELEMENT_THREAD_SUGGESTED);
} }
static void static void
gst_alsa_dispose (GObject *object) gst_alsa_dispose (GObject *object)
{ {
GstAlsa *this = GST_ALSA (object); GstAlsa *this = GST_ALSA (object);
g_free (this->device);
if (this->clock) if (this->clock)
gst_object_unparent (GST_OBJECT (this->clock)); gst_object_unparent (GST_OBJECT (this->clock));
G_OBJECT_CLASS (parent_class)->dispose (object); G_OBJECT_CLASS (parent_class)->dispose (object);
} }
static void static void
gst_alsa_set_property (GObject *object, guint prop_id, const GValue *value, gst_alsa_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
GParamSpec *pspec)
{ {
GstAlsa *this; GstAlsa *this;
gint buffer_size; gint buffer_size;
@ -242,8 +257,7 @@ gst_alsa_set_property (GObject *object, guint prop_id, const GValue *value,
} }
static void static void
gst_alsa_get_property (GObject *object, guint prop_id, GValue *value, gst_alsa_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
GParamSpec *pspec)
{ {
GstAlsa *this; GstAlsa *this;
@ -280,53 +294,52 @@ gst_alsa_get_property (GObject *object, guint prop_id, GValue *value,
/*** GSTREAMER PAD / QUERY / CONVERSION / STATE FUNCTIONS *********************/ /*** GSTREAMER PAD / QUERY / CONVERSION / STATE FUNCTIONS *********************/
static GstPad * static GstPad *
gst_alsa_request_new_pad (GstElement *element, GstPadTemplate *templ, gst_alsa_request_new_pad (GstElement *element, GstPadTemplate *templ, const gchar *name)
const gchar *name)
{ {
GstAlsa *this; GstAlsa *this;
gint channel = 0; gint track = 0;
g_return_val_if_fail ((this = GST_ALSA (element)), NULL); g_return_val_if_fail ((this = GST_ALSA (element)), NULL);
g_return_val_if_fail (!GST_FLAG_IS_SET (element, GST_ALSA_RUNNING), NULL); g_return_val_if_fail (!GST_FLAG_IS_SET (element, GST_ALSA_RUNNING), NULL);
if (name) { if (name) {
/* locate the channel number in the requested pad name. to do so look at /* locate the track number in the requested pad name. */
where the % (which begins the %d) is in the template name. */ track = (gint) strtol (name + (strchr(templ->name_template, '%') -
channel = (gint) strtol (name + (strchr (templ->name_template, '%') -
templ->name_template), NULL, 0); templ->name_template), NULL, 0);
if (channel < 1 || channel >= GST_ALSA_MAX_CHANNELS) { if (track < 1 || track >= GST_ALSA_MAX_TRACKS) {
GST_INFO_OBJECT (this, "invalid channel requested. (%d)", channel); GST_INFO_OBJECT (this, "invalid track requested. (%d)", track);
return NULL; return NULL;
} }
} }
/* make sure the requested channel is free. */ /* make sure the requested track is free. */
if (channel > 0 || this->pad[channel] != NULL) { if (track > 0 || this->pad[track] != NULL) {
GST_INFO_OBJECT (this, "requested channel %d already in use.", channel); GST_INFO_OBJECT (this, "requested track %d already in use.", track);
return NULL; return NULL;
} }
/* if the user doesn't care which channel, find the lowest channel number /* if the user doesn't care, use the lowest available track number */
that's free. */ if (track == 0) {
if (channel == 0) { for (track = 1; track < GST_ALSA_MAX_TRACKS; track++) {
for (channel = 1; channel < GST_ALSA_MAX_CHANNELS; channel++) { if (this->pad[track] != NULL) goto found_track;
if (this->pad[channel] != NULL)
goto found_channel;
} }
return NULL; return NULL;
} }
found_channel: found_track:
this->pad[channel] = gst_pad_new_from_template (templ, name); this->pad[track] = gst_pad_new_from_template (templ, name);
gst_pad_set_link_function (this->pad[channel], gst_alsa_link);
gst_pad_set_getcaps_function (this->pad[channel], gst_alsa_get_caps);
gst_element_add_pad (GST_ELEMENT (this), this->pad[channel]);
gst_pad_set_convert_function (this->pad[channel], gst_alsa_pad_convert);
gst_pad_set_query_function (this->pad[channel], gst_alsa_pad_query);
gst_pad_set_query_type_function (this->pad[channel], gst_alsa_get_query_types);
gst_pad_set_formats_function (this->pad[channel], gst_alsa_get_formats);
return this->pad[channel]; gst_pad_set_link_function (this->pad[track], gst_alsa_link);
gst_pad_set_getcaps_function (this->pad[track], gst_alsa_get_caps);
gst_element_add_pad (GST_ELEMENT (this), this->pad[track]);
gst_pad_set_convert_function (this->pad[track], gst_alsa_pad_convert);
gst_pad_set_query_function (this->pad[track], gst_alsa_pad_query);
gst_pad_set_query_type_function (this->pad[track], gst_alsa_get_query_types);
gst_pad_set_formats_function (this->pad[track], gst_alsa_get_formats);
return this->pad[track];
} }
/* gets the matching alsa format or NULL if none matches */ /* gets the matching alsa format or NULL if none matches */
@ -336,7 +349,7 @@ gst_alsa_get_format (GstCaps *caps)
const gchar *mimetype; const gchar *mimetype;
GstAlsaFormat *ret; GstAlsaFormat *ret;
if (!(ret = g_new (GstAlsaFormat, 1))) if (! (ret = g_new (GstAlsaFormat, 1)))
return NULL; return NULL;
/* we have to differentiate between int and float formats */ /* we have to differentiate between int and float formats */
@ -347,13 +360,12 @@ gst_alsa_get_format (GstCaps *caps)
gint width, depth, endianness; gint width, depth, endianness;
/* extract the needed information from the caps */ /* extract the needed information from the caps */
if (!gst_caps_get (caps, if (! gst_caps_get (caps, "width", &width, "depth", &depth, "signed", &sign, NULL))
"width", &width, "depth", &depth, "signed", &sign, NULL))
goto error; goto error;
/* extract endianness if needed */ /* extract endianness if needed */
if (width > 8) { if (width > 8) {
if (!gst_caps_get (caps, "endianness", &endianness, NULL)) if (! gst_caps_get (caps, "endianness", &endianness, NULL))
goto error; goto error;
} else { } else {
endianness = G_BYTE_ORDER; endianness = G_BYTE_ORDER;
@ -365,7 +377,7 @@ gst_alsa_get_format (GstCaps *caps)
gint width; gint width;
/* get layout */ /* get layout */
if (!gst_caps_get (caps, "width", &width, NULL)) if (! gst_caps_get (caps, "width", &width, NULL))
goto error; goto error;
/* match layout to format wrt to endianness */ /* match layout to format wrt to endianness */
@ -388,15 +400,14 @@ gst_alsa_get_format (GstCaps *caps)
} else { } else {
goto error; goto error;
} }
} else if (!strncmp (mimetype, "audio/x-alaw", 12)) { } else if (! strncmp (mimetype, "audio/x-alaw", 12)) {
ret->format = SND_PCM_FORMAT_A_LAW; ret->format = SND_PCM_FORMAT_A_LAW;
} else if (!strncmp (mimetype, "audio/x-mulaw", 13)) { } else if (! strncmp (mimetype, "audio/x-mulaw", 13)) {
ret->format = SND_PCM_FORMAT_MU_LAW; ret->format = SND_PCM_FORMAT_MU_LAW;
} }
/* get rate and channels */ /* get rate and channels */
if (!gst_caps_get (caps, if (!gst_caps_get (caps, "rate", &ret->rate, "channels", &ret->channels, NULL))
"rate", &ret->rate, "channels", &ret->channels, NULL))
goto error; goto error;
return ret; return ret;
@ -415,6 +426,7 @@ gst_alsa_formats_match (GstAlsaFormat *one, GstAlsaFormat *two)
(one->rate == two->rate) && (one->rate == two->rate) &&
(one->channels == two->channels); (one->channels == two->channels);
} }
/* get props for a spec */ /* get props for a spec */
static GstCaps * static GstCaps *
gst_alsa_get_caps_internal (snd_pcm_format_t format) gst_alsa_get_caps_internal (snd_pcm_format_t format)
@ -464,8 +476,7 @@ gst_alsa_get_caps_internal (snd_pcm_format_t format)
if (!snd_pcm_format_cpu_endian (format)) if (!snd_pcm_format_cpu_endian (format))
return NULL; return NULL;
return GST_CAPS_NEW (name, return GST_CAPS_NEW (name, "audio/x-raw-float",
"audio/x-raw-float",
"width", GST_PROPS_INT (snd_pcm_format_width (format)), "width", GST_PROPS_INT (snd_pcm_format_width (format)),
"endianness", GST_PROPS_INT (G_BYTE_ORDER)); "endianness", GST_PROPS_INT (G_BYTE_ORDER));
} }
@ -564,10 +575,10 @@ gst_alsa_get_caps (GstPad *pad, GstCaps *caps)
} }
ERROR_CHECK (snd_pcm_hw_params_get_rate_min (hw_params, &min_rate, &i), ERROR_CHECK (snd_pcm_hw_params_get_rate_min (hw_params, &min_rate, &i),
"Coulödn't get minimum rate for device %s: %s", this->device); "Couldn't get minimum rate for device %s: %s", this->device);
min_rate = min_rate < GST_ALSA_MIN_RATE ? GST_ALSA_MIN_RATE : min_rate + i; min_rate = min_rate < GST_ALSA_MIN_RATE ? GST_ALSA_MIN_RATE : min_rate + i;
ERROR_CHECK (snd_pcm_hw_params_get_rate_max (hw_params, &max_rate, &i), ERROR_CHECK (snd_pcm_hw_params_get_rate_max (hw_params, &max_rate, &i),
"Coulödn't get maximum rate for device %s: %s", this->device); "Couldn't get maximum rate for device %s: %s", this->device);
max_rate = max_rate > GST_ALSA_MAX_RATE ? GST_ALSA_MAX_RATE : max_rate + i; max_rate = max_rate > GST_ALSA_MAX_RATE ? GST_ALSA_MAX_RATE : max_rate + i;
snd_pcm_format_mask_alloca (&mask); snd_pcm_format_mask_alloca (&mask);
@ -585,6 +596,7 @@ gst_alsa_get_caps (GstPad *pad, GstCaps *caps)
return ret; return ret;
} }
/* Negotiates the caps */ /* Negotiates the caps */
GstPadLinkReturn GstPadLinkReturn
gst_alsa_link (GstPad *pad, GstCaps *caps) gst_alsa_link (GstPad *pad, GstCaps *caps)
@ -599,8 +611,7 @@ gst_alsa_link (GstPad *pad, GstCaps *caps)
this = GST_ALSA (gst_pad_get_parent (pad)); this = GST_ALSA (gst_pad_get_parent (pad));
if (GST_CAPS_IS_FIXED (caps)) { if (GST_CAPS_IS_FIXED (caps)) {
if (this->handle == NULL) if (this->handle == NULL && ! gst_alsa_open_audio (this))
if (!gst_alsa_open_audio (this))
return GST_PAD_LINK_REFUSED; return GST_PAD_LINK_REFUSED;
format = gst_alsa_get_format (caps); format = gst_alsa_get_format (caps);
@ -609,7 +620,7 @@ gst_alsa_link (GstPad *pad, GstCaps *caps)
GST_DEBUG ("found format %s", snd_pcm_format_name (format->format)); GST_DEBUG ("found format %s", snd_pcm_format_name (format->format));
if (!GST_FLAG_IS_SET (this, GST_ALSA_CAPS_NEGO)) { if (! GST_FLAG_IS_SET (this, GST_ALSA_CAPS_NEGO)) {
gint i; gint i;
GST_FLAG_SET (this, GST_ALSA_CAPS_NEGO); GST_FLAG_SET (this, GST_ALSA_CAPS_NEGO);
@ -619,15 +630,16 @@ gst_alsa_link (GstPad *pad, GstCaps *caps)
goto out; goto out;
} }
if (!gst_alsa_probe_hw_params (this, format)) { if (! gst_alsa_probe_hw_params (this, format)) {
ret = GST_PAD_LINK_REFUSED; ret = GST_PAD_LINK_REFUSED;
goto out; goto out;
} }
for (i = 0; i < ((GstElement *) this)->numpads; i++) { for (i = 0; i < ((GstElement *) this)->numpads; i++) {
g_assert (this->pad[i] != NULL); g_assert (this->pad[i] != NULL);
if (this->pad[i] == pad)
continue; if (this->pad[i] == pad) continue;
if (gst_pad_try_set_caps (this->pad[i], gst_caps_ref (caps)) == GST_PAD_LINK_REFUSED) { if (gst_pad_try_set_caps (this->pad[i], gst_caps_ref (caps)) == GST_PAD_LINK_REFUSED) {
if (this->format) { if (this->format) {
GstCaps *old = gst_alsa_caps (this->format->format, this->format->rate, this->format->channels); GstCaps *old = gst_alsa_caps (this->format->format, this->format->rate, this->format->channels);
@ -653,7 +665,7 @@ gst_alsa_link (GstPad *pad, GstCaps *caps)
if (GST_FLAG_IS_SET (this, GST_ALSA_RUNNING)) gst_alsa_stop_audio (this); if (GST_FLAG_IS_SET (this, GST_ALSA_RUNNING)) gst_alsa_stop_audio (this);
g_free (this->format); g_free (this->format);
this->format = format; this->format = format;
if (!gst_alsa_start_audio (this)) { if (! gst_alsa_start_audio (this)) {
gst_element_error (GST_ELEMENT (this), "Probed format doesn't work"); gst_element_error (GST_ELEMENT (this), "Probed format doesn't work");
return GST_PAD_LINK_REFUSED; return GST_PAD_LINK_REFUSED;
} }
@ -673,6 +685,7 @@ out:
static GstElementStateReturn static GstElementStateReturn
gst_alsa_change_state (GstElement *element) gst_alsa_change_state (GstElement *element)
{ {
int err;
GstAlsa *this; GstAlsa *this;
g_return_val_if_fail (element != NULL, FALSE); g_return_val_if_fail (element != NULL, FALSE);
@ -680,20 +693,17 @@ gst_alsa_change_state (GstElement *element)
switch (GST_STATE_TRANSITION (element)) { switch (GST_STATE_TRANSITION (element)) {
case GST_STATE_NULL_TO_READY: case GST_STATE_NULL_TO_READY:
if (!GST_FLAG_IS_SET (element, GST_ALSA_OPEN)) if (! (GST_FLAG_IS_SET (element, GST_ALSA_OPEN) ||
if (!gst_alsa_open_audio (this)) gst_alsa_open_audio (this))) return GST_STATE_FAILURE;
return GST_STATE_FAILURE;
break; break;
case GST_STATE_READY_TO_PAUSED: case GST_STATE_READY_TO_PAUSED:
if (!GST_FLAG_IS_SET (element, GST_ALSA_RUNNING)) if (! (GST_FLAG_IS_SET (element, GST_ALSA_RUNNING) ||
if (!gst_alsa_start_audio (this)) gst_alsa_start_audio (this))) return GST_STATE_FAILURE;
return GST_STATE_FAILURE;
this->transmitted = 0; this->transmitted = 0;
break; break;
case GST_STATE_PAUSED_TO_PLAYING: case GST_STATE_PAUSED_TO_PLAYING:
if (snd_pcm_state (this->handle) == SND_PCM_STATE_PAUSED) { if (snd_pcm_state (this->handle) == SND_PCM_STATE_PAUSED) {
int err = snd_pcm_pause (this->handle, 0); if ((err = snd_pcm_pause (this->handle, 0)) < 0) {
if (err < 0) {
GST_ERROR_OBJECT (this, "Error unpausing sound: %s", snd_strerror (err)); GST_ERROR_OBJECT (this, "Error unpausing sound: %s", snd_strerror (err));
return GST_STATE_FAILURE; return GST_STATE_FAILURE;
} }
@ -701,10 +711,9 @@ gst_alsa_change_state (GstElement *element)
} }
break; break;
case GST_STATE_PLAYING_TO_PAUSED: case GST_STATE_PLAYING_TO_PAUSED:
if (GST_ALSA_CAPS_IS_SET(this, GST_ALSA_CAPS_PAUSE)) { if (GST_ALSA_CAPS_IS_SET (this, GST_ALSA_CAPS_PAUSE)) {
if (snd_pcm_state (this->handle) == SND_PCM_STATE_RUNNING) { if (snd_pcm_state (this->handle) == SND_PCM_STATE_RUNNING) {
int err = snd_pcm_pause (this->handle, 1); if ((err = snd_pcm_pause (this->handle, 1)) < 0) {
if (err < 0) {
GST_ERROR_OBJECT (this, "Error pausing sound: %s", snd_strerror (err)); GST_ERROR_OBJECT (this, "Error pausing sound: %s", snd_strerror (err));
return GST_STATE_FAILURE; return GST_STATE_FAILURE;
} }
@ -714,14 +723,12 @@ gst_alsa_change_state (GstElement *element)
} }
/* if device doesn't know how to pause, we just stop */ /* if device doesn't know how to pause, we just stop */
case GST_STATE_PAUSED_TO_READY: case GST_STATE_PAUSED_TO_READY:
if (GST_FLAG_IS_SET (element, GST_ALSA_RUNNING)) if (GST_FLAG_IS_SET (element, GST_ALSA_RUNNING)) gst_alsa_stop_audio (this);
gst_alsa_stop_audio (this);
g_free (this->format); g_free (this->format);
this->format = NULL; this->format = NULL;
break; break;
case GST_STATE_READY_TO_NULL: case GST_STATE_READY_TO_NULL:
if (GST_FLAG_IS_SET (element, GST_ALSA_OPEN)) if (GST_FLAG_IS_SET (element, GST_ALSA_OPEN)) gst_alsa_close_audio (this);
gst_alsa_close_audio (this);
break; break;
default: default:
@ -733,145 +740,14 @@ gst_alsa_change_state (GstElement *element)
return GST_STATE_SUCCESS; return GST_STATE_SUCCESS;
} }
static const GstFormat *
gst_alsa_get_formats (GstPad *pad)
{
static const GstFormat formats[] = {
GST_FORMAT_TIME,
GST_FORMAT_DEFAULT,
GST_FORMAT_BYTES,
0
};
return formats;
}
static GstClock * static GstClock *
gst_alsa_get_clock (GstElement *element) gst_alsa_get_clock (GstElement *element)
{ { return GST_CLOCK (GST_ALSA (element)->clock); }
return GST_CLOCK (GST_ALSA (element)->clock);
}
static void static void
gst_alsa_set_clock (GstElement *element, GstClock *clock) gst_alsa_set_clock (GstElement *element, GstClock *clock)
{ { /* we need this function just so everybody knows we use a clock */ }
/* we only must have this function so everybody knows we use a clock */
}
static gboolean
gst_alsa_pad_convert (GstPad *pad, GstFormat src_format, gint64 src_value,
GstFormat *dest_format, gint64 *dest_value)
{
return gst_alsa_convert (GST_ALSA (GST_PAD_PARENT (pad)), src_format, src_value, dest_format, dest_value);
}
static gboolean
gst_alsa_convert (GstAlsa *this, GstFormat src_format, gint64 src_value,
GstFormat *dest_format, gint64 *dest_value)
{
gboolean res = TRUE;
if (src_format == *dest_format) {
*dest_value = src_value;
return TRUE;
}
if (this->format == NULL)
return FALSE;
switch (src_format) {
case GST_FORMAT_BYTES:
switch (*dest_format) {
case GST_FORMAT_DEFAULT:
*dest_value = gst_alsa_bytes_to_samples (this, (guint) src_value);
break;
case GST_FORMAT_TIME:
*dest_value = gst_alsa_bytes_to_timestamp (this, (guint) src_value);
break;
default:
res = FALSE;
break;
}
break;
case GST_FORMAT_TIME:
switch (*dest_format) {
case GST_FORMAT_DEFAULT:
*dest_value = gst_alsa_timestamp_to_samples (this, (GstClockTime) src_value);
break;
case GST_FORMAT_BYTES:
*dest_value = gst_alsa_timestamp_to_bytes (this, (GstClockTime) src_value);
break;
default:
res = FALSE;
break;
}
break;
case GST_FORMAT_DEFAULT:
switch (*dest_format) {
case GST_FORMAT_TIME:
*dest_value = gst_alsa_samples_to_timestamp (this, (guint) src_value);
break;
case GST_FORMAT_BYTES:
*dest_value = gst_alsa_samples_to_bytes (this, (guint) src_value);
break;
case GST_FORMAT_DEFAULT:
g_assert_not_reached ();
/* fall through */
default:
res = FALSE;
break;
}
break;
default:
res = FALSE;
}
return res;
}
static const GstQueryType *
gst_alsa_get_query_types (GstPad *pad)
{
static const GstQueryType query_types[] = {
GST_QUERY_LATENCY,
GST_QUERY_POSITION,
0,
};
return query_types;
}
static gboolean
gst_alsa_query_func (GstElement *element, GstQueryType type, GstFormat *format, gint64 *value)
{
gboolean res = FALSE;
GstAlsa *this = GST_ALSA (element);
switch (type) {
case GST_QUERY_LATENCY: {
snd_pcm_sframes_t delay;
ERROR_CHECK (snd_pcm_delay (this->handle, &delay), "Error getting delay: %s");
res = gst_alsa_convert (this, GST_FORMAT_DEFAULT, (gint64) delay, format, value);
break;
}
case GST_QUERY_POSITION:
res = gst_alsa_convert (this, GST_FORMAT_DEFAULT, this->transmitted, format, value);
break;
default:
break;
}
return res;
}
static gboolean
gst_alsa_query (GstElement *element, GstQueryType type, GstFormat *format, gint64 *value)
{
return gst_alsa_pad_query (GST_ALSA (element)->pad[0], type, format, value);
}
static gboolean
gst_alsa_pad_query (GstPad *pad, GstQueryType type, GstFormat *format, gint64 *value)
{
if (gst_alsa_query_func (GST_PAD_PARENT (pad), type, format, value))
return TRUE;
if (GST_PAD_DIRECTION (pad) == GST_PAD_SINK && gst_pad_query (gst_pad_get_peer (pad), type, format, value))
return TRUE;
return FALSE;
}
/*** AUDIO PROCESSING *********************************************************/ /*** AUDIO PROCESSING *********************************************************/
@ -888,6 +764,7 @@ gst_alsa_update_avail (GstAlsa *this)
} }
return avail; return avail;
} }
/* returns TRUE, if the loop should go on */ /* returns TRUE, if the loop should go on */
inline gboolean inline gboolean
gst_alsa_pcm_wait (GstAlsa *this) gst_alsa_pcm_wait (GstAlsa *this)
@ -1232,34 +1109,172 @@ gst_alsa_close_audio (GstAlsa *this)
return TRUE; return TRUE;
} }
/*** FORMAT FUNCTIONS *********************************************************/ /*** QUERYING/FORMAT/CONVERSION FUNCTIONS *************************************/
/* ALL THES FUNCTIONS ASSUME this->format != NULL */
static const GstFormat *
gst_alsa_get_formats (GstPad *pad)
{
static const GstFormat formats[] = {
GST_FORMAT_TIME,
GST_FORMAT_DEFAULT,
GST_FORMAT_BYTES,
0
};
return formats;
}
static gboolean
gst_alsa_pad_convert (GstPad *pad, GstFormat src_format, gint64 src_value,
GstFormat *dest_format, gint64 *dest_value)
{
return gst_alsa_convert (GST_ALSA (GST_PAD_PARENT (pad)), src_format, src_value, dest_format, dest_value);
}
static gboolean
gst_alsa_convert (GstAlsa *this, GstFormat src_format, gint64 src_value,
GstFormat *dest_format, gint64 *dest_value)
{
gboolean res = TRUE;
if (src_format == *dest_format) {
*dest_value = src_value;
return TRUE;
}
if (this->format == NULL)
return FALSE;
switch (src_format) {
case GST_FORMAT_BYTES:
switch (*dest_format) {
case GST_FORMAT_DEFAULT:
*dest_value = gst_alsa_bytes_to_samples (this, (guint) src_value);
break;
case GST_FORMAT_TIME:
*dest_value = gst_alsa_bytes_to_timestamp (this, (guint) src_value);
break;
default:
res = FALSE;
break;
}
break;
case GST_FORMAT_TIME:
switch (*dest_format) {
case GST_FORMAT_DEFAULT:
*dest_value = gst_alsa_timestamp_to_samples (this, (GstClockTime) src_value);
break;
case GST_FORMAT_BYTES:
*dest_value = gst_alsa_timestamp_to_bytes (this, (GstClockTime) src_value);
break;
default:
res = FALSE;
break;
}
break;
case GST_FORMAT_DEFAULT:
switch (*dest_format) {
case GST_FORMAT_TIME:
*dest_value = gst_alsa_samples_to_timestamp (this, (guint) src_value);
break;
case GST_FORMAT_BYTES:
*dest_value = gst_alsa_samples_to_bytes (this, (guint) src_value);
break;
case GST_FORMAT_DEFAULT:
g_assert_not_reached ();
/* fall through */
default:
res = FALSE;
break;
}
break;
default:
res = FALSE;
}
return res;
}
static const GstQueryType *
gst_alsa_get_query_types (GstPad *pad)
{
static const GstQueryType query_types[] = {
GST_QUERY_LATENCY,
GST_QUERY_POSITION,
0,
};
return query_types;
}
static gboolean
gst_alsa_query_func (GstElement *element, GstQueryType type, GstFormat *format, gint64 *value)
{
gboolean res = FALSE;
GstAlsa *this = GST_ALSA (element);
switch (type) {
case GST_QUERY_LATENCY: {
snd_pcm_sframes_t delay;
ERROR_CHECK (snd_pcm_delay (this->handle, &delay), "Error getting delay: %s");
res = gst_alsa_convert (this, GST_FORMAT_DEFAULT, (gint64) delay, format, value);
break;
}
case GST_QUERY_POSITION:
res = gst_alsa_convert (this, GST_FORMAT_DEFAULT, this->transmitted, format, value);
break;
default:
break;
}
return res;
}
static gboolean
gst_alsa_query (GstElement *element, GstQueryType type, GstFormat *format, gint64 *value)
{
return gst_alsa_pad_query (GST_ALSA (element)->pad[0], type, format, value);
}
static gboolean
gst_alsa_pad_query (GstPad *pad, GstQueryType type, GstFormat *format, gint64 *value)
{
if (gst_alsa_query_func (GST_PAD_PARENT (pad), type, format, value))
return TRUE;
if (GST_PAD_DIRECTION (pad) == GST_PAD_SINK && gst_pad_query (gst_pad_get_peer (pad), type, format, value))
return TRUE;
return FALSE;
}
inline snd_pcm_uframes_t inline snd_pcm_uframes_t
gst_alsa_timestamp_to_samples (GstAlsa *this, GstClockTime time) gst_alsa_timestamp_to_samples (GstAlsa *this, GstClockTime time)
{ {
return (snd_pcm_uframes_t) ((time * this->format->rate + this->format->rate / 2) / GST_SECOND); return (snd_pcm_uframes_t) ((time * this->format->rate + this->format->rate / 2) / GST_SECOND);
} }
inline GstClockTime inline GstClockTime
gst_alsa_samples_to_timestamp (GstAlsa *this, snd_pcm_uframes_t samples) gst_alsa_samples_to_timestamp (GstAlsa *this, snd_pcm_uframes_t samples)
{ {
return (GstClockTime) (samples * GST_SECOND / this->format->rate); return (GstClockTime) (samples * GST_SECOND / this->format->rate);
} }
inline snd_pcm_uframes_t inline snd_pcm_uframes_t
gst_alsa_bytes_to_samples (GstAlsa *this, guint bytes) gst_alsa_bytes_to_samples (GstAlsa *this, guint bytes)
{ {
return bytes / (snd_pcm_format_physical_width (this->format->format) / 8) / (GST_ELEMENT (this)->numpads == 1 ? this->format->channels : 1); return bytes / (snd_pcm_format_physical_width (this->format->format) / 8) / (GST_ELEMENT (this)->numpads == 1 ? this->format->channels : 1);
} }
inline guint inline guint
gst_alsa_samples_to_bytes (GstAlsa *this, snd_pcm_uframes_t samples) gst_alsa_samples_to_bytes (GstAlsa *this, snd_pcm_uframes_t samples)
{ {
return samples * snd_pcm_format_physical_width (this->format->format) / 8 * (GST_ELEMENT (this)->numpads == 1 ? this->format->channels : 1); return samples * snd_pcm_format_physical_width (this->format->format) / 8 * (GST_ELEMENT (this)->numpads == 1 ? this->format->channels : 1);
} }
inline GstClockTime inline GstClockTime
gst_alsa_bytes_to_timestamp (GstAlsa *this, guint bytes) gst_alsa_bytes_to_timestamp (GstAlsa *this, guint bytes)
{ {
return gst_alsa_samples_to_timestamp (this, gst_alsa_bytes_to_samples (this, bytes)); return gst_alsa_samples_to_timestamp (this, gst_alsa_bytes_to_samples (this, bytes));
} }
inline guint inline guint
gst_alsa_timestamp_to_bytes (GstAlsa *this, GstClockTime time) gst_alsa_timestamp_to_bytes (GstAlsa *this, GstClockTime time)
{ {

3
ext/alsa/gstalsa.h
View file

@ -155,9 +155,6 @@ struct _GstAlsa {
GstClockTime max_discont; /* max difference between current GstClockTime max_discont; /* max difference between current
playback timestamp and buffers timestamps playback timestamp and buffers timestamps
*/ */
/* mixer */
GList *tracklist; /* list of available tracks */
snd_mixer_t * mixer_handle;
}; };
struct _GstAlsaClass { struct _GstAlsaClass {

396
ext/alsa/gstalsamixer.c
View file

@ -1,4 +1,4 @@
/* GStreamer ALSA mixer implementation /* ALSA mixer implementation.
* Copyright (C) 2003 Leif Johnson <leif@ambient.2y.net> * Copyright (C) 2003 Leif Johnson <leif@ambient.2y.net>
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
@ -23,90 +23,172 @@
#include "gstalsamixer.h" #include "gstalsamixer.h"
static gboolean gst_alsa_mixer_supported (GstInterface *iface, /* elementfactory information */
static GstElementDetails gst_alsa_mixer_details = GST_ELEMENT_DETAILS (
"Alsa Mixer",
"Generic/Audio",
"Control sound input and output levels with ALSA",
"Leif Johnson <leif@ambient.2y.net>"
);
static void gst_alsa_interface_init (GstInterfaceClass *klass);
static void gst_alsa_mixer_class_init (gpointer g_class,
gpointer class_data);
static void gst_alsa_mixer_init (GstAlsaMixer * mixer);
static void gst_alsa_mixer_dispose (GObject * object);
static void gst_alsa_mixer_interface_init (GstMixerClass* klass);
static gboolean gst_alsa_mixer_supported (GstInterface * iface,
GType iface_type); GType iface_type);
static const GList * gst_alsa_mixer_list_tracks (GstMixer *mixer); /* GStreamer stuff */
static GstElementStateReturn gst_alsa_mixer_change_state (GstElement * element);
static void gst_alsa_mixer_set_volume (GstMixer *mixer, static void gst_alsa_mixer_build_list (GstAlsaMixer * mixer);
GstMixerTrack *track, static void gst_alsa_mixer_free_list (GstAlsaMixer * mixer);
gint *volumes);
static void gst_alsa_mixer_get_volume (GstMixer *mixer,
GstMixerTrack *track,
gint *volumes);
static void gst_alsa_mixer_set_record (GstMixer *mixer, /* interface implementation */
GstMixerTrack *track, static const GList * gst_alsa_mixer_list_tracks (GstMixer * mixer);
static void gst_alsa_mixer_set_volume (GstMixer * mixer,
GstMixerTrack* track,
gint * volumes);
static void gst_alsa_mixer_get_volume (GstMixer * mixer,
GstMixerTrack* track,
gint * volumes);
static void gst_alsa_mixer_set_record (GstMixer * mixer,
GstMixerTrack* track,
gboolean record); gboolean record);
static void gst_alsa_mixer_set_mute (GstMixer *mixer, static void gst_alsa_mixer_set_mute (GstMixer * mixer,
GstMixerTrack *track, GstMixerTrack* track,
gboolean mute); gboolean mute);
GstMixerTrack * /*** GOBJECT STUFF ************************************************************/
gst_alsa_mixer_track_new (GstAlsa *alsa,
gint track_num, static GstAlsa *parent_class = NULL;
gint channels,
gint flags) GType
gst_alsa_mixer_get_type (void)
{ {
gint i; static GType alsa_mixer_type = 0;
long min, max;
snd_mixer_elem_t *element = NULL;
GstMixerTrack *track = (GstMixerTrack *) g_new (GstAlsaMixerTrack, 1);
GstAlsaMixerTrack *alsa_track = (GstAlsaMixerTrack *) track;
/* find a pointer to the track_num-th element in the mixer. */ if (!alsa_mixer_type) {
i = 0; static const GTypeInfo alsa_mixer_info = {
element = snd_mixer_first_elem(alsa->mixer_handle); sizeof (GstAlsaMixerClass),
while (i++ < track_num) element = snd_mixer_elem_next(element); NULL,
NULL,
gst_alsa_mixer_class_init,
NULL,
NULL,
sizeof (GstAlsaMixer),
0,
(GInstanceInitFunc) gst_alsa_mixer_init,
};
static const GInterfaceInfo alsa_iface_info = {
(GInterfaceInitFunc) gst_alsa_interface_init,
NULL,
NULL,
};
static const GInterfaceInfo alsa_mixer_iface_info = {
(GInterfaceInitFunc) gst_alsa_mixer_interface_init,
NULL,
NULL,
};
/* set basic information */ alsa_mixer_type = g_type_register_static (GST_TYPE_ALSA, "GstAlsaMixer", &alsa_mixer_info, 0);
track->label = g_strdup_printf("%s", snd_mixer_selem_get_name(element));
track->num_channels = channels;
track->flags = flags;
alsa_track->element = element;
alsa_track->track_num = track_num;
/* set volume information */ g_type_add_interface_static (alsa_mixer_type, GST_TYPE_INTERFACE, &alsa_iface_info);
snd_mixer_selem_get_playback_volume_range(element, &min, &max); g_type_add_interface_static (alsa_mixer_type, GST_TYPE_MIXER, &alsa_mixer_iface_info);
track->min_volume = (gint) min;
track->max_volume = (gint) max;
snd_mixer_selem_get_capture_volume_range(element, &min, &max);
alsa_track->min_rec_volume = (gint) min;
alsa_track->max_rec_volume = (gint) max;
for (i = 0; i < channels; i++) {
long tmp;
if (snd_mixer_selem_has_playback_channel(element, i)) {
snd_mixer_selem_get_playback_volume(element, i, &tmp);
alsa_track->volumes[i] = (gint) tmp;
} else if (snd_mixer_selem_has_capture_channel(element, i)) {
snd_mixer_selem_get_capture_volume(element, i, &tmp);
alsa_track->volumes[i] = (gint) tmp;
}
} }
return track; return alsa_mixer_type;
} }
void static void
gst_alsa_mixer_track_free (GstMixerTrack *track) gst_alsa_mixer_class_init (gpointer g_class, gpointer class_data)
{ {
g_free (track->label); GObjectClass *object_class;
g_free (track); GstElementClass *element_class;
GstAlsaClass *klass;
klass = (GstAlsaClass *)g_class;
object_class = (GObjectClass *) g_class;
element_class = (GstElementClass *) g_class;
if (parent_class == NULL)
parent_class = g_type_class_ref (GST_TYPE_ALSA);
object_class->dispose = gst_alsa_mixer_dispose;
element_class->change_state = gst_alsa_mixer_change_state;
gst_element_class_set_details (element_class, &gst_alsa_mixer_details);
} }
void static void
gst_alsa_mixer_init (GstAlsaMixer * mixer)
{
gint err;
GstAlsa *alsa = GST_ALSA (mixer);
mixer->mixer_handle = (snd_mixer_t *) -1;
/* open and initialize the mixer device */
err = snd_mixer_open(&mixer->mixer_handle, 0);
if (err < 0 || mixer->mixer_handle == NULL) {
GST_ERROR_OBJECT (GST_OBJECT (mixer), "Cannot open mixer device.");
mixer->mixer_handle = (snd_mixer_t *) -1;
return;
}
if ((err = snd_mixer_attach(mixer->mixer_handle, alsa->device)) < 0) {
GST_ERROR_OBJECT (GST_OBJECT (mixer),
"Cannot attach mixer to sound device `%s'.",
alsa->device);
goto error;
}
if ((err = snd_mixer_selem_register(mixer->mixer_handle, NULL, NULL)) < 0) {
GST_ERROR_OBJECT (GST_OBJECT (mixer), "Cannot register mixer elements.");
goto error;
}
if ((err = snd_mixer_load(mixer->mixer_handle)) < 0) {
GST_ERROR_OBJECT (GST_OBJECT (mixer), "Cannot load mixer settings.");
goto error;
}
return;
error:
snd_mixer_close (mixer->mixer_handle);
mixer->mixer_handle = (snd_mixer_t *) -1;
}
static void
gst_alsa_mixer_dispose (GObject * object)
{
GstAlsaMixer *mixer = GST_ALSA_MIXER (object);
if (((gint) mixer->mixer_handle) != -1) return;
snd_mixer_close (mixer->mixer_handle);
mixer->mixer_handle = (snd_mixer_t *) -1;
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
gst_alsa_interface_init (GstInterfaceClass *klass) gst_alsa_interface_init (GstInterfaceClass *klass)
{ {
/* default virtual functions */
klass->supported = gst_alsa_mixer_supported; klass->supported = gst_alsa_mixer_supported;
} }
void static void
gst_alsa_mixer_interface_init (GstMixerClass *klass) gst_alsa_mixer_interface_init (GstMixerClass *klass)
{ {
/* default virtual functions */ /* set up the interface hooks */
klass->list_tracks = gst_alsa_mixer_list_tracks; klass->list_tracks = gst_alsa_mixer_list_tracks;
klass->set_volume = gst_alsa_mixer_set_volume; klass->set_volume = gst_alsa_mixer_set_volume;
klass->get_volume = gst_alsa_mixer_get_volume; klass->get_volume = gst_alsa_mixer_get_volume;
@ -114,22 +196,109 @@ gst_alsa_mixer_interface_init (GstMixerClass *klass)
klass->set_record = gst_alsa_mixer_set_record; klass->set_record = gst_alsa_mixer_set_record;
} }
static gboolean gboolean
gst_alsa_mixer_supported (GstInterface *iface, GType iface_type) gst_alsa_mixer_supported (GstInterface *iface, GType iface_type)
{ {
g_assert (iface_type == GST_TYPE_MIXER); g_assert (iface_type == GST_TYPE_MIXER);
return (((gint) GST_ALSA (iface)->mixer_handle) != -1); return (((gint) GST_ALSA_MIXER (iface)->mixer_handle) != -1);
} }
static void
gst_alsa_mixer_build_list (GstAlsaMixer *mixer)
{
gint i, count;
snd_mixer_elem_t *element;
g_return_if_fail (((gint) mixer->mixer_handle) != -1);
count = snd_mixer_get_count(mixer->mixer_handle);
element = snd_mixer_first_elem(mixer->mixer_handle);
/* build track list */
for (i = 0; i < count; i++) {
gint channels = 0;
if (! snd_mixer_selem_is_active(element)) continue;
/* find out if this element can be an input */
if (snd_mixer_selem_has_capture_channel(element, 0) ||
snd_mixer_selem_has_capture_switch(element) ||
snd_mixer_selem_is_capture_mono(element)) {
while (snd_mixer_selem_has_capture_channel(element, channels))
channels++;
GstMixerTrack *track = gst_alsa_mixer_track_new
(element, i, channels, GST_MIXER_TRACK_INPUT);
mixer->tracklist = g_list_append (mixer->tracklist, track);
}
/* find out if this element can also be an output */
channels = 0;
if (snd_mixer_selem_has_playback_channel(element, 0) ||
snd_mixer_selem_has_playback_switch(element) ||
snd_mixer_selem_is_playback_mono(element)) {
while (snd_mixer_selem_has_playback_channel(element, channels))
channels++;
GstMixerTrack *track = gst_alsa_mixer_track_new
(element, i, channels, GST_MIXER_TRACK_OUTPUT);
mixer->tracklist = g_list_append (mixer->tracklist, track);
}
element = snd_mixer_elem_next(element);
}
}
static void
gst_alsa_mixer_free_list (GstAlsaMixer *mixer)
{
g_return_if_fail (((gint) mixer->mixer_handle) != -1);
g_list_foreach (mixer->tracklist, (GFunc) gst_alsa_mixer_track_free, NULL);
g_list_free (mixer->tracklist);
mixer->tracklist = NULL;
}
/*** GSTREAMER FUNCTIONS ******************************************************/
static GstElementStateReturn
gst_alsa_mixer_change_state (GstElement *element)
{
GstAlsaMixer *this;
g_return_val_if_fail (element != NULL, FALSE);
this = GST_ALSA_MIXER (element);
switch (GST_STATE_TRANSITION (element)) {
case GST_STATE_NULL_TO_READY:
gst_alsa_mixer_build_list (this); break;
case GST_STATE_READY_TO_NULL:
gst_alsa_mixer_free_list (this); break;
default:
g_assert_not_reached();
}
if (GST_ELEMENT_CLASS (parent_class)->change_state)
return GST_ELEMENT_CLASS (parent_class)->change_state (element);
return GST_STATE_SUCCESS;
}
/*** INTERFACE IMPLEMENTATION *************************************************/
static const GList * static const GList *
gst_alsa_mixer_list_tracks (GstMixer *mixer) gst_alsa_mixer_list_tracks (GstMixer *mixer)
{ {
GstAlsa *alsa = GST_ALSA (mixer); GstAlsaMixer *alsa_mixer = GST_ALSA_MIXER (mixer);
g_return_val_if_fail (((gint) alsa->mixer_handle) != -1, NULL); g_return_val_if_fail (((gint) alsa_mixer->mixer_handle) != -1, NULL);
return (const GList *) GST_ALSA (mixer)->tracklist; return (const GList *) alsa_mixer->tracklist;
} }
static void static void
@ -138,10 +307,10 @@ gst_alsa_mixer_get_volume (GstMixer *mixer,
gint *volumes) gint *volumes)
{ {
gint i; gint i;
GstAlsa *alsa = GST_ALSA (mixer); GstAlsaMixer *alsa_mixer = GST_ALSA_MIXER (mixer);
GstAlsaMixerTrack *alsa_track = (GstAlsaMixerTrack *) track; GstAlsaMixerTrack *alsa_track = (GstAlsaMixerTrack *) track;
g_return_if_fail (((gint) alsa->mixer_handle) != -1); g_return_if_fail (((gint) alsa_mixer->mixer_handle) != -1);
if (track->flags & GST_MIXER_TRACK_MUTE) { if (track->flags & GST_MIXER_TRACK_MUTE) {
for (i = 0; i < track->num_channels; i++) for (i = 0; i < track->num_channels; i++)
@ -166,10 +335,10 @@ gst_alsa_mixer_set_volume (GstMixer *mixer,
gint *volumes) gint *volumes)
{ {
gint i; gint i;
GstAlsa *alsa = GST_ALSA (mixer); GstAlsaMixer *alsa_mixer = GST_ALSA_MIXER (mixer);
GstAlsaMixerTrack *alsa_track = (GstAlsaMixerTrack *) track; GstAlsaMixerTrack *alsa_track = (GstAlsaMixerTrack *) track;
g_return_if_fail (((gint) alsa->mixer_handle) != -1); g_return_if_fail (((gint) alsa_mixer->mixer_handle) != -1);
/* only set the volume with ALSA lib if the track isn't muted. */ /* only set the volume with ALSA lib if the track isn't muted. */
if (! (track->flags & GST_MIXER_TRACK_MUTE)) { if (! (track->flags & GST_MIXER_TRACK_MUTE)) {
@ -191,10 +360,10 @@ gst_alsa_mixer_set_mute (GstMixer *mixer,
gboolean mute) gboolean mute)
{ {
gint i; gint i;
GstAlsa *alsa = GST_ALSA (mixer); GstAlsaMixer *alsa_mixer = GST_ALSA_MIXER (mixer);
GstAlsaMixerTrack *alsa_track = (GstAlsaMixerTrack *) track; GstAlsaMixerTrack *alsa_track = (GstAlsaMixerTrack *) track;
g_return_if_fail (((gint) alsa->mixer_handle) != -1); g_return_if_fail (((gint) alsa_mixer->mixer_handle) != -1);
if (mute) { if (mute) {
track->flags |= GST_MIXER_TRACK_MUTE; track->flags |= GST_MIXER_TRACK_MUTE;
@ -224,10 +393,9 @@ gst_alsa_mixer_set_record (GstMixer *mixer,
GstMixerTrack *track, GstMixerTrack *track,
gboolean record) gboolean record)
{ {
GstAlsa *alsa = GST_ALSA (mixer); GstAlsaMixer *alsa_mixer = GST_ALSA_MIXER (mixer);
/* GstAlsaMixerTrack *alsa_track = (GstAlsaMixerTrack *) track; */
g_return_if_fail (((gint) alsa->mixer_handle) != -1); g_return_if_fail (((gint) alsa_mixer->mixer_handle) != -1);
if (record) { if (record) {
track->flags |= GST_MIXER_TRACK_RECORD; track->flags |= GST_MIXER_TRACK_RECORD;
@ -235,83 +403,3 @@ gst_alsa_mixer_set_record (GstMixer *mixer,
track->flags &= ~GST_MIXER_TRACK_RECORD; track->flags &= ~GST_MIXER_TRACK_RECORD;
} }
} }
void
gst_alsa_mixer_build_list (GstAlsa *alsa)
{
gint i, count, err;
snd_mixer_elem_t *element;
/* set up this mixer. */
if ((gint) alsa->mixer_handle == -1) {
if ((err = snd_mixer_open(&alsa->mixer_handle, 0)) != 0) {
GST_ERROR_OBJECT (GST_OBJECT (alsa), "Cannot open mixer device.");
alsa->mixer_handle = (snd_mixer_t *) -1;
return;
}
}
if ((err = snd_mixer_attach(alsa->mixer_handle, alsa->device)) != 0) {
GST_ERROR_OBJECT (GST_OBJECT (alsa),
"Cannot attach mixer to sound device '%s'.",
alsa->device);
return;
}
if ((err = snd_mixer_selem_register(alsa->mixer_handle, NULL, NULL)) != 0) {
GST_ERROR_OBJECT (GST_OBJECT (alsa), "Cannot register mixer elements.");
return;
}
if ((err = snd_mixer_load(alsa->mixer_handle)) != 0) {
GST_ERROR_OBJECT (GST_OBJECT (alsa), "Cannot load mixer settings.");
return;
}
count = snd_mixer_get_count(alsa->mixer_handle);
element = snd_mixer_first_elem(alsa->mixer_handle);
/* build track list */
for (i = 0; i < count; i++) {
GstMixerTrack *track;
gint channels = 0;
gboolean input = FALSE;
gint flags = 0;
/* find out if this is a capture track */
if (snd_mixer_selem_has_capture_channel(element, 0) ||
snd_mixer_selem_has_capture_switch(element) ||
snd_mixer_selem_is_capture_mono(element)) input = TRUE;
flags = (input ? GST_MIXER_TRACK_INPUT : GST_MIXER_TRACK_OUTPUT);
if (input) {
while (snd_mixer_selem_has_capture_channel(element, channels))
channels++;
} else {
while (snd_mixer_selem_has_playback_channel(element, channels))
channels++;
}
/* add track to list */
track = gst_alsa_mixer_track_new (alsa, i, channels, flags);
alsa->tracklist = g_list_append (alsa->tracklist, track);
element = snd_mixer_elem_next(element);
}
}
void
gst_alsa_mixer_free_list (GstAlsa *alsa)
{
g_return_if_fail (((gint) alsa->mixer_handle) != -1);
g_list_foreach (alsa->tracklist, (GFunc) gst_alsa_mixer_track_free, NULL);
g_list_free (alsa->tracklist);
alsa->tracklist = NULL;
snd_mixer_close (alsa->mixer_handle);
alsa->mixer_handle = (snd_mixer_t *) -1;
}

31
ext/alsa/gstalsamixer.h
View file

@ -1,4 +1,4 @@
/* /* ALSA mixer interface implementation.
* Copyright (C) 2003 Leif Johnson <leif@ambient.2y.net> * Copyright (C) 2003 Leif Johnson <leif@ambient.2y.net>
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
@ -20,29 +20,28 @@
#define __GST_ALSA_MIXER_H__ #define __GST_ALSA_MIXER_H__
#include "gstalsa.h" #include "gstalsa.h"
#include "gstalsamixertrack.h"
#include <gst/mixer/mixer.h> #include <gst/mixer/mixer.h>
G_BEGIN_DECLS G_BEGIN_DECLS
#define GST_ALSA_MIXER_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_ALSA_MIXER,GstAlsaMixer)) #define GST_ALSA_MIXER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_ALSA_MIXER,GstAlsaMixer))
#define GST_ALSA_MIXER_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ALSA_MIXER,GstAlsaMixerClass)) #define GST_ALSA_MIXER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ALSA_MIXER,GstAlsaMixerClass))
#define GST_IS_ALSA_MIXER_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_ALSA_MIXER)) #define GST_IS_ALSA_MIXER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_ALSA_MIXER))
#define GST_IS_ALSA_MIXER_TRACK_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_ALSA_MIXER)) #define GST_IS_ALSA_MIXER_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_ALSA_MIXER))
#define GST_TYPE_ALSA_MIXER_TRACK (gst_alsa_mixer_get_type()) #define GST_TYPE_ALSA_MIXER (gst_alsa_mixer_get_type())
typedef struct _GstAlsaMixerTrack GstAlsaMixerTrack; typedef struct _GstAlsaMixer GstAlsaMixer;
typedef struct _GstAlsaMixerTrackClass GstAlsaMixerTrackClass; typedef struct _GstAlsaMixerClass GstAlsaMixerClass;
struct _GstAlsaMixerTrack { struct _GstAlsaMixer {
GstMixerTrack parent; GstAlsa parent;
snd_mixer_elem_t *element; /* the ALSA mixer element for this track */ GList * tracklist; /* list of available tracks */
gint track_num; snd_mixer_t * mixer_handle;
gint min_rec_volume, max_rec_volume;
gint volumes[GST_ALSA_MAX_CHANNELS];
}; };
struct _GstAlsaMixerTrackClass { struct _GstAlsaMixerClass {
GstMixerTrackClass parent; GstAlsaClass parent;
}; };
GType gst_alsa_mixer_get_type (void); GType gst_alsa_mixer_get_type (void);

130
ext/alsa/gstalsamixertrack.c Normal file
View file

@ -0,0 +1,130 @@
/* ALSA mixer track implementation.
* Copyright (C) 2003 Leif Johnson <leif@ambient.2y.net>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "gstalsamixertrack.h"
static void gst_alsa_mixer_track_init (GstAlsaMixerTrack * alsa_track);
static void gst_alsa_mixer_track_dispose (GObject * object);
static void gst_alsa_mixer_track_class_init (gpointer g_class,
gpointer class_data);
static GstMixerTrackClass *parent_class = NULL;
GType
gst_alsa_mixer_track_get_type (void)
{
static GType track_type = 0;
if (!track_type) {
static const GTypeInfo track_info = {
sizeof (GstAlsaMixerTrackClass),
NULL,
NULL,
gst_alsa_mixer_track_class_init,
NULL,
NULL,
sizeof (GstAlsaMixerTrack),
0,
(GInstanceInitFunc) gst_alsa_mixer_track_init,
};
track_type = g_type_register_static (GST_TYPE_MIXER_TRACK, "GstAlsaMixerTrack", &track_info, 0);
}
return track_type;
}
static void
gst_alsa_mixer_track_class_init (gpointer g_class, gpointer class_data)
{
GObjectClass *object_class = (GObjectClass *) g_class;
if (parent_class == NULL)
parent_class = g_type_class_ref (GST_TYPE_MIXER_TRACK);
object_class->dispose = gst_alsa_mixer_track_dispose;
}
static void
gst_alsa_mixer_track_init (GstAlsaMixerTrack *alsa_track)
{ }
static void
gst_alsa_mixer_track_dispose (GObject *object)
{
if (object != NULL)
gst_alsa_mixer_track_free (GST_ALSA_MIXER_TRACK (object));
}
GstMixerTrack *
gst_alsa_mixer_track_new (snd_mixer_elem_t *element,
gint track_num,
gint channels,
gint flags)
{
gint i;
long min, max;
GstMixerTrack *track = (GstMixerTrack *) g_new (GstAlsaMixerTrack, 1);
GstAlsaMixerTrack *alsa_track = (GstAlsaMixerTrack *) track;
/* set basic information */
track->label = g_strdup_printf("%s", snd_mixer_selem_get_name(element));
track->num_channels = channels;
track->flags = flags;
alsa_track->element = element;
alsa_track->track_num = track_num;
/* set volume information */
snd_mixer_selem_get_playback_volume_range(element, &min, &max);
track->min_volume = (gint) min;
track->max_volume = (gint) max;
snd_mixer_selem_get_capture_volume_range(element, &min, &max);
alsa_track->min_rec_volume = (gint) min;
alsa_track->max_rec_volume = (gint) max;
for (i = 0; i < channels; i++) {
long tmp;
if (snd_mixer_selem_has_playback_channel(element, i)) {
snd_mixer_selem_get_playback_volume(element, i, &tmp);
alsa_track->volumes[i] = (gint) tmp;
} else if (snd_mixer_selem_has_capture_channel(element, i)) {
snd_mixer_selem_get_capture_volume(element, i, &tmp);
alsa_track->volumes[i] = (gint) tmp;
}
}
return track;
}
void
gst_alsa_mixer_track_free (GstAlsaMixerTrack *alsa_track)
{
if (alsa_track != NULL) {
g_free (GST_MIXER_TRACK (alsa_track)->label);
g_free (alsa_track);
}
}

57
ext/alsa/gstalsamixertrack.h Normal file
View file

@ -0,0 +1,57 @@
/* ALSA mixer track object.
* Copyright (C) 2003 Leif Johnson <leif@ambient.2y.net>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef __GST_ALSA_MIXER_TRACK_H__
#define __GST_ALSA_MIXER_TRACK_H__
#include "gstalsa.h"
#include <gst/mixer/mixertrack.h>
G_BEGIN_DECLS
#define GST_ALSA_MIXER_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_ALSA_MIXER_TRACK,GstAlsaMixerTrack))
#define GST_ALSA_MIXER_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ALSA_MIXER_TRACK,GstAlsaMixerTrackClass))
#define GST_IS_ALSA_MIXER_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_ALSA_MIXER_TRACK))
#define GST_IS_ALSA_MIXER_TRACK_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_ALSA_MIXER_TRACK))
#define GST_TYPE_ALSA_MIXER_TRACK (gst_alsa_mixer_track_get_type())
typedef struct _GstAlsaMixerTrack GstAlsaMixerTrack;
typedef struct _GstAlsaMixerTrackClass GstAlsaMixerTrackClass;
struct _GstAlsaMixerTrack {
GstMixerTrack parent;
snd_mixer_elem_t *element; /* the ALSA mixer element for this track */
gint track_num;
gint min_rec_volume, max_rec_volume;
gint volumes[GST_ALSA_MAX_CHANNELS];
};
struct _GstAlsaMixerTrackClass {
GstMixerTrackClass parent;
};
GType gst_alsa_mixer_track_get_type (void);
GstMixerTrack * gst_alsa_mixer_track_new (snd_mixer_elem_t * element,
gint track_num,
gint channels,
gint flags);
void gst_alsa_mixer_track_free (GstAlsaMixerTrack * alsa_track);
G_END_DECLS
#endif /* __GST_ALSA_MIXER_TRACK_H__ */

4
ext/alsa/gstalsaplugin.c
View file

@ -23,9 +23,9 @@
#include "config.h" #include "config.h"
#endif #endif
#include "gstalsa.h"
#include "gstalsasink.h" #include "gstalsasink.h"
#include "gstalsasrc.h" #include "gstalsasrc.h"
#include "gstalsamixer.h"
GST_DEBUG_CATEGORY (alsa_debug); GST_DEBUG_CATEGORY (alsa_debug);
@ -34,6 +34,8 @@ plugin_init (GstPlugin * plugin)
{ {
GST_DEBUG_CATEGORY_INIT (alsa_debug, "alsa", 0, "alsa plugins"); GST_DEBUG_CATEGORY_INIT (alsa_debug, "alsa", 0, "alsa plugins");
if (!gst_element_register (plugin, "alsamixer", GST_RANK_NONE, GST_TYPE_ALSA_MIXER))
return FALSE;
if (!gst_element_register (plugin, "alsasrc", GST_RANK_NONE, GST_TYPE_ALSA_SRC)) if (!gst_element_register (plugin, "alsasrc", GST_RANK_NONE, GST_TYPE_ALSA_SRC))
return FALSE; return FALSE;
if (!gst_element_register (plugin, "alsasink", GST_RANK_NONE, GST_TYPE_ALSA_SINK)) if (!gst_element_register (plugin, "alsasink", GST_RANK_NONE, GST_TYPE_ALSA_SINK))