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