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 static GstElementDetails gst_osssink_details = {
  35   "Audio Sink (OSS)",
  36   "Sink/Audio",
  37   "Output to a sound card via OSS",
  38   VERSION,
  39   "Erik Walthinsen <omega@cse.ogi.edu>, "
  40   "Wim Taymans <wim.taymans@chello.be>",
  41   "(C) 1999",
  42 };
  43
  44 static void                     gst_osssink_class_init          (GstOssSinkClass *klass);
  45 static void                     gst_osssink_init                (GstOssSink *osssink);
  46 static void                     gst_osssink_finalize            (GObject *object);
  47
  48 static gboolean                 gst_osssink_open_audio          (GstOssSink *sink);
  49 static void                     gst_osssink_close_audio         (GstOssSink *sink);
  50 static gboolean                 gst_osssink_sync_parms          (GstOssSink *osssink);
  51 static GstElementStateReturn    gst_osssink_change_state        (GstElement *element);
  52 static void                     gst_osssink_set_clock           (GstElement *element, GstClock *clock);
  53 static GstClock*                gst_osssink_get_clock           (GstElement *element);
  54
  55 static GstPadConnectReturn      gst_osssink_sinkconnect         (GstPad *pad, GstCaps *caps);
  56
  57 static void                     gst_osssink_set_property        (GObject *object, guint prop_id, const GValue *value,
  58                                                                  GParamSpec *pspec);
  59 static void                     gst_osssink_get_property        (GObject *object, guint prop_id, GValue *value,
  60                                                                  GParamSpec *pspec);
  61
  62 static void                     gst_osssink_chain               (GstPad *pad,GstBuffer *buf);
  63
  64 /* OssSink signals and args */
  65 enum {
  66   SIGNAL_HANDOFF,
  67   LAST_SIGNAL
  68 };
  69
  70 enum {
  71   ARG_0,
  72   ARG_DEVICE,
  73   ARG_MUTE,
  74   ARG_FORMAT,
  75   ARG_CHANNELS,
  76   ARG_FREQUENCY,
  77   ARG_FRAGMENT,
  78   ARG_BUFFER_SIZE
  79   /* FILL ME */
  80 };
  81
  82 GST_PAD_TEMPLATE_FACTORY (osssink_sink_factory,
  83   "sink",
  84   GST_PAD_SINK,
  85   GST_PAD_ALWAYS,
  86   GST_CAPS_NEW (
  87     "osssink_sink",
  88     "audio/raw",
  89       "format",     GST_PROPS_STRING ("int"),   /* hack */
  90       "law",        GST_PROPS_INT (0),
  91       "endianness", GST_PROPS_INT (G_BYTE_ORDER),
  92       "signed",     GST_PROPS_LIST (
  93                       GST_PROPS_BOOLEAN (FALSE),
  94                       GST_PROPS_BOOLEAN (TRUE)
  95                     ),
  96       "width",      GST_PROPS_LIST (
  97                       GST_PROPS_INT (8),
  98                       GST_PROPS_INT (16)
  99                     ),
 100       "depth",      GST_PROPS_LIST (
 101                       GST_PROPS_INT (8),
 102                       GST_PROPS_INT (16)
 103                     ),
 104       "rate",       GST_PROPS_INT_RANGE (1000, 48000),
 105       "channels",   GST_PROPS_INT_RANGE (1, 2)
 106   )
 107 );
 108
 109 #define GST_TYPE_OSSSINK_CHANNELS (gst_osssink_channels_get_type())
 110 static GType
 111 gst_osssink_channels_get_type(void) {
 112   static GType osssink_channels_type = 0;
 113   static GEnumValue osssink_channels[] = {
 114     {0, "0", "Silence"},
 115     {1, "1", "Mono"},
 116     {2, "2", "Stereo"},
 117     {0, NULL, NULL},
 118   };
 119   if (!osssink_channels_type) {
 120     osssink_channels_type = g_enum_register_static("GstAudiosinkChannels", osssink_channels);
 121   }
 122   return osssink_channels_type;
 123 }
 124
 125
 126 static GstElementClass *parent_class = NULL;
 127 static guint gst_osssink_signals[LAST_SIGNAL] = { 0 };
 128
 129 GType
 130 gst_osssink_get_type (void)
 131 {
 132   static GType osssink_type = 0;
 133
 134   if (!osssink_type) {
 135     static const GTypeInfo osssink_info = {
 136       sizeof(GstOssSinkClass),
 137       NULL,
 138       NULL,
 139       (GClassInitFunc)gst_osssink_class_init,
 140       NULL,
 141       NULL,
 142       sizeof(GstOssSink),
 143       0,
 144       (GInstanceInitFunc)gst_osssink_init,
 145     };
 146     osssink_type = g_type_register_static (GST_TYPE_ELEMENT, "GstOssSink", &osssink_info, 0);
 147   }
 148
 149   return osssink_type;
 150 }
 151
 152 static GstBufferPool*
 153 gst_osssink_get_bufferpool (GstPad *pad)
 154 {
 155   GstOssSink *oss;
 156
 157   oss = GST_OSSSINK (gst_pad_get_parent(pad));
 158
 159   return oss->sinkpool;
 160 }
 161
 162 static void
 163 gst_osssink_finalize (GObject *object)
 164 {
 165   GstOssSink *osssink = (GstOssSink *) object;
 166
 167   g_free (osssink->device);
 168
 169   G_OBJECT_CLASS (parent_class)->finalize (object);
 170 }
 171
 172 static void
 173 gst_osssink_class_init (GstOssSinkClass *klass)
 174 {
 175   GObjectClass *gobject_class;
 176   GstElementClass *gstelement_class;
 177
 178   gobject_class = (GObjectClass*)klass;
 179   gstelement_class = (GstElementClass*)klass;
 180
 181   parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
 182
 183   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_DEVICE,
 184     g_param_spec_string("device","device","device",
 185                         "/dev/dsp",G_PARAM_READWRITE)); /* CHECKME! */
 186   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_MUTE,
 187     g_param_spec_boolean("mute","mute","mute",
 188                          TRUE,G_PARAM_READWRITE));
 189
 190   /* it would be nice to show format in symbolic form, oh well */
 191   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_FORMAT,
 192     g_param_spec_int ("format","format","format",
 193                       0, G_MAXINT, AFMT_S16_LE, G_PARAM_READWRITE));
 194
 195   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_CHANNELS,
 196     g_param_spec_enum("channels","channels","channels",
 197                       GST_TYPE_OSSSINK_CHANNELS,2,G_PARAM_READWRITE));
 198   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_FREQUENCY,
 199     g_param_spec_int("frequency","frequency","frequency",
 200                      0,G_MAXINT,44100,G_PARAM_READWRITE));
 201   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_FRAGMENT,
 202     g_param_spec_int("fragment","fragment","fragment",
 203                      0,G_MAXINT,6,G_PARAM_READWRITE));
 204   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_BUFFER_SIZE,
 205     g_param_spec_int("buffer_size","buffer_size","buffer_size",
 206                      0,G_MAXINT,4096,G_PARAM_READWRITE));
 207
 208   gst_osssink_signals[SIGNAL_HANDOFF] =
 209     g_signal_new("handoff",G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
 210                    G_STRUCT_OFFSET(GstOssSinkClass,handoff), NULL, NULL,
 211                    g_cclosure_marshal_VOID__VOID,G_TYPE_NONE,0);
 212
 213   gobject_class->set_property = gst_osssink_set_property;
 214   gobject_class->get_property = gst_osssink_get_property;
 215   gobject_class->finalize     = gst_osssink_finalize;
 216
 217   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_osssink_change_state);
 218 }
 219
 220 static GstClockTime
 221 gst_osssink_get_time (GstClock *clock, gpointer data)
 222 {
 223   GstOssSink *osssink = GST_OSSSINK (data);
 224   gint delay;
 225
 226   if (!osssink->bps)
 227     return 0;
 228
 229   ioctl (osssink->fd, SNDCTL_DSP_GETODELAY, &delay);
 230
 231   return osssink->offset + (osssink->handled - delay) * 1000000LL / osssink->bps;
 232 }
 233
 234 static void
 235 gst_osssink_init (GstOssSink *osssink)
 236 {
 237   osssink->sinkpad = gst_pad_new_from_template (
 238                   GST_PAD_TEMPLATE_GET (osssink_sink_factory), "sink");
 239   gst_element_add_pad (GST_ELEMENT (osssink), osssink->sinkpad);
 240   gst_pad_set_connect_function (osssink->sinkpad, gst_osssink_sinkconnect);
 241   gst_pad_set_bufferpool_function (osssink->sinkpad, gst_osssink_get_bufferpool);
 242
 243   gst_pad_set_chain_function (osssink->sinkpad, gst_osssink_chain);
 244
 245   osssink->device = g_strdup ("/dev/dsp");
 246   osssink->fd = -1;
 247   osssink->channels = 1;
 248   osssink->frequency = 11025;
 249   osssink->fragment = 6;
 250 /* AFMT_*_BE not available on all OSS includes (e.g. FBSD) */
 251 #ifdef WORDS_BIGENDIAN
 252   osssink->format = AFMT_S16_BE;
 253 #else
 254   osssink->format = AFMT_S16_LE;
 255 #endif /* WORDS_BIGENDIAN */
 256   /* gst_clock_register (osssink->clock, GST_OBJECT (osssink)); */
 257   osssink->bufsize = 4096;
 258   osssink->offset = -1LL;
 259   osssink->handled = 0LL;
 260   /* 6 buffers per chunk by default */
 261   osssink->sinkpool = gst_buffer_pool_get_default (osssink->bufsize, 6);
 262
 263   osssink->provided_clock = NULL;
 264   osssink->provided_clock = GST_CLOCK (gst_oss_clock_new ("ossclock", gst_osssink_get_time, osssink));
 265
 266   GST_ELEMENT (osssink)->setclockfunc    = gst_osssink_set_clock;
 267   GST_ELEMENT (osssink)->getclockfunc    = gst_osssink_get_clock;
 268
 269   GST_FLAG_SET (osssink, GST_ELEMENT_THREAD_SUGGESTED);
 270   GST_FLAG_SET (osssink, GST_ELEMENT_EVENT_AWARE);
 271 }
 272
 273 static GstPadConnectReturn
 274 gst_osssink_sinkconnect (GstPad *pad, GstCaps *caps)
 275 {
 276   gint law, endianness, width, depth;
 277   gboolean sign;
 278   gint format = -1;
 279   GstOssSink *osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 280
 281   if (!GST_CAPS_IS_FIXED (caps))
 282     return GST_PAD_CONNECT_DELAYED;
 283
 284   gst_caps_get_int (caps, "width", &width);
 285   gst_caps_get_int (caps, "depth", &depth);
 286
 287   if (width != depth)
 288     return GST_PAD_CONNECT_REFUSED;
 289
 290   /* laws 1 and 2 are 1 bps anyway */
 291   osssink->bps = 1;
 292
 293   gst_caps_get_int (caps, "law", &law);
 294   gst_caps_get_int (caps, "endianness", &endianness);
 295   gst_caps_get_boolean (caps, "signed", &sign);
 296
 297   if (law == 0) {
 298     if (width == 16) {
 299       if (sign == TRUE) {
 300         if (endianness == G_LITTLE_ENDIAN)
 301           format = AFMT_S16_LE;
 302         else if (endianness == G_BIG_ENDIAN)
 303           format = AFMT_S16_BE;
 304       }
 305       else {
 306         if (endianness == G_LITTLE_ENDIAN)
 307           format = AFMT_U16_LE;
 308         else if (endianness == G_BIG_ENDIAN)
 309           format = AFMT_U16_BE;
 310       }
 311       osssink->bps = 2;
 312     }
 313     else if (width == 8) {
 314       if (sign == TRUE) {
 315         format = AFMT_S8;
 316       }
 317       else {
 318         format = AFMT_U8;
 319       }
 320       osssink->bps = 1;
 321     }
 322   } else if (law == 1) {
 323     format = AFMT_MU_LAW;
 324   } else if (law == 2) {
 325     format = AFMT_A_LAW;
 326   } else {
 327     g_critical ("unknown law");
 328     return GST_PAD_CONNECT_REFUSED;
 329   }
 330
 331   if (format == -1)
 332     return GST_PAD_CONNECT_REFUSED;
 333
 334   osssink->format = format;
 335   gst_caps_get_int (caps, "channels", &osssink->channels);
 336   gst_caps_get_int (caps, "rate", &osssink->frequency);
 337
 338   osssink->bps *= osssink->channels;
 339   osssink->bps *= osssink->frequency;
 340
 341   if (!gst_osssink_sync_parms (osssink)) {
 342     return GST_PAD_CONNECT_REFUSED;
 343   }
 344
 345   return GST_PAD_CONNECT_OK;
 346 }
 347
 348 static gboolean
 349 gst_osssink_sync_parms (GstOssSink *osssink)
 350 {
 351   audio_buf_info ospace;
 352   int frag;
 353   gint target_format;
 354   gint target_channels;
 355   gint target_frequency;
 356   GObject *object;
 357
 358   g_return_val_if_fail (osssink != NULL, FALSE);
 359   g_return_val_if_fail (GST_IS_OSSSINK (osssink), FALSE);
 360
 361   if (osssink->fd == -1)
 362     return FALSE;
 363
 364   if (osssink->fragment >> 16)
 365     frag = osssink->fragment;
 366   else
 367     frag = 0x7FFF0000 | osssink->fragment;
 368
 369   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: trying to set sound card to %dHz %d bit %s (%08x fragment)",
 370            osssink->frequency, osssink->format,
 371            (osssink->channels == 2) ? "stereo" : "mono",frag);
 372
 373   ioctl (osssink->fd, SNDCTL_DSP_SETFRAGMENT, &frag);
 374
 375   ioctl (osssink->fd, SNDCTL_DSP_RESET, 0);
 376
 377   target_format = osssink->format;
 378   target_channels = osssink->channels;
 379   target_frequency = osssink->frequency;
 380
 381   ioctl (osssink->fd, SNDCTL_DSP_SETFMT, &osssink->format);
 382   ioctl (osssink->fd, SNDCTL_DSP_CHANNELS, &osssink->channels);
 383   ioctl (osssink->fd, SNDCTL_DSP_SPEED, &osssink->frequency);
 384
 385   ioctl (osssink->fd, SNDCTL_DSP_GETBLKSIZE, &osssink->fragment);
 386   ioctl (osssink->fd, SNDCTL_DSP_GETOSPACE, &ospace);
 387
 388   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: set sound card to %dHz %d bit %s (%d bytes buffer, %08x fragment)",
 389            osssink->frequency, osssink->format,
 390            (osssink->channels == 2) ? "stereo" : "mono", ospace.bytes, osssink->fragment);
 391
 392   object = G_OBJECT (osssink);
 393   g_object_freeze_notify (object);
 394   g_object_notify (object, "channels");
 395   g_object_notify (object, "frequency");
 396   g_object_notify (object, "fragment");
 397   g_object_notify (object, "format");
 398   g_object_thaw_notify (object);
 399
 400   osssink->fragment_time = (1000000 * osssink->fragment) / osssink->bps;
 401   GST_INFO (GST_CAT_PLUGIN_INFO, "fragment time %u %llu\n", osssink->bps, osssink->fragment_time);
 402
 403   if (target_format != osssink->format ||
 404       target_channels != osssink->channels ||
 405       target_frequency != osssink->frequency)
 406   {
 407     g_warning ("could not configure oss with required parameters, enjoy the noise :)");
 408     /* we could eventually return FALSE here, or just do some additional tests
 409      * to see that the frequencies don't differ too much etc.. */
 410   }
 411   return TRUE;
 412 }
 413
 414 static GstClock*
 415 gst_osssink_get_clock (GstElement *element)
 416 {
 417   GstOssSink *osssink;
 418
 419   osssink = GST_OSSSINK (element);
 420
 421   return GST_CLOCK (osssink->provided_clock);
 422 }
 423
 424 static void
 425 gst_osssink_set_clock (GstElement *element, GstClock *clock)
 426 {
 427   GstOssSink *osssink;
 428
 429   osssink = GST_OSSSINK (element);
 430
 431   osssink->clock = clock;
 432 }
 433
 434 static void
 435 gst_osssink_chain (GstPad *pad, GstBuffer *buf)
 436 {
 437   GstOssSink *osssink;
 438   GstClockTime buftime;
 439
 440   /* this has to be an audio buffer */
 441   osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 442
 443   if (GST_IS_EVENT (buf)) {
 444     switch (GST_EVENT_TYPE (buf)) {
 445       case GST_EVENT_EOS:
 446         ioctl (osssink->fd, SNDCTL_DSP_SYNC);
 447         gst_pad_event_default (pad, GST_EVENT (buf));
 448         return;
 449       default:
 450         return;
 451     }
 452   }
 453
 454   buftime = GST_BUFFER_TIMESTAMP (buf);
 455
 456   if (!osssink->bps) {
 457     gst_buffer_unref (buf);
 458     gst_element_error (GST_ELEMENT (osssink), "capsnego was never performed, unknown data type");
 459   }
 460
 461   if (osssink->fd >= 0) {
 462     if (!osssink->mute) {
 463       guchar *data = GST_BUFFER_DATA (buf);
 464       gint size = GST_BUFFER_SIZE (buf);
 465       /* gint frag = osssink->fragment;   <-- unused, for reason see above */
 466
 467       if (osssink->clock) {
 468         /* FIXME, NEW_MEDIA/DISCONT?. Try to get our start point */
 469         if (osssink->offset == -1LL && buftime != -1LL) {
 470           /* g_print ("%lld  %lld %lld\n", osssink->offset, buftime, gst_clock_get_time (osssink->clock)); */
 471           osssink->offset = buftime;
 472           osssink->handled = 0;
 473           gst_element_clock_wait (GST_ELEMENT (osssink), osssink->clock, buftime);
 474         }
 475
 476
 477         /* FIXME: reverted wtay's patch.
 478            The way that's commented out isn't working on BE machines.
 479            I guess it should be sample accurate and not capped inbetween.
 480         while (size) {
 481           gint tosend = MIN (size, frag);
 482           write (osssink->fd, data, tosend);
 483           data += tosend;
 484           size -= tosend;
 485           osssink->handled += tosend;
 486         } */
 487         write (osssink->fd, data, size);
 488       }
 489       /* no clock, try to be as fast as possible */
 490       else {
 491         audio_buf_info ospace;
 492
 493         ioctl (osssink->fd, SNDCTL_DSP_GETOSPACE, &ospace);
 494
 495         if (ospace.bytes >= size) {
 496           write (osssink->fd, data, size);
 497         }
 498         osssink->handled += size;
 499       }
 500     }
 501   }
 502   gst_buffer_unref (buf);
 503 }
 504
 505 static void
 506 gst_osssink_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 507 {
 508   GstOssSink *osssink;
 509
 510   /* it's not null if we got it, but it might not be ours */
 511   g_return_if_fail (GST_IS_OSSSINK (object));
 512
 513   osssink = GST_OSSSINK (object);
 514
 515   switch (prop_id) {
 516     case ARG_DEVICE:
 517       /* disallow changing the device while it is opened
 518          get_property("device") should return the right one */
 519       if (!GST_FLAG_IS_SET (osssink, GST_OSSSINK_OPEN))
 520       {
 521         g_free (osssink->device);
 522         osssink->device = g_strdup (g_value_get_string (value));
 523         g_object_notify (object, "device");
 524       }
 525       break;
 526     case ARG_MUTE:
 527       osssink->mute = g_value_get_boolean (value);
 528       g_object_notify (G_OBJECT (osssink), "mute");
 529       break;
 530     case ARG_FORMAT:
 531       osssink->format = g_value_get_int (value);
 532       gst_osssink_sync_parms (osssink);
 533       break;
 534     case ARG_CHANNELS:
 535       osssink->channels = g_value_get_enum (value);
 536       gst_osssink_sync_parms (osssink);
 537       break;
 538     case ARG_FREQUENCY:
 539       osssink->frequency = g_value_get_int (value);
 540       gst_osssink_sync_parms (osssink);
 541       break;
 542     case ARG_FRAGMENT:
 543       osssink->fragment = g_value_get_int (value);
 544       gst_osssink_sync_parms (osssink);
 545       break;
 546     case ARG_BUFFER_SIZE:
 547       if (osssink->bufsize == g_value_get_int (value)) break;
 548       osssink->bufsize = g_value_get_int (value);
 549       osssink->sinkpool = gst_buffer_pool_get_default (osssink->bufsize, 6);
 550       g_object_notify (object, "buffer_size");
 551       break;
 552     default:
 553       break;
 554   }
 555 }
 556
 557 static void
 558 gst_osssink_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 559 {
 560   GstOssSink *osssink;
 561
 562   /* it's not null if we got it, but it might not be ours */
 563   g_return_if_fail (GST_IS_OSSSINK (object));
 564
 565   osssink = GST_OSSSINK (object);
 566
 567   switch (prop_id) {
 568     case ARG_DEVICE:
 569       g_value_set_string (value, osssink->device);
 570       break;
 571     case ARG_MUTE:
 572       g_value_set_boolean (value, osssink->mute);
 573       break;
 574     case ARG_FORMAT:
 575       g_value_set_int (value, osssink->format);
 576       break;
 577     case ARG_CHANNELS:
 578       g_value_set_enum (value, osssink->channels);
 579       break;
 580     case ARG_FREQUENCY:
 581       g_value_set_int (value, osssink->frequency);
 582       break;
 583     case ARG_FRAGMENT:
 584       g_value_set_int (value, osssink->fragment);
 585       break;
 586     case ARG_BUFFER_SIZE:
 587       g_value_set_int (value, osssink->bufsize);
 588       break;
 589     default:
 590       break;
 591   }
 592 }
 593
 594 static gboolean
 595 gst_osssink_open_audio (GstOssSink *sink)
 596 {
 597   gint caps;
 598   g_return_val_if_fail (sink->fd == -1, FALSE);
 599
 600   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: attempting to open sound device");
 601
 602   /* first try to open the sound card */
 603   sink->fd = open(sink->device, O_WRONLY | O_NONBLOCK);
 604   if (errno == EBUSY) {
 605     g_warning ("osssink: unable to open the sound device (in use ?)\n");
 606     return FALSE;
 607   }
 608
 609   /* re-open the sound device in blocking mode */
 610   close(sink->fd);
 611   sink->fd = open(sink->device, O_WRONLY);
 612
 613   /* if we have it, set the default parameters and go have fun */
 614   if (sink->fd >= 0) {
 615     /* set card state */
 616     ioctl(sink->fd, SNDCTL_DSP_GETCAPS, &caps);
 617
 618     GST_INFO(GST_CAT_PLUGIN_INFO, "osssink: Capabilities %08x", caps);
 619
 620     if (caps & DSP_CAP_DUPLEX)          GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Full duplex");
 621     if (caps & DSP_CAP_REALTIME)        GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Realtime");
 622     if (caps & DSP_CAP_BATCH)           GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Batch");
 623     if (caps & DSP_CAP_COPROC)          GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Has coprocessor");
 624     if (caps & DSP_CAP_TRIGGER)         GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Trigger");
 625     if (caps & DSP_CAP_MMAP)            GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Direct access");
 626
 627 #ifdef DSP_CAP_MULTI
 628     if (caps & DSP_CAP_MULTI)           GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Multiple open");
 629 #endif /* DSP_CAP_MULTI */
 630
 631 #ifdef DSP_CAP_BIND
 632     if (caps & DSP_CAP_BIND)            GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   Channel binding");
 633 #endif /* DSP_CAP_BIND */
 634
 635     ioctl(sink->fd, SNDCTL_DSP_GETFMTS, &caps);
 636
 637     GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: Formats %08x", caps);
 638     if (caps & AFMT_MU_LAW)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   MU_LAW");
 639     if (caps & AFMT_A_LAW)              GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   A_LAW");
 640     if (caps & AFMT_IMA_ADPCM)          GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   IMA_ADPCM");
 641     if (caps & AFMT_U8)                 GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   U8");
 642     if (caps & AFMT_S16_LE)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   S16_LE");
 643     if (caps & AFMT_S16_BE)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   S16_BE");
 644     if (caps & AFMT_S8)                 GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   S8");
 645     if (caps & AFMT_U16_LE)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   U16_LE");
 646     if (caps & AFMT_U16_BE)             GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   U16_BE");
 647     if (caps & AFMT_MPEG)               GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   MPEG");
 648 #ifdef AFMT_AC3
 649     if (caps & AFMT_AC3)                GST_INFO (GST_CAT_PLUGIN_INFO, "osssink:   AC3");
 650 #endif
 651
 652     GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: opened audio (%s) with fd=%d", sink->device, sink->fd);
 653     GST_FLAG_SET (sink, GST_OSSSINK_OPEN);
 654
 655     return TRUE;
 656   }
 657
 658   return FALSE;
 659 }
 660
 661 static void
 662 gst_osssink_close_audio (GstOssSink *sink)
 663 {
 664   if (sink->fd < 0) return;
 665
 666   close(sink->fd);
 667   sink->fd = -1;
 668
 669   GST_FLAG_UNSET (sink, GST_OSSSINK_OPEN);
 670
 671   GST_INFO (GST_CAT_PLUGIN_INFO, "osssink: closed sound device");
 672 }
 673
 674 static GstElementStateReturn
 675 gst_osssink_change_state (GstElement *element)
 676 {
 677   GstOssSink *osssink;
 678
 679   g_return_val_if_fail (GST_IS_OSSSINK (element), FALSE);
 680
 681   osssink = GST_OSSSINK (element);
 682
 683   switch (GST_STATE_TRANSITION (element)) {
 684     case GST_STATE_NULL_TO_READY:
 685       if (!GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN)) {
 686         if (!gst_osssink_open_audio (osssink)) {
 687           return GST_STATE_FAILURE;
 688         }
 689       }
 690       break;
 691     case GST_STATE_READY_TO_PAUSED:
 692       osssink->offset = -1LL;
 693       break;
 694     case GST_STATE_PAUSED_TO_PLAYING:
 695       /* gst_clock_adjust (osssink->clock, osssink->offset - gst_clock_get_time (osssink->clock)); */
 696       break;
 697     case GST_STATE_PLAYING_TO_PAUSED:
 698     {
 699       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN)) {
 700         if (osssink->bps) {
 701           GstClockTime time;
 702           audio_buf_info ospace;
 703           gint queued;
 704
 705           ioctl (osssink->fd, SNDCTL_DSP_GETOSPACE, &ospace);
 706           ioctl (osssink->fd, SNDCTL_DSP_RESET, 0);
 707
 708           queued = (ospace.fragstotal * ospace.fragsize) - ospace.bytes;
 709           time = osssink->offset + (osssink->handled - queued) * 1000000LL / osssink->bps;
 710
 711           //gst_clock_adjust (osssink->clock, time - gst_clock_get_time (osssink->clock));
 712         }
 713         else {
 714           ioctl (osssink->fd, SNDCTL_DSP_RESET, 0);
 715         }
 716       }
 717
 718       break;
 719     }
 720     case GST_STATE_PAUSED_TO_READY:
 721       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN))
 722         ioctl (osssink->fd, SNDCTL_DSP_RESET, 0);
 723       break;
 724     case GST_STATE_READY_TO_NULL:
 725       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN))
 726         gst_osssink_close_audio (osssink);
 727       break;
 728   }
 729
 730   if (GST_ELEMENT_CLASS (parent_class)->change_state)
 731     return GST_ELEMENT_CLASS (parent_class)->change_state (element);
 732
 733   return GST_STATE_SUCCESS;
 734 }
 735
 736 gboolean
 737 gst_osssink_factory_init (GstPlugin *plugin)
 738 {
 739   GstElementFactory *factory;
 740
 741   factory = gst_element_factory_new ("osssink", GST_TYPE_OSSSINK, &gst_osssink_details);
 742   g_return_val_if_fail (factory != NULL, FALSE);
 743
 744   gst_element_factory_add_pad_template (factory, GST_PAD_TEMPLATE_GET (osssink_sink_factory));
 745
 746   gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
 747
 748   return TRUE;
 749 }
 750