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 #include <sys/ioctl.h>
  24 #include <sys/soundcard.h>
  25
  26 #include <gstosssink.h>
  27
  28 /* elementfactory information */
  29 static GstElementDetails gst_osssink_details = {
  30   "Audio Sink (OSS)",
  31   "Sink/Audio",
  32   "LGPL",
  33   "Output to a sound card via OSS",
  34   VERSION,
  35   "Erik Walthinsen <omega@cse.ogi.edu>, "
  36   "Wim Taymans <wim.taymans@chello.be>",
  37   "(C) 1999",
  38 };
  39
  40 static void                     gst_osssink_class_init          (GstOssSinkClass *klass);
  41 static void                     gst_osssink_init                (GstOssSink *osssink);
  42 static void                     gst_osssink_dispose             (GObject *object);
  43 static void                     gst_osssink_finalize            (GObject *object);
  44
  45 static GstElementStateReturn    gst_osssink_change_state        (GstElement *element);
  46 static void                     gst_osssink_set_clock           (GstElement *element, GstClock *clock);
  47 static GstClock*                gst_osssink_get_clock           (GstElement *element);
  48 static GstClockTime             gst_osssink_get_time            (GstClock *clock, gpointer data);
  49
  50 static const GstFormat*         gst_osssink_get_formats         (GstPad *pad);
  51 static gboolean                 gst_osssink_convert             (GstPad *pad, GstFormat src_format, gint64 src_value,
  52                                                                  GstFormat *dest_format, gint64 *dest_value);
  53 static const GstQueryType*      gst_osssink_get_query_types     (GstPad *pad);
  54 static gboolean                 gst_osssink_query               (GstElement *element, GstQueryType type,
  55                                                                  GstFormat *format, gint64 *value);
  56 static gboolean                 gst_osssink_sink_query          (GstPad *pad, GstQueryType type,
  57                                                                  GstFormat *format, gint64 *value);
  58
  59 static GstPadLinkReturn gst_osssink_sinkconnect         (GstPad *pad, GstCaps *caps);
  60
  61 static void                     gst_osssink_set_property        (GObject *object, guint prop_id, const GValue *value,
  62                                                                  GParamSpec *pspec);
  63 static void                     gst_osssink_get_property        (GObject *object, guint prop_id, GValue *value,
  64                                                                  GParamSpec *pspec);
  65
  66 static void                     gst_osssink_chain               (GstPad *pad,GstBuffer *buf);
  67
  68 /* OssSink signals and args */
  69 enum {
  70   SIGNAL_HANDOFF,
  71   LAST_SIGNAL
  72 };
  73
  74 enum {
  75   ARG_0,
  76   ARG_DEVICE,
  77   ARG_MUTE,
  78   ARG_FRAGMENT,
  79   ARG_BUFFER_SIZE,
  80   ARG_SYNC
  81   /* FILL ME */
  82 };
  83
  84 GST_PAD_TEMPLATE_FACTORY (osssink_sink_factory,
  85   "sink",
  86   GST_PAD_SINK,
  87   GST_PAD_ALWAYS,
  88   GST_CAPS_NEW (
  89     "osssink_sink",
  90     "audio/raw",
  91       "format",     GST_PROPS_STRING ("int"),   /* hack */
  92       "law",        GST_PROPS_INT (0),
  93       "endianness", GST_PROPS_INT (G_BYTE_ORDER),
  94       "signed",     GST_PROPS_LIST (
  95                       GST_PROPS_BOOLEAN (FALSE),
  96                       GST_PROPS_BOOLEAN (TRUE)
  97                     ),
  98       "width",      GST_PROPS_LIST (
  99                       GST_PROPS_INT (8),
 100                       GST_PROPS_INT (16)
 101                     ),
 102       "depth",      GST_PROPS_LIST (
 103                       GST_PROPS_INT (8),
 104                       GST_PROPS_INT (16)
 105                     ),
 106       "rate",       GST_PROPS_INT_RANGE (1000, 48000),
 107       "channels",   GST_PROPS_INT_RANGE (1, 2)
 108   )
 109 );
 110
 111 static GstElementClass *parent_class = NULL;
 112 static guint gst_osssink_signals[LAST_SIGNAL] = { 0 };
 113
 114 GType
 115 gst_osssink_get_type (void)
 116 {
 117   static GType osssink_type = 0;
 118
 119   if (!osssink_type) {
 120     static const GTypeInfo osssink_info = {
 121       sizeof(GstOssSinkClass),
 122       NULL,
 123       NULL,
 124       (GClassInitFunc)gst_osssink_class_init,
 125       NULL,
 126       NULL,
 127       sizeof(GstOssSink),
 128       0,
 129       (GInstanceInitFunc)gst_osssink_init,
 130     };
 131     osssink_type = g_type_register_static (GST_TYPE_ELEMENT, "GstOssSink", &osssink_info, 0);
 132   }
 133
 134   return osssink_type;
 135 }
 136
 137 static GstBufferPool*
 138 gst_osssink_get_bufferpool (GstPad *pad)
 139 {
 140   GstOssSink *oss;
 141
 142   oss = GST_OSSSINK (gst_pad_get_parent(pad));
 143
 144   /* 6 buffers per chunk by default */
 145   if (!oss->sinkpool)
 146     oss->sinkpool = gst_buffer_pool_get_default (oss->bufsize, 6);
 147
 148   return oss->sinkpool;
 149 }
 150
 151 static void
 152 gst_osssink_dispose (GObject *object)
 153 {
 154   GstOssSink *osssink = (GstOssSink *) object;
 155
 156   gst_object_unparent (GST_OBJECT (osssink->provided_clock));
 157
 158   G_OBJECT_CLASS (parent_class)->dispose (object);
 159 }
 160
 161 static void
 162 gst_osssink_finalize (GObject *object)
 163 {
 164   GstOssSink *osssink = (GstOssSink *) object;
 165
 166   g_free (osssink->common.device);
 167
 168   G_OBJECT_CLASS (parent_class)->finalize (object);
 169 }
 170
 171 static void
 172 gst_osssink_class_init (GstOssSinkClass *klass)
 173 {
 174   GObjectClass *gobject_class;
 175   GstElementClass *gstelement_class;
 176
 177   gobject_class = (GObjectClass*)klass;
 178   gstelement_class = (GstElementClass*)klass;
 179
 180   parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
 181
 182   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DEVICE,
 183     g_param_spec_string ("device", "Device", "The device to use for output",
 184                          "/dev/dsp", G_PARAM_READWRITE)); /* CHECKME! */
 185   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MUTE,
 186     g_param_spec_boolean ("mute", "Mute", "Mute the audio",
 187                           TRUE, G_PARAM_READWRITE));
 188   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SYNC,
 189     g_param_spec_boolean ("sync", "Sync", "If syncing on timestamps should be enabled",
 190                           TRUE, G_PARAM_READWRITE));
 191   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FRAGMENT,
 192     g_param_spec_int ("fragment", "Fragment",
 193                       "The fragment as 0xMMMMSSSS (MMMM = total fragments, 2^SSSS = fragment size)",
 194                       0, G_MAXINT, 6, G_PARAM_READWRITE));
 195   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BUFFER_SIZE,
 196     g_param_spec_int ("buffer_size", "Buffer size", "The buffer size",
 197                       0, G_MAXINT, 4096, G_PARAM_READWRITE));
 198
 199   gst_osssink_signals[SIGNAL_HANDOFF] =
 200     g_signal_new ("handoff", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 201                   G_STRUCT_OFFSET (GstOssSinkClass, handoff), NULL, NULL,
 202                   g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 203
 204   gobject_class->set_property = gst_osssink_set_property;
 205   gobject_class->get_property = gst_osssink_get_property;
 206   gobject_class->dispose      = gst_osssink_dispose;
 207   gobject_class->finalize     = gst_osssink_finalize;
 208
 209   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_osssink_change_state);
 210   gstelement_class->query        = GST_DEBUG_FUNCPTR (gst_osssink_query);
 211   gstelement_class->set_clock    = gst_osssink_set_clock;
 212   gstelement_class->get_clock    = gst_osssink_get_clock;
 213
 214 }
 215
 216 static void
 217 gst_osssink_init (GstOssSink *osssink)
 218 {
 219   osssink->sinkpad = gst_pad_new_from_template (
 220                   GST_PAD_TEMPLATE_GET (osssink_sink_factory), "sink");
 221   gst_element_add_pad (GST_ELEMENT (osssink), osssink->sinkpad);
 222   gst_pad_set_link_function (osssink->sinkpad, gst_osssink_sinkconnect);
 223   gst_pad_set_bufferpool_function (osssink->sinkpad, gst_osssink_get_bufferpool);
 224   gst_pad_set_convert_function (osssink->sinkpad, gst_osssink_convert);
 225   gst_pad_set_query_function (osssink->sinkpad, gst_osssink_sink_query);
 226   gst_pad_set_query_type_function (osssink->sinkpad, gst_osssink_get_query_types);
 227   gst_pad_set_formats_function (osssink->sinkpad, gst_osssink_get_formats);
 228
 229   gst_pad_set_chain_function (osssink->sinkpad, gst_osssink_chain);
 230
 231   gst_osscommon_init (&osssink->common);
 232
 233   osssink->bufsize = 4096;
 234   osssink->resync = FALSE;
 235   osssink->sync = TRUE;
 236   osssink->sinkpool = NULL;
 237   osssink->provided_clock = GST_CLOCK (gst_oss_clock_new ("ossclock", gst_osssink_get_time, osssink));
 238   gst_object_set_parent (GST_OBJECT (osssink->provided_clock), GST_OBJECT (osssink));
 239   osssink->handled = 0;
 240
 241   GST_FLAG_SET (osssink, GST_ELEMENT_THREAD_SUGGESTED);
 242   GST_FLAG_SET (osssink, GST_ELEMENT_EVENT_AWARE);
 243 }
 244
 245
 246 static GstPadLinkReturn
 247 gst_osssink_sinkconnect (GstPad *pad, GstCaps *caps)
 248 {
 249   GstOssSink *osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 250
 251   if (!GST_CAPS_IS_FIXED (caps))
 252     return GST_PAD_LINK_DELAYED;
 253
 254   if (!gst_osscommon_parse_caps (&osssink->common, caps))
 255     return GST_PAD_LINK_REFUSED;
 256
 257   if (!gst_osscommon_sync_parms (&osssink->common)) {
 258     return GST_PAD_LINK_REFUSED;
 259   }
 260
 261   return GST_PAD_LINK_OK;
 262 }
 263
 264 static inline gint64
 265 gst_osssink_get_delay (GstOssSink *osssink)
 266 {
 267   gint delay = 0;
 268
 269   if (osssink->common.fd == -1)
 270     return 0;
 271
 272   if (ioctl (osssink->common.fd, SNDCTL_DSP_GETODELAY, &delay) < 0) {
 273     audio_buf_info info;
 274     if (ioctl (osssink->common.fd, SNDCTL_DSP_GETOSPACE, &info) < 0) {
 275       delay = 0;
 276     }
 277     else {
 278       delay = (info.fragstotal * info.fragsize) - info.bytes;
 279     }
 280   }
 281   return delay;
 282 }
 283
 284 static GstClockTime
 285 gst_osssink_get_time (GstClock *clock, gpointer data)
 286 {
 287   GstOssSink *osssink = GST_OSSSINK (data);
 288   gint delay;
 289   GstClockTime res;
 290
 291   if (!osssink->common.bps)
 292     return 0;
 293
 294   delay = gst_osssink_get_delay (osssink);
 295
 296   /* sometimes delay is bigger than the number of bytes sent to the device,
 297    * which screws up this calculation, we assume that everything is still
 298    * in the device then */
 299   if (((guint64)delay) > osssink->handled) {
 300     delay = osssink->handled;
 301   }
 302   res =  (osssink->handled - delay) * GST_SECOND / osssink->common.bps;
 303
 304   return res;
 305 }
 306
 307 static GstClock*
 308 gst_osssink_get_clock (GstElement *element)
 309 {
 310   GstOssSink *osssink;
 311
 312   osssink = GST_OSSSINK (element);
 313
 314   return GST_CLOCK (osssink->provided_clock);
 315 }
 316
 317 static void
 318 gst_osssink_set_clock (GstElement *element, GstClock *clock)
 319 {
 320   GstOssSink *osssink;
 321
 322   osssink = GST_OSSSINK (element);
 323
 324   osssink->clock = clock;
 325 }
 326
 327 static void
 328 gst_osssink_chain (GstPad *pad, GstBuffer *buf)
 329 {
 330   GstOssSink *osssink;
 331   GstClockTime buftime;
 332
 333   /* this has to be an audio buffer */
 334   osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 335
 336   if (GST_IS_EVENT (buf)) {
 337     GstEvent *event = GST_EVENT (buf);
 338
 339     switch (GST_EVENT_TYPE (event)) {
 340       case GST_EVENT_EOS:
 341         ioctl (osssink->common.fd, SNDCTL_DSP_SYNC);
 342         gst_oss_clock_set_active (osssink->provided_clock, FALSE);
 343         gst_pad_event_default (pad, event);
 344         return;
 345       case GST_EVENT_NEW_MEDIA:
 346         g_print ("new media\n");
 347         break;
 348       case GST_EVENT_DISCONTINUOUS:
 349       {
 350         gint64 value;
 351
 352         ioctl (osssink->common.fd, SNDCTL_DSP_RESET);
 353         if (gst_event_discont_get_value (event, GST_FORMAT_TIME, &value)) {
 354           if (!gst_clock_handle_discont (osssink->clock, value))
 355             gst_oss_clock_set_active (osssink->provided_clock, FALSE);
 356           osssink->handled = 0;
 357         }
 358         osssink->resync = TRUE;
 359         break;
 360       }
 361       default:
 362         gst_pad_event_default (pad, event);
 363         return;
 364     }
 365     gst_event_unref (event);
 366     return;
 367   }
 368
 369   if (!osssink->common.bps) {
 370     gst_buffer_unref (buf);
 371     gst_element_error (GST_ELEMENT (osssink), "capsnego was never performed, unknown data type");
 372     return;
 373   }
 374
 375   buftime = GST_BUFFER_TIMESTAMP (buf);
 376
 377   if (osssink->common.fd >= 0) {
 378     if (!osssink->mute) {
 379       guchar *data = GST_BUFFER_DATA (buf);
 380       gint size = GST_BUFFER_SIZE (buf);
 381
 382       if (osssink->clock) {
 383         gint delay = 0;
 384         gint64 queued;
 385         GstClockTimeDiff jitter;
 386
 387         delay = gst_osssink_get_delay (osssink);
 388         queued = delay * GST_SECOND / osssink->common.bps;
 389
 390         if  (osssink->resync && osssink->sync) {
 391           GstClockID id = gst_clock_new_single_shot_id (osssink->clock, buftime - queued);
 392
 393           gst_element_clock_wait (GST_ELEMENT (osssink), id, &jitter);
 394           gst_clock_id_free (id);
 395
 396           if (jitter >= 0) {
 397             gst_clock_handle_discont (osssink->clock, buftime - queued + jitter);
 398             write (osssink->common.fd, data, size);
 399             gst_oss_clock_set_active (osssink->provided_clock, TRUE);
 400             osssink->resync = FALSE;
 401             osssink->handled += size;
 402           }
 403         }
 404         else {
 405           write (osssink->common.fd, data, size);
 406           osssink->handled += size;
 407         }
 408       }
 409       /* no clock, try to be as fast as possible */
 410       else {
 411         audio_buf_info ospace;
 412
 413         ioctl (osssink->common.fd, SNDCTL_DSP_GETOSPACE, &ospace);
 414
 415         if (ospace.bytes >= size) {
 416           write (osssink->common.fd, data, size);
 417         }
 418       }
 419     }
 420   }
 421   gst_buffer_unref (buf);
 422 }
 423
 424 static const GstFormat*
 425 gst_osssink_get_formats (GstPad *pad)
 426 {
 427   static const GstFormat formats[] = {
 428     GST_FORMAT_TIME,
 429     GST_FORMAT_UNITS,
 430     GST_FORMAT_BYTES,
 431     0
 432   };
 433   return formats;
 434 }
 435
 436 static gboolean
 437 gst_osssink_convert (GstPad *pad, GstFormat src_format, gint64 src_value,
 438                      GstFormat *dest_format, gint64 *dest_value)
 439 {
 440   GstOssSink *osssink;
 441
 442   osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 443
 444   return gst_osscommon_convert (&osssink->common, src_format, src_value,
 445                                 dest_format, dest_value);
 446 }
 447
 448 static const GstQueryType*
 449 gst_osssink_get_query_types (GstPad *pad)
 450 {
 451   static const GstQueryType query_types[] = {
 452     GST_QUERY_LATENCY,
 453     GST_QUERY_POSITION,
 454     0,
 455   };
 456   return query_types;
 457 }
 458
 459 static gboolean
 460 gst_osssink_sink_query (GstPad *pad, GstQueryType type, GstFormat *format, gint64 *value)
 461 {
 462   gboolean res = TRUE;
 463   GstOssSink *osssink;
 464
 465   osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 466
 467   switch (type) {
 468     case GST_QUERY_LATENCY:
 469       if (!gst_osssink_convert (pad,
 470                                 GST_FORMAT_BYTES, gst_osssink_get_delay (osssink),
 471                                 format, value))
 472       {
 473         res = FALSE;
 474       }
 475       break;
 476     case GST_QUERY_POSITION:
 477       if (!gst_osssink_convert (pad,
 478                                 GST_FORMAT_TIME, gst_clock_get_time (osssink->provided_clock),
 479                                 format, value))
 480       {
 481         res = FALSE;
 482       }
 483       break;
 484     default:
 485       res = gst_pad_query (gst_pad_get_peer (osssink->sinkpad), type, format, value);
 486       break;
 487   }
 488
 489   return res;
 490 }
 491
 492 static gboolean
 493 gst_osssink_query (GstElement *element, GstQueryType type, GstFormat *format, gint64 *value)
 494 {
 495   GstOssSink *osssink = GST_OSSSINK (element);
 496
 497   return gst_osssink_sink_query (osssink->sinkpad, type, format, value);
 498 }
 499
 500 static void
 501 gst_osssink_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 502 {
 503   GstOssSink *osssink;
 504
 505   osssink = GST_OSSSINK (object);
 506
 507   switch (prop_id) {
 508     case ARG_DEVICE:
 509       /* disallow changing the device while it is opened
 510          get_property("device") should return the right one */
 511       if (!GST_FLAG_IS_SET (osssink, GST_OSSSINK_OPEN))
 512       {
 513         g_free (osssink->common.device);
 514         osssink->common.device = g_strdup (g_value_get_string (value));
 515         g_object_notify (object, "device");
 516       }
 517       break;
 518     case ARG_MUTE:
 519       osssink->mute = g_value_get_boolean (value);
 520       g_object_notify (G_OBJECT (osssink), "mute");
 521       break;
 522     case ARG_FRAGMENT:
 523       osssink->common.fragment = g_value_get_int (value);
 524       gst_osscommon_sync_parms (&osssink->common);
 525       break;
 526     case ARG_BUFFER_SIZE:
 527       if (osssink->bufsize == g_value_get_int (value)) break;
 528       osssink->bufsize = g_value_get_int (value);
 529       osssink->sinkpool = gst_buffer_pool_get_default (osssink->bufsize, 6);
 530       g_object_notify (object, "buffer_size");
 531       break;
 532     case ARG_SYNC:
 533       osssink->sync = g_value_get_boolean (value);
 534       g_object_notify (G_OBJECT (osssink), "sync");
 535       break;
 536     default:
 537       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 538       break;
 539   }
 540 }
 541
 542 static void
 543 gst_osssink_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 544 {
 545   GstOssSink *osssink;
 546
 547   osssink = GST_OSSSINK (object);
 548
 549   switch (prop_id) {
 550     case ARG_DEVICE:
 551       g_value_set_string (value, osssink->common.device);
 552       break;
 553     case ARG_MUTE:
 554       g_value_set_boolean (value, osssink->mute);
 555       break;
 556     case ARG_FRAGMENT:
 557       g_value_set_int (value, osssink->common.fragment);
 558       break;
 559     case ARG_BUFFER_SIZE:
 560       g_value_set_int (value, osssink->bufsize);
 561       break;
 562     case ARG_SYNC:
 563       g_value_set_boolean (value, osssink->sync);
 564       break;
 565     default:
 566       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 567       break;
 568   }
 569 }
 570
 571 static GstElementStateReturn
 572 gst_osssink_change_state (GstElement *element)
 573 {
 574   GstOssSink *osssink;
 575
 576   osssink = GST_OSSSINK (element);
 577
 578   switch (GST_STATE_TRANSITION (element)) {
 579     case GST_STATE_NULL_TO_READY:
 580       if (!GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN)) {
 581         gchar *error;
 582
 583         if (!gst_osscommon_open_audio (&osssink->common, GST_OSSCOMMON_WRITE, &error)) {
 584           gst_element_error (GST_ELEMENT (osssink), error);
 585           g_free (error);
 586           return GST_STATE_FAILURE;
 587         }
 588         GST_FLAG_SET (element, GST_OSSSINK_OPEN);
 589       }
 590       break;
 591     case GST_STATE_READY_TO_PAUSED:
 592       break;
 593     case GST_STATE_PAUSED_TO_PLAYING:
 594       osssink->resync = TRUE;
 595       break;
 596     case GST_STATE_PLAYING_TO_PAUSED:
 597     {
 598       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN))
 599         ioctl (osssink->common.fd, SNDCTL_DSP_RESET, 0);
 600       gst_oss_clock_set_active (osssink->provided_clock, FALSE);
 601       osssink->resync = TRUE;
 602       break;
 603     }
 604     case GST_STATE_PAUSED_TO_READY:
 605       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN))
 606         ioctl (osssink->common.fd, SNDCTL_DSP_RESET, 0);
 607       gst_osscommon_reset (&osssink->common);
 608       break;
 609     case GST_STATE_READY_TO_NULL:
 610       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN)) {
 611         gst_osscommon_close_audio (&osssink->common);
 612         GST_FLAG_UNSET (osssink, GST_OSSSINK_OPEN);
 613
 614         GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: closed sound device");
 615       }
 616       break;
 617   }
 618
 619   if (GST_ELEMENT_CLASS (parent_class)->change_state)
 620     return GST_ELEMENT_CLASS (parent_class)->change_state (element);
 621
 622   return GST_STATE_SUCCESS;
 623 }
 624
 625 gboolean
 626 gst_osssink_factory_init (GstPlugin *plugin)
 627 {
 628   GstElementFactory *factory;
 629
 630   factory = gst_element_factory_new ("osssink", GST_TYPE_OSSSINK, &gst_osssink_details);
 631   g_return_val_if_fail (factory != NULL, FALSE);
 632
 633   gst_element_factory_add_pad_template (factory, GST_PAD_TEMPLATE_GET (osssink_sink_factory));
 634
 635   gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
 636
 637   return TRUE;
 638 }