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