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