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
  32 #include <gstosssink.h>
  33
  34 static GstElementDetails gst_osssink_details = {
  35   "Audio Sink (OSS)",
  36   "Sink/Audio",
  37   "Output to a sound card via OSS",
  38   VERSION,
  39   "Erik Walthinsen <omega@cse.ogi.edu>, "
  40   "Wim Taymans <wim.taymans@chello.be>",
  41   "(C) 1999",
  42 };
  43
  44 static void                     gst_osssink_class_init          (GstOssSinkClass *klass);
  45 static void                     gst_osssink_init                (GstOssSink *osssink);
  46 static void                     gst_osssink_finalize            (GObject *object);
  47
  48 static gboolean                 gst_osssink_open_audio          (GstOssSink *sink);
  49 static void                     gst_osssink_close_audio         (GstOssSink *sink);
  50 static gboolean                 gst_osssink_sync_parms          (GstOssSink *osssink);
  51 static GstElementStateReturn    gst_osssink_change_state        (GstElement *element);
  52 static void                     gst_osssink_set_clock           (GstElement *element, GstClock *clock);
  53 static GstClock*                gst_osssink_get_clock           (GstElement *element);
  54
  55 static GstPadConnectReturn      gst_osssink_sinkconnect         (GstPad *pad, GstCaps *caps);
  56
  57 static void                     gst_osssink_set_property        (GObject *object, guint prop_id, const GValue *value,
  58                                                                  GParamSpec *pspec);
  59 static void                     gst_osssink_get_property        (GObject *object, guint prop_id, GValue *value,
  60                                                                  GParamSpec *pspec);
  61
  62 static void                     gst_osssink_chain               (GstPad *pad,GstBuffer *buf);
  63
  64 /* OssSink signals and args */
  65 enum {
  66   SIGNAL_HANDOFF,
  67   LAST_SIGNAL
  68 };
  69
  70 enum {
  71   ARG_0,
  72   ARG_DEVICE,
  73   ARG_MUTE,
  74   ARG_FORMAT,
  75   ARG_CHANNELS,
  76   ARG_FREQUENCY,
  77   ARG_FRAGMENT,
  78   ARG_BUFFER_SIZE
  79   /* FILL ME */
  80 };
  81
  82 GST_PAD_TEMPLATE_FACTORY (osssink_sink_factory,
  83   "sink",
  84   GST_PAD_SINK,
  85   GST_PAD_ALWAYS,
  86   GST_CAPS_NEW (
  87     "osssink_sink",
  88     "audio/raw",
  89       "format",     GST_PROPS_STRING ("int"),   /* hack */
  90       "law",        GST_PROPS_INT (0),
  91       "endianness", GST_PROPS_INT (G_BYTE_ORDER),
  92       "signed",     GST_PROPS_LIST (
  93                       GST_PROPS_BOOLEAN (FALSE),
  94                       GST_PROPS_BOOLEAN (TRUE)
  95                     ),
  96       "width",      GST_PROPS_LIST (
  97                       GST_PROPS_INT (8),
  98                       GST_PROPS_INT (16)
  99                     ),
 100       "depth",      GST_PROPS_LIST (
 101                       GST_PROPS_INT (8),
 102                       GST_PROPS_INT (16)
 103                     ),
 104       "rate",       GST_PROPS_INT_RANGE (1000, 48000),
 105       "channels",   GST_PROPS_INT_RANGE (1, 2)
 106   )
 107 );
 108
 109 #define GST_TYPE_OSSSINK_CHANNELS (gst_osssink_channels_get_type())
 110 static GType
 111 gst_osssink_channels_get_type(void) {
 112   static GType osssink_channels_type = 0;
 113   static GEnumValue osssink_channels[] = {
 114     {0, "0", "Silence"},
 115     {1, "1", "Mono"},
 116     {2, "2", "Stereo"},
 117     {0, NULL, NULL},
 118   };
 119   if (!osssink_channels_type) {
 120     osssink_channels_type = g_enum_register_static("GstAudiosinkChannels", osssink_channels);
 121   }
 122   return osssink_channels_type;
 123 }
 124
 125
 126 static GstElementClass *parent_class = NULL;
 127 static guint gst_osssink_signals[LAST_SIGNAL] = { 0 };
 128
 129 GType
 130 gst_osssink_get_type (void)
 131 {
 132   static GType osssink_type = 0;
 133
 134   if (!osssink_type) {
 135     static const GTypeInfo osssink_info = {
 136       sizeof(GstOssSinkClass),
 137       NULL,
 138       NULL,
 139       (GClassInitFunc)gst_osssink_class_init,
 140       NULL,
 141       NULL,
 142       sizeof(GstOssSink),
 143       0,
 144       (GInstanceInitFunc)gst_osssink_init,
 145     };
 146     osssink_type = g_type_register_static (GST_TYPE_ELEMENT, "GstOssSink", &osssink_info, 0);
 147   }
 148
 149   return osssink_type;
 150 }
 151
 152 static GstBufferPool*
 153 gst_osssink_get_bufferpool (GstPad *pad)
 154 {
 155   GstOssSink *oss;
 156
 157   oss = GST_OSSSINK (gst_pad_get_parent(pad));
 158
 159   return oss->sinkpool;
 160 }
 161
 162 static void
 163 gst_osssink_finalize (GObject *object)
 164 {
 165   GstOssSink *osssink = (GstOssSink *) object;
 166
 167   g_free (osssink->device);
 168
 169   G_OBJECT_CLASS (parent_class)->finalize (object);
 170 }
 171
 172 static void
 173 gst_osssink_class_init (GstOssSinkClass *klass)
 174 {
 175   GObjectClass *gobject_class;
 176   GstElementClass *gstelement_class;
 177
 178   gobject_class = (GObjectClass*)klass;
 179   gstelement_class = (GstElementClass*)klass;
 180
 181   parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
 182
 183   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_DEVICE,
 184     g_param_spec_string("device","device","device",
 185                         "/dev/dsp",G_PARAM_READWRITE)); /* CHECKME! */
 186   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_MUTE,
 187     g_param_spec_boolean("mute","mute","mute",
 188                          TRUE,G_PARAM_READWRITE));
 189
 190   /* it would be nice to show format in symbolic form, oh well */
 191   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_FORMAT,
 192     g_param_spec_int ("format","format","format",
 193                       0, G_MAXINT, AFMT_S16_LE, G_PARAM_READWRITE));
 194
 195   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_CHANNELS,
 196     g_param_spec_enum("channels","channels","channels",
 197                       GST_TYPE_OSSSINK_CHANNELS,2,G_PARAM_READWRITE));
 198   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_FREQUENCY,
 199     g_param_spec_int("frequency","frequency","frequency",
 200                      0,G_MAXINT,44100,G_PARAM_READWRITE));
 201   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_FRAGMENT,
 202     g_param_spec_int("fragment","fragment","fragment",
 203                      0,G_MAXINT,6,G_PARAM_READWRITE));
 204   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_BUFFER_SIZE,
 205     g_param_spec_int("buffer_size","buffer_size","buffer_size",
 206                      0,G_MAXINT,4096,G_PARAM_READWRITE));
 207
 208   gst_osssink_signals[SIGNAL_HANDOFF] =
 209     g_signal_new("handoff",G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
 210                    G_STRUCT_OFFSET(GstOssSinkClass,handoff), NULL, NULL,
 211                    g_cclosure_marshal_VOID__VOID,G_TYPE_NONE,0);
 212
 213   gobject_class->set_property = gst_osssink_set_property;
 214   gobject_class->get_property = gst_osssink_get_property;
 215   gobject_class->finalize     = gst_osssink_finalize;
 216
 217   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_osssink_change_state);
 218 }
 219
 220 static GstClockTime
 221 gst_osssink_get_time (GstClock *clock, gpointer data)
 222 {
 223   GstOssSink *osssink = GST_OSSSINK (data);
 224   gint delay;
 225   GstClockTime res;
 226
 227   if (!osssink->bps)
 228     return 0;
 229
 230   ioctl (osssink->fd, SNDCTL_DSP_GETODELAY, &delay);
 231
 232   /* sometimes delay is bigger than the number of bytes sent to the device, which screws
 233    * up this calculation, we assume that everything is still in the device then */
 234   if (delay > osssink->handled) {
 235     res = osssink->offset;
 236   }
 237   else {
 238     res = osssink->offset + (osssink->handled - delay) * 1000000LL / osssink->bps;
 239   }
 240
 241   /*
 242   g_print ("from osssink: %lld %lld %d %lld %d\n", res, osssink->offset, delay, osssink->handled,
 243                   osssink->bps);
 244                   */
 245
 246   return res;
 247 }
 248
 249 static void
 250 gst_osssink_init (GstOssSink *osssink)
 251 {
 252   osssink->sinkpad = gst_pad_new_from_template (
 253                   GST_PAD_TEMPLATE_GET (osssink_sink_factory), "sink");
 254   gst_element_add_pad (GST_ELEMENT (osssink), osssink->sinkpad);
 255   gst_pad_set_connect_function (osssink->sinkpad, gst_osssink_sinkconnect);
 256   gst_pad_set_bufferpool_function (osssink->sinkpad, gst_osssink_get_bufferpool);
 257
 258   gst_pad_set_chain_function (osssink->sinkpad, gst_osssink_chain);
 259
 260   osssink->device = g_strdup ("/dev/dsp");
 261   osssink->fd = -1;
 262   osssink->channels = 1;
 263   osssink->frequency = 11025;
 264   osssink->fragment = 6;
 265 /* AFMT_*_BE not available on all OSS includes (e.g. FBSD) */
 266 #ifdef WORDS_BIGENDIAN
 267   osssink->format = AFMT_S16_BE;
 268 #else
 269   osssink->format = AFMT_S16_LE;
 270 #endif /* WORDS_BIGENDIAN */
 271   /* gst_clock_register (osssink->clock, GST_OBJECT (osssink)); */
 272   osssink->bufsize = 4096;
 273   osssink->bps = 0;
 274   osssink->offset = 0LL;
 275   osssink->handled = 0LL;
 276   /* 6 buffers per chunk by default */
 277   osssink->sinkpool = gst_buffer_pool_get_default (osssink->bufsize, 6);
 278
 279   osssink->provided_clock = NULL;
 280   osssink->provided_clock = GST_CLOCK (gst_oss_clock_new ("ossclock", gst_osssink_get_time, osssink));
 281
 282   GST_ELEMENT (osssink)->setclockfunc    = gst_osssink_set_clock;
 283   GST_ELEMENT (osssink)->getclockfunc    = gst_osssink_get_clock;
 284
 285   GST_FLAG_SET (osssink, GST_ELEMENT_THREAD_SUGGESTED);
 286   GST_FLAG_SET (osssink, GST_ELEMENT_EVENT_AWARE);
 287 }
 288
 289 static GstPadConnectReturn
 290 gst_osssink_sinkconnect (GstPad *pad, GstCaps *caps)
 291 {
 292   gint law, endianness, width, depth;
 293   gboolean sign;
 294   gint format = -1;
 295   GstOssSink *osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 296
 297   if (!GST_CAPS_IS_FIXED (caps))
 298     return GST_PAD_CONNECT_DELAYED;
 299
 300   gst_caps_get_int (caps, "width", &width);
 301   gst_caps_get_int (caps, "depth", &depth);
 302
 303   if (width != depth)
 304     return GST_PAD_CONNECT_REFUSED;
 305
 306   /* laws 1 and 2 are 1 bps anyway */
 307   osssink->bps = 1;
 308
 309   gst_caps_get_int (caps, "law", &law);
 310   gst_caps_get_int (caps, "endianness", &endianness);
 311   gst_caps_get_boolean (caps, "signed", &sign);
 312
 313   if (law == 0) {
 314     if (width == 16) {
 315       if (sign == TRUE) {
 316         if (endianness == G_LITTLE_ENDIAN)
 317           format = AFMT_S16_LE;
 318         else if (endianness == G_BIG_ENDIAN)
 319           format = AFMT_S16_BE;
 320       }
 321       else {
 322         if (endianness == G_LITTLE_ENDIAN)
 323           format = AFMT_U16_LE;
 324         else if (endianness == G_BIG_ENDIAN)
 325           format = AFMT_U16_BE;
 326       }
 327       osssink->bps = 2;
 328     }
 329     else if (width == 8) {
 330       if (sign == TRUE) {
 331         format = AFMT_S8;
 332       }
 333       else {
 334         format = AFMT_U8;
 335       }
 336       osssink->bps = 1;
 337     }
 338   } else if (law == 1) {
 339     format = AFMT_MU_LAW;
 340   } else if (law == 2) {
 341     format = AFMT_A_LAW;
 342   } else {
 343     g_critical ("unknown law");
 344     return GST_PAD_CONNECT_REFUSED;
 345   }
 346
 347   if (format == -1)
 348     return GST_PAD_CONNECT_REFUSED;
 349
 350   osssink->format = format;
 351   gst_caps_get_int (caps, "channels", &osssink->channels);
 352   gst_caps_get_int (caps, "rate", &osssink->frequency);
 353
 354   osssink->bps *= osssink->channels;
 355   osssink->bps *= osssink->frequency;
 356
 357   if (!gst_osssink_sync_parms (osssink)) {
 358     return GST_PAD_CONNECT_REFUSED;
 359   }
 360
 361   return GST_PAD_CONNECT_OK;
 362 }
 363
 364 static gboolean
 365 gst_osssink_sync_parms (GstOssSink *osssink)
 366 {
 367   audio_buf_info ospace;
 368   int frag;
 369   gint target_format;
 370   gint target_channels;
 371   gint target_frequency;
 372   GObject *object;
 373
 374   g_return_val_if_fail (osssink != NULL, FALSE);
 375   g_return_val_if_fail (GST_IS_OSSSINK (osssink), FALSE);
 376
 377   if (osssink->fd == -1)
 378     return FALSE;
 379
 380   if (osssink->fragment >> 16)
 381     frag = osssink->fragment;
 382   else
 383     frag = 0x7FFF0000 | osssink->fragment;
 384
 385   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: trying to set sound card to %dHz %d bit %s (%08x fragment)",
 386            osssink->frequency, osssink->format,
 387            (osssink->channels == 2) ? "stereo" : "mono",frag);
 388
 389   ioctl (osssink->fd, SNDCTL_DSP_SETFRAGMENT, &frag);
 390
 391   ioctl (osssink->fd, SNDCTL_DSP_RESET, 0);
 392
 393   target_format = osssink->format;
 394   target_channels = osssink->channels;
 395   target_frequency = osssink->frequency;
 396
 397   ioctl (osssink->fd, SNDCTL_DSP_SETFMT, &osssink->format);
 398   ioctl (osssink->fd, SNDCTL_DSP_CHANNELS, &osssink->channels);
 399   ioctl (osssink->fd, SNDCTL_DSP_SPEED, &osssink->frequency);
 400
 401   ioctl (osssink->fd, SNDCTL_DSP_GETBLKSIZE, &osssink->fragment);
 402   ioctl (osssink->fd, SNDCTL_DSP_GETOSPACE, &ospace);
 403
 404   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: set sound card to %dHz %d bit %s (%d bytes buffer, %08x fragment)",
 405            osssink->frequency, osssink->format,
 406            (osssink->channels == 2) ? "stereo" : "mono", ospace.bytes, osssink->fragment);
 407
 408   object = G_OBJECT (osssink);
 409   g_object_freeze_notify (object);
 410   g_object_notify (object, "channels");
 411   g_object_notify (object, "frequency");
 412   g_object_notify (object, "fragment");
 413   g_object_notify (object, "format");
 414   g_object_thaw_notify (object);
 415
 416   osssink->fragment_time = (1000000 * osssink->fragment) / osssink->bps;
 417   GST_INFO (GST_CAT_PLUGIN_INFO, "fragment time %u %llu\n", osssink->bps, osssink->fragment_time);
 418
 419   if (target_format != osssink->format ||
 420       target_channels != osssink->channels ||
 421       target_frequency != osssink->frequency)
 422   {
 423     g_warning ("could not configure oss with required parameters, enjoy the noise :)");
 424     /* we could eventually return FALSE here, or just do some additional tests
 425      * to see that the frequencies don't differ too much etc.. */
 426   }
 427   return TRUE;
 428 }
 429
 430 static GstClock*
 431 gst_osssink_get_clock (GstElement *element)
 432 {
 433   GstOssSink *osssink;
 434
 435   osssink = GST_OSSSINK (element);
 436
 437   return GST_CLOCK (osssink->provided_clock);
 438 }
 439
 440 static void
 441 gst_osssink_set_clock (GstElement *element, GstClock *clock)
 442 {
 443   GstOssSink *osssink;
 444
 445   osssink = GST_OSSSINK (element);
 446
 447   osssink->clock = clock;
 448 }
 449
 450 static void
 451 gst_osssink_chain (GstPad *pad, GstBuffer *buf)
 452 {
 453   GstOssSink *osssink;
 454   GstClockTime buftime;
 455
 456   /* this has to be an audio buffer */
 457   osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 458
 459   if (GST_IS_EVENT (buf)) {
 460     switch (GST_EVENT_TYPE (buf)) {
 461       case GST_EVENT_EOS:
 462         ioctl (osssink->fd, SNDCTL_DSP_SYNC);
 463         gst_pad_event_default (pad, GST_EVENT (buf));
 464         return;
 465       default:
 466         return;
 467     }
 468   }
 469
 470   buftime = GST_BUFFER_TIMESTAMP (buf);
 471
 472   if (!osssink->bps) {
 473     gst_buffer_unref (buf);
 474     gst_element_error (GST_ELEMENT (osssink), "capsnego was never performed, unknown data type");
 475   }
 476
 477   if (osssink->fd >= 0) {
 478     if (!osssink->mute) {
 479       guchar *data = GST_BUFFER_DATA (buf);
 480       gint size = GST_BUFFER_SIZE (buf);
 481       /* gint frag = osssink->fragment;   <-- unused, for reason see above */
 482
 483       if (osssink->clock) {
 484         /* FIXME, NEW_MEDIA/DISCONT?. Try to get our start point */
 485         if (!osssink->have_offset && buftime != -1LL) {
 486            GST_INFO (GST_CAT_PLUGIN_INFO,
 487                            "osssink: clock at offset: %lld, new offset %lld at time %lld\n",
 488                            osssink->offset, buftime, gst_clock_get_time (osssink->clock));
 489
 490           osssink->offset = buftime;
 491           osssink->have_offset = TRUE;
 492           osssink->handled = 0;
 493           gst_element_clock_wait (GST_ELEMENT (osssink), osssink->clock, buftime);
 494         }
 495
 496
 497         /* this doesn't work on BE machines, apparently
 498         while (size) {
 499           gint tosend = MIN (size, frag);
 500           write (osssink->fd, data, tosend);
 501           data += tosend;
 502           size -= tosend;
 503           osssink->handled += tosend;
 504         } */
 505         write (osssink->fd, data, size);
 506         osssink->handled += size;
 507       }
 508       /* no clock, try to be as fast as possible */
 509       else {
 510         audio_buf_info ospace;
 511
 512         ioctl (osssink->fd, SNDCTL_DSP_GETOSPACE, &ospace);
 513
 514         if (ospace.bytes >= size) {
 515           write (osssink->fd, data, size);
 516         }
 517         osssink->handled += size;
 518       }
 519     }
 520   }
 521   gst_buffer_unref (buf);
 522 }
 523
 524 static void
 525 gst_osssink_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 526 {
 527   GstOssSink *osssink;
 528
 529   /* it's not null if we got it, but it might not be ours */
 530   g_return_if_fail (GST_IS_OSSSINK (object));
 531
 532   osssink = GST_OSSSINK (object);
 533
 534   switch (prop_id) {
 535     case ARG_DEVICE:
 536       /* disallow changing the device while it is opened
 537          get_property("device") should return the right one */
 538       if (!GST_FLAG_IS_SET (osssink, GST_OSSSINK_OPEN))
 539       {
 540         g_free (osssink->device);
 541         osssink->device = g_strdup (g_value_get_string (value));
 542         g_object_notify (object, "device");
 543       }
 544       break;
 545     case ARG_MUTE:
 546       osssink->mute = g_value_get_boolean (value);
 547       g_object_notify (G_OBJECT (osssink), "mute");
 548       break;
 549     case ARG_FORMAT:
 550       osssink->format = g_value_get_int (value);
 551       gst_osssink_sync_parms (osssink);
 552       break;
 553     case ARG_CHANNELS:
 554       osssink->channels = g_value_get_enum (value);
 555       gst_osssink_sync_parms (osssink);
 556       break;
 557     case ARG_FREQUENCY:
 558       osssink->frequency = g_value_get_int (value);
 559       gst_osssink_sync_parms (osssink);
 560       break;
 561     case ARG_FRAGMENT:
 562       osssink->fragment = g_value_get_int (value);
 563       gst_osssink_sync_parms (osssink);
 564       break;
 565     case ARG_BUFFER_SIZE:
 566       if (osssink->bufsize == g_value_get_int (value)) break;
 567       osssink->bufsize = g_value_get_int (value);
 568       osssink->sinkpool = gst_buffer_pool_get_default (osssink->bufsize, 6);
 569       g_object_notify (object, "buffer_size");
 570       break;
 571     default:
 572       break;
 573   }
 574 }
 575
 576 static void
 577 gst_osssink_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 578 {
 579   GstOssSink *osssink;
 580
 581   /* it's not null if we got it, but it might not be ours */
 582   g_return_if_fail (GST_IS_OSSSINK (object));
 583
 584   osssink = GST_OSSSINK (object);
 585
 586   switch (prop_id) {
 587     case ARG_DEVICE:
 588       g_value_set_string (value, osssink->device);
 589       break;
 590     case ARG_MUTE:
 591       g_value_set_boolean (value, osssink->mute);
 592       break;
 593     case ARG_FORMAT:
 594       g_value_set_int (value, osssink->format);
 595       break;
 596     case ARG_CHANNELS:
 597       g_value_set_enum (value, osssink->channels);
 598       break;
 599     case ARG_FREQUENCY:
 600       g_value_set_int (value, osssink->frequency);
 601       break;
 602     case ARG_FRAGMENT:
 603       g_value_set_int (value, osssink->fragment);
 604       break;
 605     case ARG_BUFFER_SIZE:
 606       g_value_set_int (value, osssink->bufsize);
 607       break;
 608     default:
 609       break;
 610   }
 611 }
 612
 613 static gboolean
 614 gst_osssink_open_audio (GstOssSink *sink)
 615 {
 616   gint caps;
 617   g_return_val_if_fail (sink->fd == -1, FALSE);
 618
 619   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: attempting to open sound device");
 620
 621   /* first try to open the sound card */
 622   sink->fd = open(sink->device, O_WRONLY | O_NONBLOCK);
 623   if (errno == EBUSY) {
 624     g_warning ("osssink: unable to open the sound device (in use ?)\n");
 625     return FALSE;
 626   }
 627
 628   /* re-open the sound device in blocking mode */
 629   close(sink->fd);
 630   sink->fd = open(sink->device, O_WRONLY);
 631
 632   /* if we have it, set the default parameters and go have fun */
 633   if (sink->fd >= 0) {
 634     /* set card state */
 635     ioctl(sink->fd, SNDCTL_DSP_GETCAPS, &caps);
 636
 637     GST_INFO(GST_CAT_PLUGIN_INFO, "osssink: Capabilities %08x", caps);
 638
 639     if (caps & DSP_CAP_DUPLEX)          GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Full duplex");
 640     if (caps & DSP_CAP_REALTIME)        GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Realtime");
 641     if (caps & DSP_CAP_BATCH)           GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Batch");
 642     if (caps & DSP_CAP_COPROC)          GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Has coprocessor");
 643     if (caps & DSP_CAP_TRIGGER)         GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Trigger");
 644     if (caps & DSP_CAP_MMAP)            GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Direct access");
 645
 646 #ifdef DSP_CAP_MULTI
 647     if (caps & DSP_CAP_MULTI)           GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Multiple open");
 648 #endif /* DSP_CAP_MULTI */
 649
 650 #ifdef DSP_CAP_BIND
 651     if (caps & DSP_CAP_BIND)            GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Channel binding");
 652 #endif /* DSP_CAP_BIND */
 653
 654     ioctl(sink->fd, SNDCTL_DSP_GETFMTS, &caps);
 655
 656     GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: Formats %08x", caps);
 657     if (caps & AFMT_MU_LAW)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   MU_LAW");
 658     if (caps & AFMT_A_LAW)              GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   A_LAW");
 659     if (caps & AFMT_IMA_ADPCM)          GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   IMA_ADPCM");
 660     if (caps & AFMT_U8)                 GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   U8");
 661     if (caps & AFMT_S16_LE)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   S16_LE");
 662     if (caps & AFMT_S16_BE)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   S16_BE");
 663     if (caps & AFMT_S8)                 GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   S8");
 664     if (caps & AFMT_U16_LE)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   U16_LE");
 665     if (caps & AFMT_U16_BE)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   U16_BE");
 666     if (caps & AFMT_MPEG)               GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   MPEG");
 667 #ifdef AFMT_AC3
 668     if (caps & AFMT_AC3)                GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   AC3");
 669 #endif
 670
 671     GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: opened audio (%s) with fd=%d", sink->device, sink->fd);
 672     GST_FLAG_SET (sink, GST_OSSSINK_OPEN);
 673
 674     return TRUE;
 675   }
 676
 677   return FALSE;
 678 }
 679
 680 static void
 681 gst_osssink_close_audio (GstOssSink *sink)
 682 {
 683   if (sink->fd < 0) return;
 684
 685   close(sink->fd);
 686   sink->fd = -1;
 687
 688   GST_FLAG_UNSET (sink, GST_OSSSINK_OPEN);
 689
 690   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: closed sound device");
 691 }
 692
 693 static GstElementStateReturn
 694 gst_osssink_change_state (GstElement *element)
 695 {
 696   GstOssSink *osssink;
 697
 698   g_return_val_if_fail (GST_IS_OSSSINK (element), FALSE);
 699
 700   osssink = GST_OSSSINK (element);
 701
 702   switch (GST_STATE_TRANSITION (element)) {
 703     case GST_STATE_NULL_TO_READY:
 704       if (!GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN)) {
 705         if (!gst_osssink_open_audio (osssink)) {
 706           return GST_STATE_FAILURE;
 707         }
 708       }
 709       break;
 710     case GST_STATE_READY_TO_PAUSED:
 711       osssink->offset = 0LL;
 712       osssink->have_offset = FALSE;
 713       break;
 714     case GST_STATE_PAUSED_TO_PLAYING:
 715       /* gst_clock_adjust (osssink->clock, osssink->offset - gst_clock_get_time (osssink->clock)); */
 716       break;
 717     case GST_STATE_PLAYING_TO_PAUSED:
 718     {
 719       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN)) {
 720         if (osssink->bps) {
 721           GstClockTime time;
 722           audio_buf_info ospace;
 723           gint queued;
 724
 725           ioctl (osssink->fd, SNDCTL_DSP_GETOSPACE, &ospace);
 726           ioctl (osssink->fd, SNDCTL_DSP_RESET, 0);
 727
 728           queued = (ospace.fragstotal * ospace.fragsize) - ospace.bytes;
 729           time = osssink->offset + (osssink->handled - queued) * 1000000LL / osssink->bps;
 730
 731           //gst_clock_adjust (osssink->clock, time - gst_clock_get_time (osssink->clock));
 732         }
 733         else {
 734           ioctl (osssink->fd, SNDCTL_DSP_RESET, 0);
 735         }
 736       }
 737
 738       break;
 739     }
 740     case GST_STATE_PAUSED_TO_READY:
 741       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN))
 742         ioctl (osssink->fd, SNDCTL_DSP_RESET, 0);
 743       break;
 744     case GST_STATE_READY_TO_NULL:
 745       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN))
 746         gst_osssink_close_audio (osssink);
 747       break;
 748   }
 749
 750   if (GST_ELEMENT_CLASS (parent_class)->change_state)
 751     return GST_ELEMENT_CLASS (parent_class)->change_state (element);
 752
 753   return GST_STATE_SUCCESS;
 754 }
 755
 756 gboolean
 757 gst_osssink_factory_init (GstPlugin *plugin)
 758 {
 759   GstElementFactory *factory;
 760
 761   factory = gst_element_factory_new ("osssink", GST_TYPE_OSSSINK, &gst_osssink_details);
 762   g_return_val_if_fail (factory != NULL, FALSE);
 763
 764   gst_element_factory_add_pad_template (factory, GST_PAD_TEMPLATE_GET (osssink_sink_factory));
 765
 766   gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
 767
 768   return TRUE;
 769 }
 770