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