sys/oss4/oss4-sink.c

   1 /* GStreamer OSS4 audio sink
   2  * Copyright (C) 2007-2008 Tim-Philipp Müller <tim centricular net>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19 /**
  20  * SECTION:element-oss4sink
  21  * @short_description: output sound using OSS4
  22  *
  23  * <refsect2>
  24  * <para>
  25  * This element lets you output sound using the Open Sound System (OSS)
  26  * version 4.
  27  * </para>
  28  * <para>
  29  * Note that you should almost always use generic audio conversion elements
  30  * like audioconvert and audioresample in front of an audiosink to make sure
  31  * your pipeline works under all circumstances (those conversion elements will
  32  * act in passthrough-mode if no conversion is necessary).
  33  * </para>
  34  * <title>Example pipelines</title>
  35  * <para>
  36  * <programlisting>
  37  * gst-launch -v audiotestsrc ! audioconvert ! volume volume=0.1 ! oss4sink
  38  * </programlisting>
  39  * will output a sine wave (continuous beep sound) to your sound card (with
  40  * a very low volume as precaution).
  41  * </para>
  42  * <para>
  43  * <programlisting>
  44  * gst-launch -v filesrc location=music.ogg ! decodebin ! audioconvert ! audioresample ! oss4sink
  45  * </programlisting>
  46  * will play an Ogg/Vorbis audio file and output it using the Open Sound System
  47  * version 4.
  48  * </para>
  49  * </refsect2>
  50  *
  51  * Since: 0.10.7
  52  */
  53
  54 /* TODO: - add "volume" property for stream volume control and intercept tags
  55  *         to set stream title
  56  */
  57
  58 #ifdef HAVE_CONFIG_H
  59 #include "config.h"
  60 #endif
  61
  62 #include <sys/types.h>
  63 #include <sys/stat.h>
  64 #include <sys/ioctl.h>
  65 #include <fcntl.h>
  66 #include <errno.h>
  67 #include <unistd.h>
  68 #include <string.h>
  69
  70 #include <gst/gst-i18n-plugin.h>
  71
  72 #define NO_LEGACY_MIXER
  73 #include "oss4-audio.h"
  74 #include "oss4-sink.h"
  75 #include "oss4-property-probe.h"
  76 #include "oss4-soundcard.h"
  77
  78 GST_DEBUG_CATEGORY_EXTERN (oss4sink_debug);
  79 #define GST_CAT_DEFAULT oss4sink_debug
  80
  81 static void gst_oss4_sink_init_interfaces (GType type);
  82 static void gst_oss4_sink_dispose (GObject * object);
  83 static void gst_oss4_sink_finalise (GObject * object);
  84
  85 static void gst_oss4_sink_get_property (GObject * object, guint prop_id,
  86     GValue * value, GParamSpec * pspec);
  87 static void gst_oss4_sink_set_property (GObject * object, guint prop_id,
  88     const GValue * value, GParamSpec * pspec);
  89
  90 static GstCaps *gst_oss4_sink_getcaps (GstBaseSink * bsink);
  91 static gboolean gst_oss4_sink_open (GstAudioSink * asink,
  92     gboolean silent_errors);
  93 static gboolean gst_oss4_sink_open_func (GstAudioSink * asink);
  94 static gboolean gst_oss4_sink_close (GstAudioSink * asink);
  95 static gboolean gst_oss4_sink_prepare (GstAudioSink * asink,
  96     GstRingBufferSpec * spec);
  97 static gboolean gst_oss4_sink_unprepare (GstAudioSink * asink);
  98 static guint gst_oss4_sink_write (GstAudioSink * asink, gpointer data,
  99     guint length);
 100 static guint gst_oss4_sink_delay (GstAudioSink * asink);
 101 static void gst_oss4_sink_reset (GstAudioSink * asink);
 102
 103 #define DEFAULT_DEVICE      NULL
 104 #define DEFAULT_DEVICE_NAME NULL
 105
 106 enum
 107 {
 108   PROP_0,
 109   PROP_DEVICE,
 110   PROP_DEVICE_NAME
 111 };
 112
 113 GST_BOILERPLATE_FULL (GstOss4Sink, gst_oss4_sink, GstAudioSink,
 114     GST_TYPE_AUDIO_SINK, gst_oss4_sink_init_interfaces);
 115
 116 static void
 117 gst_oss4_sink_dispose (GObject * object)
 118 {
 119   GstOss4Sink *osssink = GST_OSS4_SINK (object);
 120
 121   if (osssink->probed_caps) {
 122     gst_caps_unref (osssink->probed_caps);
 123     osssink->probed_caps = NULL;
 124   }
 125
 126   G_OBJECT_CLASS (parent_class)->dispose (object);
 127 }
 128
 129 static void
 130 gst_oss4_sink_base_init (gpointer g_class)
 131 {
 132   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 133   GstPadTemplate *templ;
 134
 135   gst_element_class_set_details_simple (element_class,
 136       "OSS v4 Audio Sink", "Sink/Audio",
 137       "Output to a sound card via OSS version 4",
 138       "Tim-Philipp Müller <tim centricular net>");
 139
 140   templ = gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
 141       gst_oss4_audio_get_template_caps ());
 142   gst_element_class_add_pad_template (element_class, templ);
 143 }
 144
 145 static void
 146 gst_oss4_sink_class_init (GstOss4SinkClass * klass)
 147 {
 148   GstAudioSinkClass *audiosink_class = (GstAudioSinkClass *) klass;
 149   GstBaseSinkClass *basesink_class = (GstBaseSinkClass *) klass;
 150   GObjectClass *gobject_class = (GObjectClass *) klass;
 151
 152   gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_oss4_sink_dispose);
 153   gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_oss4_sink_finalise);
 154   gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_oss4_sink_get_property);
 155   gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_oss4_sink_set_property);
 156
 157   g_object_class_install_property (gobject_class, PROP_DEVICE,
 158       g_param_spec_string ("device", "Device",
 159           "OSS4 device (e.g. /dev/oss/hdaudio0/pcm0 or /dev/dspN) "
 160           "(NULL = use first available playback device)",
 161           DEFAULT_DEVICE, G_PARAM_READWRITE));
 162
 163   g_object_class_install_property (gobject_class, PROP_DEVICE_NAME,
 164       g_param_spec_string ("device-name", "Device name",
 165           "Human-readable name of the sound device", DEFAULT_DEVICE_NAME,
 166           G_PARAM_READABLE));
 167
 168   basesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_oss4_sink_getcaps);
 169
 170   audiosink_class->open = GST_DEBUG_FUNCPTR (gst_oss4_sink_open_func);
 171   audiosink_class->close = GST_DEBUG_FUNCPTR (gst_oss4_sink_close);
 172   audiosink_class->prepare = GST_DEBUG_FUNCPTR (gst_oss4_sink_prepare);
 173   audiosink_class->unprepare = GST_DEBUG_FUNCPTR (gst_oss4_sink_unprepare);
 174   audiosink_class->write = GST_DEBUG_FUNCPTR (gst_oss4_sink_write);
 175   audiosink_class->delay = GST_DEBUG_FUNCPTR (gst_oss4_sink_delay);
 176   audiosink_class->reset = GST_DEBUG_FUNCPTR (gst_oss4_sink_reset);
 177 }
 178
 179 static void
 180 gst_oss4_sink_init (GstOss4Sink * osssink, GstOss4SinkClass * klass)
 181 {
 182   const gchar *device;
 183
 184   device = g_getenv ("AUDIODEV");
 185   if (device == NULL)
 186     device = DEFAULT_DEVICE;
 187   osssink->device = g_strdup (device);
 188   osssink->fd = -1;
 189   osssink->bytes_per_sample = 0;
 190   osssink->probed_caps = NULL;
 191   osssink->device_name = NULL;
 192 }
 193
 194 static void
 195 gst_oss4_sink_finalise (GObject * object)
 196 {
 197   GstOss4Sink *osssink = GST_OSS4_SINK (object);
 198
 199   g_free (osssink->device);
 200   osssink->device = NULL;
 201
 202   g_list_free (osssink->property_probe_list);
 203   osssink->property_probe_list = NULL;
 204
 205   G_OBJECT_CLASS (parent_class)->finalize (object);
 206 }
 207
 208 static void
 209 gst_oss4_sink_set_property (GObject * object, guint prop_id,
 210     const GValue * value, GParamSpec * pspec)
 211 {
 212   GstOss4Sink *oss = GST_OSS4_SINK (object);
 213
 214   switch (prop_id) {
 215     case PROP_DEVICE:
 216       GST_OBJECT_LOCK (oss);
 217       if (oss->fd == -1) {
 218         g_free (oss->device);
 219         oss->device = g_value_dup_string (value);
 220         if (oss->probed_caps) {
 221           gst_caps_unref (oss->probed_caps);
 222           oss->probed_caps = NULL;
 223         }
 224         g_free (oss->device_name);
 225         oss->device_name = NULL;
 226       } else {
 227         g_warning ("%s: can't change \"device\" property while audio sink "
 228             "is open", GST_OBJECT_NAME (oss));
 229       }
 230       GST_OBJECT_UNLOCK (oss);
 231       break;
 232     default:
 233       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 234       break;
 235   }
 236 }
 237
 238 static void
 239 gst_oss4_sink_get_property (GObject * object, guint prop_id,
 240     GValue * value, GParamSpec * pspec)
 241 {
 242   GstOss4Sink *oss = GST_OSS4_SINK (object);
 243
 244   switch (prop_id) {
 245     case PROP_DEVICE:
 246       GST_OBJECT_LOCK (oss);
 247       g_value_set_string (value, oss->device);
 248       GST_OBJECT_UNLOCK (oss);
 249       break;
 250     case PROP_DEVICE_NAME:
 251       GST_OBJECT_LOCK (oss);
 252       if (oss->fd == -1 && oss->device != NULL) {
 253         /* If device is set, try to retrieve the name even if we're not open */
 254         if (gst_oss4_sink_open (GST_AUDIO_SINK (oss), TRUE)) {
 255           g_value_set_string (value, oss->device_name);
 256           gst_oss4_sink_close (GST_AUDIO_SINK (oss));
 257         } else {
 258           gchar *name = NULL;
 259
 260           gst_oss4_property_probe_find_device_name_nofd (GST_OBJECT (oss),
 261               oss->device, &name);
 262           g_value_set_string (value, name);
 263           g_free (name);
 264         }
 265       } else {
 266         g_value_set_string (value, oss->device_name);
 267       }
 268       GST_OBJECT_UNLOCK (oss);
 269       break;
 270     default:
 271       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 272       break;
 273   }
 274 }
 275
 276 static GstCaps *
 277 gst_oss4_sink_getcaps (GstBaseSink * bsink)
 278 {
 279   GstOss4Sink *oss;
 280   GstCaps *caps;
 281
 282   oss = GST_OSS4_SINK (bsink);
 283
 284   if (oss->fd == -1) {
 285     caps = gst_caps_copy (gst_oss4_audio_get_template_caps ());
 286   } else if (oss->probed_caps) {
 287     caps = gst_caps_copy (oss->probed_caps);
 288   } else {
 289     caps = gst_oss4_audio_probe_caps (GST_OBJECT (oss), oss->fd);
 290     if (caps != NULL && !gst_caps_is_empty (caps)) {
 291       oss->probed_caps = gst_caps_copy (caps);
 292     }
 293   }
 294
 295   return caps;
 296 }
 297
 298 /* note: we must not take the object lock here unless we fix up get_property */
 299 static gboolean
 300 gst_oss4_sink_open (GstAudioSink * asink, gboolean silent_errors)
 301 {
 302   GstOss4Sink *oss;
 303   gchar *device;
 304   int mode;
 305
 306   oss = GST_OSS4_SINK (asink);
 307
 308   if (oss->device)
 309     device = g_strdup (oss->device);
 310   else
 311     device = gst_oss4_audio_find_device (GST_OBJECT_CAST (oss));
 312
 313   /* desperate times, desperate measures */
 314   if (device == NULL)
 315     device = g_strdup ("/dev/dsp0");
 316
 317   GST_INFO_OBJECT (oss, "Trying to open OSS4 device '%s'", device);
 318
 319   /* we open in non-blocking mode even if we don't really want to do writes
 320    * non-blocking because we can't be sure that this is really a genuine
 321    * OSS4 device with well-behaved drivers etc. We really don't want to
 322    * hang forever under any circumstances. */
 323   oss->fd = open (device, O_WRONLY | O_NONBLOCK, 0);
 324   if (oss->fd == -1) {
 325     switch (errno) {
 326       case EBUSY:
 327         goto busy;
 328       case EACCES:
 329         goto no_permission;
 330       default:
 331         goto open_failed;
 332     }
 333   }
 334
 335   GST_INFO_OBJECT (oss, "Opened device '%s'", device);
 336
 337   /* Make sure it's OSS4. If it's old OSS, let osssink handle it */
 338   if (!gst_oss4_audio_check_version (GST_OBJECT_CAST (oss), oss->fd))
 339     goto legacy_oss;
 340
 341   /* now remove the non-blocking flag. */
 342   mode = fcntl (oss->fd, F_GETFL);
 343   mode &= ~O_NONBLOCK;
 344   if (fcntl (oss->fd, F_SETFL, mode) < 0) {
 345     /* some drivers do no support unsetting the non-blocking flag, try to
 346      * close/open the device then. This is racy but we error out properly. */
 347     GST_WARNING_OBJECT (oss, "failed to unset O_NONBLOCK (buggy driver?), "
 348         "will try to re-open device now");
 349     gst_oss4_sink_close (asink);
 350     if ((oss->fd = open (device, O_WRONLY, 0)) == -1)
 351       goto non_block;
 352   }
 353
 354   oss->open_device = device;
 355
 356   /* not using ENGINEINFO here because it sometimes returns a different and
 357    * less useful name than AUDIOINFO for the same device */
 358   if (!gst_oss4_property_probe_find_device_name (GST_OBJECT (oss), oss->fd,
 359           oss->open_device, &oss->device_name)) {
 360     oss->device_name = NULL;
 361   }
 362
 363   /* list output routings, for informational purposes only so far */
 364   {
 365     oss_mixer_enuminfo routings = { 0, };
 366     guint i;
 367
 368     if (ioctl (oss->fd, SNDCTL_DSP_GET_PLAYTGT_NAMES, &routings) != -1) {
 369       GST_LOG_OBJECT (oss, "%u output routings (static list: %d)",
 370           routings.nvalues, !!(routings.version == 0));
 371       for (i = 0; i < routings.nvalues; ++i) {
 372         GST_LOG_OBJECT (oss, "  output routing %d: %s", i,
 373             &routings.strings[routings.strindex[i]]);
 374       }
 375     }
 376   }
 377
 378   return TRUE;
 379
 380   /* ERRORS */
 381 busy:
 382   {
 383     if (!silent_errors) {
 384       GST_ELEMENT_ERROR (oss, RESOURCE, BUSY,
 385           (_("Could not open audio device for playback. "
 386                   "Device is being used by another application.")), (NULL));
 387     }
 388     g_free (device);
 389     return FALSE;
 390   }
 391 no_permission:
 392   {
 393     if (!silent_errors) {
 394       GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_WRITE,
 395           (_("Could not open audio device for playback."
 396                   "You don't have permission to open the device.")),
 397           GST_ERROR_SYSTEM);
 398     }
 399     g_free (device);
 400     return FALSE;
 401   }
 402 open_failed:
 403   {
 404     if (!silent_errors) {
 405       GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_WRITE,
 406           (_("Could not open audio device for playback.")), GST_ERROR_SYSTEM);
 407     }
 408     g_free (device);
 409     return FALSE;
 410   }
 411 legacy_oss:
 412   {
 413     if (!silent_errors) {
 414       GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_WRITE,
 415           (_("Could not open audio device for playback."
 416                   "This version of the Open Sound System is not supported by this "
 417                   "element.")), ("Try the 'osssink' element instead"));
 418     }
 419     gst_oss4_sink_close (asink);
 420     g_free (device);
 421     return FALSE;
 422   }
 423 non_block:
 424   {
 425     if (!silent_errors) {
 426       GST_ELEMENT_ERROR (oss, RESOURCE, SETTINGS, (NULL),
 427           ("Unable to set device %s into non-blocking mode: %s",
 428               oss->device, g_strerror (errno)));
 429     }
 430     g_free (device);
 431     return FALSE;
 432   }
 433 }
 434
 435 static gboolean
 436 gst_oss4_sink_open_func (GstAudioSink * asink)
 437 {
 438   return gst_oss4_sink_open (asink, FALSE);
 439 }
 440
 441 static gboolean
 442 gst_oss4_sink_close (GstAudioSink * asink)
 443 {
 444   GstOss4Sink *oss = GST_OSS4_SINK (asink);
 445
 446   if (oss->fd != -1) {
 447     GST_DEBUG_OBJECT (oss, "closing device");
 448     close (oss->fd);
 449     oss->fd = -1;
 450   }
 451
 452   oss->bytes_per_sample = 0;
 453   /* we keep the probed caps cached, at least until the device changes */
 454
 455   g_free (oss->open_device);
 456   oss->open_device = NULL;
 457
 458   g_free (oss->device_name);
 459   oss->device_name = NULL;
 460
 461   if (oss->probed_caps) {
 462     gst_caps_unref (oss->probed_caps);
 463     oss->probed_caps = NULL;
 464   }
 465
 466   return TRUE;
 467 }
 468
 469 static gboolean
 470 gst_oss4_sink_prepare (GstAudioSink * asink, GstRingBufferSpec * spec)
 471 {
 472   GstOss4Sink *oss;
 473
 474   oss = GST_OSS4_SINK (asink);
 475
 476   if (!gst_oss4_audio_set_format (GST_OBJECT_CAST (oss), oss->fd, spec)) {
 477     GST_WARNING_OBJECT (oss, "Couldn't set requested format %" GST_PTR_FORMAT,
 478         spec->caps);
 479     return FALSE;
 480   }
 481
 482   oss->bytes_per_sample = spec->bytes_per_sample;
 483   return TRUE;
 484 }
 485
 486 static gboolean
 487 gst_oss4_sink_unprepare (GstAudioSink * asink)
 488 {
 489   /* could do a SNDCTL_DSP_HALT, but the OSS manual recommends a close/open,
 490    * since HALT won't properly reset some devices, apparently */
 491
 492   if (!gst_oss4_sink_close (asink))
 493     goto couldnt_close;
 494
 495   if (!gst_oss4_sink_open_func (asink))
 496     goto couldnt_reopen;
 497
 498   return TRUE;
 499
 500   /* ERRORS */
 501 couldnt_close:
 502   {
 503     GST_DEBUG_OBJECT (asink, "Couldn't close the audio device");
 504     return FALSE;
 505   }
 506 couldnt_reopen:
 507   {
 508     GST_DEBUG_OBJECT (asink, "Couldn't reopen the audio device");
 509     return FALSE;
 510   }
 511 }
 512
 513 static guint
 514 gst_oss4_sink_write (GstAudioSink * asink, gpointer data, guint length)
 515 {
 516   GstOss4Sink *oss;
 517   int n;
 518
 519   oss = GST_OSS4_SINK_CAST (asink);
 520
 521   n = write (oss->fd, data, length);
 522   GST_LOG_OBJECT (asink, "wrote %d/%d samples, %d bytes",
 523       n / oss->bytes_per_sample, length / oss->bytes_per_sample, n);
 524
 525   if (G_UNLIKELY (n < 0)) {
 526     switch (errno) {
 527       case ENOTSUP:
 528       case EACCES:{
 529         /* This is the most likely cause, I think */
 530         GST_ELEMENT_ERROR (asink, RESOURCE, WRITE,
 531             (_("Playback is not supported by this audio device.")),
 532             ("write: %s (device: %s) (maybe this is an input-only device?)",
 533                 g_strerror (errno), oss->open_device));
 534         break;
 535       }
 536       default:{
 537         GST_ELEMENT_ERROR (asink, RESOURCE, WRITE,
 538             (_("Audio playback error.")),
 539             ("write: %s (device: %s)", g_strerror (errno), oss->open_device));
 540         break;
 541       }
 542     }
 543   }
 544
 545   return n;
 546 }
 547
 548 static guint
 549 gst_oss4_sink_delay (GstAudioSink * asink)
 550 {
 551   GstOss4Sink *oss;
 552   gint delay = -1;
 553
 554   oss = GST_OSS4_SINK_CAST (asink);
 555
 556   if (ioctl (oss->fd, SNDCTL_DSP_GETODELAY, &delay) < 0 || delay < 0) {
 557     GST_LOG_OBJECT (oss, "GETODELAY failed");
 558     return 0;
 559   }
 560
 561   return delay / oss->bytes_per_sample;
 562 }
 563
 564 static void
 565 gst_oss4_sink_reset (GstAudioSink * asink)
 566 {
 567   /* There's nothing we can do here really: OSS can't handle access to the
 568    * same device/fd from multiple threads and might deadlock or blow up in
 569    * other ways if we try an ioctl SNDCTL_DSP_HALT or similar */
 570 }
 571
 572 static void
 573 gst_oss4_sink_init_interfaces (GType type)
 574 {
 575   gst_oss4_add_property_probe_interface (type);
 576 }