diff -r 9b2c3c7a1a9c -r 567bb019e3e3 gst_plugins_base/gst-libs/gst/audio/gstbaseaudiosrc.c --- a/gst_plugins_base/gst-libs/gst/audio/gstbaseaudiosrc.c Wed Mar 31 22:03:18 2010 +0300 +++ b/gst_plugins_base/gst-libs/gst/audio/gstbaseaudiosrc.c Tue Aug 31 15:30:33 2010 +0300 @@ -42,12 +42,31 @@ #include "gst/gst-i18n-plugin.h" +GST_DEBUG_CATEGORY_STATIC (gst_base_audio_src_debug); +#define GST_CAT_DEFAULT gst_base_audio_src_debug + #ifdef __SYMBIAN32__ -#include +EXPORT_C #endif -GST_DEBUG_CATEGORY_STATIC (gst_base_audio_src_debug); -#define GST_CAT_DEFAULT gst_base_audio_src_debug +GType +gst_base_audio_src_slave_method_get_type (void) +{ + static GType slave_method_type = 0; + static const GEnumValue slave_method[] = { + {GST_BASE_AUDIO_SRC_SLAVE_RESAMPLE, "Resampling slaving", "resample"}, + {GST_BASE_AUDIO_SRC_SLAVE_RETIMESTAMP, "Re-timestamp", "re-timestamp"}, + {GST_BASE_AUDIO_SRC_SLAVE_SKEW, "Skew", "skew"}, + {GST_BASE_AUDIO_SRC_SLAVE_NONE, "No slaving", "none"}, + {0, NULL, NULL}, + }; + + if (!slave_method_type) { + slave_method_type = + g_enum_register_static ("GstBaseAudioSrcSlaveMethod", slave_method); + } + return slave_method_type; +} #define GST_BASE_AUDIO_SRC_GET_PRIVATE(obj) \ (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_BASE_AUDIO_SRC, GstBaseAudioSrcPrivate)) @@ -55,6 +74,9 @@ struct _GstBaseAudioSrcPrivate { gboolean provide_clock; + + /* the clock slaving algorithm in use */ + GstBaseAudioSrcSlaveMethod slave_method; }; /* BaseAudioSrc signals and args */ @@ -66,14 +88,21 @@ #define DEFAULT_BUFFER_TIME ((200 * GST_MSECOND) / GST_USECOND) #define DEFAULT_LATENCY_TIME ((10 * GST_MSECOND) / GST_USECOND) +#define DEFAULT_ACTUAL_BUFFER_TIME -1 +#define DEFAULT_ACTUAL_LATENCY_TIME -1 #define DEFAULT_PROVIDE_CLOCK TRUE +#define DEFAULT_SLAVE_METHOD GST_BASE_AUDIO_SRC_SLAVE_RETIMESTAMP enum { PROP_0, PROP_BUFFER_TIME, PROP_LATENCY_TIME, - PROP_PROVIDE_CLOCK + PROP_ACTUAL_BUFFER_TIME, + PROP_ACTUAL_LATENCY_TIME, + PROP_PROVIDE_CLOCK, + PROP_SLAVE_METHOD, + PROP_LAST }; static void @@ -86,6 +115,7 @@ GST_DEBUG ("binding text domain %s to locale dir %s", GETTEXT_PACKAGE, LOCALEDIR); bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); #endif /* ENABLE_NLS */ } @@ -147,17 +177,51 @@ g_object_class_install_property (gobject_class, PROP_BUFFER_TIME, g_param_spec_int64 ("buffer-time", "Buffer Time", "Size of audio buffer in microseconds", 1, - G_MAXINT64, DEFAULT_BUFFER_TIME, G_PARAM_READWRITE)); + G_MAXINT64, DEFAULT_BUFFER_TIME, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_LATENCY_TIME, g_param_spec_int64 ("latency-time", "Latency Time", "Audio latency in microseconds", 1, - G_MAXINT64, DEFAULT_LATENCY_TIME, G_PARAM_READWRITE)); + G_MAXINT64, DEFAULT_LATENCY_TIME, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + /** + * GstBaseAudioSrc:actual-buffer-time: + * + * Actual configured size of audio buffer in microseconds. + * + * Since: 0.10.20 + **/ + g_object_class_install_property (gobject_class, PROP_ACTUAL_BUFFER_TIME, + g_param_spec_int64 ("actual-buffer-time", "Actual Buffer Time", + "Actual configured size of audio buffer in microseconds", + DEFAULT_ACTUAL_BUFFER_TIME, G_MAXINT64, DEFAULT_ACTUAL_BUFFER_TIME, + G_PARAM_READABLE)); + + /** + * GstBaseAudioSrc:actual-latency-time: + * + * Actual configured audio latency in microseconds. + * + * Since: 0.10.20 + **/ + g_object_class_install_property (gobject_class, PROP_ACTUAL_LATENCY_TIME, + g_param_spec_int64 ("actual-latency-time", "Actual Latency Time", + "Actual configured audio latency in microseconds", + DEFAULT_ACTUAL_LATENCY_TIME, G_MAXINT64, DEFAULT_ACTUAL_LATENCY_TIME, + G_PARAM_READABLE)); g_object_class_install_property (gobject_class, PROP_PROVIDE_CLOCK, g_param_spec_boolean ("provide-clock", "Provide Clock", "Provide a clock to be used as the global pipeline clock", - DEFAULT_PROVIDE_CLOCK, G_PARAM_READWRITE)); + DEFAULT_PROVIDE_CLOCK, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property (gobject_class, PROP_SLAVE_METHOD, + g_param_spec_enum ("slave-method", "Slave Method", + "Algorithm to use to match the rate of the masterclock", + GST_TYPE_BASE_AUDIO_SRC_SLAVE_METHOD, DEFAULT_SLAVE_METHOD, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_base_audio_src_change_state); @@ -177,6 +241,7 @@ /* ref class from a thread-safe context to work around missing bit of * thread-safety in GObject */ g_type_class_ref (GST_TYPE_AUDIO_CLOCK); + g_type_class_ref (GST_TYPE_RING_BUFFER); } static void @@ -188,6 +253,7 @@ baseaudiosrc->buffer_time = DEFAULT_BUFFER_TIME; baseaudiosrc->latency_time = DEFAULT_LATENCY_TIME; baseaudiosrc->priv->provide_clock = DEFAULT_PROVIDE_CLOCK; + baseaudiosrc->priv->slave_method = DEFAULT_SLAVE_METHOD; /* reset blocksize we use latency time to calculate a more useful * value based on negotiated format. */ GST_BASE_SRC (baseaudiosrc)->blocksize = 0; @@ -208,6 +274,7 @@ src = GST_BASE_AUDIO_SRC (object); + GST_OBJECT_LOCK (src); if (src->clock) gst_object_unref (src->clock); src->clock = NULL; @@ -216,6 +283,7 @@ gst_object_unparent (GST_OBJECT_CAST (src->ringbuffer)); src->ringbuffer = NULL; } + GST_OBJECT_UNLOCK (src); G_OBJECT_CLASS (parent_class)->dispose (object); } @@ -350,6 +418,58 @@ return result; } +/** + * gst_base_audio_src_set_slave_method: + * @src: a #GstBaseAudioSrc + * @method: the new slave method + * + * Controls how clock slaving will be performed in @src. + * + * Since: 0.10.20 + */ +#ifdef __SYMBIAN32__ +EXPORT_C +#endif + +void +gst_base_audio_src_set_slave_method (GstBaseAudioSrc * src, + GstBaseAudioSrcSlaveMethod method) +{ + g_return_if_fail (GST_IS_BASE_AUDIO_SRC (src)); + + GST_OBJECT_LOCK (src); + src->priv->slave_method = method; + GST_OBJECT_UNLOCK (src); +} + +/** + * gst_base_audio_src_get_slave_method: + * @src: a #GstBaseAudioSrc + * + * Get the current slave method used by @src. + * + * Returns: The current slave method used by @src. + * + * Since: 0.10.20 + */ +#ifdef __SYMBIAN32__ +EXPORT_C +#endif + +GstBaseAudioSrcSlaveMethod +gst_base_audio_src_get_slave_method (GstBaseAudioSrc * src) +{ + GstBaseAudioSrcSlaveMethod result; + + g_return_val_if_fail (GST_IS_BASE_AUDIO_SRC (src), -1); + + GST_OBJECT_LOCK (src); + result = src->priv->slave_method; + GST_OBJECT_UNLOCK (src); + + return result; +} + static void gst_base_audio_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) @@ -368,6 +488,9 @@ case PROP_PROVIDE_CLOCK: gst_base_audio_src_set_provide_clock (src, g_value_get_boolean (value)); break; + case PROP_SLAVE_METHOD: + gst_base_audio_src_set_slave_method (src, g_value_get_enum (value)); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -389,9 +512,28 @@ case PROP_LATENCY_TIME: g_value_set_int64 (value, src->latency_time); break; + case PROP_ACTUAL_BUFFER_TIME: + GST_OBJECT_LOCK (src); + if (src->ringbuffer && src->ringbuffer->acquired) + g_value_set_int64 (value, src->ringbuffer->spec.buffer_time); + else + g_value_set_int64 (value, DEFAULT_ACTUAL_BUFFER_TIME); + GST_OBJECT_UNLOCK (src); + break; + case PROP_ACTUAL_LATENCY_TIME: + GST_OBJECT_LOCK (src); + if (src->ringbuffer && src->ringbuffer->acquired) + g_value_set_int64 (value, src->ringbuffer->spec.latency_time); + else + g_value_set_int64 (value, DEFAULT_ACTUAL_LATENCY_TIME); + GST_OBJECT_UNLOCK (src); + break; case PROP_PROVIDE_CLOCK: g_value_set_boolean (value, gst_base_audio_src_get_provide_clock (src)); break; + case PROP_SLAVE_METHOD: + g_value_set_enum (value, gst_base_audio_src_get_slave_method (src)); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -463,6 +605,9 @@ gst_ring_buffer_debug_spec_buff (spec); + g_object_notify (G_OBJECT (src), "actual-buffer-time"); + g_object_notify (G_OBJECT (src), "actual-latency-time"); + return TRUE; /* ERRORS */ @@ -538,21 +683,31 @@ gst_base_audio_src_event (GstBaseSrc * bsrc, GstEvent * event) { GstBaseAudioSrc *src = GST_BASE_AUDIO_SRC (bsrc); + gboolean res; + + res = TRUE; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_FLUSH_START: + GST_DEBUG_OBJECT (bsrc, "flush-start"); gst_ring_buffer_pause (src->ringbuffer); gst_ring_buffer_clear_all (src->ringbuffer); break; case GST_EVENT_FLUSH_STOP: + GST_DEBUG_OBJECT (bsrc, "flush-stop"); /* always resync on sample after a flush */ src->next_sample = -1; gst_ring_buffer_clear_all (src->ringbuffer); break; + case GST_EVENT_SEEK: + GST_DEBUG_OBJECT (bsrc, "refuse to seek"); + res = FALSE; + break; default: + GST_DEBUG_OBJECT (bsrc, "dropping event %p", event); break; } - return TRUE; + return res; } /* get the next offset in the ringbuffer for reading samples. @@ -591,7 +746,7 @@ if (diff >= segtotal) { GST_DEBUG_OBJECT (src, "dropped, align to segment %d", segdone); /* sample would be dropped, position to next playable position */ - sample = (segdone - segtotal + 1) * sps; + sample = ((guint64) (segdone)) * sps; } return sample; @@ -677,7 +832,9 @@ G_GUINT64_FORMAT, sample - src->next_sample, sample); GST_ELEMENT_WARNING (src, CORE, CLOCK, (_("Can't record audio fast enough")), - ("dropped %" G_GUINT64_FORMAT " samples", sample - src->next_sample)); + ("Dropped %" G_GUINT64_FORMAT " samples. This is most likely because " + "downstream can't keep up and is consuming samples too slowly.", + sample - src->next_sample)); GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT); } @@ -689,28 +846,179 @@ spec->rate) - timestamp; GST_OBJECT_LOCK (src); - clock = GST_ELEMENT_CLOCK (src); - if (clock != NULL && clock != src->clock) { - GstClockTime base_time, latency; + if (!(clock = GST_ELEMENT_CLOCK (src))) + goto no_sync; + + if (clock != src->clock) { + /* we are slaved, check how to handle this */ + switch (src->priv->slave_method) { + case GST_BASE_AUDIO_SRC_SLAVE_RESAMPLE: + /* not implemented, use skew algorithm. This algorithm should + * work on the readout pointer and produces more or less samples based + * on the clock drift */ + case GST_BASE_AUDIO_SRC_SLAVE_SKEW: + { + GstClockTime running_time; + GstClockTime base_time; + GstClockTime current_time; + guint64 running_time_sample; + gint running_time_segment; + gint current_segment; + gint segment_skew; + gint sps; + + /* samples per segment */ + sps = ringbuffer->samples_per_seg; + + /* get the current time */ + current_time = gst_clock_get_time (clock); + + /* get the basetime */ + base_time = GST_ELEMENT_CAST (src)->base_time; + + /* get the running_time */ + running_time = current_time - base_time; + + /* the running_time converted to a sample (relative to the ringbuffer) */ + running_time_sample = + gst_util_uint64_scale_int (running_time, spec->rate, GST_SECOND); + + /* the segmentnr corrensponding to running_time, round down */ + running_time_segment = running_time_sample / sps; + + /* the segment currently read from the ringbuffer */ + current_segment = sample / sps; + + /* the skew we have between running_time and the ringbuffertime */ + segment_skew = running_time_segment - current_segment; + + GST_DEBUG_OBJECT (bsrc, "\n running_time = %" GST_TIME_FORMAT + "\n timestamp = %" GST_TIME_FORMAT + "\n running_time_segment = %d" + "\n current_segment = %d" + "\n segment_skew = %d", + GST_TIME_ARGS (running_time), + GST_TIME_ARGS (timestamp), + running_time_segment, current_segment, segment_skew); - /* We are slaved to another clock, take running time of the clock and just - * timestamp against it. Somebody else in the pipeline should figure out the - * clock drift, for now. We keep the duration we calculated above. */ - timestamp = gst_clock_get_time (clock); + /* Resync the ringbuffer if: + * 1. We get one segment into the future. + * This is clearly a lie, because we can't + * possibly have a buffer with timestamp 1 at + * time 0. (unless it has time-travelled...) + * + * 2. We are more than the length of the ringbuffer behind. + * The length of the ringbuffer then gets to dictate + * the threshold for what is concidered "too late" + * + * 3. If this is our first buffer. + * We know that we should catch up to running_time + * the first time we are ran. + */ + if ((segment_skew < 0) || + (segment_skew >= ringbuffer->spec.segtotal) || + (current_segment == 0)) { + gint segments_written; + gint first_segment; + gint last_segment; + gint new_last_segment; + gint segment_diff; + gint new_first_segment; + guint64 new_sample; + + /* we are going to say that the last segment was captured at the current time + (running_time), minus one segment of creation-latency in the ringbuffer. + This can be thought of as: The segment arrived in the ringbuffer at time X, and + that means it was created at time X - (one segment). */ + new_last_segment = running_time_segment - 1; + + /* for better readablity */ + first_segment = current_segment; + + /* get the amount of segments written from the device by now */ + segments_written = g_atomic_int_get (&ringbuffer->segdone); + + /* subtract the base to segments_written to get the number of the + last written segment in the ringbuffer (one segment written = segment 0) */ + last_segment = segments_written - ringbuffer->segbase - 1; + + /* we see how many segments the ringbuffer was timeshifted */ + segment_diff = new_last_segment - last_segment; + + /* we move the first segment an equal amount */ + new_first_segment = first_segment + segment_diff; + + /* and we also move the segmentbase the same amount */ + ringbuffer->segbase -= segment_diff; + + /* we calculate the new sample value */ + new_sample = ((guint64) new_first_segment) * sps; + + /* and get the relative time to this -> our new timestamp */ + timestamp = + gst_util_uint64_scale_int (new_sample, GST_SECOND, spec->rate); + + /* we update the next sample accordingly */ + src->next_sample = new_sample + samples; + + GST_DEBUG_OBJECT (bsrc, + "Timeshifted the ringbuffer with %d segments: " + "Updating the timestamp to %" GST_TIME_FORMAT ", " + "and src->next_sample to %" G_GUINT64_FORMAT, segment_diff, + GST_TIME_ARGS (timestamp), src->next_sample); + } + break; + } + case GST_BASE_AUDIO_SRC_SLAVE_RETIMESTAMP: + { + GstClockTime base_time, latency; + + /* We are slaved to another clock, take running time of the pipeline clock and + * timestamp against it. Somebody else in the pipeline should figure out the + * clock drift. We keep the duration we calculated above. */ + timestamp = gst_clock_get_time (clock); + base_time = GST_ELEMENT_CAST (src)->base_time; + + if (timestamp > base_time) + timestamp -= base_time; + else + timestamp = 0; + + /* subtract latency */ + latency = + gst_util_uint64_scale_int (total_samples, GST_SECOND, spec->rate); + if (timestamp > latency) + timestamp -= latency; + else + timestamp = 0; + } + case GST_BASE_AUDIO_SRC_SLAVE_NONE: + break; + } + } else { + GstClockTime base_time; + + /* to get the timestamp against the clock we also need to add our offset */ + timestamp = gst_audio_clock_adjust (clock, timestamp); + + /* we are not slaved, subtract base_time */ base_time = GST_ELEMENT_CAST (src)->base_time; - if (timestamp > base_time) + if (timestamp > base_time) { timestamp -= base_time; - else + GST_LOG_OBJECT (src, + "buffer timestamp %" GST_TIME_FORMAT " (base_time %" GST_TIME_FORMAT + ")", GST_TIME_ARGS (timestamp), GST_TIME_ARGS (base_time)); + } else { + GST_LOG_OBJECT (src, + "buffer timestamp 0, ts %" GST_TIME_FORMAT " <= base_time %" + GST_TIME_FORMAT, GST_TIME_ARGS (timestamp), + GST_TIME_ARGS (base_time)); timestamp = 0; + } + } - /* subtract latency */ - latency = gst_util_uint64_scale_int (total_samples, GST_SECOND, spec->rate); - if (timestamp > latency) - timestamp -= latency; - else - timestamp = 0; - } +no_sync: GST_OBJECT_UNLOCK (src); GST_BUFFER_TIMESTAMP (buf) = timestamp; @@ -718,8 +1026,6 @@ GST_BUFFER_OFFSET (buf) = sample; GST_BUFFER_OFFSET_END (buf) = sample + samples; - gst_buffer_set_caps (buf, GST_PAD_CAPS (GST_BASE_SRC_PAD (bsrc))); - *outbuf = buf; return GST_FLOW_OK; @@ -785,9 +1091,12 @@ switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: GST_DEBUG_OBJECT (src, "NULL->READY"); + GST_OBJECT_LOCK (src); if (src->ringbuffer == NULL) { + gst_audio_clock_reset (GST_AUDIO_CLOCK (src->clock), 0); src->ringbuffer = gst_base_audio_src_create_ringbuffer (src); } + GST_OBJECT_UNLOCK (src); if (!gst_ring_buffer_open_device (src->ringbuffer)) goto open_failed; break; @@ -824,8 +1133,10 @@ case GST_STATE_CHANGE_READY_TO_NULL: GST_DEBUG_OBJECT (src, "READY->NULL"); gst_ring_buffer_close_device (src->ringbuffer); + GST_OBJECT_LOCK (src); gst_object_unparent (GST_OBJECT_CAST (src->ringbuffer)); src->ringbuffer = NULL; + GST_OBJECT_UNLOCK (src); break; default: break;