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 NULL;
 466   return GST_CLOCK (osssink->provided_clock);
 467 }
 468
 469 static void
 470 gst_osssink_set_clock (GstElement *element, GstClock *clock)
 471 {
 472   GstOssSink *osssink;
 473
 474   osssink = GST_OSSSINK (element);
 475
 476   osssink->clock = clock;
 477 }
 478
 479 static void
 480 gst_osssink_chain (GstPad *pad, GstBuffer *buf)
 481 {
 482   GstOssSink *osssink;
 483   GstClockTime buftime;
 484
 485   /* this has to be an audio buffer */
 486   osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 487
 488   if (GST_IS_EVENT (buf)) {
 489     GstEvent *event = GST_EVENT (buf);
 490
 491     switch (GST_EVENT_TYPE (event)) {
 492       case GST_EVENT_EOS:
 493         ioctl (osssink->fd, SNDCTL_DSP_SYNC);
 494         gst_oss_clock_set_active (osssink->provided_clock, FALSE);
 495         gst_pad_event_default (pad, event);
 496         return;
 497       case GST_EVENT_NEW_MEDIA:
 498         g_print ("new media\n");
 499         return;
 500       case GST_EVENT_DISCONTINUOUS:
 501       {
 502         gint64 value;
 503
 504         ioctl (osssink->fd, SNDCTL_DSP_RESET);
 505         if (gst_event_discont_get_value (event, GST_FORMAT_TIME, &value)) {
 506           if (!gst_clock_handle_discont (osssink->clock, value))
 507             gst_oss_clock_set_active (osssink->provided_clock, FALSE);
 508           osssink->handled = 0;
 509         }
 510         osssink->resync = TRUE;
 511         return;
 512       }
 513       default:
 514         gst_pad_event_default (pad, event);
 515         return;
 516     }
 517     gst_event_free (event);
 518   }
 519
 520   if (!osssink->bps) {
 521     gst_buffer_unref (buf);
 522     gst_element_error (GST_ELEMENT (osssink), "capsnego was never performed, unknown data type");
 523     return;
 524   }
 525
 526   buftime = GST_BUFFER_TIMESTAMP (buf);
 527
 528   if (osssink->fd >= 0) {
 529     if (!osssink->mute) {
 530       guchar *data = GST_BUFFER_DATA (buf);
 531       gint size = GST_BUFFER_SIZE (buf);
 532
 533       if (osssink->clock) {
 534         gint delay = 0;
 535         gint64 queued;
 536         GstClockTimeDiff jitter;
 537
 538         delay = gst_osssink_get_delay (osssink);
 539         queued = delay * GST_SECOND / osssink->bps;
 540
 541         if  (osssink->resync && osssink->sync) {
 542           gst_element_clock_wait (GST_ELEMENT (osssink), osssink->clock,
 543                                 buftime - queued, &jitter);
 544
 545           if (jitter > 0) {
 546             gst_clock_handle_discont (osssink->clock, buftime - queued + jitter);
 547             write (osssink->fd, data, size);
 548             gst_oss_clock_set_active (osssink->provided_clock, TRUE);
 549             osssink->resync = FALSE;
 550             osssink->handled += size;
 551           }
 552         }
 553         else {
 554           write (osssink->fd, data, size);
 555           osssink->handled += size;
 556         }
 557       }
 558       /* no clock, try to be as fast as possible */
 559       else {
 560         audio_buf_info ospace;
 561
 562         ioctl (osssink->fd, SNDCTL_DSP_GETOSPACE, &ospace);
 563
 564         if (ospace.bytes >= size) {
 565           write (osssink->fd, data, size);
 566         }
 567       }
 568     }
 569   }
 570   gst_buffer_unref (buf);
 571 }
 572
 573 static gboolean
 574 gst_osssink_convert (GstPad *pad, GstFormat src_format, gint64 src_value,
 575                      GstFormat *dest_format, gint64 *dest_value)
 576 {
 577   gboolean res = TRUE;
 578
 579   GstOssSink *osssink;
 580
 581   if (src_format == *dest_format) {
 582     *dest_value = src_value;
 583     return TRUE;
 584   }
 585
 586   osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 587
 588   if (osssink->bps == 0 || osssink->channels == 0 || osssink->width == 0)
 589     return FALSE;
 590
 591   switch (src_format) {
 592     case GST_FORMAT_BYTES:
 593       switch (*dest_format) {
 594         case GST_FORMAT_DEFAULT:
 595           *dest_format = GST_FORMAT_TIME;
 596         case GST_FORMAT_TIME:
 597           *dest_value = src_value * GST_SECOND / osssink->bps;
 598           break;
 599         case GST_FORMAT_UNIT:
 600           *dest_value = src_value / (osssink->channels * osssink->width);
 601           break;
 602         default:
 603           res = FALSE;
 604       }
 605       break;
 606     case GST_FORMAT_TIME:
 607       switch (*dest_format) {
 608         case GST_FORMAT_DEFAULT:
 609           *dest_format = GST_FORMAT_BYTES;
 610         case GST_FORMAT_BYTES:
 611           *dest_value = src_value * osssink->bps / GST_SECOND;
 612           break;
 613         case GST_FORMAT_UNIT:
 614           *dest_value = osssink->frequency;
 615           break;
 616         default:
 617           res = FALSE;
 618       }
 619       break;
 620     case GST_FORMAT_UNIT:
 621       switch (*dest_format) {
 622         case GST_FORMAT_DEFAULT:
 623           *dest_format = GST_FORMAT_TIME;
 624         case GST_FORMAT_TIME:
 625           *dest_value = src_value * GST_SECOND / osssink->frequency;
 626           break;
 627         case GST_FORMAT_BYTES:
 628           *dest_value = src_value * osssink->channels * osssink->width;
 629           break;
 630         default:
 631           res = FALSE;
 632       }
 633       break;
 634     default:
 635       res = FALSE;
 636   }
 637
 638   return res;
 639 }
 640
 641 static gboolean
 642 gst_osssink_query (GstPad *pad, GstPadQueryType type, GstFormat *format, gint64 *value)
 643 {
 644   gboolean res = TRUE;
 645   GstOssSink *osssink;
 646
 647   osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 648
 649   switch (type) {
 650     case GST_PAD_QUERY_LATENCY:
 651       if (!gst_osssink_convert (pad,
 652                                 GST_FORMAT_BYTES, gst_osssink_get_delay (osssink),
 653                                 format, value))
 654       {
 655         res = FALSE;
 656       }
 657       break;
 658     default:
 659       res = FALSE;
 660       break;
 661   }
 662
 663   return res;
 664 }
 665
 666 static void
 667 gst_osssink_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 668 {
 669   GstOssSink *osssink;
 670
 671   /* it's not null if we got it, but it might not be ours */
 672   g_return_if_fail (GST_IS_OSSSINK (object));
 673
 674   osssink = GST_OSSSINK (object);
 675
 676   switch (prop_id) {
 677     case ARG_DEVICE:
 678       /* disallow changing the device while it is opened
 679          get_property("device") should return the right one */
 680       if (!GST_FLAG_IS_SET (osssink, GST_OSSSINK_OPEN))
 681       {
 682         g_free (osssink->device);
 683         osssink->device = g_strdup (g_value_get_string (value));
 684         g_object_notify (object, "device");
 685       }
 686       break;
 687     case ARG_MUTE:
 688       osssink->mute = g_value_get_boolean (value);
 689       g_object_notify (G_OBJECT (osssink), "mute");
 690       break;
 691     case ARG_FORMAT:
 692       osssink->format = g_value_get_int (value);
 693       gst_osssink_sync_parms (osssink);
 694       break;
 695     case ARG_CHANNELS:
 696       osssink->channels = g_value_get_enum (value);
 697       gst_osssink_sync_parms (osssink);
 698       break;
 699     case ARG_FREQUENCY:
 700       osssink->frequency = g_value_get_int (value);
 701       gst_osssink_sync_parms (osssink);
 702       break;
 703     case ARG_FRAGMENT:
 704       osssink->fragment = g_value_get_int (value);
 705       gst_osssink_sync_parms (osssink);
 706       break;
 707     case ARG_BUFFER_SIZE:
 708       if (osssink->bufsize == g_value_get_int (value)) break;
 709       osssink->bufsize = g_value_get_int (value);
 710       osssink->sinkpool = gst_buffer_pool_get_default (osssink->bufsize, 6);
 711       g_object_notify (object, "buffer_size");
 712       break;
 713     case ARG_SYNC:
 714       osssink->sync = g_value_get_boolean (value);
 715       g_object_notify (G_OBJECT (osssink), "sync");
 716     default:
 717       break;
 718   }
 719 }
 720
 721 static void
 722 gst_osssink_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 723 {
 724   GstOssSink *osssink;
 725
 726   /* it's not null if we got it, but it might not be ours */
 727   g_return_if_fail (GST_IS_OSSSINK (object));
 728
 729   osssink = GST_OSSSINK (object);
 730
 731   switch (prop_id) {
 732     case ARG_DEVICE:
 733       g_value_set_string (value, osssink->device);
 734       break;
 735     case ARG_MUTE:
 736       g_value_set_boolean (value, osssink->mute);
 737       break;
 738     case ARG_FORMAT:
 739       g_value_set_int (value, osssink->format);
 740       break;
 741     case ARG_CHANNELS:
 742       g_value_set_enum (value, osssink->channels);
 743       break;
 744     case ARG_FREQUENCY:
 745       g_value_set_int (value, osssink->frequency);
 746       break;
 747     case ARG_FRAGMENT:
 748       g_value_set_int (value, osssink->fragment);
 749       break;
 750     case ARG_BUFFER_SIZE:
 751       g_value_set_int (value, osssink->bufsize);
 752       break;
 753     case ARG_SYNC:
 754       g_value_set_boolean (value, osssink->sync);
 755       break;
 756     default:
 757       break;
 758   }
 759 }
 760
 761 static gboolean
 762 gst_osssink_open_audio (GstOssSink *sink)
 763 {
 764   gint caps;
 765   g_return_val_if_fail (sink->fd == -1, FALSE);
 766
 767   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: attempting to open sound device");
 768
 769   /* first try to open the sound card */
 770   sink->fd = open(sink->device, O_WRONLY | O_NONBLOCK);
 771   if (errno == EBUSY) {
 772     g_warning ("osssink: unable to open the sound device (in use ?)\n");
 773     return FALSE;
 774   }
 775
 776   /* re-open the sound device in blocking mode */
 777   close(sink->fd);
 778   sink->fd = open(sink->device, O_WRONLY);
 779
 780   /* if we have it, set the default parameters and go have fun */
 781   if (sink->fd >= 0) {
 782     /* set card state */
 783     ioctl(sink->fd, SNDCTL_DSP_GETCAPS, &caps);
 784
 785     GST_INFO(GST_CAT_PLUGIN_INFO, "osssink: Capabilities %08x", caps);
 786
 787     if (caps & DSP_CAP_DUPLEX)          GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Full duplex");
 788     if (caps & DSP_CAP_REALTIME)        GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Realtime");
 789     if (caps & DSP_CAP_BATCH)           GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Batch");
 790     if (caps & DSP_CAP_COPROC)          GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Has coprocessor");
 791     if (caps & DSP_CAP_TRIGGER)         GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Trigger");
 792     if (caps & DSP_CAP_MMAP)            GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Direct access");
 793
 794 #ifdef DSP_CAP_MULTI
 795     if (caps & DSP_CAP_MULTI)           GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Multiple open");
 796 #endif /* DSP_CAP_MULTI */
 797
 798 #ifdef DSP_CAP_BIND
 799     if (caps & DSP_CAP_BIND)            GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Channel binding");
 800 #endif /* DSP_CAP_BIND */
 801
 802     ioctl(sink->fd, SNDCTL_DSP_GETFMTS, &caps);
 803
 804     GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: Formats %08x", caps);
 805     if (caps & AFMT_MU_LAW)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   MU_LAW");
 806     if (caps & AFMT_A_LAW)              GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   A_LAW");
 807     if (caps & AFMT_IMA_ADPCM)          GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   IMA_ADPCM");
 808     if (caps & AFMT_U8)                 GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   U8");
 809     if (caps & AFMT_S16_LE)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   S16_LE");
 810     if (caps & AFMT_S16_BE)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   S16_BE");
 811     if (caps & AFMT_S8)                 GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   S8");
 812     if (caps & AFMT_U16_LE)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   U16_LE");
 813     if (caps & AFMT_U16_BE)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   U16_BE");
 814     if (caps & AFMT_MPEG)               GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   MPEG");
 815 #ifdef AFMT_AC3
 816     if (caps & AFMT_AC3)                GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   AC3");
 817 #endif
 818
 819     GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: opened audio (%s) with fd=%d", sink->device, sink->fd);
 820     GST_FLAG_SET (sink, GST_OSSSINK_OPEN);
 821
 822     return TRUE;
 823   }
 824
 825   return FALSE;
 826 }
 827
 828 static void
 829 gst_osssink_close_audio (GstOssSink *sink)
 830 {
 831   if (sink->fd < 0) return;
 832
 833   close(sink->fd);
 834   sink->fd = -1;
 835
 836   GST_FLAG_UNSET (sink, GST_OSSSINK_OPEN);
 837
 838   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: closed sound device");
 839 }
 840
 841 static GstElementStateReturn
 842 gst_osssink_change_state (GstElement *element)
 843 {
 844   GstOssSink *osssink;
 845
 846   g_return_val_if_fail (GST_IS_OSSSINK (element), FALSE);
 847
 848   osssink = GST_OSSSINK (element);
 849
 850   switch (GST_STATE_TRANSITION (element)) {
 851     case GST_STATE_NULL_TO_READY:
 852       if (!GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN)) {
 853         if (!gst_osssink_open_audio (osssink)) {
 854           return GST_STATE_FAILURE;
 855         }
 856       }
 857       break;
 858     case GST_STATE_READY_TO_PAUSED:
 859     case GST_STATE_PAUSED_TO_PLAYING:
 860       osssink->resync = TRUE;
 861       break;
 862     case GST_STATE_PLAYING_TO_PAUSED:
 863     {
 864       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN))
 865         ioctl (osssink->fd, SNDCTL_DSP_RESET, 0);
 866       gst_oss_clock_set_active (osssink->provided_clock, FALSE);
 867       osssink->resync = TRUE;
 868       break;
 869     }
 870     case GST_STATE_PAUSED_TO_READY:
 871       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN))
 872         ioctl (osssink->fd, SNDCTL_DSP_RESET, 0);
 873       break;
 874     case GST_STATE_READY_TO_NULL:
 875       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN))
 876         gst_osssink_close_audio (osssink);
 877       break;
 878   }
 879
 880   if (GST_ELEMENT_CLASS (parent_class)->change_state)
 881     return GST_ELEMENT_CLASS (parent_class)->change_state (element);
 882
 883   return GST_STATE_SUCCESS;
 884 }
 885
 886 gboolean
 887 gst_osssink_factory_init (GstPlugin *plugin)
 888 {
 889   GstElementFactory *factory;
 890
 891   factory = gst_element_factory_new ("osssink", GST_TYPE_OSSSINK, &gst_osssink_details);
 892   g_return_val_if_fail (factory != NULL, FALSE);
 893
 894   gst_element_factory_add_pad_template (factory, GST_PAD_TEMPLATE_GET (osssink_sink_factory));
 895
 896   gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
 897
 898   return TRUE;
 899 }
 900