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