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 #include <string.h>
  31
  32 #include "gstosssink.h"
  33
  34 /* elementfactory information */
  35 static GstElementDetails gst_osssink_details =
  36 GST_ELEMENT_DETAILS ("Audio Sink (OSS)",
  37     "Sink/Audio",
  38     "Output to a sound card via OSS",
  39     "Erik Walthinsen <omega@cse.ogi.edu>, "
  40     "Wim Taymans <wim.taymans@chello.be>");
  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,
  54     gint64 src_value, 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 GstCaps *gst_osssink_sink_fixate (GstPad * pad, const GstCaps * caps);
  62 static GstPadLinkReturn gst_osssink_sinkconnect (GstPad * pad,
  63     const GstCaps * caps);
  64
  65 static void gst_osssink_set_property (GObject * object, guint prop_id,
  66     const GValue * value, GParamSpec * pspec);
  67 static void gst_osssink_get_property (GObject * object, guint prop_id,
  68     GValue * value, GParamSpec * pspec);
  69
  70 static void gst_osssink_chain (GstPad * pad, GstData * _data);
  71
  72 /* OssSink signals and args */
  73 enum
  74 {
  75   SIGNAL_HANDOFF,
  76   LAST_SIGNAL
  77 };
  78
  79 enum
  80 {
  81   ARG_0,
  82   ARG_MUTE,
  83   ARG_FRAGMENT,
  84   ARG_BUFFER_SIZE,
  85   ARG_SYNC,
  86   ARG_CHUNK_SIZE,
  87   /* FILL ME */
  88 };
  89
  90 static GstStaticPadTemplate osssink_sink_factory =
  91 GST_STATIC_PAD_TEMPLATE ("sink",
  92     GST_PAD_SINK,
  93     GST_PAD_ALWAYS,
  94     GST_STATIC_CAPS ("audio/x-raw-int, "
  95         "endianness = (int) BYTE_ORDER, "
  96         "signed = (boolean) { TRUE, FALSE }, "
  97         "width = (int) { 8, 16 }, "
  98         "depth = (int) { 8, 16 }, "
  99         "rate = (int) [ 1000, 48000 ], " "channels = (int) [ 1, 2 ]")
 100     );
 101
 102 static GstElementClass *parent_class = NULL;
 103 static guint gst_osssink_signals[LAST_SIGNAL] = { 0 };
 104
 105 GType
 106 gst_osssink_get_type (void)
 107 {
 108   static GType osssink_type = 0;
 109
 110   if (!osssink_type) {
 111     static const GTypeInfo osssink_info = {
 112       sizeof (GstOssSinkClass),
 113       gst_osssink_base_init,
 114       NULL,
 115       (GClassInitFunc) gst_osssink_class_init,
 116       NULL,
 117       NULL,
 118       sizeof (GstOssSink),
 119       0,
 120       (GInstanceInitFunc) gst_osssink_init,
 121     };
 122     osssink_type =
 123         g_type_register_static (GST_TYPE_OSSELEMENT, "GstOssSink",
 124         &osssink_info, 0);
 125   }
 126
 127   return osssink_type;
 128 }
 129
 130 static void
 131 gst_osssink_dispose (GObject * object)
 132 {
 133   GstOssSink *osssink = (GstOssSink *) object;
 134
 135   gst_object_unparent (GST_OBJECT (osssink->provided_clock));
 136
 137   G_OBJECT_CLASS (parent_class)->dispose (object);
 138 }
 139
 140 static void
 141 gst_osssink_base_init (gpointer g_class)
 142 {
 143   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 144
 145   gst_element_class_set_details (element_class, &gst_osssink_details);
 146   gst_element_class_add_pad_template (element_class,
 147       gst_static_pad_template_get (&osssink_sink_factory));
 148 }
 149 static void
 150 gst_osssink_class_init (GstOssSinkClass * klass)
 151 {
 152   GObjectClass *gobject_class;
 153   GstElementClass *gstelement_class;
 154
 155   gobject_class = (GObjectClass *) klass;
 156   gstelement_class = (GstElementClass *) klass;
 157
 158   parent_class = g_type_class_ref (GST_TYPE_OSSELEMENT);
 159
 160   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MUTE,
 161       g_param_spec_boolean ("mute", "Mute", "Mute the audio",
 162           FALSE, G_PARAM_READWRITE));
 163   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SYNC,
 164       g_param_spec_boolean ("sync", "Sync",
 165           "If syncing on timestamps should be enabled", TRUE,
 166           G_PARAM_READWRITE));
 167   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FRAGMENT,
 168       g_param_spec_int ("fragment", "Fragment",
 169           "The fragment as 0xMMMMSSSS (MMMM = total fragments, 2^SSSS = fragment size)",
 170           0, G_MAXINT, 6, G_PARAM_READWRITE));
 171   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BUFFER_SIZE,
 172       g_param_spec_uint ("buffer_size", "Buffer size",
 173           "Size of buffers in osssink's bufferpool (bytes)", 0, G_MAXINT, 4096,
 174           G_PARAM_READWRITE));
 175   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_CHUNK_SIZE,
 176       g_param_spec_uint ("chunk_size", "Chunk size",
 177           "Write data in chunk sized buffers", 0, G_MAXUINT, 4096,
 178           G_PARAM_READWRITE));
 179
 180   gst_osssink_signals[SIGNAL_HANDOFF] =
 181       g_signal_new ("handoff", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 182       G_STRUCT_OFFSET (GstOssSinkClass, handoff), NULL, NULL,
 183       g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 184
 185   gobject_class->set_property = gst_osssink_set_property;
 186   gobject_class->get_property = gst_osssink_get_property;
 187   gobject_class->dispose = gst_osssink_dispose;
 188
 189   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_osssink_change_state);
 190   gstelement_class->query = GST_DEBUG_FUNCPTR (gst_osssink_query);
 191   gstelement_class->set_clock = gst_osssink_set_clock;
 192   gstelement_class->get_clock = gst_osssink_get_clock;
 193
 194 }
 195
 196 static void
 197 gst_osssink_init (GstOssSink * osssink)
 198 {
 199   osssink->sinkpad =
 200       gst_pad_new_from_template (gst_static_pad_template_get
 201       (&osssink_sink_factory), "sink");
 202   gst_element_add_pad (GST_ELEMENT (osssink), osssink->sinkpad);
 203   gst_pad_set_link_function (osssink->sinkpad, gst_osssink_sinkconnect);
 204   gst_pad_set_fixate_function (osssink->sinkpad, gst_osssink_sink_fixate);
 205   gst_pad_set_convert_function (osssink->sinkpad, gst_osssink_convert);
 206   gst_pad_set_query_function (osssink->sinkpad, gst_osssink_sink_query);
 207   gst_pad_set_query_type_function (osssink->sinkpad,
 208       gst_osssink_get_query_types);
 209   gst_pad_set_formats_function (osssink->sinkpad, gst_osssink_get_formats);
 210
 211   gst_pad_set_chain_function (osssink->sinkpad, gst_osssink_chain);
 212
 213   GST_DEBUG ("initializing osssink");
 214   osssink->bufsize = 4096;
 215   osssink->chunk_size = 4096;
 216   osssink->mute = FALSE;
 217   osssink->sync = TRUE;
 218   osssink->resync = TRUE;
 219   osssink->provided_clock =
 220       gst_audio_clock_new ("ossclock", gst_osssink_get_time, osssink);
 221   gst_object_set_parent (GST_OBJECT (osssink->provided_clock),
 222       GST_OBJECT (osssink));
 223   osssink->handled = 0;
 224
 225   GST_FLAG_SET (osssink, GST_ELEMENT_THREAD_SUGGESTED);
 226   GST_FLAG_SET (osssink, GST_ELEMENT_EVENT_AWARE);
 227 }
 228
 229 static GstCaps *
 230 gst_osssink_sink_fixate (GstPad * pad, const GstCaps * caps)
 231 {
 232   GstCaps *newcaps;
 233   GstStructure *structure;
 234
 235   newcaps =
 236       gst_caps_new_full (gst_structure_copy (gst_caps_get_structure (caps, 0)),
 237       NULL);
 238   structure = gst_caps_get_structure (newcaps, 0);
 239
 240   if (gst_caps_structure_fixate_field_nearest_int (structure, "rate", 44100)) {
 241     return newcaps;
 242   }
 243   if (gst_caps_structure_fixate_field_nearest_int (structure, "depth", 16)) {
 244     return newcaps;
 245   }
 246   if (gst_caps_structure_fixate_field_nearest_int (structure, "width", 16)) {
 247     return newcaps;
 248   }
 249   if (gst_caps_structure_fixate_field_nearest_int (structure, "channels", 2)) {
 250     return newcaps;
 251   }
 252
 253   gst_caps_free (newcaps);
 254
 255   return NULL;
 256 }
 257
 258 static GstPadLinkReturn
 259 gst_osssink_sinkconnect (GstPad * pad, const GstCaps * caps)
 260 {
 261   GstOssSink *osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 262
 263   if (!gst_osselement_parse_caps (GST_OSSELEMENT (osssink), caps))
 264     return GST_PAD_LINK_REFUSED;
 265
 266   if (!gst_osselement_sync_parms (GST_OSSELEMENT (osssink))) {
 267     return GST_PAD_LINK_REFUSED;
 268   }
 269
 270   return GST_PAD_LINK_OK;
 271 }
 272
 273 static inline gint
 274 gst_osssink_get_delay (GstOssSink * osssink)
 275 {
 276   gint delay = 0;
 277   gint ret;
 278
 279   if (GST_OSSELEMENT (osssink)->fd == -1)
 280     return 0;
 281
 282 #ifdef SNDCTL_DSP_GETODELAY
 283   ret = ioctl (GST_OSSELEMENT (osssink)->fd, SNDCTL_DSP_GETODELAY, &delay);
 284 #else
 285   ret = -1;
 286 #endif
 287   if (ret < 0) {
 288     audio_buf_info info;
 289
 290     if (ioctl (GST_OSSELEMENT (osssink)->fd, SNDCTL_DSP_GETOSPACE, &info) < 0) {
 291       delay = 0;
 292     } else {
 293       delay = (info.fragstotal * info.fragsize) - info.bytes;
 294     }
 295   }
 296
 297   return delay;
 298 }
 299
 300 static GstClockTime
 301 gst_osssink_get_time (GstClock * clock, gpointer data)
 302 {
 303   GstOssSink *osssink = GST_OSSSINK (data);
 304   gint delay;
 305   GstClockTimeDiff res;
 306
 307   if (!GST_OSSELEMENT (osssink)->bps)
 308     return 0;
 309
 310   delay = gst_osssink_get_delay (osssink);
 311
 312   /* sometimes delay is bigger than the number of bytes sent to the device,
 313    * which screws up this calculation, we assume that everything is still
 314    * in the device then
 315    * thomas: with proper handling of the return value, this doesn't seem to
 316    * happen anymore, so remove the second code path after april 2004 */
 317   if (delay > (gint64) osssink->handled) {
 318     /*g_warning ("Delay %d > osssink->handled %" G_GUINT64_FORMAT
 319        ", setting to osssink->handled",
 320        delay, osssink->handled); */
 321     delay = osssink->handled;
 322   }
 323   res =
 324       ((gint64) osssink->handled -
 325       delay) * GST_SECOND / GST_OSSELEMENT (osssink)->bps;
 326   if (res < 0)
 327     res = 0;
 328
 329   return res;
 330 }
 331
 332 static GstClock *
 333 gst_osssink_get_clock (GstElement * element)
 334 {
 335   GstOssSink *osssink;
 336
 337   osssink = GST_OSSSINK (element);
 338
 339   return GST_CLOCK (osssink->provided_clock);
 340 }
 341
 342 static void
 343 gst_osssink_set_clock (GstElement * element, GstClock * clock)
 344 {
 345   GstOssSink *osssink;
 346
 347   osssink = GST_OSSSINK (element);
 348
 349   osssink->clock = clock;
 350 }
 351
 352 static void
 353 gst_osssink_chain (GstPad * pad, GstData * _data)
 354 {
 355   GstBuffer *buf = GST_BUFFER (_data);
 356   GstOssSink *osssink;
 357   GstClockTimeDiff buftime, soundtime, elementtime;
 358   guchar *data;
 359   guint to_write;
 360   gint delay;
 361
 362   /* this has to be an audio buffer */
 363   osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 364
 365   if (GST_IS_EVENT (buf)) {
 366     GstEvent *event = GST_EVENT (buf);
 367
 368     switch (GST_EVENT_TYPE (event)) {
 369       case GST_EVENT_EOS:
 370         ioctl (GST_OSSELEMENT (osssink)->fd, SNDCTL_DSP_SYNC, 0);
 371         gst_audio_clock_set_active (GST_AUDIO_CLOCK (osssink->provided_clock),
 372             FALSE);
 373         gst_pad_event_default (pad, event);
 374         return;
 375       case GST_EVENT_DISCONTINUOUS:
 376         osssink->resync = TRUE;
 377         /* pass-through */
 378       default:
 379         gst_pad_event_default (pad, event);
 380         return;
 381     }
 382     g_assert_not_reached ();
 383   }
 384
 385   if (!GST_OSSELEMENT (osssink)->bps) {
 386     gst_buffer_unref (buf);
 387     GST_ELEMENT_ERROR (osssink, CORE, NEGOTIATION, (NULL),
 388         ("format wasn't negotiated before chain function"));
 389     return;
 390   }
 391
 392   data = GST_BUFFER_DATA (buf);
 393   to_write = GST_BUFFER_SIZE (buf);
 394   /* sync audio with buffers timestamp. elementtime is the *current* time.
 395    * soundtime is the time if the soundcard has processed all queued data. */
 396   elementtime = gst_element_get_time (GST_ELEMENT (osssink));
 397   delay = gst_osssink_get_delay (osssink);
 398   if (delay < 0)
 399     delay = 0;
 400   soundtime = elementtime + delay * GST_SECOND / GST_OSSELEMENT (osssink)->bps;
 401   if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {
 402     buftime = GST_BUFFER_TIMESTAMP (buf);
 403   } else {
 404     buftime = soundtime;
 405   }
 406   GST_LOG_OBJECT (osssink,
 407       "time: real %" G_GUINT64_FORMAT ", buffer: %" G_GUINT64_FORMAT, soundtime,
 408       buftime);
 409   if (MAX (buftime, soundtime) - MIN (buftime, soundtime) > (GST_SECOND / 10)) {
 410     /* we need to adjust to the buffers here */
 411     GST_INFO_OBJECT (osssink,
 412         "need sync: real %" G_GUINT64_FORMAT ", buffer: %" G_GUINT64_FORMAT,
 413         soundtime, buftime);
 414     if (soundtime > buftime) {
 415       /* do *not* throw frames out. It's useless. The next frame will come in
 416        * too late. And the next one. And so on. We don't want to lose sound.
 417        * This is a placeholder for what - some day - should become QoS, i.e.
 418        * sending events upstream to drop buffers. */
 419     } else {
 420       guint64 to_handle =
 421           (((buftime -
 422                   soundtime) * GST_OSSELEMENT (osssink)->bps / GST_SECOND) /
 423           ((GST_OSSELEMENT (osssink)->width / 8) *
 424               GST_OSSELEMENT (osssink)->channels)) *
 425           (GST_OSSELEMENT (osssink)->width / 8) *
 426           GST_OSSELEMENT (osssink)->channels;
 427
 428       if (!osssink->resync) {
 429         guint8 *buf = g_new (guint8, to_handle);
 430
 431         memset (buf, (GST_OSSELEMENT (osssink)->width == 8) ? 0 : 128,
 432             to_handle);
 433         while (to_handle > 0) {
 434           gint done = write (GST_OSSELEMENT (osssink)->fd, buf,
 435               MIN (to_handle, osssink->chunk_size));
 436
 437           if (done == -1 && errno != EINTR) {
 438             break;
 439           } else {
 440             to_handle -= done;
 441             osssink->handled += done;
 442           }
 443         }
 444         g_free (buf);
 445       } else {
 446         /* Timestamps at start-of-stream (MPEG) or after seek (hey,
 447          * again MPEG!) can be borken, therefore this hacklet. */
 448         osssink->handled += to_handle;
 449       }
 450     }
 451   }
 452
 453   if (GST_OSSELEMENT (osssink)->fd >= 0 && to_write > 0) {
 454     if (!osssink->mute) {
 455
 456       while (to_write > 0) {
 457         gint done = write (GST_OSSELEMENT (osssink)->fd, data,
 458             MIN (to_write, osssink->chunk_size));
 459
 460         if (done == -1) {
 461           if (errno != EINTR)
 462             break;
 463         } else {
 464           to_write -= done;
 465           data += done;
 466           osssink->handled += done;
 467         }
 468       }
 469     } else {
 470       g_warning ("muting osssinks unimplemented wrt clocks!");
 471     }
 472   }
 473
 474   gst_audio_clock_update_time ((GstAudioClock *) osssink->provided_clock,
 475       gst_osssink_get_time (osssink->provided_clock, osssink));
 476
 477   gst_buffer_unref (buf);
 478 }
 479
 480 static const GstFormat *
 481 gst_osssink_get_formats (GstPad * pad)
 482 {
 483   static const GstFormat formats[] = {
 484     GST_FORMAT_TIME,
 485     GST_FORMAT_DEFAULT,
 486     GST_FORMAT_BYTES,
 487     0
 488   };
 489   return formats;
 490 }
 491
 492 static gboolean
 493 gst_osssink_convert (GstPad * pad, GstFormat src_format, gint64 src_value,
 494     GstFormat * dest_format, gint64 * dest_value)
 495 {
 496   GstOssSink *osssink;
 497
 498   osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 499
 500   return gst_osselement_convert (GST_OSSELEMENT (osssink),
 501       src_format, src_value, dest_format, dest_value);
 502 }
 503
 504 static const GstQueryType *
 505 gst_osssink_get_query_types (GstPad * pad)
 506 {
 507   static const GstQueryType query_types[] = {
 508     GST_QUERY_LATENCY,
 509     GST_QUERY_POSITION,
 510     0,
 511   };
 512   return query_types;
 513 }
 514
 515 static gboolean
 516 gst_osssink_sink_query (GstPad * pad, GstQueryType type, GstFormat * format,
 517     gint64 * value)
 518 {
 519   gboolean res = TRUE;
 520   GstOssSink *osssink;
 521
 522   osssink = GST_OSSSINK (gst_pad_get_parent (pad));
 523
 524   switch (type) {
 525     case GST_QUERY_LATENCY:
 526       if (!gst_osssink_convert (pad,
 527               GST_FORMAT_BYTES, gst_osssink_get_delay (osssink),
 528               format, value)) {
 529         res = FALSE;
 530       }
 531       break;
 532     case GST_QUERY_POSITION:
 533       if (!gst_osssink_convert (pad,
 534               GST_FORMAT_TIME, gst_element_get_time (GST_ELEMENT (osssink)),
 535               format, value)) {
 536         res = FALSE;
 537       }
 538       break;
 539     default:
 540       res =
 541           gst_pad_query (gst_pad_get_peer (osssink->sinkpad), type, format,
 542           value);
 543       break;
 544   }
 545
 546   return res;
 547 }
 548
 549 static gboolean
 550 gst_osssink_query (GstElement * element, GstQueryType type, GstFormat * format,
 551     gint64 * value)
 552 {
 553   GstOssSink *osssink = GST_OSSSINK (element);
 554
 555   return gst_osssink_sink_query (osssink->sinkpad, type, format, value);
 556 }
 557
 558 static void
 559 gst_osssink_set_property (GObject * object, guint prop_id, const GValue * value,
 560     GParamSpec * pspec)
 561 {
 562   GstOssSink *osssink;
 563
 564   osssink = GST_OSSSINK (object);
 565
 566   switch (prop_id) {
 567     case ARG_MUTE:
 568       osssink->mute = g_value_get_boolean (value);
 569       g_object_notify (G_OBJECT (osssink), "mute");
 570       break;
 571     case ARG_FRAGMENT:
 572       GST_OSSELEMENT (osssink)->fragment = g_value_get_int (value);
 573       gst_osselement_sync_parms (GST_OSSELEMENT (osssink));
 574       break;
 575     case ARG_BUFFER_SIZE:
 576       osssink->bufsize = g_value_get_uint (value);
 577       g_object_notify (object, "buffer_size");
 578       break;
 579     case ARG_SYNC:
 580       osssink->sync = g_value_get_boolean (value);
 581       g_object_notify (G_OBJECT (osssink), "sync");
 582       break;
 583     case ARG_CHUNK_SIZE:
 584       osssink->chunk_size = g_value_get_uint (value);
 585       break;
 586     default:
 587       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 588       break;
 589   }
 590 }
 591
 592 static void
 593 gst_osssink_get_property (GObject * object, guint prop_id, GValue * value,
 594     GParamSpec * pspec)
 595 {
 596   GstOssSink *osssink;
 597
 598   osssink = GST_OSSSINK (object);
 599
 600   switch (prop_id) {
 601     case ARG_MUTE:
 602       g_value_set_boolean (value, osssink->mute);
 603       break;
 604     case ARG_FRAGMENT:
 605       g_value_set_int (value, GST_OSSELEMENT (osssink)->fragment);
 606       break;
 607     case ARG_BUFFER_SIZE:
 608       g_value_set_uint (value, osssink->bufsize);
 609       break;
 610     case ARG_SYNC:
 611       g_value_set_boolean (value, osssink->sync);
 612       break;
 613     case ARG_CHUNK_SIZE:
 614       g_value_set_uint (value, osssink->chunk_size);
 615       break;
 616     default:
 617       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 618       break;
 619   }
 620 }
 621
 622 static GstElementStateReturn
 623 gst_osssink_change_state (GstElement * element)
 624 {
 625   GstOssSink *osssink;
 626
 627   osssink = GST_OSSSINK (element);
 628
 629   switch (GST_STATE_TRANSITION (element)) {
 630     case GST_STATE_READY_TO_PAUSED:
 631       break;
 632     case GST_STATE_PAUSED_TO_PLAYING:
 633       gst_audio_clock_set_active (GST_AUDIO_CLOCK (osssink->provided_clock),
 634           TRUE);
 635       break;
 636     case GST_STATE_PLAYING_TO_PAUSED:
 637       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN))
 638         ioctl (GST_OSSELEMENT (osssink)->fd, SNDCTL_DSP_RESET, 0);
 639       gst_audio_clock_set_active (GST_AUDIO_CLOCK (osssink->provided_clock),
 640           FALSE);
 641       break;
 642     case GST_STATE_PAUSED_TO_READY:
 643       if (GST_FLAG_IS_SET (element, GST_OSSSINK_OPEN))
 644         ioctl (GST_OSSELEMENT (osssink)->fd, SNDCTL_DSP_RESET, 0);
 645       gst_osselement_reset (GST_OSSELEMENT (osssink));
 646       osssink->handled = 0;
 647       osssink->resync = TRUE;
 648       break;
 649     default:
 650       break;
 651   }
 652
 653   if (GST_ELEMENT_CLASS (parent_class)->change_state)
 654     return GST_ELEMENT_CLASS (parent_class)->change_state (element);
 655
 656   return GST_STATE_SUCCESS;
 657 }