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   gint offset = 0;
 226
 227   if (!osssink->bps)
 228     return 0;
 229
 230   /* if we have a start time, use offset */
 231   if (osssink->offset >= 0LL) {
 232     offset = osssink->offset;
 233   }
 234
 235   ioctl (osssink->fd, SNDCTL_DSP_GETODELAY, &delay);
 236
 237   return offset + (osssink->handled - delay) * 1000000LL / osssink->bps;
 238 }
 239
 240 static void
 241 gst_osssink_init (GstOssSink *osssink)
 242 {
 243   osssink->sinkpad = gst_pad_new_from_template (
 244                   GST_PAD_TEMPLATE_GET (osssink_sink_factory), "sink");
 245   gst_element_add_pad (GST_ELEMENT (osssink), osssink->sinkpad);
 246   gst_pad_set_connect_function (osssink->sinkpad, gst_osssink_sinkconnect);
 247   gst_pad_set_bufferpool_function (osssink->sinkpad, gst_osssink_get_bufferpool);
 248
 249   gst_pad_set_chain_function (osssink->sinkpad, gst_osssink_chain);
 250
 251   osssink->device = g_strdup ("/dev/dsp");
 252   osssink->fd = -1;
 253   osssink->channels = 1;
 254   osssink->frequency = 11025;
 255   osssink->fragment = 6;
 256 /* AFMT_*_BE not available on all OSS includes (e.g. FBSD) */
 257 #ifdef WORDS_BIGENDIAN
 258   osssink->format = AFMT_S16_BE;
 259 #else
 260   osssink->format = AFMT_S16_LE;
 261 #endif /* WORDS_BIGENDIAN */
 262   /* gst_clock_register (osssink->clock, GST_OBJECT (osssink)); */
 263   osssink->bufsize = 4096;
 264   osssink->offset = -1LL;
 265   osssink->handled = 0LL;
 266   /* 6 buffers per chunk by default */
 267   osssink->sinkpool = gst_buffer_pool_get_default (osssink->bufsize, 6);
 268
 269   osssink->provided_clock = NULL;
 270   osssink->provided_clock = GST_CLOCK (gst_oss_clock_new ("ossclock", gst_osssink_get_time, osssink));
 271
 272   GST_ELEMENT (osssink)->setclockfunc    = gst_osssink_set_clock;
 273   GST_ELEMENT (osssink)->getclockfunc    = gst_osssink_get_clock;
 274
 275   GST_FLAG_SET (osssink, GST_ELEMENT_THREAD_SUGGESTED);
 276   GST_FLAG_SET (osssink, GST_ELEMENT_EVENT_AWARE);
 277 }
 278
 279 static GstPadConnectReturn
 280 gst_osssink_sinkconnect (GstPad *pad, GstCaps *caps)
 281 {
 282   gint law, endianness, width, depth;
 283   gboolean sign;
 284   gint format = -1;
 285   GstOssSink *osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 286
 287   if (!GST_CAPS_IS_FIXED (caps))
 288     return GST_PAD_CONNECT_DELAYED;
 289
 290   gst_caps_get_int (caps, "width", &width);
 291   gst_caps_get_int (caps, "depth", &depth);
 292
 293   if (width != depth)
 294     return GST_PAD_CONNECT_REFUSED;
 295
 296   /* laws 1 and 2 are 1 bps anyway */
 297   osssink->bps = 1;
 298
 299   gst_caps_get_int (caps, "law", &law);
 300   gst_caps_get_int (caps, "endianness", &endianness);
 301   gst_caps_get_boolean (caps, "signed", &sign);
 302
 303   if (law == 0) {
 304     if (width == 16) {
 305       if (sign == TRUE) {
 306         if (endianness == G_LITTLE_ENDIAN)
 307           format = AFMT_S16_LE;
 308         else if (endianness == G_BIG_ENDIAN)
 309           format = AFMT_S16_BE;
 310       }
 311       else {
 312         if (endianness == G_LITTLE_ENDIAN)
 313           format = AFMT_U16_LE;
 314         else if (endianness == G_BIG_ENDIAN)
 315           format = AFMT_U16_BE;
 316       }
 317       osssink->bps = 2;
 318     }
 319     else if (width == 8) {
 320       if (sign == TRUE) {
 321         format = AFMT_S8;
 322       }
 323       else {
 324         format = AFMT_U8;
 325       }
 326       osssink->bps = 1;
 327     }
 328   } else if (law == 1) {
 329     format = AFMT_MU_LAW;
 330   } else if (law == 2) {
 331     format = AFMT_A_LAW;
 332   } else {
 333     g_critical ("unknown law");
 334     return GST_PAD_CONNECT_REFUSED;
 335   }
 336
 337   if (format == -1)
 338     return GST_PAD_CONNECT_REFUSED;
 339
 340   osssink->format = format;
 341   gst_caps_get_int (caps, "channels", &osssink->channels);
 342   gst_caps_get_int (caps, "rate", &osssink->frequency);
 343
 344   osssink->bps *= osssink->channels;
 345   osssink->bps *= osssink->frequency;
 346
 347   if (!gst_osssink_sync_parms (osssink)) {
 348     return GST_PAD_CONNECT_REFUSED;
 349   }
 350
 351   return GST_PAD_CONNECT_OK;
 352 }
 353
 354 static gboolean
 355 gst_osssink_sync_parms (GstOssSink *osssink)
 356 {
 357   audio_buf_info ospace;
 358   int frag;
 359   gint target_format;
 360   gint target_channels;
 361   gint target_frequency;
 362   GObject *object;
 363
 364   g_return_val_if_fail (osssink != NULL, FALSE);
 365   g_return_val_if_fail (GST_IS_OSSSINK (osssink), FALSE);
 366
 367   if (osssink->fd == -1)
 368     return FALSE;
 369
 370   if (osssink->fragment >> 16)
 371     frag = osssink->fragment;
 372   else
 373     frag = 0x7FFF0000 | osssink->fragment;
 374
 375   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: trying to set sound card to %dHz %d bit %s (%08x fragment)",
 376            osssink->frequency, osssink->format,
 377            (osssink->channels == 2) ? "stereo" : "mono",frag);
 378
 379   ioctl (osssink->fd, SNDCTL_DSP_SETFRAGMENT, &frag);
 380
 381   ioctl (osssink->fd, SNDCTL_DSP_RESET, 0);
 382
 383   target_format = osssink->format;
 384   target_channels = osssink->channels;
 385   target_frequency = osssink->frequency;
 386
 387   ioctl (osssink->fd, SNDCTL_DSP_SETFMT, &osssink->format);
 388   ioctl (osssink->fd, SNDCTL_DSP_CHANNELS, &osssink->channels);
 389   ioctl (osssink->fd, SNDCTL_DSP_SPEED, &osssink->frequency);
 390
 391   ioctl (osssink->fd, SNDCTL_DSP_GETBLKSIZE, &osssink->fragment);
 392   ioctl (osssink->fd, SNDCTL_DSP_GETOSPACE, &ospace);
 393
 394   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: set sound card to %dHz %d bit %s (%d bytes buffer, %08x fragment)",
 395            osssink->frequency, osssink->format,
 396            (osssink->channels == 2) ? "stereo" : "mono", ospace.bytes, osssink->fragment);
 397
 398   object = G_OBJECT (osssink);
 399   g_object_freeze_notify (object);
 400   g_object_notify (object, "channels");
 401   g_object_notify (object, "frequency");
 402   g_object_notify (object, "fragment");
 403   g_object_notify (object, "format");
 404   g_object_thaw_notify (object);
 405
 406   osssink->fragment_time = (1000000 * osssink->fragment) / osssink->bps;
 407   GST_INFO (GST_CAT_PLUGIN_INFO, "fragment time %u %llu\n", osssink->bps, osssink->fragment_time);
 408
 409   if (target_format != osssink->format ||
 410       target_channels != osssink->channels ||
 411       target_frequency != osssink->frequency)
 412   {
 413     g_warning ("could not configure oss with required parameters, enjoy the noise :)");
 414     /* we could eventually return FALSE here, or just do some additional tests
 415      * to see that the frequencies don't differ too much etc.. */
 416   }
 417   return TRUE;
 418 }
 419
 420 static GstClock*
 421 gst_osssink_get_clock (GstElement *element)
 422 {
 423   GstOssSink *osssink;
 424
 425   osssink = GST_OSSSINK (element);
 426
 427   return GST_CLOCK (osssink->provided_clock);
 428 }
 429
 430 static void
 431 gst_osssink_set_clock (GstElement *element, GstClock *clock)
 432 {
 433   GstOssSink *osssink;
 434
 435   osssink = GST_OSSSINK (element);
 436
 437   osssink->clock = clock;
 438 }
 439
 440 static void
 441 gst_osssink_chain (GstPad *pad, GstBuffer *buf)
 442 {
 443   GstOssSink *osssink;
 444   GstClockTime buftime;
 445
 446   /* this has to be an audio buffer */
 447   osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 448
 449   if (GST_IS_EVENT (buf)) {
 450     switch (GST_EVENT_TYPE (buf)) {
 451       case GST_EVENT_EOS:
 452         ioctl (osssink->fd, SNDCTL_DSP_SYNC);
 453         gst_pad_event_default (pad, GST_EVENT (buf));
 454         return;
 455       default:
 456         return;
 457     }
 458   }
 459
 460   buftime = GST_BUFFER_TIMESTAMP (buf);
 461
 462   if (!osssink->bps) {
 463     gst_buffer_unref (buf);
 464     gst_element_error (GST_ELEMENT (osssink), "capsnego was never performed, unknown data type");
 465   }
 466
 467   if (osssink->fd >= 0) {
 468     if (!osssink->mute) {
 469       guchar *data = GST_BUFFER_DATA (buf);
 470       gint size = GST_BUFFER_SIZE (buf);
 471       /* gint frag = osssink->fragment;   <-- unused, for reason see above */
 472
 473       if (osssink->clock) {
 474         /* FIXME, NEW_MEDIA/DISCONT?. Try to get our start point */
 475         if (osssink->offset == -1LL && buftime != -1LL) {
 476            GST_INFO (GST_CAT_PLUGIN_INFO,
 477                            "osssink: clock at offset: %lld, new offset %lld at time %lld\n",
 478                            osssink->offset, buftime, gst_clock_get_time (osssink->clock));
 479
 480           osssink->offset = buftime;
 481           osssink->handled = 0;
 482           gst_element_clock_wait (GST_ELEMENT (osssink), osssink->clock, buftime);
 483         }
 484
 485
 486         /* this doesn't work on BE machines, apparently
 487         while (size) {
 488           gint tosend = MIN (size, frag);
 489           write (osssink->fd, data, tosend);
 490           data += tosend;
 491           size -= tosend;
 492           osssink->handled += tosend;
 493         } */
 494         write (osssink->fd, data, size);
 495         osssink->handled += size;
 496       }
 497       /* no clock, try to be as fast as possible */
 498       else {
 499         audio_buf_info ospace;
 500
 501         ioctl (osssink->fd, SNDCTL_DSP_GETOSPACE, &ospace);
 502
 503         if (ospace.bytes >= size) {
 504           write (osssink->fd, data, size);
 505         }
 506         osssink->handled += size;
 507       }
 508     }
 509   }
 510   gst_buffer_unref (buf);
 511 }
 512
 513 static void
 514 gst_osssink_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 515 {
 516   GstOssSink *osssink;
 517
 518   /* it's not null if we got it, but it might not be ours */
 519   g_return_if_fail (GST_IS_OSSSINK (object));
 520
 521   osssink = GST_OSSSINK (object);
 522
 523   switch (prop_id) {
 524     case ARG_DEVICE:
 525       /* disallow changing the device while it is opened
 526          get_property("device") should return the right one */
 527       if (!GST_FLAG_IS_SET (osssink, GST_OSSSINK_OPEN))
 528       {
 529         g_free (osssink->device);
 530         osssink->device = g_strdup (g_value_get_string (value));
 531         g_object_notify (object, "device");
 532       }
 533       break;
 534     case ARG_MUTE:
 535       osssink->mute = g_value_get_boolean (value);
 536       g_object_notify (G_OBJECT (osssink), "mute");
 537       break;
 538     case ARG_FORMAT:
 539       osssink->format = g_value_get_int (value);
 540       gst_osssink_sync_parms (osssink);
 541       break;
 542     case ARG_CHANNELS:
 543       osssink->channels = g_value_get_enum (value);
 544       gst_osssink_sync_parms (osssink);
 545       break;
 546     case ARG_FREQUENCY:
 547       osssink->frequency = g_value_get_int (value);
 548       gst_osssink_sync_parms (osssink);
 549       break;
 550     case ARG_FRAGMENT:
 551       osssink->fragment = g_value_get_int (value);
 552       gst_osssink_sync_parms (osssink);
 553       break;
 554     case ARG_BUFFER_SIZE:
 555       if (osssink->bufsize == g_value_get_int (value)) break;
 556       osssink->bufsize = g_value_get_int (value);
 557       osssink->sinkpool = gst_buffer_pool_get_default (osssink->bufsize, 6);
 558       g_object_notify (object, "buffer_size");
 559       break;
 560     default:
 561       break;
 562   }
 563 }
 564
 565 static void
 566 gst_osssink_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 567 {
 568   GstOssSink *osssink;
 569
 570   /* it's not null if we got it, but it might not be ours */
 571   g_return_if_fail (GST_IS_OSSSINK (object));
 572
 573   osssink = GST_OSSSINK (object);
 574
 575   switch (prop_id) {
 576     case ARG_DEVICE:
 577       g_value_set_string (value, osssink->device);
 578       break;
 579     case ARG_MUTE:
 580       g_value_set_boolean (value, osssink->mute);
 581       break;
 582     case ARG_FORMAT:
 583       g_value_set_int (value, osssink->format);
 584       break;
 585     case ARG_CHANNELS:
 586       g_value_set_enum (value, osssink->channels);
 587       break;
 588     case ARG_FREQUENCY:
 589       g_value_set_int (value, osssink->frequency);
 590       break;
 591     case ARG_FRAGMENT:
 592       g_value_set_int (value, osssink->fragment);
 593       break;
 594     case ARG_BUFFER_SIZE:
 595       g_value_set_int (value, osssink->bufsize);
 596       break;
 597     default:
 598       break;
 599   }
 600 }
 601
 602 static gboolean
 603 gst_osssink_open_audio (GstOssSink *sink)
 604 {
 605   gint caps;
 606   g_return_val_if_fail (sink->fd == -1, FALSE);
 607
 608   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: attempting to open sound device");
 609
 610   /* first try to open the sound card */
 611   sink->fd = open(sink->device, O_WRONLY | O_NONBLOCK);
 612   if (errno == EBUSY) {
 613     g_warning ("osssink: unable to open the sound device (in use ?)\n");
 614     return FALSE;
 615   }
 616
 617   /* re-open the sound device in blocking mode */
 618   close(sink->fd);
 619   sink->fd = open(sink->device, O_WRONLY);
 620
 621   /* if we have it, set the default parameters and go have fun */
 622   if (sink->fd >= 0) {
 623     /* set card state */
 624     ioctl(sink->fd, SNDCTL_DSP_GETCAPS, &caps);
 625
 626     GST_INFO(GST_CAT_PLUGIN_INFO, "osssink: Capabilities %08x", caps);
 627
 628     if (caps & DSP_CAP_DUPLEX)          GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Full duplex");
 629     if (caps & DSP_CAP_REALTIME)        GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Realtime");
 630     if (caps & DSP_CAP_BATCH)           GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Batch");
 631     if (caps & DSP_CAP_COPROC)          GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Has coprocessor");
 632     if (caps & DSP_CAP_TRIGGER)         GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Trigger");
 633     if (caps & DSP_CAP_MMAP)            GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Direct access");
 634
 635 #ifdef DSP_CAP_MULTI
 636     if (caps & DSP_CAP_MULTI)           GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Multiple open");
 637 #endif /* DSP_CAP_MULTI */
 638
 639 #ifdef DSP_CAP_BIND
 640     if (caps & DSP_CAP_BIND)            GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Channel binding");
 641 #endif /* DSP_CAP_BIND */
 642
 643     ioctl(sink->fd, SNDCTL_DSP_GETFMTS, &caps);
 644
 645     GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: Formats %08x", caps);
 646     if (caps & AFMT_MU_LAW)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   MU_LAW");
 647     if (caps & AFMT_A_LAW)              GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   A_LAW");
 648     if (caps & AFMT_IMA_ADPCM)          GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   IMA_ADPCM");
 649     if (caps & AFMT_U8)                 GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   U8");
 650     if (caps & AFMT_S16_LE)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   S16_LE");
 651     if (caps & AFMT_S16_BE)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   S16_BE");
 652     if (caps & AFMT_S8)                 GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   S8");
 653     if (caps & AFMT_U16_LE)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   U16_LE");
 654     if (caps & AFMT_U16_BE)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   U16_BE");
 655     if (caps & AFMT_MPEG)               GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   MPEG");
 656 #ifdef AFMT_AC3
 657     if (caps & AFMT_AC3)                GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   AC3");
 658 #endif
 659
 660     GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: opened audio (%s) with fd=%d", sink->device, sink->fd);
 661     GST_FLAG_SET (sink, GST_OSSSINK_OPEN);
 662
 663     return TRUE;
 664   }
 665
 666   return FALSE;
 667 }
 668
 669 static void
 670 gst_osssink_close_audio (GstOssSink *sink)
 671 {
 672   if (sink->fd < 0) return;
 673
 674   close(sink->fd);
 675   sink->fd = -1;
 676
 677   GST_FLAG_UNSET (sink, GST_OSSSINK_OPEN);
 678
 679   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: closed sound device");
 680 }
 681
 682 static GstElementStateReturn
 683 gst_osssink_change_state (GstElement *element)
 684 {
 685   GstOssSink *osssink;
 686
 687   g_return_val_if_fail (GST_IS_OSSSINK (element), FALSE);
 688
 689   osssink = GST_OSSSINK (element);
 690
 691   switch (GST_STATE_TRANSITION (element)) {
 692     case GST_STATE_NULL_TO_READY:
 693       if (!GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN)) {
 694         if (!gst_osssink_open_audio (osssink)) {
 695           return GST_STATE_FAILURE;
 696         }
 697       }
 698       break;
 699     case GST_STATE_READY_TO_PAUSED:
 700       osssink->offset = -1LL;
 701       break;
 702     case GST_STATE_PAUSED_TO_PLAYING:
 703       /* gst_clock_adjust (osssink->clock, osssink->offset - gst_clock_get_time (osssink->clock)); */
 704       break;
 705     case GST_STATE_PLAYING_TO_PAUSED:
 706     {
 707       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN)) {
 708         if (osssink->bps) {
 709           GstClockTime time;
 710           audio_buf_info ospace;
 711           gint queued;
 712
 713           ioctl (osssink->fd, SNDCTL_DSP_GETOSPACE, &ospace);
 714           ioctl (osssink->fd, SNDCTL_DSP_RESET, 0);
 715
 716           queued = (ospace.fragstotal * ospace.fragsize) - ospace.bytes;
 717           time = osssink->offset + (osssink->handled - queued) * 1000000LL / osssink->bps;
 718
 719           //gst_clock_adjust (osssink->clock, time - gst_clock_get_time (osssink->clock));
 720         }
 721         else {
 722           ioctl (osssink->fd, SNDCTL_DSP_RESET, 0);
 723         }
 724       }
 725
 726       break;
 727     }
 728     case GST_STATE_PAUSED_TO_READY:
 729       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN))
 730         ioctl (osssink->fd, SNDCTL_DSP_RESET, 0);
 731       break;
 732     case GST_STATE_READY_TO_NULL:
 733       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN))
 734         gst_osssink_close_audio (osssink);
 735       break;
 736   }
 737
 738   if (GST_ELEMENT_CLASS (parent_class)->change_state)
 739     return GST_ELEMENT_CLASS (parent_class)->change_state (element);
 740
 741   return GST_STATE_SUCCESS;
 742 }
 743
 744 gboolean
 745 gst_osssink_factory_init (GstPlugin *plugin)
 746 {
 747   GstElementFactory *factory;
 748
 749   factory = gst_element_factory_new ("osssink", GST_TYPE_OSSSINK, &gst_osssink_details);
 750   g_return_val_if_fail (factory != NULL, FALSE);
 751
 752   gst_element_factory_add_pad_template (factory, GST_PAD_TEMPLATE_GET (osssink_sink_factory));
 753
 754   gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
 755
 756   return TRUE;
 757 }
 758