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