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