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