gstreamer/ext/sndio/sndiosink.c
2012-04-25 10:26:48 +02:00

532 lines
14 KiB
C

/*
* Copyright (C) <2008> Jacob Meuser <jakemsr@sdf.lonestar.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/**
* SECTION:element-sndiosink
* @see_also: #GstAutoAudioSink
*
* <refsect2>
* <para>
* This element outputs sound to a sound card using sndio.
* </para>
* <para>
* Simple example pipeline that plays an Ogg/Vorbis file via sndio:
* <programlisting>
* gst-launch -v filesrc location=foo.ogg ! decodebin ! audioconvert ! audioresample ! sndiosink
* </programlisting>
* </para>
* </refsect2>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "sndiosink.h"
#include <unistd.h>
#include <errno.h>
#include <gst/gst-i18n-plugin.h>
GST_DEBUG_CATEGORY_EXTERN (gst_sndio_debug);
#define GST_CAT_DEFAULT gst_sndio_debug
enum
{
PROP_0,
PROP_HOST
};
static GstStaticPadTemplate sndio_sink_factory =
GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS ("audio/x-raw-int, "
"endianness = (int) { 1234, 4321 }, "
"signed = (boolean) { TRUE, FALSE }, "
"width = (int) { 8, 16, 24, 32 }, "
"depth = (int) { 8, 16, 24, 32 }, "
"rate = (int) [ 8000, 192000 ], "
"channels = (int) [ 1, 16 ] ")
);
static void gst_sndiosink_finalize (GObject * object);
static GstCaps *gst_sndiosink_getcaps (GstBaseSink * bsink);
static gboolean gst_sndiosink_open (GstAudioSink * asink);
static gboolean gst_sndiosink_close (GstAudioSink * asink);
static gboolean gst_sndiosink_prepare (GstAudioSink * asink,
GstRingBufferSpec * spec);
static gboolean gst_sndiosink_unprepare (GstAudioSink * asink);
static guint gst_sndiosink_write (GstAudioSink * asink, gpointer data,
guint length);
static guint gst_sndiosink_delay (GstAudioSink * asink);
static void gst_sndiosink_reset (GstAudioSink * asink);
static void gst_sndiosink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_sndiosink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static void gst_sndiosink_cb (void *addr, int delta);
GST_BOILERPLATE (GstSndioSink, gst_sndiosink, GstAudioSink,
GST_TYPE_AUDIO_SINK);
static void
gst_sndiosink_base_init (gpointer g_class)
{
GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
gst_element_class_set_details_simple (element_class,
"Sndio audio sink",
"Sink/Audio",
"Plays audio through sndio",
"Jacob Meuser <jakemsr@sdf.lonestar.org>");
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&sndio_sink_factory));
}
static void
gst_sndiosink_class_init (GstSndioSinkClass * klass)
{
GObjectClass *gobject_class;
GstBaseSinkClass *gstbasesink_class;
GstBaseAudioSinkClass *gstbaseaudiosink_class;
GstAudioSinkClass *gstaudiosink_class;
gobject_class = (GObjectClass *) klass;
gstbasesink_class = (GstBaseSinkClass *) klass;
gstbaseaudiosink_class = (GstBaseAudioSinkClass *) klass;
gstaudiosink_class = (GstAudioSinkClass *) klass;
parent_class = g_type_class_peek_parent (klass);
gobject_class->finalize = gst_sndiosink_finalize;
gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_sndiosink_getcaps);
gstaudiosink_class->open = GST_DEBUG_FUNCPTR (gst_sndiosink_open);
gstaudiosink_class->close = GST_DEBUG_FUNCPTR (gst_sndiosink_close);
gstaudiosink_class->prepare = GST_DEBUG_FUNCPTR (gst_sndiosink_prepare);
gstaudiosink_class->unprepare =
GST_DEBUG_FUNCPTR (gst_sndiosink_unprepare);
gstaudiosink_class->write = GST_DEBUG_FUNCPTR (gst_sndiosink_write);
gstaudiosink_class->delay = GST_DEBUG_FUNCPTR (gst_sndiosink_delay);
gstaudiosink_class->reset = GST_DEBUG_FUNCPTR (gst_sndiosink_reset);
gobject_class->set_property = gst_sndiosink_set_property;
gobject_class->get_property = gst_sndiosink_get_property;
/* default value is filled in the _init method */
g_object_class_install_property (gobject_class, PROP_HOST,
g_param_spec_string ("host", "Host",
"Device or socket sndio will access", NULL, G_PARAM_READWRITE));
}
static void
gst_sndiosink_init (GstSndioSink * sndiosink,
GstSndioSinkClass * klass)
{
sndiosink->hdl = NULL;
sndiosink->host = g_strdup (g_getenv ("AUDIODEVICE"));
}
static void
gst_sndiosink_finalize (GObject * object)
{
GstSndioSink *sndiosink = GST_SNDIOSINK (object);
gst_caps_replace (&sndiosink->cur_caps, NULL);
g_free (sndiosink->host);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static GstCaps *
gst_sndiosink_getcaps (GstBaseSink * bsink)
{
GstSndioSink *sndiosink;
sndiosink = GST_SNDIOSINK (bsink);
/* no hdl, we're done with the template caps */
if (sndiosink->cur_caps == NULL) {
GST_LOG_OBJECT (sndiosink, "getcaps called, returning template caps");
return NULL;
}
GST_LOG_OBJECT (sndiosink, "returning %" GST_PTR_FORMAT,
sndiosink->cur_caps);
return gst_caps_ref (sndiosink->cur_caps);
}
static gboolean
gst_sndiosink_open (GstAudioSink * asink)
{
GstPadTemplate *pad_template;
GstSndioSink *sndiosink;
struct sio_par par;
struct sio_cap cap;
GArray *rates, *chans;
GValue rates_v = { 0 };
GValue chans_v = { 0 };
GValue value = { 0 };
struct sio_enc enc;
struct sio_conf conf;
int confs[SIO_NCONF];
int rate, chan;
int i, j, k;
int nconfs;
sndiosink = GST_SNDIOSINK (asink);
GST_DEBUG_OBJECT (sndiosink, "open");
/* conect */
sndiosink->hdl = sio_open (sndiosink->host, SIO_PLAY, 0);
if (sndiosink->hdl == NULL)
goto couldnt_connect;
/* Use sndio defaults as the only encodings, but get the supported
* sample rates and number of channels.
*/
if (!sio_getpar (sndiosink->hdl, &par))
goto no_server_info;
if (!sio_getcap (sndiosink->hdl, &cap))
goto no_server_info;
rates = g_array_new (FALSE, FALSE, sizeof (int));
chans = g_array_new (FALSE, FALSE, sizeof (int));
/* find confs that have the default encoding */
nconfs = 0;
for (i = 0; i < cap.nconf; i++) {
for (j = 0; j < SIO_NENC; j++) {
if (cap.confs[i].enc & (1 << j)) {
enc = cap.enc[j];
if (enc.bits == par.bits && enc.sig == par.sig && enc.le == par.le) {
confs[nconfs] = i;
nconfs++;
break;
}
}
}
}
/* find the rates and channels of the confs that have the default encoding */
for (i = 0; i < nconfs; i++) {
conf = cap.confs[confs[i]];
/* rates */
for (j = 0; j < SIO_NRATE; j++) {
if (conf.rate & (1 << j)) {
rate = cap.rate[j];
for (k = 0; k < rates->len && rate; k++) {
if (rate == g_array_index (rates, int, k))
rate = 0;
}
/* add in ascending order */
if (rate) {
for (k = 0; k < rates->len; k++) {
if (rate < g_array_index (rates, int, k))
{
g_array_insert_val (rates, k, rate);
break;
}
}
if (k == rates->len)
g_array_append_val (rates, rate);
}
}
}
/* channels */
for (j = 0; j < SIO_NCHAN; j++) {
if (conf.pchan & (1 << j)) {
chan = cap.pchan[j];
for (k = 0; k < chans->len && chan; k++) {
if (chan == g_array_index (chans, int, k))
chan = 0;
}
/* add in ascending order */
if (chan) {
for (k = 0; k < chans->len; k++) {
if (chan < g_array_index (chans, int, k))
{
g_array_insert_val (chans, k, chan);
break;
}
}
if (k == chans->len)
g_array_append_val (chans, chan);
}
}
}
}
/* not sure how this can happen, but it might */
if (cap.nconf == 0) {
g_array_append_val (rates, par.rate);
g_array_append_val (chans, par.pchan);
}
g_value_init (&rates_v, GST_TYPE_LIST);
g_value_init (&chans_v, GST_TYPE_LIST);
g_value_init (&value, G_TYPE_INT);
for (i = 0; i < rates->len; i++) {
g_value_set_int (&value, g_array_index (rates, int, i));
gst_value_list_append_value (&rates_v, &value);
}
for (i = 0; i < chans->len; i++) {
g_value_set_int (&value, g_array_index (chans, int, i));
gst_value_list_append_value (&chans_v, &value);
}
g_array_free (rates, TRUE);
g_array_free (chans, TRUE);
pad_template = gst_static_pad_template_get (&sndio_sink_factory);
sndiosink->cur_caps =
gst_caps_copy (gst_pad_template_get_caps (pad_template));
gst_object_unref (pad_template);
for (i = 0; i < sndiosink->cur_caps->structs->len; i++) {
GstStructure *s;
s = gst_caps_get_structure (sndiosink->cur_caps, i);
gst_structure_set (s, "endianness", G_TYPE_INT, par.le ? 1234 : 4321, NULL);
gst_structure_set (s, "signed", G_TYPE_BOOLEAN, par.sig ? TRUE : FALSE,
NULL);
gst_structure_set (s, "width", G_TYPE_INT, par.bits, NULL);
// gst_structure_set (s, "depth", G_TYPE_INT, par.bps * 8, NULL); /* XXX */
gst_structure_set_value (s, "rate", &rates_v);
gst_structure_set_value (s, "channels", &chans_v);
}
return TRUE;
/* ERRORS */
couldnt_connect:
{
GST_ELEMENT_ERROR (sndiosink, RESOURCE, OPEN_WRITE,
(_("Could not establish connection to sndio")),
("can't open connection to sndio"));
return FALSE;
}
no_server_info:
{
GST_ELEMENT_ERROR (sndiosink, RESOURCE, OPEN_WRITE,
(_("Failed to query sndio capabilities")),
("couldn't get sndio info!"));
return FALSE;
}
}
static gboolean
gst_sndiosink_close (GstAudioSink * asink)
{
GstSndioSink *sndiosink = GST_SNDIOSINK (asink);
GST_DEBUG_OBJECT (sndiosink, "close");
gst_caps_replace (&sndiosink->cur_caps, NULL);
sio_close (sndiosink->hdl);
sndiosink->hdl = NULL;
return TRUE;
}
static void
gst_sndiosink_cb (void *addr, int delta)
{
GstSndioSink *sndiosink = GST_SNDIOSINK ((GstAudioSink *) addr);
sndiosink->realpos += delta;
if (sndiosink->realpos >= sndiosink->playpos)
sndiosink->latency = 0;
else
sndiosink->latency = sndiosink->playpos - sndiosink->realpos;
}
static gboolean
gst_sndiosink_prepare (GstAudioSink * asink, GstRingBufferSpec * spec)
{
GstSndioSink *sndiosink = GST_SNDIOSINK (asink);
struct sio_par par;
int spec_bpf;
GST_DEBUG_OBJECT (sndiosink, "prepare");
sndiosink->playpos = sndiosink->realpos = sndiosink->latency = 0;
sio_initpar (&par);
par.sig = spec->sign;
par.le = !spec->bigend;
par.bits = spec->width;
// par.bps = spec->depth / 8; /* XXX */
par.rate = spec->rate;
par.pchan = spec->channels;
spec_bpf = ((spec->width / 8) * spec->channels);
par.appbufsz = (spec->segsize * spec->segtotal) / spec_bpf;
if (!sio_setpar (sndiosink->hdl, &par))
goto cannot_configure;
sio_getpar (sndiosink->hdl, &par);
spec->sign = par.sig;
spec->bigend = !par.le;
spec->width = par.bits;
// spec->depth = par.bps * 8; /* XXX */
spec->rate = par.rate;
spec->channels = par.pchan;
sndiosink->bpf = par.bps * par.pchan;
spec->segsize = par.round * par.pchan * par.bps;
spec->segtotal = par.bufsz / par.round;
/* FIXME: this is wrong for signed ints (and the
* audioringbuffers should do it for us anyway) */
spec->silence_sample[0] = 0;
spec->silence_sample[1] = 0;
spec->silence_sample[2] = 0;
spec->silence_sample[3] = 0;
sio_onmove (sndiosink->hdl, gst_sndiosink_cb, sndiosink);
if (!sio_start (sndiosink->hdl))
goto cannot_start;
GST_INFO_OBJECT (sndiosink, "successfully opened connection to sndio");
return TRUE;
/* ERRORS */
cannot_configure:
{
GST_ELEMENT_ERROR (sndiosink, RESOURCE, OPEN_WRITE,
(_("Could not configure sndio")), ("can't configure sndio"));
return FALSE;
}
cannot_start:
{
GST_ELEMENT_ERROR (sndiosink, RESOURCE, OPEN_WRITE,
(_("Could not start sndio")), ("can't start sndio"));
return FALSE;
}
}
static gboolean
gst_sndiosink_unprepare (GstAudioSink * asink)
{
GstSndioSink *sndiosink = GST_SNDIOSINK (asink);
if (sndiosink->hdl == NULL)
return TRUE;
sio_stop (sndiosink->hdl);
return TRUE;
}
static guint
gst_sndiosink_write (GstAudioSink * asink, gpointer data, guint length)
{
GstSndioSink *sndiosink = GST_SNDIOSINK (asink);
guint done;
done = sio_write (sndiosink->hdl, data, length);
if (done == 0)
goto write_error;
sndiosink->playpos += (done / sndiosink->bpf);
data = (char *) data + done;
return done;
/* ERRORS */
write_error:
{
GST_ELEMENT_ERROR (sndiosink, RESOURCE, WRITE,
("Failed to write data to sndio"), GST_ERROR_SYSTEM);
return 0;
}
}
static guint
gst_sndiosink_delay (GstAudioSink * asink)
{
GstSndioSink *sndiosink = GST_SNDIOSINK (asink);
if (sndiosink->latency == (guint) - 1) {
GST_WARNING_OBJECT (asink, "couldn't get latency");
return 0;
}
GST_DEBUG_OBJECT (asink, "got latency: %u", sndiosink->latency);
return sndiosink->latency;
}
static void
gst_sndiosink_reset (GstAudioSink * asink)
{
/* no way to flush the buffers with sndio ? */
GST_DEBUG_OBJECT (asink, "reset called");
}
static void
gst_sndiosink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstSndioSink *sndiosink = GST_SNDIOSINK (object);
switch (prop_id) {
case PROP_HOST:
g_free (sndiosink->host);
sndiosink->host = g_value_dup_string (value);
break;
default:
break;
}
}
static void
gst_sndiosink_get_property (GObject * object, guint prop_id, GValue * value,
GParamSpec * pspec)
{
GstSndioSink *sndiosink = GST_SNDIOSINK (object);
switch (prop_id) {
case PROP_HOST:
g_value_set_string (value, sndiosink->host);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}