sys/oss/gstosssink.c

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *               2000,2005 Wim Taymans <wim@fluendo.com>
   4  *
   5  * gstosssink.c:
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  20  * Boston, MA 02110-1301, USA.
  21  */
  22
  23 /**
  24  * SECTION:element-osssink
  25  *
  26  * This element lets you output sound using the Open Sound System (OSS).
  27  *
  28  * Note that you should almost always use generic audio conversion elements
  29  * like audioconvert and audioresample in front of an audiosink to make sure
  30  * your pipeline works under all circumstances (those conversion elements will
  31  * act in passthrough-mode if no conversion is necessary).
  32  *
  33  * <refsect2>
  34  * <title>Example pipelines</title>
  35  * |[
  36  * gst-launch-1.0 -v audiotestsrc ! audioconvert ! volume volume=0.1 ! osssink
  37  * ]| will output a sine wave (continuous beep sound) to your sound card (with
  38  * a very low volume as precaution).
  39  * |[
  40  * gst-launch-1.0 -v filesrc location=music.ogg ! decodebin ! audioconvert ! audioresample ! osssink
  41  * ]| will play an Ogg/Vorbis audio file and output it using the Open Sound System.
  42  * </refsect2>
  43  */
  44
  45 #ifdef HAVE_CONFIG_H
  46 #include "config.h"
  47 #endif
  48 #include <sys/ioctl.h>
  49 #include <fcntl.h>
  50 #include <errno.h>
  51 #include <unistd.h>
  52 #include <string.h>
  53
  54 #ifdef HAVE_OSS_INCLUDE_IN_SYS
  55 # include <sys/soundcard.h>
  56 #else
  57 # ifdef HAVE_OSS_INCLUDE_IN_ROOT
  58 #  include <soundcard.h>
  59 # else
  60 #  ifdef HAVE_OSS_INCLUDE_IN_MACHINE
  61 #   include <machine/soundcard.h>
  62 #  else
  63 #   error "What to include?"
  64 #  endif /* HAVE_OSS_INCLUDE_IN_MACHINE */
  65 # endif /* HAVE_OSS_INCLUDE_IN_ROOT */
  66 #endif /* HAVE_OSS_INCLUDE_IN_SYS */
  67
  68 #include "common.h"
  69 #include "gstosssink.h"
  70
  71 #include <gst/gst-i18n-plugin.h>
  72
  73 GST_DEBUG_CATEGORY_EXTERN (oss_debug);
  74 #define GST_CAT_DEFAULT oss_debug
  75
  76 static void gst_oss_sink_dispose (GObject * object);
  77 static void gst_oss_sink_finalise (GObject * object);
  78
  79 static void gst_oss_sink_get_property (GObject * object, guint prop_id,
  80     GValue * value, GParamSpec * pspec);
  81 static void gst_oss_sink_set_property (GObject * object, guint prop_id,
  82     const GValue * value, GParamSpec * pspec);
  83
  84 static GstCaps *gst_oss_sink_getcaps (GstBaseSink * bsink, GstCaps * filter);
  85
  86 static gboolean gst_oss_sink_open (GstAudioSink * asink);
  87 static gboolean gst_oss_sink_close (GstAudioSink * asink);
  88 static gboolean gst_oss_sink_prepare (GstAudioSink * asink,
  89     GstAudioRingBufferSpec * spec);
  90 static gboolean gst_oss_sink_unprepare (GstAudioSink * asink);
  91 static gint gst_oss_sink_write (GstAudioSink * asink, gpointer data,
  92     guint length);
  93 static guint gst_oss_sink_delay (GstAudioSink * asink);
  94 static void gst_oss_sink_reset (GstAudioSink * asink);
  95
  96 /* OssSink signals and args */
  97 enum
  98 {
  99   LAST_SIGNAL
 100 };
 101
 102 #define DEFAULT_DEVICE  "/dev/dsp"
 103 enum
 104 {
 105   PROP_0,
 106   PROP_DEVICE,
 107 };
 108
 109 #define FORMATS "{" GST_AUDIO_NE(S16)","GST_AUDIO_NE(U16)", S8, U8 }"
 110
 111 static GstStaticPadTemplate osssink_sink_factory =
 112     GST_STATIC_PAD_TEMPLATE ("sink",
 113     GST_PAD_SINK,
 114     GST_PAD_ALWAYS,
 115     GST_STATIC_CAPS ("audio/x-raw, "
 116         "format = (string) " FORMATS ", "
 117         "layout = (string) interleaved, "
 118         "rate = (int) [ 1, MAX ], "
 119         "channels = (int) 1; "
 120         "audio/x-raw, "
 121         "format = (string) " FORMATS ", "
 122         "layout = (string) interleaved, "
 123         "rate = (int) [ 1, MAX ], "
 124         "channels = (int) 2, " "channel-mask = (bitmask) 0x3")
 125     );
 126
 127 /* static guint gst_oss_sink_signals[LAST_SIGNAL] = { 0 }; */
 128
 129 #define gst_oss_sink_parent_class parent_class
 130 G_DEFINE_TYPE (GstOssSink, gst_oss_sink, GST_TYPE_AUDIO_SINK);
 131
 132 static void
 133 gst_oss_sink_dispose (GObject * object)
 134 {
 135   GstOssSink *osssink = GST_OSSSINK (object);
 136
 137   if (osssink->probed_caps) {
 138     gst_caps_unref (osssink->probed_caps);
 139     osssink->probed_caps = NULL;
 140   }
 141
 142   G_OBJECT_CLASS (parent_class)->dispose (object);
 143 }
 144
 145 static void
 146 gst_oss_sink_class_init (GstOssSinkClass * klass)
 147 {
 148   GObjectClass *gobject_class;
 149   GstElementClass *gstelement_class;
 150   GstBaseSinkClass *gstbasesink_class;
 151   GstAudioSinkClass *gstaudiosink_class;
 152
 153   gobject_class = (GObjectClass *) klass;
 154   gstelement_class = (GstElementClass *) klass;
 155   gstbasesink_class = (GstBaseSinkClass *) klass;
 156   gstaudiosink_class = (GstAudioSinkClass *) klass;
 157
 158   parent_class = g_type_class_peek_parent (klass);
 159
 160   gobject_class->dispose = gst_oss_sink_dispose;
 161   gobject_class->finalize = gst_oss_sink_finalise;
 162   gobject_class->get_property = gst_oss_sink_get_property;
 163   gobject_class->set_property = gst_oss_sink_set_property;
 164
 165   g_object_class_install_property (gobject_class, PROP_DEVICE,
 166       g_param_spec_string ("device", "Device",
 167           "OSS device (usually /dev/dspN)", DEFAULT_DEVICE,
 168           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 169
 170   gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_oss_sink_getcaps);
 171
 172   gstaudiosink_class->open = GST_DEBUG_FUNCPTR (gst_oss_sink_open);
 173   gstaudiosink_class->close = GST_DEBUG_FUNCPTR (gst_oss_sink_close);
 174   gstaudiosink_class->prepare = GST_DEBUG_FUNCPTR (gst_oss_sink_prepare);
 175   gstaudiosink_class->unprepare = GST_DEBUG_FUNCPTR (gst_oss_sink_unprepare);
 176   gstaudiosink_class->write = GST_DEBUG_FUNCPTR (gst_oss_sink_write);
 177   gstaudiosink_class->delay = GST_DEBUG_FUNCPTR (gst_oss_sink_delay);
 178   gstaudiosink_class->reset = GST_DEBUG_FUNCPTR (gst_oss_sink_reset);
 179
 180   gst_element_class_set_static_metadata (gstelement_class, "Audio Sink (OSS)",
 181       "Sink/Audio",
 182       "Output to a sound card via OSS",
 183       "Erik Walthinsen <omega@cse.ogi.edu>, "
 184       "Wim Taymans <wim.taymans@chello.be>");
 185
 186   gst_element_class_add_static_pad_template (gstelement_class,
 187       &osssink_sink_factory);
 188 }
 189
 190 static void
 191 gst_oss_sink_init (GstOssSink * osssink)
 192 {
 193   const gchar *device;
 194
 195   GST_DEBUG_OBJECT (osssink, "initializing osssink");
 196
 197   device = g_getenv ("AUDIODEV");
 198   if (device == NULL)
 199     device = DEFAULT_DEVICE;
 200   osssink->device = g_strdup (device);
 201   osssink->fd = -1;
 202 }
 203
 204 static void
 205 gst_oss_sink_finalise (GObject * object)
 206 {
 207   GstOssSink *osssink = GST_OSSSINK (object);
 208
 209   g_free (osssink->device);
 210
 211   G_OBJECT_CLASS (parent_class)->finalize ((GObject *) (object));
 212 }
 213
 214 static void
 215 gst_oss_sink_set_property (GObject * object, guint prop_id,
 216     const GValue * value, GParamSpec * pspec)
 217 {
 218   GstOssSink *sink;
 219
 220   sink = GST_OSSSINK (object);
 221
 222   switch (prop_id) {
 223     case PROP_DEVICE:
 224       g_free (sink->device);
 225       sink->device = g_value_dup_string (value);
 226       if (sink->probed_caps) {
 227         gst_caps_unref (sink->probed_caps);
 228         sink->probed_caps = NULL;
 229       }
 230       break;
 231     default:
 232       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 233       break;
 234   }
 235 }
 236
 237 static void
 238 gst_oss_sink_get_property (GObject * object, guint prop_id,
 239     GValue * value, GParamSpec * pspec)
 240 {
 241   GstOssSink *sink;
 242
 243   sink = GST_OSSSINK (object);
 244
 245   switch (prop_id) {
 246     case PROP_DEVICE:
 247       g_value_set_string (value, sink->device);
 248       break;
 249     default:
 250       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 251       break;
 252   }
 253 }
 254
 255 static GstCaps *
 256 gst_oss_sink_getcaps (GstBaseSink * bsink, GstCaps * filter)
 257 {
 258   GstOssSink *osssink;
 259   GstCaps *caps;
 260
 261   osssink = GST_OSSSINK (bsink);
 262
 263   if (osssink->fd == -1) {
 264     caps = gst_pad_get_pad_template_caps (GST_BASE_SINK_PAD (bsink));
 265   } else if (osssink->probed_caps) {
 266     caps = gst_caps_ref (osssink->probed_caps);
 267   } else {
 268     caps = gst_oss_helper_probe_caps (osssink->fd);
 269     if (caps && !gst_caps_is_empty (caps)) {
 270       osssink->probed_caps = gst_caps_ref (caps);
 271     }
 272   }
 273
 274   if (filter && caps) {
 275     GstCaps *intersection;
 276
 277     intersection =
 278         gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
 279     gst_caps_unref (caps);
 280     return intersection;
 281   } else {
 282     return caps;
 283   }
 284 }
 285
 286 static gint
 287 ilog2 (gint x)
 288 {
 289   /* well... hacker's delight explains... */
 290   x = x | (x >> 1);
 291   x = x | (x >> 2);
 292   x = x | (x >> 4);
 293   x = x | (x >> 8);
 294   x = x | (x >> 16);
 295   x = x - ((x >> 1) & 0x55555555);
 296   x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
 297   x = (x + (x >> 4)) & 0x0f0f0f0f;
 298   x = x + (x >> 8);
 299   x = x + (x >> 16);
 300   return (x & 0x0000003f) - 1;
 301 }
 302
 303 static gint
 304 gst_oss_sink_get_format (GstAudioRingBufferFormatType fmt, GstAudioFormat rfmt)
 305 {
 306   gint result;
 307
 308   switch (fmt) {
 309     case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MU_LAW:
 310       result = AFMT_MU_LAW;
 311       break;
 312     case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_A_LAW:
 313       result = AFMT_A_LAW;
 314       break;
 315     case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_IMA_ADPCM:
 316       result = AFMT_IMA_ADPCM;
 317       break;
 318     case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG:
 319       result = AFMT_MPEG;
 320       break;
 321     case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_RAW:
 322     {
 323       switch (rfmt) {
 324         case GST_AUDIO_FORMAT_U8:
 325           result = AFMT_U8;
 326           break;
 327         case GST_AUDIO_FORMAT_S16LE:
 328           result = AFMT_S16_LE;
 329           break;
 330         case GST_AUDIO_FORMAT_S16BE:
 331           result = AFMT_S16_BE;
 332           break;
 333         case GST_AUDIO_FORMAT_S8:
 334           result = AFMT_S8;
 335           break;
 336         case GST_AUDIO_FORMAT_U16LE:
 337           result = AFMT_U16_LE;
 338           break;
 339         case GST_AUDIO_FORMAT_U16BE:
 340           result = AFMT_U16_BE;
 341           break;
 342         default:
 343           result = 0;
 344           break;
 345       }
 346       break;
 347     }
 348     default:
 349       result = 0;
 350       break;
 351   }
 352   return result;
 353 }
 354
 355 static gboolean
 356 gst_oss_sink_open (GstAudioSink * asink)
 357 {
 358   GstOssSink *oss;
 359   int mode;
 360
 361   oss = GST_OSSSINK (asink);
 362
 363   mode = O_WRONLY;
 364   mode |= O_NONBLOCK;
 365
 366   oss->fd = open (oss->device, mode, 0);
 367   if (oss->fd == -1) {
 368     switch (errno) {
 369       case EBUSY:
 370         goto busy;
 371       case EACCES:
 372         goto no_permission;
 373       default:
 374         goto open_failed;
 375     }
 376   }
 377
 378   return TRUE;
 379
 380   /* ERRORS */
 381 busy:
 382   {
 383     GST_ELEMENT_ERROR (oss, RESOURCE, BUSY,
 384         (_("Could not open audio device for playback. "
 385                 "Device is being used by another application.")), (NULL));
 386     return FALSE;
 387   }
 388 no_permission:
 389   {
 390     GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_WRITE,
 391         (_("Could not open audio device for playback. "
 392                 "You don't have permission to open the device.")),
 393         GST_ERROR_SYSTEM);
 394     return FALSE;
 395   }
 396 open_failed:
 397   {
 398     GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_WRITE,
 399         (_("Could not open audio device for playback.")), GST_ERROR_SYSTEM);
 400     return FALSE;
 401   }
 402 }
 403
 404 static gboolean
 405 gst_oss_sink_close (GstAudioSink * asink)
 406 {
 407   close (GST_OSSSINK (asink)->fd);
 408   GST_OSSSINK (asink)->fd = -1;
 409   return TRUE;
 410 }
 411
 412 static gboolean
 413 gst_oss_sink_prepare (GstAudioSink * asink, GstAudioRingBufferSpec * spec)
 414 {
 415   GstOssSink *oss;
 416   struct audio_buf_info info;
 417   int mode;
 418   int tmp;
 419   guint width, rate, channels;
 420
 421   oss = GST_OSSSINK (asink);
 422
 423   /* we opened non-blocking so that we can detect if the device is available
 424    * without hanging forever. We now want to remove the non-blocking flag. */
 425   mode = fcntl (oss->fd, F_GETFL);
 426   mode &= ~O_NONBLOCK;
 427   if (fcntl (oss->fd, F_SETFL, mode) == -1) {
 428     /* some drivers do no support unsetting the non-blocking flag, try to
 429      * close/open the device then. This is racy but we error out properly. */
 430     gst_oss_sink_close (asink);
 431     if ((oss->fd = open (oss->device, O_WRONLY, 0)) == -1)
 432       goto non_block;
 433   }
 434
 435   tmp = gst_oss_sink_get_format (spec->type,
 436       GST_AUDIO_INFO_FORMAT (&spec->info));
 437   if (tmp == 0)
 438     goto wrong_format;
 439
 440   width = GST_AUDIO_INFO_WIDTH (&spec->info);
 441   rate = GST_AUDIO_INFO_RATE (&spec->info);
 442   channels = GST_AUDIO_INFO_CHANNELS (&spec->info);
 443
 444   if (width != 16 && width != 8)
 445     goto dodgy_width;
 446
 447   SET_PARAM (oss, SNDCTL_DSP_SETFMT, tmp, "SETFMT");
 448   if (channels == 2)
 449     SET_PARAM (oss, SNDCTL_DSP_STEREO, 1, "STEREO");
 450   SET_PARAM (oss, SNDCTL_DSP_CHANNELS, channels, "CHANNELS");
 451   SET_PARAM (oss, SNDCTL_DSP_SPEED, rate, "SPEED");
 452
 453   tmp = ilog2 (spec->segsize);
 454   tmp = ((spec->segtotal & 0x7fff) << 16) | tmp;
 455   GST_DEBUG_OBJECT (oss, "set segsize: %d, segtotal: %d, value: %08x",
 456       spec->segsize, spec->segtotal, tmp);
 457
 458   SET_PARAM (oss, SNDCTL_DSP_SETFRAGMENT, tmp, "SETFRAGMENT");
 459   GET_PARAM (oss, SNDCTL_DSP_GETOSPACE, &info, "GETOSPACE");
 460
 461   spec->segsize = info.fragsize;
 462   spec->segtotal = info.fragstotal;
 463
 464   oss->bytes_per_sample = GST_AUDIO_INFO_BPF (&spec->info);
 465
 466   GST_DEBUG_OBJECT (oss, "got segsize: %d, segtotal: %d, value: %08x",
 467       spec->segsize, spec->segtotal, tmp);
 468
 469   return TRUE;
 470
 471   /* ERRORS */
 472 non_block:
 473   {
 474     GST_ELEMENT_ERROR (oss, RESOURCE, SETTINGS, (NULL),
 475         ("Unable to set device %s in non blocking mode: %s",
 476             oss->device, g_strerror (errno)));
 477     return FALSE;
 478   }
 479 wrong_format:
 480   {
 481     GST_ELEMENT_ERROR (oss, RESOURCE, SETTINGS, (NULL),
 482         ("Unable to get format (%d, %d)", spec->type,
 483             GST_AUDIO_INFO_FORMAT (&spec->info)));
 484     return FALSE;
 485   }
 486 dodgy_width:
 487   {
 488     GST_ELEMENT_ERROR (oss, RESOURCE, SETTINGS, (NULL),
 489         ("unexpected width %d", width));
 490     return FALSE;
 491   }
 492 }
 493
 494 static gboolean
 495 gst_oss_sink_unprepare (GstAudioSink * asink)
 496 {
 497   /* could do a SNDCTL_DSP_RESET, but the OSS manual recommends a close/open */
 498
 499   if (!gst_oss_sink_close (asink))
 500     goto couldnt_close;
 501
 502   if (!gst_oss_sink_open (asink))
 503     goto couldnt_reopen;
 504
 505   return TRUE;
 506
 507   /* ERRORS */
 508 couldnt_close:
 509   {
 510     GST_DEBUG_OBJECT (asink, "Could not close the audio device");
 511     return FALSE;
 512   }
 513 couldnt_reopen:
 514   {
 515     GST_DEBUG_OBJECT (asink, "Could not reopen the audio device");
 516     return FALSE;
 517   }
 518 }
 519
 520 static gint
 521 gst_oss_sink_write (GstAudioSink * asink, gpointer data, guint length)
 522 {
 523   return write (GST_OSSSINK (asink)->fd, data, length);
 524 }
 525
 526 static guint
 527 gst_oss_sink_delay (GstAudioSink * asink)
 528 {
 529   GstOssSink *oss;
 530   gint delay = 0;
 531   gint ret;
 532
 533   oss = GST_OSSSINK (asink);
 534
 535 #ifdef SNDCTL_DSP_GETODELAY
 536   ret = ioctl (oss->fd, SNDCTL_DSP_GETODELAY, &delay);
 537 #else
 538   ret = -1;
 539 #endif
 540   if (ret < 0) {
 541     audio_buf_info info;
 542
 543     ret = ioctl (oss->fd, SNDCTL_DSP_GETOSPACE, &info);
 544
 545     delay = (ret < 0 ? 0 : (info.fragstotal * info.fragsize) - info.bytes);
 546   }
 547   return delay / oss->bytes_per_sample;
 548 }
 549
 550 static void
 551 gst_oss_sink_reset (GstAudioSink * asink)
 552 {
 553   /* There's nothing we can do here really: OSS can't handle access to the
 554    * same device/fd from multiple threads and might deadlock or blow up in
 555    * other ways if we try an ioctl SNDCTL_DSP_RESET or similar */
 556 }