--- /dev/null
+/* GStreamer
+ * Copyright (C) 2016 Centricular Ltd.
+ * Author: Arun Raghavan <arun@centricular.com>
+ *
+ * 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., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+/**
+ * SECTION:element-tinyalsasink
+ * @see_also: alsasink
+ *
+ * This element renders raw audio samples using the ALSA audio API via the
+ * tinyalsa library.
+ *
+ * <refsect2>
+ * <title>Example pipelines</title>
+ * |[
+ * gst-launch-1.0 -v uridecodebin uri=file:///path/to/audio.ogg ! audioconvert ! audioresample ! alsasink
+ * ]| Play an Ogg/Vorbis file and output audio via ALSA using the tinalsa
+ * library.
+ * </refsect2>
+ */
+
+#include <gst/audio/gstaudiobasesink.h>
+
+#include <tinyalsa/asoundlib.h>
+
+#include "tinyalsasink.h"
+
+/* Hardcoding these bitmask values rather than including a kernel header */
+#define SNDRV_PCM_FORMAT_S8 0
+#define SNDRV_PCM_FORMAT_S16_LE 2
+#define SNDRV_PCM_FORMAT_S24_LE 6
+#define SNDRV_PCM_FORMAT_S32_LE 10
+#define SNDRV_PCM_FORMAT_ANY \
+ ((1 << SNDRV_PCM_FORMAT_S8) | \
+ (1 << SNDRV_PCM_FORMAT_S16_LE) | \
+ (1 << SNDRV_PCM_FORMAT_S24_LE) | \
+ (1 << SNDRV_PCM_FORMAT_S32_LE))
+
+GST_DEBUG_CATEGORY_STATIC (tinyalsa_sink_debug);
+#define GST_CAT_DEFAULT tinyalsa_sink_debug
+
+#define parent_class gst_tinyalsa_sink_parent_class
+G_DEFINE_TYPE (GstTinyalsaSink, gst_tinyalsa_sink, GST_TYPE_AUDIO_SINK);
+
+enum
+{
+ PROP_0,
+ PROP_CARD,
+ PROP_DEVICE,
+ PROP_LAST
+};
+
+#define DEFAULT_CARD 0
+#define DEFAULT_DEVICE 0
+
+static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
+ GST_PAD_SINK,
+ GST_PAD_ALWAYS,
+ GST_STATIC_CAPS ("audio/x-raw, "
+ "format = (string) { S16LE, S32LE, S24_32LE, S8 }, "
+ "channels = (int) [ 1, MAX ], "
+ "rate = (int) [ 1, MAX ], " "layout = (string) interleaved"));
+
+static void
+gst_tinyalsa_sink_get_property (GObject * object, guint prop_id,
+ GValue * value, GParamSpec * pspec)
+{
+ GstTinyalsaSink *sink = GST_TINYALSA_SINK (object);
+
+ switch (prop_id) {
+ case PROP_CARD:
+ g_value_set_uint (value, sink->card);
+ break;
+
+ case PROP_DEVICE:
+ g_value_set_uint (value, sink->device);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gst_tinyalsa_sink_set_property (GObject * object, guint prop_id,
+ const GValue * value, GParamSpec * pspec)
+{
+ GstTinyalsaSink *sink = GST_TINYALSA_SINK (object);
+
+ switch (prop_id) {
+ case PROP_CARD:
+ sink->card = g_value_get_uint (value);
+ break;
+
+ case PROP_DEVICE:
+ sink->device = g_value_get_uint (value);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static GstCaps *
+gst_tinyalsa_sink_getcaps (GstBaseSink * bsink, GstCaps * filter)
+{
+ GstTinyalsaSink *sink = GST_TINYALSA_SINK (bsink);
+ GstCaps *caps = NULL;
+ GValue formats = { 0, };
+ GValue format = { 0, };
+ struct pcm_params *params = NULL;
+ struct pcm_mask *mask;
+ guint16 m;
+
+ GST_DEBUG_OBJECT (sink, "Querying caps");
+
+ GST_OBJECT_LOCK (sink);
+
+ if (sink->cached_caps) {
+ GST_DEBUG_OBJECT (sink, "Returning cached caps");
+ caps = gst_caps_ref (sink->cached_caps);
+ goto done;
+ }
+
+ if (sink->pcm) {
+ /* We can't query the device while it's open, so return current caps */
+ caps = gst_pad_get_current_caps (GST_BASE_SINK_PAD (bsink));
+ goto done;
+ }
+
+ params = pcm_params_get (sink->card, sink->device, PCM_OUT);
+ if (!params) {
+ GST_ERROR_OBJECT (sink, "Could not get PCM params");
+ goto done;
+ }
+
+ mask = pcm_params_get_mask (params, PCM_PARAM_FORMAT);
+ m = (mask->bits[1] << 8) | mask->bits[0];
+
+ if (!(m & SNDRV_PCM_FORMAT_ANY)) {
+ GST_ERROR_OBJECT (sink, "Could not find any supported format");
+ goto done;
+ }
+
+ caps = gst_caps_new_empty_simple ("audio/x-raw");
+
+ g_value_init (&formats, GST_TYPE_LIST);
+ g_value_init (&format, G_TYPE_STRING);
+
+ if (m & (1 << SNDRV_PCM_FORMAT_S8)) {
+ g_value_set_static_string (&format, "S8");
+ gst_value_list_prepend_value (&formats, &format);
+ }
+ if (m & (1 << SNDRV_PCM_FORMAT_S16_LE)) {
+ g_value_set_static_string (&format, "S16LE");
+ gst_value_list_prepend_value (&formats, &format);
+ }
+ if (m & (1 << SNDRV_PCM_FORMAT_S24_LE)) {
+ g_value_set_static_string (&format, "S24_32LE");
+ gst_value_list_prepend_value (&formats, &format);
+ }
+ if (m & (1 << SNDRV_PCM_FORMAT_S32_LE)) {
+ g_value_set_static_string (&format, "S32LE");
+ gst_value_list_prepend_value (&formats, &format);
+ }
+
+ gst_caps_set_value (caps, "format", &formats);
+
+ g_value_unset (&format);
+ g_value_unset (&formats);
+
+ /* This is a bit of a lie, since the device likely only supports some
+ * standard rates in this range. We should probably filter the range to
+ * those, standard audio rates but even that isn't guaranteed to be accurate.
+ */
+ gst_caps_set_simple (caps, "rate", GST_TYPE_INT_RANGE,
+ pcm_params_get_min (params, PCM_PARAM_RATE),
+ pcm_params_get_max (params, PCM_PARAM_RATE), NULL);
+
+ gst_caps_set_simple (caps, "channels", GST_TYPE_INT_RANGE,
+ pcm_params_get_min (params, PCM_PARAM_CHANNELS),
+ pcm_params_get_max (params, PCM_PARAM_CHANNELS), NULL);
+
+ gst_caps_replace (&sink->cached_caps, caps);
+
+done:
+ GST_OBJECT_UNLOCK (sink);
+
+ GST_DEBUG_OBJECT (sink, "Got caps %" GST_PTR_FORMAT, caps);
+
+ if (caps && filter) {
+ GstCaps *intersection =
+ gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
+
+ gst_caps_unref (caps);
+ caps = intersection;
+ }
+
+ if (params)
+ pcm_params_free (params);
+
+ return caps;
+}
+
+static gboolean
+gst_tinyalsa_sink_open (GstAudioSink * asink)
+{
+ /* Nothing to do here, we can't call pcm_open() till we have stream
+ * parameters available */
+ return TRUE;
+}
+
+static enum pcm_format
+pcm_format_from_gst (GstAudioFormat format)
+{
+ switch (format) {
+ case GST_AUDIO_FORMAT_S8:
+ return PCM_FORMAT_S8;
+
+ case GST_AUDIO_FORMAT_S16LE:
+ return PCM_FORMAT_S16_LE;
+
+ case GST_AUDIO_FORMAT_S24_32LE:
+ return PCM_FORMAT_S24_LE;
+
+ case GST_AUDIO_FORMAT_S32LE:
+ return PCM_FORMAT_S32_LE;
+
+ default:
+ g_assert_not_reached ();
+ }
+}
+
+static void
+pcm_config_from_spec (struct pcm_config *config,
+ const GstAudioRingBufferSpec * spec)
+{
+ gint64 frames;
+
+ config->format = pcm_format_from_gst (GST_AUDIO_INFO_FORMAT (&spec->info));
+ config->channels = GST_AUDIO_INFO_CHANNELS (&spec->info);
+ config->rate = GST_AUDIO_INFO_RATE (&spec->info);
+
+ gst_audio_info_convert (&spec->info,
+ GST_FORMAT_TIME, spec->latency_time * GST_USECOND,
+ GST_FORMAT_DEFAULT /* frames */ , &frames);
+
+ config->period_size = frames;
+ config->period_count = spec->buffer_time / spec->latency_time;
+}
+
+static gboolean
+gst_tinyalsa_sink_prepare (GstAudioSink * asink, GstAudioRingBufferSpec * spec)
+{
+ GstTinyalsaSink *sink = GST_TINYALSA_SINK (asink);
+ struct pcm_config config = { 0, };
+
+ pcm_config_from_spec (&config, spec);
+
+ GST_DEBUG_OBJECT (sink, "Requesting %u periods of %u frames",
+ config.period_count, config.period_size);
+
+ /* mutex with getcaps */
+ GST_OBJECT_LOCK (sink);
+
+ sink->pcm = pcm_open (sink->card, sink->device, PCM_OUT | PCM_NORESTART,
+ &config);
+
+ GST_OBJECT_UNLOCK (sink);
+
+ if (!sink->pcm || !pcm_is_ready (sink->pcm)) {
+ GST_ERROR_OBJECT (sink, "Could not open device: %s",
+ pcm_get_error (sink->pcm));
+ goto fail;
+ }
+
+ if (pcm_prepare (sink->pcm) < 0) {
+ GST_ERROR_OBJECT (sink, "Could not prepare device: %s",
+ pcm_get_error (sink->pcm));
+ goto fail;
+ }
+
+ spec->segsize = pcm_frames_to_bytes (sink->pcm, config.period_size);
+ spec->segtotal = config.period_count;
+
+ GST_DEBUG_OBJECT (sink, "Configured for %u periods of %u frames",
+ config.period_count, config.period_size);
+
+ return TRUE;
+
+fail:
+ if (sink->pcm)
+ pcm_close (sink->pcm);
+
+ return FALSE;
+}
+
+static gboolean
+gst_tinyalsa_sink_unprepare (GstAudioSink * asink)
+{
+ GstTinyalsaSink *sink = GST_TINYALSA_SINK (asink);
+
+ if (pcm_stop (sink->pcm) < 0) {
+ GST_ERROR_OBJECT (sink, "Could not stop device: %s",
+ pcm_get_error (sink->pcm));
+ }
+
+ /* mutex with getcaps */
+ GST_OBJECT_LOCK (sink);
+
+ if (pcm_close (sink->pcm)) {
+ GST_ERROR_OBJECT (sink, "Could not close device: %s",
+ pcm_get_error (sink->pcm));
+ return FALSE;
+ }
+
+ sink->pcm = NULL;
+
+ gst_caps_replace (&sink->cached_caps, NULL);
+
+ GST_OBJECT_UNLOCK (sink);
+
+ GST_DEBUG_OBJECT (sink, "Device unprepared");
+
+ return TRUE;
+}
+
+static gboolean
+gst_tinyalsa_sink_close (GstAudioSink * asink)
+{
+ /* Nothing to do here, see gst_tinyalsa_sink_open() */
+ return TRUE;
+}
+
+static gint
+gst_tinyalsa_sink_write (GstAudioSink * asink, gpointer data, guint length)
+{
+ GstTinyalsaSink *sink = GST_TINYALSA_SINK (asink);
+ int ret;
+
+again:
+ GST_DEBUG_OBJECT (sink, "Starting write");
+
+ ret = pcm_write (sink->pcm, data, length);
+ if (ret == -EPIPE) {
+ GST_WARNING_OBJECT (sink, "Got an underrun");
+
+ if (pcm_prepare (sink->pcm) < 0) {
+ GST_ERROR_OBJECT (sink, "Could not prepare device: %s",
+ pcm_get_error (sink->pcm));
+ return -1;
+ }
+
+ goto again;
+
+ } else if (ret < 0) {
+ GST_ERROR_OBJECT (sink, "Could not write data to device: %s",
+ pcm_get_error (sink->pcm));
+ return -1;
+ }
+
+ GST_DEBUG_OBJECT (sink, "Wrote %u bytes", length);
+
+ return length;
+}
+
+static void
+gst_tinyalsa_sink_reset (GstAudioSink * asink)
+{
+ GstTinyalsaSink *sink = GST_TINYALSA_SINK (asink);
+
+ if (pcm_stop (sink->pcm) < 0) {
+ GST_ERROR_OBJECT (sink, "Could not stop device: %s",
+ pcm_get_error (sink->pcm));
+ }
+
+ if (pcm_prepare (sink->pcm) < 0) {
+ GST_ERROR_OBJECT (sink, "Could not prepare device: %s",
+ pcm_get_error (sink->pcm));
+ }
+}
+
+static guint
+gst_tinyalsa_sink_delay (GstAudioSink * asink)
+{
+ GstTinyalsaSink *sink = GST_TINYALSA_SINK (asink);
+ int delay;
+
+ delay = pcm_get_delay (sink->pcm);
+
+ if (delay < 0) {
+ /* This might happen before the stream has started */
+ GST_DEBUG_OBJECT (sink, "Got negative delay");
+ delay = 0;
+ } else
+ GST_DEBUG_OBJECT (sink, "Got delay of %u", delay);
+
+ return delay;
+}
+
+static void
+gst_tinyalsa_sink_class_init (GstTinyalsaSinkClass * klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
+ GstBaseSinkClass *basesink_class = GST_BASE_SINK_CLASS (klass);
+ GstAudioSinkClass *audiosink_class = GST_AUDIO_SINK_CLASS (klass);
+
+ gobject_class->get_property =
+ GST_DEBUG_FUNCPTR (gst_tinyalsa_sink_get_property);
+ gobject_class->set_property =
+ GST_DEBUG_FUNCPTR (gst_tinyalsa_sink_set_property);
+
+ basesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_tinyalsa_sink_getcaps);
+
+ audiosink_class->open = GST_DEBUG_FUNCPTR (gst_tinyalsa_sink_open);
+ audiosink_class->prepare = GST_DEBUG_FUNCPTR (gst_tinyalsa_sink_prepare);
+ audiosink_class->unprepare = GST_DEBUG_FUNCPTR (gst_tinyalsa_sink_unprepare);
+ audiosink_class->close = GST_DEBUG_FUNCPTR (gst_tinyalsa_sink_close);
+ audiosink_class->write = GST_DEBUG_FUNCPTR (gst_tinyalsa_sink_write);
+ audiosink_class->reset = GST_DEBUG_FUNCPTR (gst_tinyalsa_sink_reset);
+ audiosink_class->delay = GST_DEBUG_FUNCPTR (gst_tinyalsa_sink_delay);
+
+ gst_element_class_set_static_metadata (element_class,
+ "tinyalsa Audio Sink",
+ "Sink/Audio", "Plays audio to an ALSA device",
+ "Arun Raghavan <arun@centricular.com>");
+
+ gst_element_class_add_pad_template (element_class,
+ gst_static_pad_template_get (&sink_template));
+
+ g_object_class_install_property (gobject_class,
+ PROP_CARD,
+ g_param_spec_uint ("card", "Card", "The ALSA card to use",
+ 0, G_MAXUINT, DEFAULT_CARD,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (gobject_class,
+ PROP_DEVICE,
+ g_param_spec_uint ("device", "Device", "The ALSA device to use",
+ 0, G_MAXUINT, DEFAULT_CARD,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ GST_DEBUG_CATEGORY_INIT (tinyalsa_sink_debug, "tinyalsasink", 0,
+ "tinyalsa Sink");
+}
+
+static void
+gst_tinyalsa_sink_init (GstTinyalsaSink * sink)
+{
+ sink->card = DEFAULT_CARD;
+ sink->device = DEFAULT_DEVICE;
+
+ sink->cached_caps = NULL;
+}
projects / platform / upstream / gstreamer.git / commitdiff