sys/oss/gstosssink.c

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *                    2000 Wim Taymans <wim.taymans@chello.be>
   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., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <sys/ioctl.h>
  27 #include <fcntl.h>
  28 #include <sys/soundcard.h>
  29 #include <unistd.h>
  30 #include <errno.h>
  31 #include <string.h>
  32
  33 #include <gstosssink.h>
  34 #include <gstosscommon.h>
  35
  36 /* elementfactory information */
  37 static GstElementDetails gst_osssink_details = {
  38   "Audio Sink (OSS)",
  39   "Sink/Audio",
  40   "LGPL",
  41   "Output to a sound card via OSS",
  42   VERSION,
  43   "Erik Walthinsen <omega@cse.ogi.edu>, "
  44   "Wim Taymans <wim.taymans@chello.be>",
  45   "(C) 1999",
  46 };
  47
  48 static void                     gst_osssink_class_init          (GstOssSinkClass *klass);
  49 static void                     gst_osssink_init                (GstOssSink *osssink);
  50 static void                     gst_osssink_finalize            (GObject *object);
  51
  52 static gboolean                 gst_osssink_open_audio          (GstOssSink *sink);
  53 static void                     gst_osssink_close_audio         (GstOssSink *sink);
  54 static gboolean                 gst_osssink_sync_parms          (GstOssSink *osssink);
  55 static GstElementStateReturn    gst_osssink_change_state        (GstElement *element);
  56 static void                     gst_osssink_set_clock           (GstElement *element, GstClock *clock);
  57 static GstClock*                gst_osssink_get_clock           (GstElement *element);
  58 static GstClockTime             gst_osssink_get_time            (GstClock *clock, gpointer data);
  59
  60 static const GstFormat*         gst_osssink_get_formats         (GstPad *pad);
  61 static gboolean                 gst_osssink_convert             (GstPad *pad, GstFormat src_format, gint64 src_value,
  62                                                                  GstFormat *dest_format, gint64 *dest_value);
  63 static const GstPadQueryType*   gst_osssink_get_query_types     (GstPad *pad);
  64 static gboolean                 gst_osssink_query               (GstElement *element, GstPadQueryType type,
  65                                                                  GstFormat *format, gint64 *value);
  66 static gboolean                 gst_osssink_sink_query          (GstPad *pad, GstPadQueryType type,
  67                                                                  GstFormat *format, gint64 *value);
  68
  69 static GstPadConnectReturn      gst_osssink_sinkconnect         (GstPad *pad, GstCaps *caps);
  70
  71 static void                     gst_osssink_set_property        (GObject *object, guint prop_id, const GValue *value,
  72                                                                  GParamSpec *pspec);
  73 static void                     gst_osssink_get_property        (GObject *object, guint prop_id, GValue *value,
  74                                                                  GParamSpec *pspec);
  75
  76 static void                     gst_osssink_chain               (GstPad *pad,GstBuffer *buf);
  77
  78 /* OssSink signals and args */
  79 enum {
  80   SIGNAL_HANDOFF,
  81   LAST_SIGNAL
  82 };
  83
  84 enum {
  85   ARG_0,
  86   ARG_DEVICE,
  87   ARG_MUTE,
  88   ARG_FRAGMENT,
  89   ARG_BUFFER_SIZE,
  90   ARG_SYNC
  91   /* FILL ME */
  92 };
  93
  94 GST_PAD_TEMPLATE_FACTORY (osssink_sink_factory,
  95   "sink",
  96   GST_PAD_SINK,
  97   GST_PAD_ALWAYS,
  98   GST_CAPS_NEW (
  99     "osssink_sink",
 100     "audio/raw",
 101       "format",     GST_PROPS_STRING ("int"),   /* hack */
 102       "law",        GST_PROPS_INT (0),
 103       "endianness", GST_PROPS_INT (G_BYTE_ORDER),
 104       "signed",     GST_PROPS_LIST (
 105                       GST_PROPS_BOOLEAN (FALSE),
 106                       GST_PROPS_BOOLEAN (TRUE)
 107                     ),
 108       "width",      GST_PROPS_LIST (
 109                       GST_PROPS_INT (8),
 110                       GST_PROPS_INT (16)
 111                     ),
 112       "depth",      GST_PROPS_LIST (
 113                       GST_PROPS_INT (8),
 114                       GST_PROPS_INT (16)
 115                     ),
 116       "rate",       GST_PROPS_INT_RANGE (1000, 48000),
 117       "channels",   GST_PROPS_INT_RANGE (1, 2)
 118   )
 119 );
 120
 121 static GstElementClass *parent_class = NULL;
 122 static guint gst_osssink_signals[LAST_SIGNAL] = { 0 };
 123
 124 GType
 125 gst_osssink_get_type (void)
 126 {
 127   static GType osssink_type = 0;
 128
 129   if (!osssink_type) {
 130     static const GTypeInfo osssink_info = {
 131       sizeof(GstOssSinkClass),
 132       NULL,
 133       NULL,
 134       (GClassInitFunc)gst_osssink_class_init,
 135       NULL,
 136       NULL,
 137       sizeof(GstOssSink),
 138       0,
 139       (GInstanceInitFunc)gst_osssink_init,
 140     };
 141     osssink_type = g_type_register_static (GST_TYPE_ELEMENT, "GstOssSink", &osssink_info, 0);
 142   }
 143
 144   return osssink_type;
 145 }
 146
 147 static GstBufferPool*
 148 gst_osssink_get_bufferpool (GstPad *pad)
 149 {
 150   GstOssSink *oss;
 151
 152   oss = GST_OSSSINK (gst_pad_get_parent(pad));
 153
 154   /* 6 buffers per chunk by default */
 155   if (!oss->sinkpool)
 156     oss->sinkpool = gst_buffer_pool_get_default (oss->bufsize, 6);
 157
 158   return oss->sinkpool;
 159 }
 160
 161 static void
 162 gst_osssink_finalize (GObject *object)
 163 {
 164   GstOssSink *osssink = (GstOssSink *) object;
 165
 166   g_free (osssink->device);
 167
 168   G_OBJECT_CLASS (parent_class)->finalize (object);
 169 }
 170
 171 static void
 172 gst_osssink_class_init (GstOssSinkClass *klass)
 173 {
 174   GObjectClass *gobject_class;
 175   GstElementClass *gstelement_class;
 176
 177   gobject_class = (GObjectClass*)klass;
 178   gstelement_class = (GstElementClass*)klass;
 179
 180   parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
 181
 182   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DEVICE,
 183     g_param_spec_string ("device", "Device", "The device to use for output",
 184                          "/dev/dsp", G_PARAM_READWRITE)); /* CHECKME! */
 185   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MUTE,
 186     g_param_spec_boolean ("mute", "Mute", "Mute the audio",
 187                           TRUE, G_PARAM_READWRITE));
 188   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SYNC,
 189     g_param_spec_boolean ("sync", "Sync", "If syncing on timestamps should be enabled",
 190                           TRUE, G_PARAM_READWRITE));
 191   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FRAGMENT,
 192     g_param_spec_int ("fragment", "Fragment",
 193                       "The fragment as 0xMMMMSSSS (MMMM = total fragments, 2^SSSS = fragment size)",
 194                       0, G_MAXINT, 6, G_PARAM_READWRITE));
 195   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BUFFER_SIZE,
 196     g_param_spec_int ("buffer_size", "Buffer size", "The buffer size",
 197                       0, G_MAXINT, 4096, G_PARAM_READWRITE));
 198
 199   gst_osssink_signals[SIGNAL_HANDOFF] =
 200     g_signal_new ("handoff", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 201                   G_STRUCT_OFFSET (GstOssSinkClass, handoff), NULL, NULL,
 202                   g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 203
 204   gobject_class->set_property = gst_osssink_set_property;
 205   gobject_class->get_property = gst_osssink_get_property;
 206   gobject_class->finalize     = gst_osssink_finalize;
 207
 208   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_osssink_change_state);
 209   gstelement_class->query        = GST_DEBUG_FUNCPTR (gst_osssink_query);
 210   gstelement_class->set_clock    = gst_osssink_set_clock;
 211   gstelement_class->get_clock    = gst_osssink_get_clock;
 212
 213 }
 214
 215 static void
 216 gst_osssink_init (GstOssSink *osssink)
 217 {
 218   osssink->sinkpad = gst_pad_new_from_template (
 219                   GST_PAD_TEMPLATE_GET (osssink_sink_factory), "sink");
 220   gst_element_add_pad (GST_ELEMENT (osssink), osssink->sinkpad);
 221   gst_pad_set_connect_function (osssink->sinkpad, gst_osssink_sinkconnect);
 222   gst_pad_set_bufferpool_function (osssink->sinkpad, gst_osssink_get_bufferpool);
 223   gst_pad_set_convert_function (osssink->sinkpad, gst_osssink_convert);
 224   gst_pad_set_query_function (osssink->sinkpad, gst_osssink_sink_query);
 225   gst_pad_set_query_type_function (osssink->sinkpad, gst_osssink_get_query_types);
 226   gst_pad_set_formats_function (osssink->sinkpad, gst_osssink_get_formats);
 227
 228   gst_pad_set_chain_function (osssink->sinkpad, gst_osssink_chain);
 229
 230   osssink->device = g_strdup ("/dev/dsp");
 231   osssink->fd = -1;
 232   osssink->channels = 1;
 233   osssink->frequency = 11025;
 234   osssink->fragment = 6;
 235 /* AFMT_*_BE not available on all OSS includes (e.g. FBSD) */
 236 #ifdef WORDS_BIGENDIAN
 237   osssink->format = AFMT_S16_BE;
 238 #else
 239   osssink->format = AFMT_S16_LE;
 240 #endif /* WORDS_BIGENDIAN */
 241   osssink->bufsize = 4096;
 242   osssink->bps = 0;
 243   osssink->resync = FALSE;
 244   osssink->sync = TRUE;
 245   osssink->sinkpool = NULL;
 246   osssink->provided_clock = GST_CLOCK (gst_oss_clock_new ("ossclock", gst_osssink_get_time, osssink));
 247   osssink->handled = 0;
 248
 249   GST_FLAG_SET (osssink, GST_ELEMENT_THREAD_SUGGESTED);
 250   GST_FLAG_SET (osssink, GST_ELEMENT_EVENT_AWARE);
 251 }
 252
 253
 254 static GstPadConnectReturn
 255 gst_osssink_sinkconnect (GstPad *pad, GstCaps *caps)
 256 {
 257   gint law, endianness, width, depth, bps;
 258   gboolean sign;
 259   gint format = -1;
 260   GstOssSink *osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 261
 262   if (!GST_CAPS_IS_FIXED (caps))
 263     return GST_PAD_CONNECT_DELAYED;
 264
 265   gst_caps_get_int (caps, "width", &width);
 266   gst_caps_get_int (caps, "depth", &depth);
 267
 268   if (width != depth)
 269     return GST_PAD_CONNECT_REFUSED;
 270
 271   osssink->width = width;
 272
 273   /* laws 1 and 2 are 1 bps anyway */
 274   osssink->bps = 1;
 275
 276   gst_caps_get_int (caps, "law", &law);
 277   gst_caps_get_int (caps, "endianness", &endianness);
 278   gst_caps_get_boolean (caps, "signed", &sign);
 279
 280   if (!gst_ossformat_get (law, endianness, sign,
 281                           width, depth, &format, &bps))
 282   {
 283     GST_DEBUG (GST_CAT_PLUGIN_INFO, "could not get format");
 284     return GST_PAD_CONNECT_REFUSED;
 285   }
 286
 287   osssink->bps = bps;
 288   osssink->format = format;
 289
 290   gst_caps_get_int (caps, "channels", &osssink->channels);
 291   gst_caps_get_int (caps, "rate", &osssink->frequency);
 292
 293   osssink->bps *= osssink->channels;
 294   osssink->bps *= osssink->frequency;
 295
 296   if (!gst_osssink_sync_parms (osssink)) {
 297     return GST_PAD_CONNECT_REFUSED;
 298   }
 299
 300   return GST_PAD_CONNECT_OK;
 301 }
 302
 303 static gboolean
 304 gst_osssink_sync_parms (GstOssSink *osssink)
 305 {
 306   audio_buf_info ospace;
 307   int frag;
 308   gint target_format;
 309   gint target_channels;
 310   gint target_frequency;
 311   GObject *object;
 312   gint fragscale, frag_ln;
 313
 314   g_return_val_if_fail (osssink != NULL, FALSE);
 315   g_return_val_if_fail (GST_IS_OSSSINK (osssink), FALSE);
 316
 317   if (osssink->fd == -1)
 318     return FALSE;
 319
 320   if (osssink->fragment >> 16)
 321     frag = osssink->fragment;
 322   else
 323     frag = 0x7FFF0000 | osssink->fragment;
 324
 325   GST_INFO (GST_CAT_PLUGIN_INFO,
 326             "osssink: setting sound card to %dHz %d format %s (%08x fragment)",
 327             osssink->frequency, osssink->format,
 328             (osssink->channels == 2) ? "stereo" : "mono", frag);
 329
 330   ioctl (osssink->fd, SNDCTL_DSP_SETFRAGMENT, &frag);
 331
 332   ioctl (osssink->fd, SNDCTL_DSP_RESET, 0);
 333
 334   target_format = osssink->format;
 335   target_channels = osssink->channels;
 336   target_frequency = osssink->frequency;
 337
 338   ioctl (osssink->fd, SNDCTL_DSP_SETFMT, &osssink->format);
 339   ioctl (osssink->fd, SNDCTL_DSP_CHANNELS, &osssink->channels);
 340   ioctl (osssink->fd, SNDCTL_DSP_SPEED, &osssink->frequency);
 341
 342   ioctl (osssink->fd, SNDCTL_DSP_GETBLKSIZE, &osssink->fragment_size);
 343   ioctl (osssink->fd, SNDCTL_DSP_GETOSPACE, &ospace);
 344
 345   /* calculate new fragment using a poor man's logarithm function */
 346   fragscale = 1;
 347   frag_ln = 0;
 348   while (fragscale < ospace.fragsize) {
 349     fragscale <<= 1;
 350     frag_ln++;
 351   }
 352   osssink->fragment = ospace.fragstotal << 16 | frag_ln;
 353
 354   GST_INFO (GST_CAT_PLUGIN_INFO,
 355             "osssink: set sound card to %dHz %d format %s "
 356             "(%d bytes buffer, %08x fragment)",
 357             osssink->frequency, osssink->format,
 358             (osssink->channels == 2) ? "stereo" : "mono",
 359             ospace.bytes, osssink->fragment);
 360
 361   object = G_OBJECT (osssink);
 362   g_object_freeze_notify (object);
 363   g_object_notify (object, "fragment");
 364   g_object_thaw_notify (object);
 365
 366   osssink->fragment_time = (GST_SECOND * osssink->fragment_size) / osssink->bps;
 367   GST_INFO (GST_CAT_PLUGIN_INFO, "fragment time %u %llu\n",
 368             osssink->bps, osssink->fragment_time);
 369
 370   if (target_format != osssink->format ||
 371       target_channels != osssink->channels ||
 372       target_frequency != osssink->frequency)
 373   {
 374     g_warning ("couldn't set requested OSS parameters, enjoy the noise :)");
 375     /* we could eventually return FALSE here, or just do some additional tests
 376      * to see that the frequencies don't differ too much etc.. */
 377   }
 378   return TRUE;
 379 }
 380
 381 static inline gint64
 382 gst_osssink_get_delay (GstOssSink *osssink)
 383 {
 384   gint delay = 0;
 385
 386   if (osssink->fd == -1)
 387     return 0;
 388
 389   if (ioctl (osssink->fd, SNDCTL_DSP_GETODELAY, &delay) < 0) {
 390     audio_buf_info info;
 391     if (ioctl (osssink->fd, SNDCTL_DSP_GETOSPACE, &info) < 0) {
 392       delay = 0;
 393     }
 394     else {
 395       delay = (info.fragstotal * info.fragsize) - info.bytes;
 396     }
 397   }
 398   return delay;
 399 }
 400
 401 static GstClockTime
 402 gst_osssink_get_time (GstClock *clock, gpointer data)
 403 {
 404   GstOssSink *osssink = GST_OSSSINK (data);
 405   gint delay;
 406   GstClockTime res;
 407
 408   if (!osssink->bps)
 409     return 0;
 410
 411   delay = gst_osssink_get_delay (osssink);
 412
 413   /* sometimes delay is bigger than the number of bytes sent to the device,
 414    * which screws up this calculation, we assume that everything is still
 415    * in the device then */
 416   if (((guint64)delay) > osssink->handled) {
 417     delay = osssink->handled;
 418   }
 419   res =  (osssink->handled - delay) * GST_SECOND / osssink->bps;
 420
 421   return res;
 422 }
 423
 424 static GstClock*
 425 gst_osssink_get_clock (GstElement *element)
 426 {
 427   GstOssSink *osssink;
 428
 429   osssink = GST_OSSSINK (element);
 430
 431   return GST_CLOCK (osssink->provided_clock);
 432 }
 433
 434 static void
 435 gst_osssink_set_clock (GstElement *element, GstClock *clock)
 436 {
 437   GstOssSink *osssink;
 438
 439   osssink = GST_OSSSINK (element);
 440
 441   osssink->clock = clock;
 442 }
 443
 444 static void
 445 gst_osssink_chain (GstPad *pad, GstBuffer *buf)
 446 {
 447   GstOssSink *osssink;
 448   GstClockTime buftime;
 449
 450   /* this has to be an audio buffer */
 451   osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 452
 453   if (GST_IS_EVENT (buf)) {
 454     GstEvent *event = GST_EVENT (buf);
 455
 456     switch (GST_EVENT_TYPE (event)) {
 457       case GST_EVENT_EOS:
 458         ioctl (osssink->fd, SNDCTL_DSP_SYNC);
 459         gst_oss_clock_set_active (osssink->provided_clock, FALSE);
 460         gst_pad_event_default (pad, event);
 461         return;
 462       case GST_EVENT_NEW_MEDIA:
 463         g_print ("new media\n");
 464         break;
 465       case GST_EVENT_DISCONTINUOUS:
 466       {
 467         gint64 value;
 468
 469         ioctl (osssink->fd, SNDCTL_DSP_RESET);
 470         if (gst_event_discont_get_value (event, GST_FORMAT_TIME, &value)) {
 471           if (!gst_clock_handle_discont (osssink->clock, value))
 472             gst_oss_clock_set_active (osssink->provided_clock, FALSE);
 473           osssink->handled = 0;
 474         }
 475         osssink->resync = TRUE;
 476         break;
 477       }
 478       default:
 479         gst_pad_event_default (pad, event);
 480         return;
 481     }
 482     gst_event_unref (event);
 483     return;
 484   }
 485
 486   if (!osssink->bps) {
 487     gst_buffer_unref (buf);
 488     gst_element_error (GST_ELEMENT (osssink), "capsnego was never performed, unknown data type");
 489     return;
 490   }
 491
 492   buftime = GST_BUFFER_TIMESTAMP (buf);
 493
 494   if (osssink->fd >= 0) {
 495     if (!osssink->mute) {
 496       guchar *data = GST_BUFFER_DATA (buf);
 497       gint size = GST_BUFFER_SIZE (buf);
 498
 499       if (osssink->clock) {
 500         gint delay = 0;
 501         gint64 queued;
 502         GstClockTimeDiff jitter;
 503
 504         delay = gst_osssink_get_delay (osssink);
 505         queued = delay * GST_SECOND / osssink->bps;
 506
 507         if  (osssink->resync && osssink->sync) {
 508           gst_element_clock_wait (GST_ELEMENT (osssink), osssink->clock,
 509                                 buftime - queued, &jitter);
 510
 511           if (jitter >= 0) {
 512             gst_clock_handle_discont (osssink->clock, buftime - queued + jitter);
 513             write (osssink->fd, data, size);
 514             gst_oss_clock_set_active (osssink->provided_clock, TRUE);
 515             osssink->resync = FALSE;
 516             osssink->handled += size;
 517           }
 518         }
 519         else {
 520           write (osssink->fd, data, size);
 521           osssink->handled += size;
 522         }
 523       }
 524       /* no clock, try to be as fast as possible */
 525       else {
 526         audio_buf_info ospace;
 527
 528         ioctl (osssink->fd, SNDCTL_DSP_GETOSPACE, &ospace);
 529
 530         if (ospace.bytes >= size) {
 531           write (osssink->fd, data, size);
 532         }
 533       }
 534     }
 535   }
 536   gst_buffer_unref (buf);
 537 }
 538
 539 static const GstFormat*
 540 gst_osssink_get_formats (GstPad *pad)
 541 {
 542   static const GstFormat formats[] = {
 543     GST_FORMAT_TIME,
 544     GST_FORMAT_UNITS,
 545     GST_FORMAT_BYTES,
 546     0
 547   };
 548   return formats;
 549 }
 550
 551 static gboolean
 552 gst_osssink_convert (GstPad *pad, GstFormat src_format, gint64 src_value,
 553                      GstFormat *dest_format, gint64 *dest_value)
 554 {
 555   gboolean res = TRUE;
 556
 557   GstOssSink *osssink;
 558
 559   if (src_format == *dest_format) {
 560     *dest_value = src_value;
 561     return TRUE;
 562   }
 563
 564   osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 565
 566   if (osssink->bps == 0 || osssink->channels == 0 || osssink->width == 0)
 567     return FALSE;
 568
 569   switch (src_format) {
 570     case GST_FORMAT_BYTES:
 571       switch (*dest_format) {
 572         case GST_FORMAT_DEFAULT:
 573           *dest_format = GST_FORMAT_TIME;
 574         case GST_FORMAT_TIME:
 575           *dest_value = src_value * GST_SECOND / osssink->bps;
 576           break;
 577         case GST_FORMAT_UNITS:
 578           *dest_value = src_value / (osssink->channels * osssink->width);
 579           break;
 580         default:
 581           res = FALSE;
 582       }
 583       break;
 584     case GST_FORMAT_TIME:
 585       switch (*dest_format) {
 586         case GST_FORMAT_DEFAULT:
 587           *dest_format = GST_FORMAT_BYTES;
 588         case GST_FORMAT_BYTES:
 589           *dest_value = src_value * osssink->bps / GST_SECOND;
 590           break;
 591         case GST_FORMAT_UNITS:
 592           *dest_value = src_value * osssink->frequency / GST_SECOND;
 593           break;
 594         default:
 595           res = FALSE;
 596       }
 597       break;
 598     case GST_FORMAT_UNITS:
 599       switch (*dest_format) {
 600         case GST_FORMAT_DEFAULT:
 601           *dest_format = GST_FORMAT_TIME;
 602         case GST_FORMAT_TIME:
 603           *dest_value = src_value * GST_SECOND / osssink->frequency;
 604           break;
 605         case GST_FORMAT_BYTES:
 606           *dest_value = src_value * osssink->channels * osssink->width;
 607           break;
 608         default:
 609           res = FALSE;
 610       }
 611       break;
 612     default:
 613       res = FALSE;
 614   }
 615
 616   return res;
 617 }
 618
 619 static const GstPadQueryType*
 620 gst_osssink_get_query_types (GstPad *pad)
 621 {
 622   static const GstPadQueryType query_types[] = {
 623     GST_PAD_QUERY_LATENCY,
 624     GST_PAD_QUERY_POSITION,
 625     0,
 626   };
 627   return query_types;
 628 }
 629
 630 static gboolean
 631 gst_osssink_sink_query (GstPad *pad, GstPadQueryType type, GstFormat *format, gint64 *value)
 632 {
 633   gboolean res = TRUE;
 634   GstOssSink *osssink;
 635
 636   osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 637
 638   switch (type) {
 639     case GST_PAD_QUERY_LATENCY:
 640       if (!gst_osssink_convert (pad,
 641                                 GST_FORMAT_BYTES, gst_osssink_get_delay (osssink),
 642                                 format, value))
 643       {
 644         res = FALSE;
 645       }
 646       break;
 647     case GST_PAD_QUERY_POSITION:
 648       if (!gst_osssink_convert (pad,
 649                                 GST_FORMAT_TIME, gst_clock_get_time (osssink->provided_clock),
 650                                 format, value))
 651       {
 652         res = FALSE;
 653       }
 654       break;
 655     default:
 656       res = gst_pad_query (gst_pad_get_peer (osssink->sinkpad), type, format, value);
 657       break;
 658   }
 659
 660   return res;
 661 }
 662
 663 static gboolean
 664 gst_osssink_query (GstElement *element, GstPadQueryType type, GstFormat *format, gint64 *value)
 665 {
 666   GstOssSink *osssink = GST_OSSSINK (element);
 667
 668   return gst_osssink_sink_query (osssink->sinkpad, type, format, value);
 669 }
 670
 671 static void
 672 gst_osssink_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 673 {
 674   GstOssSink *osssink;
 675
 676   /* it's not null if we got it, but it might not be ours */
 677   g_return_if_fail (GST_IS_OSSSINK (object));
 678
 679   osssink = GST_OSSSINK (object);
 680
 681   switch (prop_id) {
 682     case ARG_DEVICE:
 683       /* disallow changing the device while it is opened
 684          get_property("device") should return the right one */
 685       if (!GST_FLAG_IS_SET (osssink, GST_OSSSINK_OPEN))
 686       {
 687         g_free (osssink->device);
 688         osssink->device = g_strdup (g_value_get_string (value));
 689         g_object_notify (object, "device");
 690       }
 691       break;
 692     case ARG_MUTE:
 693       osssink->mute = g_value_get_boolean (value);
 694       g_object_notify (G_OBJECT (osssink), "mute");
 695       break;
 696     case ARG_FRAGMENT:
 697       osssink->fragment = g_value_get_int (value);
 698       gst_osssink_sync_parms (osssink);
 699       break;
 700     case ARG_BUFFER_SIZE:
 701       if (osssink->bufsize == g_value_get_int (value)) break;
 702       osssink->bufsize = g_value_get_int (value);
 703       osssink->sinkpool = gst_buffer_pool_get_default (osssink->bufsize, 6);
 704       g_object_notify (object, "buffer_size");
 705       break;
 706     case ARG_SYNC:
 707       osssink->sync = g_value_get_boolean (value);
 708       g_object_notify (G_OBJECT (osssink), "sync");
 709       break;
 710     default:
 711       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 712       break;
 713   }
 714 }
 715
 716 static void
 717 gst_osssink_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 718 {
 719   GstOssSink *osssink;
 720
 721   /* it's not null if we got it, but it might not be ours */
 722   g_return_if_fail (GST_IS_OSSSINK (object));
 723
 724   osssink = GST_OSSSINK (object);
 725
 726   switch (prop_id) {
 727     case ARG_DEVICE:
 728       g_value_set_string (value, osssink->device);
 729       break;
 730     case ARG_MUTE:
 731       g_value_set_boolean (value, osssink->mute);
 732       break;
 733     case ARG_FRAGMENT:
 734       g_value_set_int (value, osssink->fragment);
 735       break;
 736     case ARG_BUFFER_SIZE:
 737       g_value_set_int (value, osssink->bufsize);
 738       break;
 739     case ARG_SYNC:
 740       g_value_set_boolean (value, osssink->sync);
 741       break;
 742     default:
 743       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 744       break;
 745   }
 746 }
 747
 748 static gboolean
 749 gst_osssink_open_audio (GstOssSink *sink)
 750 {
 751   gint caps;
 752   g_return_val_if_fail (sink->fd == -1, FALSE);
 753
 754   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: attempting to open sound device");
 755
 756   /* first try to open the sound card */
 757   /* FIXME: this code is dubious, why do we need to open and close this ?*/
 758   sink->fd = open (sink->device, O_WRONLY | O_NONBLOCK);
 759   if (errno == EBUSY) {
 760     g_warning ("osssink: unable to open the sound device (in use ?)\n");
 761   }
 762
 763   if (sink->fd >= 0)
 764     close (sink->fd);
 765
 766   /* re-open the sound device in blocking mode */
 767   sink->fd = open (sink->device, O_WRONLY);
 768
 769   if (sink->fd < 0) {
 770     switch (errno) {
 771       case EISDIR:
 772         gst_element_error (GST_ELEMENT (sink),
 773                            "osssink: Device %s is a directory",
 774                            sink->device);
 775         break;
 776       case EACCES:
 777       case ETXTBSY:
 778         gst_element_error (GST_ELEMENT (sink),
 779                            "osssink: Cannot access %s, check permissions",
 780                            sink->device);
 781         break;
 782       case ENXIO:
 783       case ENODEV:
 784       case ENOENT:
 785         gst_element_error (GST_ELEMENT (sink),
 786                            "osssink: Cannot access %s, does it exist ?",
 787                            sink->device);
 788         break;
 789       case EROFS:
 790         gst_element_error (GST_ELEMENT (sink),
 791                            "osssink: Cannot access %s, read-only filesystem ?",
 792                            sink->device);
 793       default:
 794         /* FIXME: strerror is not threadsafe */
 795         gst_element_error (GST_ELEMENT (sink),
 796                            "osssink: Cannot open %s, generic error: %s",
 797                            sink->device, strerror (errno));
 798         break;
 799     }
 800     return FALSE;
 801   }
 802   /* we have it, set the default parameters and go have fun */
 803   /* set card state */
 804   ioctl (sink->fd, SNDCTL_DSP_GETCAPS, &caps);
 805
 806   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: Capabilities %08x", caps);
 807
 808   if (caps & DSP_CAP_DUPLEX)    GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Full duplex");
 809   if (caps & DSP_CAP_REALTIME)  GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Realtime");
 810   if (caps & DSP_CAP_BATCH)     GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Batch");
 811   if (caps & DSP_CAP_COPROC)    GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Has coprocessor");
 812   if (caps & DSP_CAP_TRIGGER)   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Trigger");
 813   if (caps & DSP_CAP_MMAP)      GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Direct access");
 814
 815 #ifdef DSP_CAP_MULTI
 816   if (caps & DSP_CAP_MULTI)     GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Multiple open");
 817 #endif /* DSP_CAP_MULTI */
 818
 819 #ifdef DSP_CAP_BIND
 820   if (caps & DSP_CAP_BIND)      GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Channel binding");
 821 #endif /* DSP_CAP_BIND */
 822
 823   ioctl(sink->fd, SNDCTL_DSP_GETFMTS, &caps);
 824
 825   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: Formats %08x", caps);
 826   if (caps & AFMT_MU_LAW)               GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   MU_LAW");
 827   if (caps & AFMT_A_LAW)                GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   A_LAW");
 828   if (caps & AFMT_IMA_ADPCM)            GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   IMA_ADPCM");
 829   if (caps & AFMT_U8)                   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   U8");
 830   if (caps & AFMT_S16_LE)               GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   S16_LE");
 831   if (caps & AFMT_S16_BE)               GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   S16_BE");
 832   if (caps & AFMT_S8)                   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   S8");
 833   if (caps & AFMT_U16_LE)               GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   U16_LE");
 834   if (caps & AFMT_U16_BE)               GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   U16_BE");
 835   if (caps & AFMT_MPEG)                 GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   MPEG");
 836 #ifdef AFMT_AC3
 837   if (caps & AFMT_AC3)                  GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   AC3");
 838 #endif
 839
 840   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: opened audio (%s) with fd=%d", sink->device, sink->fd);
 841   GST_FLAG_SET (sink, GST_OSSSINK_OPEN);
 842
 843   return TRUE;
 844 }
 845
 846 static void
 847 gst_osssink_close_audio (GstOssSink *sink)
 848 {
 849   if (sink->fd < 0) return;
 850
 851   close(sink->fd);
 852   sink->fd = -1;
 853
 854   GST_FLAG_UNSET (sink, GST_OSSSINK_OPEN);
 855
 856   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: closed sound device");
 857 }
 858
 859 static GstElementStateReturn
 860 gst_osssink_change_state (GstElement *element)
 861 {
 862   GstOssSink *osssink;
 863
 864   g_return_val_if_fail (GST_IS_OSSSINK (element), FALSE);
 865
 866   osssink = GST_OSSSINK (element);
 867
 868   switch (GST_STATE_TRANSITION (element)) {
 869     case GST_STATE_NULL_TO_READY:
 870       if (!GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN)) {
 871         if (!gst_osssink_open_audio (osssink)) {
 872           return GST_STATE_FAILURE;
 873         }
 874       }
 875       break;
 876     case GST_STATE_READY_TO_PAUSED:
 877       break;
 878     case GST_STATE_PAUSED_TO_PLAYING:
 879       osssink->resync = TRUE;
 880       break;
 881     case GST_STATE_PLAYING_TO_PAUSED:
 882     {
 883       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN))
 884         ioctl (osssink->fd, SNDCTL_DSP_RESET, 0);
 885       gst_oss_clock_set_active (osssink->provided_clock, FALSE);
 886       osssink->resync = TRUE;
 887       break;
 888     }
 889     case GST_STATE_PAUSED_TO_READY:
 890       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN))
 891         ioctl (osssink->fd, SNDCTL_DSP_RESET, 0);
 892       break;
 893     case GST_STATE_READY_TO_NULL:
 894       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN))
 895         gst_osssink_close_audio (osssink);
 896       break;
 897   }
 898
 899   if (GST_ELEMENT_CLASS (parent_class)->change_state)
 900     return GST_ELEMENT_CLASS (parent_class)->change_state (element);
 901
 902   return GST_STATE_SUCCESS;
 903 }
 904
 905 gboolean
 906 gst_osssink_factory_init (GstPlugin *plugin)
 907 {
 908   GstElementFactory *factory;
 909
 910   factory = gst_element_factory_new ("osssink", GST_TYPE_OSSSINK, &gst_osssink_details);
 911   g_return_val_if_fail (factory != NULL, FALSE);
 912
 913   gst_element_factory_add_pad_template (factory, GST_PAD_TEMPLATE_GET (osssink_sink_factory));
 914
 915   gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
 916
 917   return TRUE;
 918 }
 919