gst-libs/gst/audio/gstaudiobasesink.c

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *                    2005 Wim Taymans <wim@fluendo.com>
   4  *
   5  * gstaudiobasesink.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., 51 Franklin St, Fifth Floor,
  20  * Boston, MA 02110-1301, USA.
  21  */
  22
  23 /**
  24  * SECTION:gstaudiobasesink
  25  * @short_description: Base class for audio sinks
  26  * @see_also: #GstAudioSink, #GstAudioRingBuffer.
  27  *
  28  * This is the base class for audio sinks. Subclasses need to implement the
  29  * ::create_ringbuffer vmethod. This base class will then take care of
  30  * writing samples to the ringbuffer, synchronisation, clipping and flushing.
  31  *
  32  * Last reviewed on 2006-09-27 (0.10.12)
  33  */
  34
  35 #include <string.h>
  36
  37 #include <gst/audio/audio.h>
  38 #include "gstaudiobasesink.h"
  39
  40 GST_DEBUG_CATEGORY_STATIC (gst_audio_base_sink_debug);
  41 #define GST_CAT_DEFAULT gst_audio_base_sink_debug
  42
  43 #define GST_AUDIO_BASE_SINK_GET_PRIVATE(obj)  \
  44    (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_AUDIO_BASE_SINK, GstAudioBaseSinkPrivate))
  45
  46 struct _GstAudioBaseSinkPrivate
  47 {
  48   /* upstream latency */
  49   GstClockTime us_latency;
  50   /* the clock slaving algorithm in use */
  51   GstAudioBaseSinkSlaveMethod slave_method;
  52   /* running average of clock skew */
  53   GstClockTimeDiff avg_skew;
  54   /* the number of samples we aligned last time */
  55   gint64 last_align;
  56
  57   gboolean sync_latency;
  58
  59   GstClockTime eos_time;
  60
  61   /* number of microseconds we allow clock slaving to drift
  62    * before resyncing */
  63   guint64 drift_tolerance;
  64
  65   /* number of nanoseconds we allow timestamps to drift
  66    * before resyncing */
  67   GstClockTime alignment_threshold;
  68
  69   /* time of the previous detected discont candidate */
  70   GstClockTime discont_time;
  71
  72   /* number of nanoseconds to wait until creating a discontinuity */
  73   GstClockTime discont_wait;
  74 };
  75
  76 /* BaseAudioSink signals and args */
  77 enum
  78 {
  79   /* FILL ME */
  80   LAST_SIGNAL
  81 };
  82
  83 /* FIXME: 0.11, store the buffer_time and latency_time in nanoseconds */
  84 #define DEFAULT_BUFFER_TIME     ((200 * GST_MSECOND) / GST_USECOND)
  85 #define DEFAULT_LATENCY_TIME    ((10 * GST_MSECOND) / GST_USECOND)
  86 #define DEFAULT_PROVIDE_CLOCK   TRUE
  87 #define DEFAULT_SLAVE_METHOD    GST_AUDIO_BASE_SINK_SLAVE_SKEW
  88
  89 /* FIXME, enable pull mode when clock slaving and trick modes are figured out */
  90 #define DEFAULT_CAN_ACTIVATE_PULL FALSE
  91
  92 /* when timestamps drift for more than 40ms we resync. This should
  93  * be anough to compensate for timestamp rounding errors. */
  94 #define DEFAULT_ALIGNMENT_THRESHOLD   (40 * GST_MSECOND)
  95
  96 /* when clock slaving drift for more than 40ms we resync. This is
  97  * a reasonable default */
  98 #define DEFAULT_DRIFT_TOLERANCE   ((40 * GST_MSECOND) / GST_USECOND)
  99
 100 /* allow for one second before resyncing to see if the timestamps drift will
 101  * fix itself, or is a permanent offset */
 102 #define DEFAULT_DISCONT_WAIT        (1 * GST_SECOND)
 103
 104 enum
 105 {
 106   PROP_0,
 107
 108   PROP_BUFFER_TIME,
 109   PROP_LATENCY_TIME,
 110   PROP_PROVIDE_CLOCK,
 111   PROP_SLAVE_METHOD,
 112   PROP_CAN_ACTIVATE_PULL,
 113   PROP_ALIGNMENT_THRESHOLD,
 114   PROP_DRIFT_TOLERANCE,
 115   PROP_DISCONT_WAIT,
 116
 117   PROP_LAST
 118 };
 119
 120 GType
 121 gst_audio_base_sink_slave_method_get_type (void)
 122 {
 123   static volatile gsize slave_method_type = 0;
 124   static const GEnumValue slave_method[] = {
 125     {GST_AUDIO_BASE_SINK_SLAVE_RESAMPLE, "GST_AUDIO_BASE_SINK_SLAVE_RESAMPLE",
 126         "resample"},
 127     {GST_AUDIO_BASE_SINK_SLAVE_SKEW, "GST_AUDIO_BASE_SINK_SLAVE_SKEW", "skew"},
 128     {GST_AUDIO_BASE_SINK_SLAVE_NONE, "GST_AUDIO_BASE_SINK_SLAVE_NONE", "none"},
 129     {0, NULL, NULL},
 130   };
 131
 132   if (g_once_init_enter (&slave_method_type)) {
 133     GType tmp =
 134         g_enum_register_static ("GstAudioBaseSinkSlaveMethod", slave_method);
 135     g_once_init_leave (&slave_method_type, tmp);
 136   }
 137
 138   return (GType) slave_method_type;
 139 }
 140
 141
 142 #define _do_init \
 143     GST_DEBUG_CATEGORY_INIT (gst_audio_base_sink_debug, "audiobasesink", 0, "audiobasesink element");
 144 #define gst_audio_base_sink_parent_class parent_class
 145 G_DEFINE_TYPE_WITH_CODE (GstAudioBaseSink, gst_audio_base_sink,
 146     GST_TYPE_BASE_SINK, _do_init);
 147
 148 static void gst_audio_base_sink_dispose (GObject * object);
 149
 150 static void gst_audio_base_sink_set_property (GObject * object, guint prop_id,
 151     const GValue * value, GParamSpec * pspec);
 152 static void gst_audio_base_sink_get_property (GObject * object, guint prop_id,
 153     GValue * value, GParamSpec * pspec);
 154
 155 #if 0
 156 static GstStateChangeReturn gst_audio_base_sink_async_play (GstBaseSink *
 157     basesink);
 158 #endif
 159 static GstStateChangeReturn gst_audio_base_sink_change_state (GstElement *
 160     element, GstStateChange transition);
 161 static gboolean gst_audio_base_sink_activate_pull (GstBaseSink * basesink,
 162     gboolean active);
 163 static gboolean gst_audio_base_sink_query (GstElement * element, GstQuery *
 164     query);
 165
 166 static GstClock *gst_audio_base_sink_provide_clock (GstElement * elem);
 167 static GstClockTime gst_audio_base_sink_get_time (GstClock * clock,
 168     GstAudioBaseSink * sink);
 169 static void gst_audio_base_sink_callback (GstAudioRingBuffer * rbuf,
 170     guint8 * data, guint len, gpointer user_data);
 171
 172 static GstFlowReturn gst_audio_base_sink_preroll (GstBaseSink * bsink,
 173     GstBuffer * buffer);
 174 static GstFlowReturn gst_audio_base_sink_render (GstBaseSink * bsink,
 175     GstBuffer * buffer);
 176 static gboolean gst_audio_base_sink_event (GstBaseSink * bsink,
 177     GstEvent * event);
 178 static GstFlowReturn gst_audio_base_sink_wait_event (GstBaseSink * bsink,
 179     GstEvent * event);
 180 static void gst_audio_base_sink_get_times (GstBaseSink * bsink,
 181     GstBuffer * buffer, GstClockTime * start, GstClockTime * end);
 182 static gboolean gst_audio_base_sink_setcaps (GstBaseSink * bsink,
 183     GstCaps * caps);
 184 static GstCaps *gst_audio_base_sink_fixate (GstBaseSink * bsink,
 185     GstCaps * caps);
 186
 187 static gboolean gst_audio_base_sink_query_pad (GstBaseSink * bsink,
 188     GstQuery * query);
 189
 190
 191 /* static guint gst_audio_base_sink_signals[LAST_SIGNAL] = { 0 }; */
 192
 193 static void
 194 gst_audio_base_sink_class_init (GstAudioBaseSinkClass * klass)
 195 {
 196   GObjectClass *gobject_class;
 197   GstElementClass *gstelement_class;
 198   GstBaseSinkClass *gstbasesink_class;
 199
 200   gobject_class = (GObjectClass *) klass;
 201   gstelement_class = (GstElementClass *) klass;
 202   gstbasesink_class = (GstBaseSinkClass *) klass;
 203
 204   g_type_class_add_private (klass, sizeof (GstAudioBaseSinkPrivate));
 205
 206   gobject_class->set_property = gst_audio_base_sink_set_property;
 207   gobject_class->get_property = gst_audio_base_sink_get_property;
 208   gobject_class->dispose = gst_audio_base_sink_dispose;
 209
 210   g_object_class_install_property (gobject_class, PROP_BUFFER_TIME,
 211       g_param_spec_int64 ("buffer-time", "Buffer Time",
 212           "Size of audio buffer in microseconds, this is the minimum "
 213           "latency that the sink reports", 1, G_MAXINT64, DEFAULT_BUFFER_TIME,
 214           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 215
 216   g_object_class_install_property (gobject_class, PROP_LATENCY_TIME,
 217       g_param_spec_int64 ("latency-time", "Latency Time",
 218           "The minimum amount of data to write in each iteration in microseconds",
 219           1, G_MAXINT64, DEFAULT_LATENCY_TIME,
 220           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 221
 222   g_object_class_install_property (gobject_class, PROP_PROVIDE_CLOCK,
 223       g_param_spec_boolean ("provide-clock", "Provide Clock",
 224           "Provide a clock to be used as the global pipeline clock",
 225           DEFAULT_PROVIDE_CLOCK, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 226
 227   g_object_class_install_property (gobject_class, PROP_SLAVE_METHOD,
 228       g_param_spec_enum ("slave-method", "Slave Method",
 229           "Algorithm to use to match the rate of the masterclock",
 230           GST_TYPE_AUDIO_BASE_SINK_SLAVE_METHOD, DEFAULT_SLAVE_METHOD,
 231           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 232
 233   g_object_class_install_property (gobject_class, PROP_CAN_ACTIVATE_PULL,
 234       g_param_spec_boolean ("can-activate-pull", "Allow Pull Scheduling",
 235           "Allow pull-based scheduling", DEFAULT_CAN_ACTIVATE_PULL,
 236           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 237   /**
 238    * GstAudioBaseSink:drift-tolerance:
 239    *
 240    * Controls the amount of time in microseconds that clocks are allowed
 241    * to drift before resynchronisation happens.
 242    */
 243   g_object_class_install_property (gobject_class, PROP_DRIFT_TOLERANCE,
 244       g_param_spec_int64 ("drift-tolerance", "Drift Tolerance",
 245           "Tolerance for clock drift in microseconds", 1,
 246           G_MAXINT64, DEFAULT_DRIFT_TOLERANCE,
 247           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 248   /**
 249    * GstAudioBaseSink:alignment_threshold:
 250    *
 251    * Controls the amount of time in nanoseconds that timestamps are allowed
 252    * to drift from their ideal time before choosing not to align them.
 253    */
 254   g_object_class_install_property (gobject_class, PROP_ALIGNMENT_THRESHOLD,
 255       g_param_spec_uint64 ("alignment-threshold", "Alignment Threshold",
 256           "Timestamp alignment threshold in nanoseconds", 1,
 257           G_MAXUINT64 - 1, DEFAULT_ALIGNMENT_THRESHOLD,
 258           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 259
 260   /**
 261    * GstAudioBaseSink:discont-wait:
 262    *
 263    * A window of time in nanoseconds to wait before creating a discontinuity as
 264    * a result of breaching the drift-tolerance.
 265    */
 266   g_object_class_install_property (gobject_class, PROP_DISCONT_WAIT,
 267       g_param_spec_uint64 ("discont-wait", "Discont Wait",
 268           "Window of time in nanoseconds to wait before "
 269           "creating a discontinuity", 0,
 270           G_MAXUINT64 - 1, DEFAULT_DISCONT_WAIT,
 271           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 272
 273   gstelement_class->change_state =
 274       GST_DEBUG_FUNCPTR (gst_audio_base_sink_change_state);
 275   gstelement_class->provide_clock =
 276       GST_DEBUG_FUNCPTR (gst_audio_base_sink_provide_clock);
 277   gstelement_class->query = GST_DEBUG_FUNCPTR (gst_audio_base_sink_query);
 278
 279   gstbasesink_class->fixate = GST_DEBUG_FUNCPTR (gst_audio_base_sink_fixate);
 280   gstbasesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_audio_base_sink_setcaps);
 281   gstbasesink_class->event = GST_DEBUG_FUNCPTR (gst_audio_base_sink_event);
 282   gstbasesink_class->wait_event =
 283       GST_DEBUG_FUNCPTR (gst_audio_base_sink_wait_event);
 284   gstbasesink_class->get_times =
 285       GST_DEBUG_FUNCPTR (gst_audio_base_sink_get_times);
 286   gstbasesink_class->preroll = GST_DEBUG_FUNCPTR (gst_audio_base_sink_preroll);
 287   gstbasesink_class->render = GST_DEBUG_FUNCPTR (gst_audio_base_sink_render);
 288   gstbasesink_class->query = GST_DEBUG_FUNCPTR (gst_audio_base_sink_query_pad);
 289   gstbasesink_class->activate_pull =
 290       GST_DEBUG_FUNCPTR (gst_audio_base_sink_activate_pull);
 291
 292   /* ref class from a thread-safe context to work around missing bit of
 293    * thread-safety in GObject */
 294   g_type_class_ref (GST_TYPE_AUDIO_CLOCK);
 295   g_type_class_ref (GST_TYPE_AUDIO_RING_BUFFER);
 296
 297 }
 298
 299 static void
 300 gst_audio_base_sink_init (GstAudioBaseSink * audiobasesink)
 301 {
 302   GstBaseSink *basesink;
 303
 304   audiobasesink->priv = GST_AUDIO_BASE_SINK_GET_PRIVATE (audiobasesink);
 305
 306   audiobasesink->buffer_time = DEFAULT_BUFFER_TIME;
 307   audiobasesink->latency_time = DEFAULT_LATENCY_TIME;
 308   audiobasesink->priv->slave_method = DEFAULT_SLAVE_METHOD;
 309   audiobasesink->priv->drift_tolerance = DEFAULT_DRIFT_TOLERANCE;
 310   audiobasesink->priv->alignment_threshold = DEFAULT_ALIGNMENT_THRESHOLD;
 311   audiobasesink->priv->discont_wait = DEFAULT_DISCONT_WAIT;
 312
 313   audiobasesink->provided_clock = gst_audio_clock_new ("GstAudioSinkClock",
 314       (GstAudioClockGetTimeFunc) gst_audio_base_sink_get_time, audiobasesink,
 315       NULL);
 316
 317   basesink = GST_BASE_SINK_CAST (audiobasesink);
 318   basesink->can_activate_push = TRUE;
 319   basesink->can_activate_pull = DEFAULT_CAN_ACTIVATE_PULL;
 320
 321   gst_base_sink_set_last_sample_enabled (basesink, FALSE);
 322   if (DEFAULT_PROVIDE_CLOCK)
 323     GST_OBJECT_FLAG_SET (basesink, GST_ELEMENT_FLAG_PROVIDE_CLOCK);
 324   else
 325     GST_OBJECT_FLAG_UNSET (basesink, GST_ELEMENT_FLAG_PROVIDE_CLOCK);
 326 }
 327
 328 static void
 329 gst_audio_base_sink_dispose (GObject * object)
 330 {
 331   GstAudioBaseSink *sink;
 332
 333   sink = GST_AUDIO_BASE_SINK (object);
 334
 335   if (sink->provided_clock) {
 336     gst_audio_clock_invalidate (sink->provided_clock);
 337     gst_object_unref (sink->provided_clock);
 338     sink->provided_clock = NULL;
 339   }
 340
 341   if (sink->ringbuffer) {
 342     gst_object_unparent (GST_OBJECT_CAST (sink->ringbuffer));
 343     sink->ringbuffer = NULL;
 344   }
 345
 346   G_OBJECT_CLASS (parent_class)->dispose (object);
 347 }
 348
 349
 350 static GstClock *
 351 gst_audio_base_sink_provide_clock (GstElement * elem)
 352 {
 353   GstAudioBaseSink *sink;
 354   GstClock *clock;
 355
 356   sink = GST_AUDIO_BASE_SINK (elem);
 357
 358   /* we have no ringbuffer (must be NULL state) */
 359   if (sink->ringbuffer == NULL)
 360     goto wrong_state;
 361
 362   if (!gst_audio_ring_buffer_is_acquired (sink->ringbuffer))
 363     goto wrong_state;
 364
 365   GST_OBJECT_LOCK (sink);
 366   if (!GST_OBJECT_FLAG_IS_SET (sink, GST_ELEMENT_FLAG_PROVIDE_CLOCK))
 367     goto clock_disabled;
 368
 369   clock = GST_CLOCK_CAST (gst_object_ref (sink->provided_clock));
 370   GST_OBJECT_UNLOCK (sink);
 371
 372   return clock;
 373
 374   /* ERRORS */
 375 wrong_state:
 376   {
 377     GST_DEBUG_OBJECT (sink, "ringbuffer not acquired");
 378     return NULL;
 379   }
 380 clock_disabled:
 381   {
 382     GST_DEBUG_OBJECT (sink, "clock provide disabled");
 383     GST_OBJECT_UNLOCK (sink);
 384     return NULL;
 385   }
 386 }
 387
 388 static gboolean
 389 gst_audio_base_sink_query_pad (GstBaseSink * bsink, GstQuery * query)
 390 {
 391   gboolean res = FALSE;
 392   GstAudioBaseSink *basesink;
 393
 394   basesink = GST_AUDIO_BASE_SINK (bsink);
 395
 396   switch (GST_QUERY_TYPE (query)) {
 397     case GST_QUERY_CONVERT:
 398     {
 399       GstFormat src_fmt, dest_fmt;
 400       gint64 src_val, dest_val;
 401
 402       GST_LOG_OBJECT (basesink, "query convert");
 403
 404       if (basesink->ringbuffer) {
 405         gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, NULL);
 406         res =
 407             gst_audio_ring_buffer_convert (basesink->ringbuffer, src_fmt,
 408             src_val, dest_fmt, &dest_val);
 409         if (res) {
 410           gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
 411         }
 412       }
 413       break;
 414     }
 415     default:
 416       res = GST_BASE_SINK_CLASS (parent_class)->query (bsink, query);
 417       break;
 418   }
 419   return res;
 420 }
 421
 422 static gboolean
 423 gst_audio_base_sink_query (GstElement * element, GstQuery * query)
 424 {
 425   gboolean res = FALSE;
 426   GstAudioBaseSink *basesink;
 427
 428   basesink = GST_AUDIO_BASE_SINK (element);
 429
 430   switch (GST_QUERY_TYPE (query)) {
 431     case GST_QUERY_LATENCY:
 432     {
 433       gboolean live, us_live;
 434       GstClockTime min_l, max_l;
 435
 436       GST_DEBUG_OBJECT (basesink, "latency query");
 437
 438       /* ask parent first, it will do an upstream query for us. */
 439       if ((res =
 440               gst_base_sink_query_latency (GST_BASE_SINK_CAST (basesink), &live,
 441                   &us_live, &min_l, &max_l))) {
 442         GstClockTime base_latency, min_latency, max_latency;
 443
 444         /* we and upstream are both live, adjust the min_latency */
 445         if (live && us_live) {
 446           GstAudioRingBufferSpec *spec;
 447
 448           GST_OBJECT_LOCK (basesink);
 449           if (!basesink->ringbuffer || !basesink->ringbuffer->spec.info.rate) {
 450             GST_OBJECT_UNLOCK (basesink);
 451
 452             GST_DEBUG_OBJECT (basesink,
 453                 "we are not yet negotiated, can't report latency yet");
 454             res = FALSE;
 455             goto done;
 456           }
 457           spec = &basesink->ringbuffer->spec;
 458
 459           basesink->priv->us_latency = min_l;
 460
 461           base_latency =
 462               gst_util_uint64_scale_int (spec->seglatency * spec->segsize,
 463               GST_SECOND, spec->info.rate * spec->info.bpf);
 464           GST_OBJECT_UNLOCK (basesink);
 465
 466           /* we cannot go lower than the buffer size and the min peer latency */
 467           min_latency = base_latency + min_l;
 468           /* the max latency is the max of the peer, we can delay an infinite
 469            * amount of time. */
 470           max_latency = (max_l == -1) ? -1 : (base_latency + max_l);
 471
 472           GST_DEBUG_OBJECT (basesink,
 473               "peer min %" GST_TIME_FORMAT ", our min latency: %"
 474               GST_TIME_FORMAT, GST_TIME_ARGS (min_l),
 475               GST_TIME_ARGS (min_latency));
 476           GST_DEBUG_OBJECT (basesink,
 477               "peer max %" GST_TIME_FORMAT ", our max latency: %"
 478               GST_TIME_FORMAT, GST_TIME_ARGS (max_l),
 479               GST_TIME_ARGS (max_latency));
 480         } else {
 481           GST_DEBUG_OBJECT (basesink,
 482               "peer or we are not live, don't care about latency");
 483           min_latency = min_l;
 484           max_latency = max_l;
 485         }
 486         gst_query_set_latency (query, live, min_latency, max_latency);
 487       }
 488       break;
 489     }
 490     case GST_QUERY_CONVERT:
 491     {
 492       GstFormat src_fmt, dest_fmt;
 493       gint64 src_val, dest_val;
 494
 495       GST_LOG_OBJECT (basesink, "query convert");
 496
 497       if (basesink->ringbuffer) {
 498         gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, NULL);
 499         res =
 500             gst_audio_ring_buffer_convert (basesink->ringbuffer, src_fmt,
 501             src_val, dest_fmt, &dest_val);
 502         if (res) {
 503           gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
 504         }
 505       }
 506       break;
 507     }
 508     default:
 509       res = GST_ELEMENT_CLASS (parent_class)->query (element, query);
 510       break;
 511   }
 512
 513 done:
 514   return res;
 515 }
 516
 517
 518 static GstClockTime
 519 gst_audio_base_sink_get_time (GstClock * clock, GstAudioBaseSink * sink)
 520 {
 521   guint64 raw, samples;
 522   guint delay;
 523   GstClockTime result;
 524
 525   if (sink->ringbuffer == NULL || sink->ringbuffer->spec.info.rate == 0)
 526     return GST_CLOCK_TIME_NONE;
 527
 528   /* our processed samples are always increasing */
 529   raw = samples = gst_audio_ring_buffer_samples_done (sink->ringbuffer);
 530
 531   /* the number of samples not yet processed, this is still queued in the
 532    * device (not played for playback). */
 533   delay = gst_audio_ring_buffer_delay (sink->ringbuffer);
 534
 535   if (G_LIKELY (samples >= delay))
 536     samples -= delay;
 537   else
 538     samples = 0;
 539
 540   result = gst_util_uint64_scale_int (samples, GST_SECOND,
 541       sink->ringbuffer->spec.info.rate);
 542
 543   GST_DEBUG_OBJECT (sink,
 544       "processed samples: raw %" G_GUINT64_FORMAT ", delay %u, real %"
 545       G_GUINT64_FORMAT ", time %" GST_TIME_FORMAT,
 546       raw, delay, samples, GST_TIME_ARGS (result));
 547
 548   return result;
 549 }
 550
 551 /**
 552  * gst_audio_base_sink_set_provide_clock:
 553  * @sink: a #GstAudioBaseSink
 554  * @provide: new state
 555  *
 556  * Controls whether @sink will provide a clock or not. If @provide is %TRUE,
 557  * gst_element_provide_clock() will return a clock that reflects the datarate
 558  * of @sink. If @provide is %FALSE, gst_element_provide_clock() will return NULL.
 559  */
 560 void
 561 gst_audio_base_sink_set_provide_clock (GstAudioBaseSink * sink,
 562     gboolean provide)
 563 {
 564   g_return_if_fail (GST_IS_AUDIO_BASE_SINK (sink));
 565
 566   GST_OBJECT_LOCK (sink);
 567   if (provide)
 568     GST_OBJECT_FLAG_SET (sink, GST_ELEMENT_FLAG_PROVIDE_CLOCK);
 569   else
 570     GST_OBJECT_FLAG_UNSET (sink, GST_ELEMENT_FLAG_PROVIDE_CLOCK);
 571   GST_OBJECT_UNLOCK (sink);
 572 }
 573
 574 /**
 575  * gst_audio_base_sink_get_provide_clock:
 576  * @sink: a #GstAudioBaseSink
 577  *
 578  * Queries whether @sink will provide a clock or not. See also
 579  * gst_audio_base_sink_set_provide_clock.
 580  *
 581  * Returns: %TRUE if @sink will provide a clock.
 582  */
 583 gboolean
 584 gst_audio_base_sink_get_provide_clock (GstAudioBaseSink * sink)
 585 {
 586   gboolean result;
 587
 588   g_return_val_if_fail (GST_IS_AUDIO_BASE_SINK (sink), FALSE);
 589
 590   GST_OBJECT_LOCK (sink);
 591   result = GST_OBJECT_FLAG_IS_SET (sink, GST_ELEMENT_FLAG_PROVIDE_CLOCK);
 592   GST_OBJECT_UNLOCK (sink);
 593
 594   return result;
 595 }
 596
 597 /**
 598  * gst_audio_base_sink_set_slave_method:
 599  * @sink: a #GstAudioBaseSink
 600  * @method: the new slave method
 601  *
 602  * Controls how clock slaving will be performed in @sink.
 603  */
 604 void
 605 gst_audio_base_sink_set_slave_method (GstAudioBaseSink * sink,
 606     GstAudioBaseSinkSlaveMethod method)
 607 {
 608   g_return_if_fail (GST_IS_AUDIO_BASE_SINK (sink));
 609
 610   GST_OBJECT_LOCK (sink);
 611   sink->priv->slave_method = method;
 612   GST_OBJECT_UNLOCK (sink);
 613 }
 614
 615 /**
 616  * gst_audio_base_sink_get_slave_method:
 617  * @sink: a #GstAudioBaseSink
 618  *
 619  * Get the current slave method used by @sink.
 620  *
 621  * Returns: The current slave method used by @sink.
 622  */
 623 GstAudioBaseSinkSlaveMethod
 624 gst_audio_base_sink_get_slave_method (GstAudioBaseSink * sink)
 625 {
 626   GstAudioBaseSinkSlaveMethod result;
 627
 628   g_return_val_if_fail (GST_IS_AUDIO_BASE_SINK (sink), -1);
 629
 630   GST_OBJECT_LOCK (sink);
 631   result = sink->priv->slave_method;
 632   GST_OBJECT_UNLOCK (sink);
 633
 634   return result;
 635 }
 636
 637
 638 /**
 639  * gst_audio_base_sink_set_drift_tolerance:
 640  * @sink: a #GstAudioBaseSink
 641  * @drift_tolerance: the new drift tolerance in microseconds
 642  *
 643  * Controls the sink's drift tolerance.
 644  */
 645 void
 646 gst_audio_base_sink_set_drift_tolerance (GstAudioBaseSink * sink,
 647     gint64 drift_tolerance)
 648 {
 649   g_return_if_fail (GST_IS_AUDIO_BASE_SINK (sink));
 650
 651   GST_OBJECT_LOCK (sink);
 652   sink->priv->drift_tolerance = drift_tolerance;
 653   GST_OBJECT_UNLOCK (sink);
 654 }
 655
 656 /**
 657  * gst_audio_base_sink_get_drift_tolerance:
 658  * @sink: a #GstAudioBaseSink
 659  *
 660  * Get the current drift tolerance, in microseconds, used by @sink.
 661  *
 662  * Returns: The current drift tolerance used by @sink.
 663  */
 664 gint64
 665 gst_audio_base_sink_get_drift_tolerance (GstAudioBaseSink * sink)
 666 {
 667   gint64 result;
 668
 669   g_return_val_if_fail (GST_IS_AUDIO_BASE_SINK (sink), -1);
 670
 671   GST_OBJECT_LOCK (sink);
 672   result = sink->priv->drift_tolerance;
 673   GST_OBJECT_UNLOCK (sink);
 674
 675   return result;
 676 }
 677
 678 /**
 679  * gst_audio_base_sink_set_alignment_threshold:
 680  * @sink: a #GstAudioBaseSink
 681  * @alignment_threshold: the new alignment threshold in nanoseconds
 682  *
 683  * Controls the sink's alignment threshold.
 684  */
 685 void
 686 gst_audio_base_sink_set_alignment_threshold (GstAudioBaseSink * sink,
 687     GstClockTime alignment_threshold)
 688 {
 689   g_return_if_fail (GST_IS_AUDIO_BASE_SINK (sink));
 690
 691   GST_OBJECT_LOCK (sink);
 692   sink->priv->alignment_threshold = alignment_threshold;
 693   GST_OBJECT_UNLOCK (sink);
 694 }
 695
 696 /**
 697  * gst_audio_base_sink_get_alignment_threshold:
 698  * @sink: a #GstAudioBaseSink
 699  *
 700  * Get the current alignment threshold, in nanoseconds, used by @sink.
 701  *
 702  * Returns: The current alignment threshold used by @sink.
 703  */
 704 GstClockTime
 705 gst_audio_base_sink_get_alignment_threshold (GstAudioBaseSink * sink)
 706 {
 707   GstClockTime result;
 708
 709   g_return_val_if_fail (GST_IS_AUDIO_BASE_SINK (sink), GST_CLOCK_TIME_NONE);
 710
 711   GST_OBJECT_LOCK (sink);
 712   result = sink->priv->alignment_threshold;
 713   GST_OBJECT_UNLOCK (sink);
 714
 715   return result;
 716 }
 717
 718 /**
 719  * gst_audio_base_sink_set_discont_wait:
 720  * @sink: a #GstAudioBaseSink
 721  * @discont_wait: the new discont wait in nanoseconds
 722  *
 723  * Controls how long the sink will wait before creating a discontinuity.
 724  */
 725 void
 726 gst_audio_base_sink_set_discont_wait (GstAudioBaseSink * sink,
 727     GstClockTime discont_wait)
 728 {
 729   g_return_if_fail (GST_IS_AUDIO_BASE_SINK (sink));
 730
 731   GST_OBJECT_LOCK (sink);
 732   sink->priv->discont_wait = discont_wait;
 733   GST_OBJECT_UNLOCK (sink);
 734 }
 735
 736 /**
 737  * gst_audio_base_sink_get_discont_wait:
 738  * @sink: a #GstAudioBaseSink
 739  *
 740  * Get the current discont wait, in nanoseconds, used by @sink.
 741  *
 742  * Returns: The current discont wait used by @sink.
 743  */
 744 GstClockTime
 745 gst_audio_base_sink_get_discont_wait (GstAudioBaseSink * sink)
 746 {
 747   GstClockTime result;
 748
 749   g_return_val_if_fail (GST_IS_AUDIO_BASE_SINK (sink), -1);
 750
 751   GST_OBJECT_LOCK (sink);
 752   result = sink->priv->discont_wait;
 753   GST_OBJECT_UNLOCK (sink);
 754
 755   return result;
 756 }
 757
 758 static void
 759 gst_audio_base_sink_set_property (GObject * object, guint prop_id,
 760     const GValue * value, GParamSpec * pspec)
 761 {
 762   GstAudioBaseSink *sink;
 763
 764   sink = GST_AUDIO_BASE_SINK (object);
 765
 766   switch (prop_id) {
 767     case PROP_BUFFER_TIME:
 768       sink->buffer_time = g_value_get_int64 (value);
 769       break;
 770     case PROP_LATENCY_TIME:
 771       sink->latency_time = g_value_get_int64 (value);
 772       break;
 773     case PROP_PROVIDE_CLOCK:
 774       gst_audio_base_sink_set_provide_clock (sink, g_value_get_boolean (value));
 775       break;
 776     case PROP_SLAVE_METHOD:
 777       gst_audio_base_sink_set_slave_method (sink, g_value_get_enum (value));
 778       break;
 779     case PROP_CAN_ACTIVATE_PULL:
 780       GST_BASE_SINK (sink)->can_activate_pull = g_value_get_boolean (value);
 781       break;
 782     case PROP_DRIFT_TOLERANCE:
 783       gst_audio_base_sink_set_drift_tolerance (sink, g_value_get_int64 (value));
 784       break;
 785     case PROP_ALIGNMENT_THRESHOLD:
 786       gst_audio_base_sink_set_alignment_threshold (sink,
 787           g_value_get_uint64 (value));
 788       break;
 789     case PROP_DISCONT_WAIT:
 790       gst_audio_base_sink_set_discont_wait (sink, g_value_get_uint64 (value));
 791       break;
 792     default:
 793       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 794       break;
 795   }
 796 }
 797
 798 static void
 799 gst_audio_base_sink_get_property (GObject * object, guint prop_id,
 800     GValue * value, GParamSpec * pspec)
 801 {
 802   GstAudioBaseSink *sink;
 803
 804   sink = GST_AUDIO_BASE_SINK (object);
 805
 806   switch (prop_id) {
 807     case PROP_BUFFER_TIME:
 808       g_value_set_int64 (value, sink->buffer_time);
 809       break;
 810     case PROP_LATENCY_TIME:
 811       g_value_set_int64 (value, sink->latency_time);
 812       break;
 813     case PROP_PROVIDE_CLOCK:
 814       g_value_set_boolean (value, gst_audio_base_sink_get_provide_clock (sink));
 815       break;
 816     case PROP_SLAVE_METHOD:
 817       g_value_set_enum (value, gst_audio_base_sink_get_slave_method (sink));
 818       break;
 819     case PROP_CAN_ACTIVATE_PULL:
 820       g_value_set_boolean (value, GST_BASE_SINK (sink)->can_activate_pull);
 821       break;
 822     case PROP_DRIFT_TOLERANCE:
 823       g_value_set_int64 (value, gst_audio_base_sink_get_drift_tolerance (sink));
 824       break;
 825     case PROP_ALIGNMENT_THRESHOLD:
 826       g_value_set_uint64 (value,
 827           gst_audio_base_sink_get_alignment_threshold (sink));
 828       break;
 829     case PROP_DISCONT_WAIT:
 830       g_value_set_uint64 (value, gst_audio_base_sink_get_discont_wait (sink));
 831       break;
 832     default:
 833       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 834       break;
 835   }
 836 }
 837
 838 static gboolean
 839 gst_audio_base_sink_setcaps (GstBaseSink * bsink, GstCaps * caps)
 840 {
 841   GstAudioBaseSink *sink = GST_AUDIO_BASE_SINK (bsink);
 842   GstAudioRingBufferSpec *spec;
 843   GstClockTime now;
 844   GstClockTime crate_num, crate_denom;
 845
 846   if (!sink->ringbuffer)
 847     return FALSE;
 848
 849   spec = &sink->ringbuffer->spec;
 850
 851   if (G_UNLIKELY (spec->caps && gst_caps_is_equal (spec->caps, caps))) {
 852     GST_DEBUG_OBJECT (sink,
 853         "Ringbuffer caps haven't changed, skipping reconfiguration");
 854     return TRUE;
 855   }
 856
 857   GST_DEBUG_OBJECT (sink, "release old ringbuffer");
 858
 859   /* get current time, updates the last_time. When the subclass has a clock that
 860    * restarts from 0 when a new format is negotiated, it will call
 861    * gst_audio_clock_reset() which will use this last_time to create an offset
 862    * so that time from the clock keeps on increasing monotonically. */
 863   now = gst_clock_get_time (sink->provided_clock);
 864
 865   GST_DEBUG_OBJECT (sink, "time was %" GST_TIME_FORMAT, GST_TIME_ARGS (now));
 866
 867   /* release old ringbuffer */
 868   gst_audio_ring_buffer_pause (sink->ringbuffer);
 869   gst_audio_ring_buffer_activate (sink->ringbuffer, FALSE);
 870   gst_audio_ring_buffer_release (sink->ringbuffer);
 871
 872   GST_DEBUG_OBJECT (sink, "parse caps");
 873
 874   spec->buffer_time = sink->buffer_time;
 875   spec->latency_time = sink->latency_time;
 876
 877   /* parse new caps */
 878   if (!gst_audio_ring_buffer_parse_caps (spec, caps))
 879     goto parse_error;
 880
 881   gst_audio_ring_buffer_debug_spec_buff (spec);
 882
 883   GST_DEBUG_OBJECT (sink, "acquire ringbuffer");
 884   if (!gst_audio_ring_buffer_acquire (sink->ringbuffer, spec))
 885     goto acquire_error;
 886
 887   /* We need to resync since the ringbuffer restarted */
 888   sink->priv->avg_skew = -1;
 889   sink->next_sample = -1;
 890   sink->priv->eos_time = -1;
 891   sink->priv->discont_time = -1;
 892
 893   if (bsink->pad_mode == GST_PAD_MODE_PUSH) {
 894     GST_DEBUG_OBJECT (sink, "activate ringbuffer");
 895     gst_audio_ring_buffer_activate (sink->ringbuffer, TRUE);
 896   }
 897
 898   /* due to possible changes in the spec file we should recalibrate the clock */
 899   gst_clock_get_calibration (sink->provided_clock, NULL, NULL,
 900       &crate_num, &crate_denom);
 901   gst_clock_set_calibration (sink->provided_clock,
 902       gst_clock_get_internal_time (sink->provided_clock), now, crate_num,
 903       crate_denom);
 904
 905   /* calculate actual latency and buffer times.
 906    * FIXME: In 0.11, store the latency_time internally in ns */
 907   spec->latency_time = gst_util_uint64_scale (spec->segsize,
 908       (GST_SECOND / GST_USECOND), spec->info.rate * spec->info.bpf);
 909
 910   spec->buffer_time = spec->segtotal * spec->latency_time;
 911
 912   gst_audio_ring_buffer_debug_spec_buff (spec);
 913
 914   return TRUE;
 915
 916   /* ERRORS */
 917 parse_error:
 918   {
 919     GST_DEBUG_OBJECT (sink, "could not parse caps");
 920     GST_ELEMENT_ERROR (sink, STREAM, FORMAT,
 921         (NULL), ("cannot parse audio format."));
 922     return FALSE;
 923   }
 924 acquire_error:
 925   {
 926     GST_DEBUG_OBJECT (sink, "could not acquire ringbuffer");
 927     return FALSE;
 928   }
 929 }
 930
 931 static GstCaps *
 932 gst_audio_base_sink_fixate (GstBaseSink * bsink, GstCaps * caps)
 933 {
 934   GstStructure *s;
 935   gint width, depth;
 936
 937   caps = gst_caps_make_writable (caps);
 938
 939   s = gst_caps_get_structure (caps, 0);
 940
 941   /* fields for all formats */
 942   gst_structure_fixate_field_nearest_int (s, "rate", 44100);
 943   gst_structure_fixate_field_nearest_int (s, "channels", 2);
 944   gst_structure_fixate_field_nearest_int (s, "width", 16);
 945
 946   /* fields for int */
 947   if (gst_structure_has_field (s, "depth")) {
 948     gst_structure_get_int (s, "width", &width);
 949     /* round width to nearest multiple of 8 for the depth */
 950     depth = GST_ROUND_UP_8 (width);
 951     gst_structure_fixate_field_nearest_int (s, "depth", depth);
 952   }
 953   if (gst_structure_has_field (s, "signed"))
 954     gst_structure_fixate_field_boolean (s, "signed", TRUE);
 955   if (gst_structure_has_field (s, "endianness"))
 956     gst_structure_fixate_field_nearest_int (s, "endianness", G_BYTE_ORDER);
 957
 958   caps = GST_BASE_SINK_CLASS (parent_class)->fixate (bsink, caps);
 959
 960   return caps;
 961 }
 962
 963 static void
 964 gst_audio_base_sink_get_times (GstBaseSink * bsink, GstBuffer * buffer,
 965     GstClockTime * start, GstClockTime * end)
 966 {
 967   /* our clock sync is a bit too much for the base class to handle so
 968    * we implement it ourselves. */
 969   *start = GST_CLOCK_TIME_NONE;
 970   *end = GST_CLOCK_TIME_NONE;
 971 }
 972
 973 /* This waits for the drain to happen and can be canceled */
 974 static gboolean
 975 gst_audio_base_sink_drain (GstAudioBaseSink * sink)
 976 {
 977   if (!sink->ringbuffer)
 978     return TRUE;
 979   if (!sink->ringbuffer->spec.info.rate)
 980     return TRUE;
 981
 982   /* if PLAYING is interrupted,
 983    * arrange to have clock running when going to PLAYING again */
 984   g_atomic_int_set (&sink->eos_rendering, 1);
 985
 986   /* need to start playback before we can drain, but only when
 987    * we have successfully negotiated a format and thus acquired the
 988    * ringbuffer. */
 989   if (gst_audio_ring_buffer_is_acquired (sink->ringbuffer))
 990     gst_audio_ring_buffer_start (sink->ringbuffer);
 991
 992   if (sink->priv->eos_time != -1) {
 993     GST_DEBUG_OBJECT (sink,
 994         "last sample time %" GST_TIME_FORMAT,
 995         GST_TIME_ARGS (sink->priv->eos_time));
 996
 997     /* wait for the EOS time to be reached, this is the time when the last
 998      * sample is played. */
 999     gst_base_sink_wait (GST_BASE_SINK (sink), sink->priv->eos_time, NULL);
1000
1001     GST_DEBUG_OBJECT (sink, "drained audio");
1002   }
1003   g_atomic_int_set (&sink->eos_rendering, 0);
1004   return TRUE;
1005 }
1006
1007 static GstFlowReturn
1008 gst_audio_base_sink_wait_event (GstBaseSink * bsink, GstEvent * event)
1009 {
1010   GstAudioBaseSink *sink = GST_AUDIO_BASE_SINK (bsink);
1011   GstFlowReturn ret;
1012
1013   ret = GST_BASE_SINK_CLASS (parent_class)->wait_event (bsink, event);
1014   if (ret != GST_FLOW_OK)
1015     return ret;
1016
1017   switch (GST_EVENT_TYPE (event)) {
1018     case GST_EVENT_GAP:{
1019       GstClockTime timestamp, duration;
1020       GstAudioRingBufferSpec *spec;
1021       GstBuffer *buffer;
1022       gint n_samples = 0;
1023       GstMapInfo minfo;
1024
1025       spec = &sink->ringbuffer->spec;
1026       gst_event_parse_gap (event, &timestamp, &duration);
1027
1028       /* If the GAP event has a duration, handle it like a
1029        * silence buffer of that duration. Otherwise at least
1030        * start the ringbuffer to make sure the clock is running.
1031        */
1032       if (duration != GST_CLOCK_TIME_NONE) {
1033         n_samples =
1034             gst_util_uint64_scale_ceil (duration, spec->info.rate, GST_SECOND);
1035         buffer = gst_buffer_new_and_alloc (n_samples * spec->info.bpf);
1036
1037         if (n_samples != 0) {
1038           gst_buffer_map (buffer, &minfo, GST_MAP_WRITE);
1039           gst_audio_format_fill_silence (spec->info.finfo, minfo.data,
1040               minfo.size);
1041           gst_buffer_unmap (buffer, &minfo);
1042         }
1043         GST_BUFFER_PTS (buffer) = timestamp;
1044         GST_BUFFER_DURATION (buffer) = duration;
1045         GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_GAP);
1046
1047         ret = gst_audio_base_sink_render (bsink, buffer);
1048         gst_buffer_unref (buffer);
1049       } else {
1050         gst_audio_base_sink_drain (sink);
1051       }
1052       break;
1053     }
1054     case GST_EVENT_EOS:
1055       /* now wait till we played everything */
1056       gst_audio_base_sink_drain (sink);
1057       break;
1058     default:
1059       break;
1060   }
1061   return ret;
1062 }
1063
1064 static gboolean
1065 gst_audio_base_sink_event (GstBaseSink * bsink, GstEvent * event)
1066 {
1067   GstAudioBaseSink *sink = GST_AUDIO_BASE_SINK (bsink);
1068
1069   switch (GST_EVENT_TYPE (event)) {
1070     case GST_EVENT_FLUSH_START:
1071       if (sink->ringbuffer)
1072         gst_audio_ring_buffer_set_flushing (sink->ringbuffer, TRUE);
1073       break;
1074     case GST_EVENT_FLUSH_STOP:
1075       /* always resync on sample after a flush */
1076       sink->priv->avg_skew = -1;
1077       sink->next_sample = -1;
1078       sink->priv->eos_time = -1;
1079       sink->priv->discont_time = -1;
1080       if (sink->ringbuffer)
1081         gst_audio_ring_buffer_set_flushing (sink->ringbuffer, FALSE);
1082       break;
1083     default:
1084       break;
1085   }
1086   return GST_BASE_SINK_CLASS (parent_class)->event (bsink, event);
1087 }
1088
1089 static GstFlowReturn
1090 gst_audio_base_sink_preroll (GstBaseSink * bsink, GstBuffer * buffer)
1091 {
1092   GstAudioBaseSink *sink = GST_AUDIO_BASE_SINK (bsink);
1093
1094   if (!gst_audio_ring_buffer_is_acquired (sink->ringbuffer))
1095     goto wrong_state;
1096
1097   /* we don't really do anything when prerolling. We could make a
1098    * property to play this buffer to have some sort of scrubbing
1099    * support. */
1100   return GST_FLOW_OK;
1101
1102 wrong_state:
1103   {
1104     GST_DEBUG_OBJECT (sink, "ringbuffer in wrong state");
1105     GST_ELEMENT_ERROR (sink, STREAM, FORMAT, (NULL), ("sink not negotiated."));
1106     return GST_FLOW_NOT_NEGOTIATED;
1107   }
1108 }
1109
1110 static guint64
1111 gst_audio_base_sink_get_offset (GstAudioBaseSink * sink)
1112 {
1113   guint64 sample;
1114   gint writeseg, segdone, sps;
1115   gint diff;
1116
1117   /* assume we can append to the previous sample */
1118   sample = sink->next_sample;
1119   /* no previous sample, try to insert at position 0 */
1120   if (sample == -1)
1121     sample = 0;
1122
1123   sps = sink->ringbuffer->samples_per_seg;
1124
1125   /* figure out the segment and the offset inside the segment where
1126    * the sample should be written. */
1127   writeseg = sample / sps;
1128
1129   /* get the currently processed segment */
1130   segdone = g_atomic_int_get (&sink->ringbuffer->segdone)
1131       - sink->ringbuffer->segbase;
1132
1133   /* see how far away it is from the write segment */
1134   diff = writeseg - segdone;
1135   if (diff < 0) {
1136     /* sample would be dropped, position to next playable position */
1137     sample = (segdone + 1) * sps;
1138   }
1139
1140   return sample;
1141 }
1142
1143 static GstClockTime
1144 clock_convert_external (GstClockTime external, GstClockTime cinternal,
1145     GstClockTime cexternal, GstClockTime crate_num, GstClockTime crate_denom)
1146 {
1147   /* adjust for rate and speed */
1148   if (external >= cexternal) {
1149     external =
1150         gst_util_uint64_scale (external - cexternal, crate_denom, crate_num);
1151     external += cinternal;
1152   } else {
1153     external =
1154         gst_util_uint64_scale (cexternal - external, crate_denom, crate_num);
1155     if (cinternal > external)
1156       external = cinternal - external;
1157     else
1158       external = 0;
1159   }
1160   return external;
1161 }
1162
1163 /* algorithm to calculate sample positions that will result in resampling to
1164  * match the clock rate of the master */
1165 static void
1166 gst_audio_base_sink_resample_slaving (GstAudioBaseSink * sink,
1167     GstClockTime render_start, GstClockTime render_stop,
1168     GstClockTime * srender_start, GstClockTime * srender_stop)
1169 {
1170   GstClockTime cinternal, cexternal;
1171   GstClockTime crate_num, crate_denom;
1172
1173   /* FIXME, we can sample and add observations here or use the timeouts on the
1174    * clock. No idea which one is better or more stable. The timeout seems more
1175    * arbitrary but this one seems more demanding and does not work when there is
1176    * no data comming in to the sink. */
1177 #if 0
1178   GstClockTime etime, itime;
1179   gdouble r_squared;
1180
1181   /* sample clocks and figure out clock skew */
1182   etime = gst_clock_get_time (GST_ELEMENT_CLOCK (sink));
1183   itime = gst_audio_clock_get_time (sink->provided_clock);
1184
1185   /* add new observation */
1186   gst_clock_add_observation (sink->provided_clock, itime, etime, &r_squared);
1187 #endif
1188
1189   /* get calibration parameters to compensate for speed and offset differences
1190    * when we are slaved */
1191   gst_clock_get_calibration (sink->provided_clock, &cinternal, &cexternal,
1192       &crate_num, &crate_denom);
1193
1194   GST_DEBUG_OBJECT (sink, "internal %" GST_TIME_FORMAT " external %"
1195       GST_TIME_FORMAT " %" G_GUINT64_FORMAT "/%" G_GUINT64_FORMAT " = %f",
1196       GST_TIME_ARGS (cinternal), GST_TIME_ARGS (cexternal), crate_num,
1197       crate_denom, gst_guint64_to_gdouble (crate_num) /
1198       gst_guint64_to_gdouble (crate_denom));
1199
1200   if (crate_num == 0)
1201     crate_denom = crate_num = 1;
1202
1203   /* bring external time to internal time */
1204   render_start = clock_convert_external (render_start, cinternal, cexternal,
1205       crate_num, crate_denom);
1206   render_stop = clock_convert_external (render_stop, cinternal, cexternal,
1207       crate_num, crate_denom);
1208
1209   GST_DEBUG_OBJECT (sink,
1210       "after slaving: start %" GST_TIME_FORMAT " - stop %" GST_TIME_FORMAT,
1211       GST_TIME_ARGS (render_start), GST_TIME_ARGS (render_stop));
1212
1213   *srender_start = render_start;
1214   *srender_stop = render_stop;
1215 }
1216
1217 /* algorithm to calculate sample positions that will result in changing the
1218  * playout pointer to match the clock rate of the master */
1219 static void
1220 gst_audio_base_sink_skew_slaving (GstAudioBaseSink * sink,
1221     GstClockTime render_start, GstClockTime render_stop,
1222     GstClockTime * srender_start, GstClockTime * srender_stop)
1223 {
1224   GstClockTime cinternal, cexternal, crate_num, crate_denom;
1225   GstClockTime etime, itime;
1226   GstClockTimeDiff skew, mdrift, mdrift2;
1227   gint driftsamples;
1228   gint64 last_align;
1229
1230   /* get calibration parameters to compensate for offsets */
1231   gst_clock_get_calibration (sink->provided_clock, &cinternal, &cexternal,
1232       &crate_num, &crate_denom);
1233
1234   /* sample clocks and figure out clock skew */
1235   etime = gst_clock_get_time (GST_ELEMENT_CLOCK (sink));
1236   itime = gst_audio_clock_get_time (sink->provided_clock);
1237   itime = gst_audio_clock_adjust (sink->provided_clock, itime);
1238
1239   GST_DEBUG_OBJECT (sink,
1240       "internal %" GST_TIME_FORMAT " external %" GST_TIME_FORMAT
1241       " cinternal %" GST_TIME_FORMAT " cexternal %" GST_TIME_FORMAT,
1242       GST_TIME_ARGS (itime), GST_TIME_ARGS (etime),
1243       GST_TIME_ARGS (cinternal), GST_TIME_ARGS (cexternal));
1244
1245   /* make sure we never go below 0 */
1246   etime = etime > cexternal ? etime - cexternal : 0;
1247   itime = itime > cinternal ? itime - cinternal : 0;
1248
1249   /* do itime - etime.
1250    * positive value means external clock goes slower
1251    * negative value means external clock goes faster */
1252   skew = GST_CLOCK_DIFF (etime, itime);
1253   if (sink->priv->avg_skew == -1) {
1254     /* first observation */
1255     sink->priv->avg_skew = skew;
1256   } else {
1257     /* next observations use a moving average */
1258     sink->priv->avg_skew = (31 * sink->priv->avg_skew + skew) / 32;
1259   }
1260
1261   GST_DEBUG_OBJECT (sink, "internal %" GST_TIME_FORMAT " external %"
1262       GST_TIME_FORMAT " skew %" G_GINT64_FORMAT " avg %" G_GINT64_FORMAT,
1263       GST_TIME_ARGS (itime), GST_TIME_ARGS (etime), skew, sink->priv->avg_skew);
1264
1265   /* the max drift we allow */
1266   mdrift = sink->priv->drift_tolerance * 1000;
1267   mdrift2 = mdrift / 2;
1268
1269   /* adjust playout pointer based on skew */
1270   if (sink->priv->avg_skew > mdrift2) {
1271     /* master is running slower, move internal time forward */
1272     GST_WARNING_OBJECT (sink,
1273         "correct clock skew %" G_GINT64_FORMAT " > %" G_GINT64_FORMAT,
1274         sink->priv->avg_skew, mdrift2);
1275     cexternal = cexternal > mdrift ? cexternal - mdrift : 0;
1276     sink->priv->avg_skew -= mdrift;
1277
1278     driftsamples = (sink->ringbuffer->spec.info.rate * mdrift) / GST_SECOND;
1279     last_align = sink->priv->last_align;
1280
1281     /* if we were aligning in the wrong direction or we aligned more than what we
1282      * will correct, resync */
1283     if (last_align < 0 || last_align > driftsamples)
1284       sink->next_sample = -1;
1285
1286     GST_DEBUG_OBJECT (sink,
1287         "last_align %" G_GINT64_FORMAT " driftsamples %u, next %"
1288         G_GUINT64_FORMAT, last_align, driftsamples, sink->next_sample);
1289
1290     gst_clock_set_calibration (sink->provided_clock, cinternal, cexternal,
1291         crate_num, crate_denom);
1292   } else if (sink->priv->avg_skew < -mdrift2) {
1293     /* master is running faster, move external time forwards */
1294     GST_WARNING_OBJECT (sink,
1295         "correct clock skew %" G_GINT64_FORMAT " < %" G_GINT64_FORMAT,
1296         sink->priv->avg_skew, -mdrift2);
1297     cexternal += mdrift;
1298     sink->priv->avg_skew += mdrift;
1299
1300     driftsamples = (sink->ringbuffer->spec.info.rate * mdrift) / GST_SECOND;
1301     last_align = sink->priv->last_align;
1302
1303     /* if we were aligning in the wrong direction or we aligned more than what we
1304      * will correct, resync */
1305     if (last_align > 0 || -last_align > driftsamples)
1306       sink->next_sample = -1;
1307
1308     GST_DEBUG_OBJECT (sink,
1309         "last_align %" G_GINT64_FORMAT " driftsamples %u, next %"
1310         G_GUINT64_FORMAT, last_align, driftsamples, sink->next_sample);
1311
1312     gst_clock_set_calibration (sink->provided_clock, cinternal, cexternal,
1313         crate_num, crate_denom);
1314   }
1315
1316   /* convert, ignoring speed */
1317   render_start = clock_convert_external (render_start, cinternal, cexternal,
1318       crate_num, crate_denom);
1319   render_stop = clock_convert_external (render_stop, cinternal, cexternal,
1320       crate_num, crate_denom);
1321
1322   *srender_start = render_start;
1323   *srender_stop = render_stop;
1324 }
1325
1326 /* apply the clock offset but do no slaving otherwise */
1327 static void
1328 gst_audio_base_sink_none_slaving (GstAudioBaseSink * sink,
1329     GstClockTime render_start, GstClockTime render_stop,
1330     GstClockTime * srender_start, GstClockTime * srender_stop)
1331 {
1332   GstClockTime cinternal, cexternal, crate_num, crate_denom;
1333
1334   /* get calibration parameters to compensate for offsets */
1335   gst_clock_get_calibration (sink->provided_clock, &cinternal, &cexternal,
1336       &crate_num, &crate_denom);
1337
1338   /* convert, ignoring speed */
1339   render_start = clock_convert_external (render_start, cinternal, cexternal,
1340       crate_num, crate_denom);
1341   render_stop = clock_convert_external (render_stop, cinternal, cexternal,
1342       crate_num, crate_denom);
1343
1344   *srender_start = render_start;
1345   *srender_stop = render_stop;
1346 }
1347
1348 /* converts render_start and render_stop to their slaved values */
1349 static void
1350 gst_audio_base_sink_handle_slaving (GstAudioBaseSink * sink,
1351     GstClockTime render_start, GstClockTime render_stop,
1352     GstClockTime * srender_start, GstClockTime * srender_stop)
1353 {
1354   switch (sink->priv->slave_method) {
1355     case GST_AUDIO_BASE_SINK_SLAVE_RESAMPLE:
1356       gst_audio_base_sink_resample_slaving (sink, render_start, render_stop,
1357           srender_start, srender_stop);
1358       break;
1359     case GST_AUDIO_BASE_SINK_SLAVE_SKEW:
1360       gst_audio_base_sink_skew_slaving (sink, render_start, render_stop,
1361           srender_start, srender_stop);
1362       break;
1363     case GST_AUDIO_BASE_SINK_SLAVE_NONE:
1364       gst_audio_base_sink_none_slaving (sink, render_start, render_stop,
1365           srender_start, srender_stop);
1366       break;
1367     default:
1368       g_warning ("unknown slaving method %d", sink->priv->slave_method);
1369       break;
1370   }
1371 }
1372
1373 /* must be called with LOCK */
1374 static GstFlowReturn
1375 gst_audio_base_sink_sync_latency (GstBaseSink * bsink, GstMiniObject * obj)
1376 {
1377   GstClock *clock;
1378   GstClockReturn status;
1379   GstClockTime time, render_delay;
1380   GstFlowReturn ret;
1381   GstAudioBaseSink *sink;
1382   GstClockTime itime, etime;
1383   GstClockTime rate_num, rate_denom;
1384   GstClockTimeDiff jitter;
1385
1386   sink = GST_AUDIO_BASE_SINK (bsink);
1387
1388   clock = GST_ELEMENT_CLOCK (sink);
1389   if (G_UNLIKELY (clock == NULL))
1390     goto no_clock;
1391
1392   /* we provided the global clock, don't need to do anything special */
1393   if (clock == sink->provided_clock)
1394     goto no_slaving;
1395
1396   GST_OBJECT_UNLOCK (sink);
1397
1398   do {
1399     GST_DEBUG_OBJECT (sink, "checking preroll");
1400
1401     ret = gst_base_sink_do_preroll (bsink, obj);
1402     if (ret != GST_FLOW_OK)
1403       goto flushing;
1404
1405     GST_OBJECT_LOCK (sink);
1406     time = sink->priv->us_latency;
1407     GST_OBJECT_UNLOCK (sink);
1408
1409     /* Renderdelay is added onto our own latency, and needs
1410      * to be subtracted as well */
1411     render_delay = gst_base_sink_get_render_delay (bsink);
1412
1413     if (G_LIKELY (time > render_delay))
1414       time -= render_delay;
1415     else
1416       time = 0;
1417
1418     /* preroll done, we can sync since we are in PLAYING now. */
1419     GST_DEBUG_OBJECT (sink, "possibly waiting for clock to reach %"
1420         GST_TIME_FORMAT, GST_TIME_ARGS (time));
1421
1422     /* wait for the clock, this can be interrupted because we got shut down or
1423      * we PAUSED. */
1424     status = gst_base_sink_wait_clock (bsink, time, &jitter);
1425
1426     GST_DEBUG_OBJECT (sink, "clock returned %d %" GST_TIME_FORMAT, status,
1427         GST_TIME_ARGS (jitter));
1428
1429     /* invalid time, no clock or sync disabled, just continue then */
1430     if (status == GST_CLOCK_BADTIME)
1431       break;
1432
1433     /* waiting could have been interrupted and we can be flushing now */
1434     if (G_UNLIKELY (bsink->flushing))
1435       goto flushing;
1436
1437     /* retry if we got unscheduled, which means we did not reach the timeout
1438      * yet. if some other error occures, we continue. */
1439   } while (status == GST_CLOCK_UNSCHEDULED);
1440
1441   GST_OBJECT_LOCK (sink);
1442   GST_DEBUG_OBJECT (sink, "latency synced");
1443
1444   /* when we prerolled in time, we can accurately set the calibration,
1445    * our internal clock should exactly have been the latency (== the running
1446    * time of the external clock) */
1447   etime = GST_ELEMENT_CAST (sink)->base_time + time;
1448   itime = gst_audio_clock_get_time (sink->provided_clock);
1449   itime = gst_audio_clock_adjust (sink->provided_clock, itime);
1450
1451   if (status == GST_CLOCK_EARLY) {
1452     /* when we prerolled late, we have to take into account the lateness */
1453     GST_DEBUG_OBJECT (sink, "late preroll, adding jitter");
1454     etime += jitter;
1455   }
1456
1457   /* start ringbuffer so we can start slaving right away when we need to */
1458   gst_audio_ring_buffer_start (sink->ringbuffer);
1459
1460   GST_DEBUG_OBJECT (sink,
1461       "internal time: %" GST_TIME_FORMAT " external time: %" GST_TIME_FORMAT,
1462       GST_TIME_ARGS (itime), GST_TIME_ARGS (etime));
1463
1464   /* copy the original calibrated rate but update the internal and external
1465    * times. */
1466   gst_clock_get_calibration (sink->provided_clock, NULL, NULL, &rate_num,
1467       &rate_denom);
1468   gst_clock_set_calibration (sink->provided_clock, itime, etime,
1469       rate_num, rate_denom);
1470
1471   switch (sink->priv->slave_method) {
1472     case GST_AUDIO_BASE_SINK_SLAVE_RESAMPLE:
1473       /* only set as master when we are resampling */
1474       GST_DEBUG_OBJECT (sink, "Setting clock as master");
1475       gst_clock_set_master (sink->provided_clock, clock);
1476       break;
1477     case GST_AUDIO_BASE_SINK_SLAVE_SKEW:
1478     case GST_AUDIO_BASE_SINK_SLAVE_NONE:
1479     default:
1480       break;
1481   }
1482
1483   sink->priv->avg_skew = -1;
1484   sink->next_sample = -1;
1485   sink->priv->eos_time = -1;
1486   sink->priv->discont_time = -1;
1487
1488   return GST_FLOW_OK;
1489
1490   /* ERRORS */
1491 no_clock:
1492   {
1493     GST_DEBUG_OBJECT (sink, "we have no clock");
1494     return GST_FLOW_OK;
1495   }
1496 no_slaving:
1497   {
1498     GST_DEBUG_OBJECT (sink, "we are not slaved");
1499     return GST_FLOW_OK;
1500   }
1501 flushing:
1502   {
1503     GST_DEBUG_OBJECT (sink, "we are flushing");
1504     GST_OBJECT_LOCK (sink);
1505     return GST_FLOW_FLUSHING;
1506   }
1507 }
1508
1509 static gint64
1510 gst_audio_base_sink_get_alignment (GstAudioBaseSink * sink,
1511     GstClockTime sample_offset)
1512 {
1513   GstAudioRingBuffer *ringbuf = sink->ringbuffer;
1514   gint64 align;
1515   gint64 sample_diff;
1516   gint64 max_sample_diff;
1517   gint segdone = g_atomic_int_get (&ringbuf->segdone) - ringbuf->segbase;
1518   gint64 samples_done = segdone * ringbuf->samples_per_seg;
1519   gint64 headroom = sample_offset - samples_done;
1520   gboolean allow_align = TRUE;
1521   gboolean discont = FALSE;
1522   gint rate;
1523
1524   /* now try to align the sample to the previous one, first see how big the
1525    * difference is. */
1526   if (sample_offset >= sink->next_sample)
1527     sample_diff = sample_offset - sink->next_sample;
1528   else
1529     sample_diff = sink->next_sample - sample_offset;
1530
1531   rate = GST_AUDIO_INFO_RATE (&ringbuf->spec.info);
1532
1533   /* calculate the max allowed drift in units of samples. */
1534   max_sample_diff = gst_util_uint64_scale_int (sink->priv->alignment_threshold,
1535       rate, GST_SECOND);
1536
1537   /* calc align with previous sample */
1538   align = sink->next_sample - sample_offset;
1539
1540   /* don't align if it means writing behind the read-segment */
1541   if (sample_diff > headroom && align < 0)
1542     allow_align = FALSE;
1543
1544   if (G_UNLIKELY (sample_diff >= max_sample_diff)) {
1545     /* wait before deciding to make a discontinuity */
1546     if (sink->priv->discont_wait > 0) {
1547       GstClockTime time = gst_util_uint64_scale_int (sample_offset,
1548           GST_SECOND, rate);
1549       if (sink->priv->discont_time == -1) {
1550         /* discont candidate */
1551         sink->priv->discont_time = time;
1552       } else if (time - sink->priv->discont_time >= sink->priv->discont_wait) {
1553         /* discont_wait expired, discontinuity detected */
1554         discont = TRUE;
1555         sink->priv->discont_time = -1;
1556       }
1557     } else {
1558       discont = TRUE;
1559     }
1560   } else if (G_UNLIKELY (sink->priv->discont_time != -1)) {
1561     /* we have had a discont, but are now back on track! */
1562     sink->priv->discont_time = -1;
1563   }
1564
1565   if (G_LIKELY (!discont && allow_align)) {
1566     GST_DEBUG_OBJECT (sink,
1567         "align with prev sample, ABS (%" G_GINT64_FORMAT ") < %"
1568         G_GINT64_FORMAT, align, max_sample_diff);
1569   } else {
1570     gint64 diff_s G_GNUC_UNUSED;
1571
1572     /* calculate sample diff in seconds for error message */
1573     diff_s = gst_util_uint64_scale_int (sample_diff, GST_SECOND, rate);
1574
1575     /* timestamps drifted apart from previous samples too much, we need to
1576      * resync. We log this as an element warning. */
1577     GST_WARNING_OBJECT (sink,
1578         "Unexpected discontinuity in audio timestamps of "
1579         "%s%" GST_TIME_FORMAT ", resyncing",
1580         sample_offset > sink->next_sample ? "+" : "-", GST_TIME_ARGS (diff_s));
1581     align = 0;
1582   }
1583
1584   return align;
1585 }
1586
1587 static GstFlowReturn
1588 gst_audio_base_sink_render (GstBaseSink * bsink, GstBuffer * buf)
1589 {
1590   guint64 in_offset;
1591   GstClockTime time, stop, render_start, render_stop, sample_offset;
1592   GstClockTimeDiff sync_offset, ts_offset;
1593   GstAudioBaseSinkClass *bclass;
1594   GstAudioBaseSink *sink;
1595   GstAudioRingBuffer *ringbuf;
1596   gint64 diff, align;
1597   guint64 ctime, cstop;
1598   gsize offset;
1599   GstMapInfo info;
1600   gsize size;
1601   guint samples, written;
1602   gint bpf, rate;
1603   gint accum;
1604   gint out_samples;
1605   GstClockTime base_time, render_delay, latency;
1606   GstClock *clock;
1607   gboolean sync, slaved, align_next;
1608   GstFlowReturn ret;
1609   GstSegment clip_seg;
1610   gint64 time_offset;
1611   GstBuffer *out = NULL;
1612
1613   sink = GST_AUDIO_BASE_SINK (bsink);
1614   bclass = GST_AUDIO_BASE_SINK_GET_CLASS (sink);
1615
1616   ringbuf = sink->ringbuffer;
1617
1618   /* can't do anything when we don't have the device */
1619   if (G_UNLIKELY (!gst_audio_ring_buffer_is_acquired (ringbuf)))
1620     goto wrong_state;
1621
1622   /* Wait for upstream latency before starting the ringbuffer, we do this so
1623    * that we can align the first sample of the ringbuffer to the base_time +
1624    * latency. */
1625   GST_OBJECT_LOCK (sink);
1626   base_time = GST_ELEMENT_CAST (sink)->base_time;
1627   if (G_UNLIKELY (sink->priv->sync_latency)) {
1628     ret = gst_audio_base_sink_sync_latency (bsink, GST_MINI_OBJECT_CAST (buf));
1629     GST_OBJECT_UNLOCK (sink);
1630     if (G_UNLIKELY (ret != GST_FLOW_OK))
1631       goto sync_latency_failed;
1632     /* only do this once until we are set back to PLAYING */
1633     sink->priv->sync_latency = FALSE;
1634   } else {
1635     GST_OBJECT_UNLOCK (sink);
1636   }
1637
1638   /* Before we go on, let's see if we need to payload the data. If yes, we also
1639    * need to unref the output buffer before leaving. */
1640   if (bclass->payload) {
1641     out = bclass->payload (sink, buf);
1642
1643     if (!out)
1644       goto payload_failed;
1645
1646     buf = out;
1647   }
1648
1649   bpf = GST_AUDIO_INFO_BPF (&ringbuf->spec.info);
1650   rate = GST_AUDIO_INFO_RATE (&ringbuf->spec.info);
1651
1652   size = gst_buffer_get_size (buf);
1653   if (G_UNLIKELY (size % bpf) != 0)
1654     goto wrong_size;
1655
1656   samples = size / bpf;
1657   out_samples = samples;
1658
1659   in_offset = GST_BUFFER_OFFSET (buf);
1660   time = GST_BUFFER_TIMESTAMP (buf);
1661
1662   GST_DEBUG_OBJECT (sink,
1663       "time %" GST_TIME_FORMAT ", offset %" G_GUINT64_FORMAT ", start %"
1664       GST_TIME_FORMAT ", samples %u", GST_TIME_ARGS (time), in_offset,
1665       GST_TIME_ARGS (bsink->segment.start), samples);
1666
1667   offset = 0;
1668
1669   /* if not valid timestamp or we can't clip or sync, try to play
1670    * sample ASAP */
1671   if (!GST_CLOCK_TIME_IS_VALID (time)) {
1672     render_start = gst_audio_base_sink_get_offset (sink);
1673     render_stop = render_start + samples;
1674     GST_DEBUG_OBJECT (sink, "Buffer of size %" G_GSIZE_FORMAT " has no time."
1675         " Using render_start=%" G_GUINT64_FORMAT, size, render_start);
1676     /* we don't have a start so we don't know stop either */
1677     stop = -1;
1678     goto no_align;
1679   }
1680
1681   /* let's calc stop based on the number of samples in the buffer instead
1682    * of trusting the DURATION */
1683   stop = time + gst_util_uint64_scale_int (samples, GST_SECOND, rate);
1684
1685   /* prepare the clipping segment. Since we will be subtracting ts-offset and
1686    * device-delay later we scale the start and stop with those values so that we
1687    * can correctly clip them */
1688   clip_seg.format = GST_FORMAT_TIME;
1689   clip_seg.start = bsink->segment.start;
1690   clip_seg.stop = bsink->segment.stop;
1691   clip_seg.duration = -1;
1692
1693   /* the sync offset is the combination of ts-offset and device-delay */
1694   latency = gst_base_sink_get_latency (bsink);
1695   ts_offset = gst_base_sink_get_ts_offset (bsink);
1696   render_delay = gst_base_sink_get_render_delay (bsink);
1697   sync_offset = ts_offset - render_delay + latency;
1698
1699   GST_DEBUG_OBJECT (sink,
1700       "sync-offset %" G_GINT64_FORMAT ", render-delay %" GST_TIME_FORMAT
1701       ", ts-offset %" G_GINT64_FORMAT, sync_offset,
1702       GST_TIME_ARGS (render_delay), ts_offset);
1703
1704   /* compensate for ts-offset and device-delay when negative we need to
1705    * clip. */
1706   if (G_UNLIKELY (sync_offset < 0)) {
1707     clip_seg.start += -sync_offset;
1708     if (clip_seg.stop != -1)
1709       clip_seg.stop += -sync_offset;
1710   }
1711
1712   /* samples should be rendered based on their timestamp. All samples
1713    * arriving before the segment.start or after segment.stop are to be
1714    * thrown away. All samples should also be clipped to the segment
1715    * boundaries */
1716   if (G_UNLIKELY (!gst_segment_clip (&clip_seg, GST_FORMAT_TIME, time, stop,
1717               &ctime, &cstop)))
1718     goto out_of_segment;
1719
1720   /* see if some clipping happened */
1721   diff = ctime - time;
1722   if (G_UNLIKELY (diff > 0)) {
1723     /* bring clipped time to samples */
1724     diff = gst_util_uint64_scale_int (diff, rate, GST_SECOND);
1725     GST_DEBUG_OBJECT (sink, "clipping start to %" GST_TIME_FORMAT " %"
1726         G_GUINT64_FORMAT " samples", GST_TIME_ARGS (ctime), diff);
1727     samples -= diff;
1728     offset += diff * bpf;
1729     time = ctime;
1730   }
1731   diff = stop - cstop;
1732   if (G_UNLIKELY (diff > 0)) {
1733     /* bring clipped time to samples */
1734     diff = gst_util_uint64_scale_int (diff, rate, GST_SECOND);
1735     GST_DEBUG_OBJECT (sink, "clipping stop to %" GST_TIME_FORMAT " %"
1736         G_GUINT64_FORMAT " samples", GST_TIME_ARGS (cstop), diff);
1737     samples -= diff;
1738     stop = cstop;
1739   }
1740
1741   /* figure out how to sync */
1742   if (G_LIKELY ((clock = GST_ELEMENT_CLOCK (bsink))))
1743     sync = bsink->sync;
1744   else
1745     sync = FALSE;
1746
1747   if (G_UNLIKELY (!sync)) {
1748     /* no sync needed, play sample ASAP */
1749     render_start = gst_audio_base_sink_get_offset (sink);
1750     render_stop = render_start + samples;
1751     GST_DEBUG_OBJECT (sink,
1752         "no sync needed. Using render_start=%" G_GUINT64_FORMAT, render_start);
1753     goto no_align;
1754   }
1755
1756   /* bring buffer start and stop times to running time */
1757   render_start =
1758       gst_segment_to_running_time (&bsink->segment, GST_FORMAT_TIME, time);
1759   render_stop =
1760       gst_segment_to_running_time (&bsink->segment, GST_FORMAT_TIME, stop);
1761
1762   GST_DEBUG_OBJECT (sink,
1763       "running: start %" GST_TIME_FORMAT " - stop %" GST_TIME_FORMAT,
1764       GST_TIME_ARGS (render_start), GST_TIME_ARGS (render_stop));
1765
1766   /* store the time of the last sample, we'll use this to perform sync on the
1767    * last sample when draining the buffer */
1768   if (G_LIKELY (bsink->segment.rate >= 0.0)) {
1769     sink->priv->eos_time = render_stop;
1770   } else {
1771     sink->priv->eos_time = render_start;
1772   }
1773
1774   if (G_UNLIKELY (sync_offset != 0)) {
1775     /* compensate for ts-offset and delay we know this will not underflow because we
1776      * clipped above. */
1777     GST_DEBUG_OBJECT (sink,
1778         "compensating for sync-offset %" GST_TIME_FORMAT,
1779         GST_TIME_ARGS (sync_offset));
1780     render_start += sync_offset;
1781     render_stop += sync_offset;
1782   }
1783
1784   if (base_time != 0) {
1785     GST_DEBUG_OBJECT (sink, "adding base_time %" GST_TIME_FORMAT,
1786         GST_TIME_ARGS (base_time));
1787
1788     /* add base time to sync against the clock */
1789     render_start += base_time;
1790     render_stop += base_time;
1791   }
1792
1793   if (G_UNLIKELY ((slaved = (clock != sink->provided_clock)))) {
1794     /* handle clock slaving */
1795     gst_audio_base_sink_handle_slaving (sink, render_start, render_stop,
1796         &render_start, &render_stop);
1797   } else {
1798     /* no slaving needed but we need to adapt to the clock calibration
1799      * parameters */
1800     gst_audio_base_sink_none_slaving (sink, render_start, render_stop,
1801         &render_start, &render_stop);
1802   }
1803
1804   GST_DEBUG_OBJECT (sink,
1805       "final timestamps: start %" GST_TIME_FORMAT " - stop %" GST_TIME_FORMAT,
1806       GST_TIME_ARGS (render_start), GST_TIME_ARGS (render_stop));
1807
1808   /* bring to position in the ringbuffer */
1809   time_offset = GST_AUDIO_CLOCK_CAST (sink->provided_clock)->time_offset;
1810
1811   if (G_UNLIKELY (time_offset != 0)) {
1812     GST_DEBUG_OBJECT (sink,
1813         "apply time offset %" GST_TIME_FORMAT, GST_TIME_ARGS (time_offset));
1814
1815     if (render_start > time_offset)
1816       render_start -= time_offset;
1817     else
1818       render_start = 0;
1819     if (render_stop > time_offset)
1820       render_stop -= time_offset;
1821     else
1822       render_stop = 0;
1823   }
1824
1825   /* in some clock slaving cases, all late samples end up at 0 first,
1826    * and subsequent ones align with that until threshold exceeded,
1827    * and then sync back to 0 and so on, so avoid that altogether */
1828   if (G_UNLIKELY (render_start == 0 && render_stop == 0))
1829     goto too_late;
1830
1831   /* and bring the time to the rate corrected offset in the buffer */
1832   render_start = gst_util_uint64_scale_int (render_start, rate, GST_SECOND);
1833   render_stop = gst_util_uint64_scale_int (render_stop, rate, GST_SECOND);
1834
1835   /* positive playback rate, first sample is render_start, negative rate, first
1836    * sample is render_stop. When no rate conversion is active, render exactly
1837    * the amount of input samples to avoid aligning to rounding errors. */
1838   if (G_LIKELY (bsink->segment.rate >= 0.0)) {
1839     sample_offset = render_start;
1840     if (G_LIKELY (bsink->segment.rate == 1.0))
1841       render_stop = sample_offset + samples;
1842   } else {
1843     sample_offset = render_stop;
1844     if (bsink->segment.rate == -1.0)
1845       render_start = sample_offset + samples;
1846   }
1847
1848   /* always resync after a discont */
1849   if (G_UNLIKELY (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DISCONT))) {
1850     GST_DEBUG_OBJECT (sink, "resync after discont");
1851     goto no_align;
1852   }
1853
1854   /* resync when we don't know what to align the sample with */
1855   if (G_UNLIKELY (sink->next_sample == -1)) {
1856     GST_DEBUG_OBJECT (sink,
1857         "no align possible: no previous sample position known");
1858     goto no_align;
1859   }
1860
1861   align = gst_audio_base_sink_get_alignment (sink, sample_offset);
1862   sink->priv->last_align = align;
1863
1864   /* apply alignment */
1865   render_start += align;
1866
1867   /* only align stop if we are not slaved to resample */
1868   if (G_UNLIKELY (slaved
1869           && sink->priv->slave_method == GST_AUDIO_BASE_SINK_SLAVE_RESAMPLE)) {
1870     GST_DEBUG_OBJECT (sink, "no stop time align needed: we are slaved");
1871     goto no_align;
1872   }
1873   render_stop += align;
1874
1875 no_align:
1876   /* number of target samples is difference between start and stop */
1877   out_samples = render_stop - render_start;
1878
1879   /* we render the first or last sample first, depending on the rate */
1880   if (G_LIKELY (bsink->segment.rate >= 0.0))
1881     sample_offset = render_start;
1882   else
1883     sample_offset = render_stop;
1884
1885   GST_DEBUG_OBJECT (sink, "rendering at %" G_GUINT64_FORMAT " %d/%d",
1886       sample_offset, samples, out_samples);
1887
1888   /* we need to accumulate over different runs for when we get interrupted */
1889   accum = 0;
1890   align_next = TRUE;
1891   gst_buffer_map (buf, &info, GST_MAP_READ);
1892   do {
1893     written =
1894         gst_audio_ring_buffer_commit (ringbuf, &sample_offset,
1895         info.data + offset, samples, out_samples, &accum);
1896
1897     GST_DEBUG_OBJECT (sink, "wrote %u of %u", written, samples);
1898     /* if we wrote all, we're done */
1899     if (G_LIKELY (written == samples))
1900       break;
1901
1902     /* else something interrupted us and we wait for preroll. */
1903     if ((ret = gst_base_sink_wait_preroll (bsink)) != GST_FLOW_OK)
1904       goto stopping;
1905
1906     /* if we got interrupted, we cannot assume that the next sample should
1907      * be aligned to this one */
1908     align_next = FALSE;
1909
1910     /* update the output samples. FIXME, this will just skip them when pausing
1911      * during trick mode */
1912     if (out_samples > written) {
1913       out_samples -= written;
1914       accum = 0;
1915     } else
1916       break;
1917
1918     samples -= written;
1919     offset += written * bpf;
1920   } while (TRUE);
1921   gst_buffer_unmap (buf, &info);
1922
1923   if (G_LIKELY (align_next))
1924     sink->next_sample = sample_offset;
1925   else
1926     sink->next_sample = -1;
1927
1928   GST_DEBUG_OBJECT (sink, "next sample expected at %" G_GUINT64_FORMAT,
1929       sink->next_sample);
1930
1931   if (G_UNLIKELY (GST_CLOCK_TIME_IS_VALID (stop)
1932           && stop >= bsink->segment.stop)) {
1933     GST_DEBUG_OBJECT (sink,
1934         "start playback because we are at the end of segment");
1935     gst_audio_ring_buffer_start (ringbuf);
1936   }
1937
1938   ret = GST_FLOW_OK;
1939
1940 done:
1941   if (out)
1942     gst_buffer_unref (out);
1943
1944   return ret;
1945
1946   /* SPECIAL cases */
1947 out_of_segment:
1948   {
1949     GST_DEBUG_OBJECT (sink,
1950         "dropping sample out of segment time %" GST_TIME_FORMAT ", start %"
1951         GST_TIME_FORMAT, GST_TIME_ARGS (time),
1952         GST_TIME_ARGS (bsink->segment.start));
1953     ret = GST_FLOW_OK;
1954     goto done;
1955   }
1956 too_late:
1957   {
1958     GST_DEBUG_OBJECT (sink, "dropping late sample");
1959     ret = GST_FLOW_OK;
1960     goto done;
1961   }
1962   /* ERRORS */
1963 payload_failed:
1964   {
1965     GST_ELEMENT_ERROR (sink, STREAM, FORMAT, (NULL), ("failed to payload."));
1966     ret = GST_FLOW_ERROR;
1967     goto done;
1968   }
1969 wrong_state:
1970   {
1971     GST_DEBUG_OBJECT (sink, "ringbuffer not negotiated");
1972     GST_ELEMENT_ERROR (sink, STREAM, FORMAT, (NULL), ("sink not negotiated."));
1973     ret = GST_FLOW_NOT_NEGOTIATED;
1974     goto done;
1975   }
1976 wrong_size:
1977   {
1978     GST_DEBUG_OBJECT (sink, "wrong size");
1979     GST_ELEMENT_ERROR (sink, STREAM, WRONG_TYPE,
1980         (NULL), ("sink received buffer of wrong size."));
1981     ret = GST_FLOW_ERROR;
1982     goto done;
1983   }
1984 stopping:
1985   {
1986     GST_DEBUG_OBJECT (sink, "preroll got interrupted: %d (%s)", ret,
1987         gst_flow_get_name (ret));
1988     gst_buffer_unmap (buf, &info);
1989     goto done;
1990   }
1991 sync_latency_failed:
1992   {
1993     GST_DEBUG_OBJECT (sink, "failed waiting for latency");
1994     goto done;
1995   }
1996 }
1997
1998 /**
1999  * gst_audio_base_sink_create_ringbuffer:
2000  * @sink: a #GstAudioBaseSink.
2001  *
2002  * Create and return the #GstAudioRingBuffer for @sink. This function will call the
2003  * ::create_ringbuffer vmethod and will set @sink as the parent of the returned
2004  * buffer (see gst_object_set_parent()).
2005  *
2006  * Returns: (transfer none): The new ringbuffer of @sink.
2007  */
2008 GstAudioRingBuffer *
2009 gst_audio_base_sink_create_ringbuffer (GstAudioBaseSink * sink)
2010 {
2011   GstAudioBaseSinkClass *bclass;
2012   GstAudioRingBuffer *buffer = NULL;
2013
2014   bclass = GST_AUDIO_BASE_SINK_GET_CLASS (sink);
2015   if (bclass->create_ringbuffer)
2016     buffer = bclass->create_ringbuffer (sink);
2017
2018   if (buffer)
2019     gst_object_set_parent (GST_OBJECT (buffer), GST_OBJECT (sink));
2020
2021   return buffer;
2022 }
2023
2024 static void
2025 gst_audio_base_sink_callback (GstAudioRingBuffer * rbuf, guint8 * data,
2026     guint len, gpointer user_data)
2027 {
2028   GstBaseSink *basesink;
2029   GstAudioBaseSink *sink;
2030   GstBuffer *buf = NULL;
2031   GstFlowReturn ret;
2032   gsize size;
2033
2034   basesink = GST_BASE_SINK (user_data);
2035   sink = GST_AUDIO_BASE_SINK (user_data);
2036
2037   GST_PAD_STREAM_LOCK (basesink->sinkpad);
2038
2039   /* would be nice to arrange for pad_alloc_buffer to return data -- as it is we
2040      will copy twice, once into data, once into DMA */
2041   GST_LOG_OBJECT (basesink, "pulling %u bytes offset %" G_GUINT64_FORMAT
2042       " to fill audio buffer", len, basesink->offset);
2043   ret =
2044       gst_pad_pull_range (basesink->sinkpad, basesink->segment.position, len,
2045       &buf);
2046
2047   if (ret != GST_FLOW_OK) {
2048     if (ret == GST_FLOW_EOS)
2049       goto eos;
2050     else
2051       goto error;
2052   }
2053
2054   GST_BASE_SINK_PREROLL_LOCK (basesink);
2055   if (basesink->flushing)
2056     goto flushing;
2057
2058   /* complete preroll and wait for PLAYING */
2059   ret = gst_base_sink_do_preroll (basesink, GST_MINI_OBJECT_CAST (buf));
2060   if (ret != GST_FLOW_OK)
2061     goto preroll_error;
2062
2063   size = gst_buffer_get_size (buf);
2064
2065   if (len != size) {
2066     GST_INFO_OBJECT (basesink,
2067         "got different size than requested from sink pad: %u"
2068         " != %" G_GSIZE_FORMAT, len, size);
2069     len = MIN (size, len);
2070   }
2071
2072   basesink->segment.position += len;
2073
2074   gst_buffer_extract (buf, 0, data, len);
2075   GST_BASE_SINK_PREROLL_UNLOCK (basesink);
2076
2077   GST_PAD_STREAM_UNLOCK (basesink->sinkpad);
2078
2079   return;
2080
2081 error:
2082   {
2083     GST_WARNING_OBJECT (basesink, "Got flow '%s' but can't return it: %d",
2084         gst_flow_get_name (ret), ret);
2085     gst_audio_ring_buffer_pause (rbuf);
2086     GST_PAD_STREAM_UNLOCK (basesink->sinkpad);
2087     return;
2088   }
2089 eos:
2090   {
2091     /* FIXME: this is not quite correct; we'll be called endlessly until
2092      * the sink gets shut down; maybe we should set a flag somewhere, or
2093      * set segment.stop and segment.duration to the last sample or so */
2094     GST_DEBUG_OBJECT (sink, "EOS");
2095     gst_audio_base_sink_drain (sink);
2096     gst_audio_ring_buffer_pause (rbuf);
2097     gst_element_post_message (GST_ELEMENT_CAST (sink),
2098         gst_message_new_eos (GST_OBJECT_CAST (sink)));
2099     GST_PAD_STREAM_UNLOCK (basesink->sinkpad);
2100   }
2101 flushing:
2102   {
2103     GST_DEBUG_OBJECT (sink, "we are flushing");
2104     gst_audio_ring_buffer_pause (rbuf);
2105     GST_BASE_SINK_PREROLL_UNLOCK (basesink);
2106     GST_PAD_STREAM_UNLOCK (basesink->sinkpad);
2107     return;
2108   }
2109 preroll_error:
2110   {
2111     GST_DEBUG_OBJECT (sink, "error %s", gst_flow_get_name (ret));
2112     gst_audio_ring_buffer_pause (rbuf);
2113     GST_BASE_SINK_PREROLL_UNLOCK (basesink);
2114     GST_PAD_STREAM_UNLOCK (basesink->sinkpad);
2115     return;
2116   }
2117 }
2118
2119 static gboolean
2120 gst_audio_base_sink_activate_pull (GstBaseSink * basesink, gboolean active)
2121 {
2122   gboolean ret;
2123   GstAudioBaseSink *sink = GST_AUDIO_BASE_SINK (basesink);
2124
2125   if (active) {
2126     GST_DEBUG_OBJECT (basesink, "activating pull");
2127
2128     gst_audio_ring_buffer_set_callback (sink->ringbuffer,
2129         gst_audio_base_sink_callback, sink);
2130
2131     ret = gst_audio_ring_buffer_activate (sink->ringbuffer, TRUE);
2132   } else {
2133     GST_DEBUG_OBJECT (basesink, "deactivating pull");
2134     gst_audio_ring_buffer_set_callback (sink->ringbuffer, NULL, NULL);
2135     ret = gst_audio_ring_buffer_activate (sink->ringbuffer, FALSE);
2136   }
2137
2138   return ret;
2139 }
2140
2141 #if 0
2142 /* should be called with the LOCK */
2143 static GstStateChangeReturn
2144 gst_audio_base_sink_async_play (GstBaseSink * basesink)
2145 {
2146   GstAudioBaseSink *sink;
2147
2148   sink = GST_AUDIO_BASE_SINK (basesink);
2149
2150   GST_DEBUG_OBJECT (sink, "ringbuffer may start now");
2151   sink->priv->sync_latency = TRUE;
2152   gst_audio_ring_buffer_may_start (sink->ringbuffer, TRUE);
2153   if (basesink->pad_mode == GST_PAD_MODE_PULL) {
2154     /* we always start the ringbuffer in pull mode immediatly */
2155     gst_audio_ring_buffer_start (sink->ringbuffer);
2156   }
2157
2158   return GST_STATE_CHANGE_SUCCESS;
2159 }
2160 #endif
2161
2162 static GstStateChangeReturn
2163 gst_audio_base_sink_change_state (GstElement * element,
2164     GstStateChange transition)
2165 {
2166   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
2167   GstAudioBaseSink *sink = GST_AUDIO_BASE_SINK (element);
2168
2169   switch (transition) {
2170     case GST_STATE_CHANGE_NULL_TO_READY:
2171       if (sink->ringbuffer == NULL) {
2172         gst_audio_clock_reset (GST_AUDIO_CLOCK (sink->provided_clock), 0);
2173         sink->ringbuffer = gst_audio_base_sink_create_ringbuffer (sink);
2174       }
2175       if (!gst_audio_ring_buffer_open_device (sink->ringbuffer))
2176         goto open_failed;
2177       break;
2178     case GST_STATE_CHANGE_READY_TO_PAUSED:
2179       sink->next_sample = -1;
2180       sink->priv->last_align = -1;
2181       sink->priv->eos_time = -1;
2182       sink->priv->discont_time = -1;
2183       gst_audio_ring_buffer_set_flushing (sink->ringbuffer, FALSE);
2184       gst_audio_ring_buffer_may_start (sink->ringbuffer, FALSE);
2185
2186       /* Only post clock-provide messages if this is the clock that
2187        * we've created. If the subclass has overriden it the subclass
2188        * should post this messages whenever necessary */
2189       if (sink->provided_clock && GST_IS_AUDIO_CLOCK (sink->provided_clock) &&
2190           GST_AUDIO_CLOCK_CAST (sink->provided_clock)->func ==
2191           (GstAudioClockGetTimeFunc) gst_audio_base_sink_get_time)
2192         gst_element_post_message (element,
2193             gst_message_new_clock_provide (GST_OBJECT_CAST (element),
2194                 sink->provided_clock, TRUE));
2195       break;
2196     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
2197     {
2198       gboolean eos;
2199
2200       GST_OBJECT_LOCK (sink);
2201       GST_DEBUG_OBJECT (sink, "ringbuffer may start now");
2202       sink->priv->sync_latency = TRUE;
2203       eos = GST_BASE_SINK (sink)->eos;
2204       GST_OBJECT_UNLOCK (sink);
2205
2206       gst_audio_ring_buffer_may_start (sink->ringbuffer, TRUE);
2207       if (GST_BASE_SINK_CAST (sink)->pad_mode == GST_PAD_MODE_PULL ||
2208           g_atomic_int_get (&sink->eos_rendering) || eos) {
2209         /* we always start the ringbuffer in pull mode immediatly */
2210         /* sync rendering on eos needs running clock,
2211          * and others need running clock when finished rendering eos */
2212         gst_audio_ring_buffer_start (sink->ringbuffer);
2213       }
2214       break;
2215     }
2216     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
2217       /* ringbuffer cannot start anymore */
2218       gst_audio_ring_buffer_may_start (sink->ringbuffer, FALSE);
2219       gst_audio_ring_buffer_pause (sink->ringbuffer);
2220
2221       GST_OBJECT_LOCK (sink);
2222       sink->priv->sync_latency = FALSE;
2223       GST_OBJECT_UNLOCK (sink);
2224       break;
2225     case GST_STATE_CHANGE_PAUSED_TO_READY:
2226       /* Only post clock-lost messages if this is the clock that
2227        * we've created. If the subclass has overriden it the subclass
2228        * should post this messages whenever necessary */
2229       if (sink->provided_clock && GST_IS_AUDIO_CLOCK (sink->provided_clock) &&
2230           GST_AUDIO_CLOCK_CAST (sink->provided_clock)->func ==
2231           (GstAudioClockGetTimeFunc) gst_audio_base_sink_get_time)
2232         gst_element_post_message (element,
2233             gst_message_new_clock_lost (GST_OBJECT_CAST (element),
2234                 sink->provided_clock));
2235
2236       /* make sure we unblock before calling the parent state change
2237        * so it can grab the STREAM_LOCK */
2238       gst_audio_ring_buffer_set_flushing (sink->ringbuffer, TRUE);
2239       break;
2240     default:
2241       break;
2242   }
2243
2244   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
2245
2246   switch (transition) {
2247     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
2248       /* stop slaving ourselves to the master, if any */
2249       gst_clock_set_master (sink->provided_clock, NULL);
2250       break;
2251     case GST_STATE_CHANGE_PAUSED_TO_READY:
2252       gst_audio_ring_buffer_activate (sink->ringbuffer, FALSE);
2253       gst_audio_ring_buffer_release (sink->ringbuffer);
2254       break;
2255     case GST_STATE_CHANGE_READY_TO_NULL:
2256       /* we release again here because the aqcuire happens when setting the
2257        * caps, which happens before we commit the state to PAUSED and thus the
2258        * PAUSED->READY state change (see above, where we release the ringbuffer)
2259        * might not be called when we get here. */
2260       gst_audio_ring_buffer_activate (sink->ringbuffer, FALSE);
2261       gst_audio_ring_buffer_release (sink->ringbuffer);
2262       gst_audio_ring_buffer_close_device (sink->ringbuffer);
2263       GST_OBJECT_LOCK (sink);
2264       gst_object_unparent (GST_OBJECT_CAST (sink->ringbuffer));
2265       sink->ringbuffer = NULL;
2266       GST_OBJECT_UNLOCK (sink);
2267       break;
2268     default:
2269       break;
2270   }
2271
2272   return ret;
2273
2274   /* ERRORS */
2275 open_failed:
2276   {
2277     /* subclass must post a meaningful error message */
2278     GST_DEBUG_OBJECT (sink, "open failed");
2279     return GST_STATE_CHANGE_FAILURE;
2280   }
2281 }