mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-19 14:56:36 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst-libs/gst/audio/gstbaseaudiosrc.c
Wim Taymans dae848818d audio: rework audio caps. 
Rework the audio caps similar to the video caps. Remove
width/depth/endianness/signed fields and replace with a simple string
format and media type audio/x-raw.
Create a GstAudioInfo and some helper methods to parse caps.
Remove duplicate code from the ringbuffer and replace with audio info.
Use AudioInfo in the base audio filter class.
Port elements to new API.
2011-08-18 19:15:03 +02:00

1153 lines
36 KiB
C
Raw Blame History

/* GStreamer
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2005 Wim Taymans <wim@fluendo.com>
*
* gstbaseaudiosrc.c:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/**
* SECTION:gstbaseaudiosrc
* @short_description: Base class for audio sources
* @see_also: #GstAudioSrc, #GstRingBuffer.
*
* This is the base class for audio sources. Subclasses need to implement the
* ::create_ringbuffer vmethod. This base class will then take care of
* reading samples from the ringbuffer, synchronisation and flushing.
*
* Last reviewed on 2006-09-27 (0.10.12)
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <string.h>
#include "gstbaseaudiosrc.h"
#include "gst/gst-i18n-plugin.h"
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 volatile gsize slave_method_type = 0;
/* FIXME 0.11: nick should be "retimestamp" not "re-timestamp" */
static const GEnumValue slave_method[] = {
{GST_BASE_AUDIO_SRC_SLAVE_RESAMPLE,
"GST_BASE_AUDIO_SRC_SLAVE_RESAMPLE", "resample"},
{GST_BASE_AUDIO_SRC_SLAVE_RETIMESTAMP,
"GST_BASE_AUDIO_SRC_SLAVE_RETIMESTAMP", "re-timestamp"},
{GST_BASE_AUDIO_SRC_SLAVE_SKEW, "GST_BASE_AUDIO_SRC_SLAVE_SKEW", "skew"},
{GST_BASE_AUDIO_SRC_SLAVE_NONE, "GST_BASE_AUDIO_SRC_SLAVE_NONE", "none"},
{0, NULL, NULL},
};
if (g_once_init_enter (&slave_method_type)) {
GType tmp =
g_enum_register_static ("GstBaseAudioSrcSlaveMethod", slave_method);
g_once_init_leave (&slave_method_type, tmp);
}
return (GType) slave_method_type;
}
#define GST_BASE_AUDIO_SRC_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_BASE_AUDIO_SRC, GstBaseAudioSrcPrivate))
struct _GstBaseAudioSrcPrivate
{
gboolean provide_clock;
/* the clock slaving algorithm in use */
GstBaseAudioSrcSlaveMethod slave_method;
};
/* BaseAudioSrc signals and args */
enum
{
/* FILL ME */
LAST_SIGNAL
};
#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_SKEW
enum
{
PROP_0,
PROP_BUFFER_TIME,
PROP_LATENCY_TIME,
PROP_ACTUAL_BUFFER_TIME,
PROP_ACTUAL_LATENCY_TIME,
PROP_PROVIDE_CLOCK,
PROP_SLAVE_METHOD,
PROP_LAST
};
static void
_do_init (GType type)
{
GST_DEBUG_CATEGORY_INIT (gst_base_audio_src_debug, "baseaudiosrc", 0,
"baseaudiosrc element");
#ifdef ENABLE_NLS
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 */
}
#define gst_base_audio_src_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstBaseAudioSrc, gst_base_audio_src, GST_TYPE_PUSH_SRC,
_do_init (g_define_type_id));
static void gst_base_audio_src_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_base_audio_src_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static void gst_base_audio_src_dispose (GObject * object);
static GstStateChangeReturn gst_base_audio_src_change_state (GstElement *
element, GstStateChange transition);
static GstClock *gst_base_audio_src_provide_clock (GstElement * elem);
static GstClockTime gst_base_audio_src_get_time (GstClock * clock,
GstBaseAudioSrc * src);
static GstFlowReturn gst_base_audio_src_create (GstBaseSrc * bsrc,
guint64 offset, guint length, GstBuffer ** buf);
static gboolean gst_base_audio_src_event (GstBaseSrc * bsrc, GstEvent * event);
static void gst_base_audio_src_get_times (GstBaseSrc * bsrc,
GstBuffer * buffer, GstClockTime * start, GstClockTime * end);
static gboolean gst_base_audio_src_setcaps (GstBaseSrc * bsrc, GstCaps * caps);
static gboolean gst_base_audio_src_query (GstBaseSrc * bsrc, GstQuery * query);
static void gst_base_audio_src_fixate (GstBaseSrc * bsrc, GstCaps * caps);
/* static guint gst_base_audio_src_signals[LAST_SIGNAL] = { 0 }; */
static void
gst_base_audio_src_class_init (GstBaseAudioSrcClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
GstBaseSrcClass *gstbasesrc_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
gstbasesrc_class = (GstBaseSrcClass *) klass;
g_type_class_add_private (klass, sizeof (GstBaseAudioSrcPrivate));
gobject_class->set_property = gst_base_audio_src_set_property;
gobject_class->get_property = gst_base_audio_src_get_property;
gobject_class->dispose = gst_base_audio_src_dispose;
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_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_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 | G_PARAM_STATIC_STRINGS));
/**
* 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_PARAM_STATIC_STRINGS));
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 | 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);
gstelement_class->provide_clock =
GST_DEBUG_FUNCPTR (gst_base_audio_src_provide_clock);
gstbasesrc_class->set_caps = GST_DEBUG_FUNCPTR (gst_base_audio_src_setcaps);
gstbasesrc_class->event = GST_DEBUG_FUNCPTR (gst_base_audio_src_event);
gstbasesrc_class->query = GST_DEBUG_FUNCPTR (gst_base_audio_src_query);
gstbasesrc_class->get_times =
GST_DEBUG_FUNCPTR (gst_base_audio_src_get_times);
gstbasesrc_class->create = GST_DEBUG_FUNCPTR (gst_base_audio_src_create);
gstbasesrc_class->fixate = GST_DEBUG_FUNCPTR (gst_base_audio_src_fixate);
/* 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
gst_base_audio_src_init (GstBaseAudioSrc * baseaudiosrc)
{
baseaudiosrc->priv = GST_BASE_AUDIO_SRC_GET_PRIVATE (baseaudiosrc);
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;
baseaudiosrc->clock = gst_audio_clock_new ("GstAudioSrcClock",
(GstAudioClockGetTimeFunc) gst_base_audio_src_get_time, baseaudiosrc);
/* we are always a live source */
gst_base_src_set_live (GST_BASE_SRC (baseaudiosrc), TRUE);
/* we operate in time */
gst_base_src_set_format (GST_BASE_SRC (baseaudiosrc), GST_FORMAT_TIME);
}
static void
gst_base_audio_src_dispose (GObject * object)
{
GstBaseAudioSrc *src;
src = GST_BASE_AUDIO_SRC (object);
GST_OBJECT_LOCK (src);
if (src->clock) {
gst_audio_clock_invalidate (src->clock);
gst_object_unref (src->clock);
src->clock = NULL;
}
if (src->ringbuffer) {
gst_object_unparent (GST_OBJECT_CAST (src->ringbuffer));
src->ringbuffer = NULL;
}
GST_OBJECT_UNLOCK (src);
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static GstClock *
gst_base_audio_src_provide_clock (GstElement * elem)
{
GstBaseAudioSrc *src;
GstClock *clock;
src = GST_BASE_AUDIO_SRC (elem);
/* we have no ringbuffer (must be NULL state) */
if (src->ringbuffer == NULL)
goto wrong_state;
if (!gst_ring_buffer_is_acquired (src->ringbuffer))
goto wrong_state;
GST_OBJECT_LOCK (src);
if (!src->priv->provide_clock)
goto clock_disabled;
clock = GST_CLOCK_CAST (gst_object_ref (src->clock));
GST_OBJECT_UNLOCK (src);
return clock;
/* ERRORS */
wrong_state:
{
GST_DEBUG_OBJECT (src, "ringbuffer not acquired");
return NULL;
}
clock_disabled:
{
GST_DEBUG_OBJECT (src, "clock provide disabled");
GST_OBJECT_UNLOCK (src);
return NULL;
}
}
static GstClockTime
gst_base_audio_src_get_time (GstClock * clock, GstBaseAudioSrc * src)
{
guint64 raw, samples;
guint delay;
GstClockTime result;
if (G_UNLIKELY (src->ringbuffer == NULL
|| src->ringbuffer->spec.info.rate == 0))
return GST_CLOCK_TIME_NONE;
raw = samples = gst_ring_buffer_samples_done (src->ringbuffer);
/* the number of samples not yet processed, this is still queued in the
* device (not yet read for capture). */
delay = gst_ring_buffer_delay (src->ringbuffer);
samples += delay;
result = gst_util_uint64_scale_int (samples, GST_SECOND,
src->ringbuffer->spec.info.rate);
GST_DEBUG_OBJECT (src,
"processed samples: raw %" G_GUINT64_FORMAT ", delay %u, real %"
G_GUINT64_FORMAT ", time %" GST_TIME_FORMAT, raw, delay, samples,
GST_TIME_ARGS (result));
return result;
}
/**
* gst_base_audio_src_set_provide_clock:
* @src: a #GstBaseAudioSrc
* @provide: new state
*
* Controls whether @src will provide a clock or not. If @provide is %TRUE,
* gst_element_provide_clock() will return a clock that reflects the datarate
* of @src. If @provide is %FALSE, gst_element_provide_clock() will return NULL.
*
* Since: 0.10.16
*/
void
gst_base_audio_src_set_provide_clock (GstBaseAudioSrc * src, gboolean provide)
{
g_return_if_fail (GST_IS_BASE_AUDIO_SRC (src));
GST_OBJECT_LOCK (src);
src->priv->provide_clock = provide;
GST_OBJECT_UNLOCK (src);
}
/**
* gst_base_audio_src_get_provide_clock:
* @src: a #GstBaseAudioSrc
*
* Queries whether @src will provide a clock or not. See also
* gst_base_audio_src_set_provide_clock.
*
* Returns: %TRUE if @src will provide a clock.
*
* Since: 0.10.16
*/
gboolean
gst_base_audio_src_get_provide_clock (GstBaseAudioSrc * src)
{
gboolean result;
g_return_val_if_fail (GST_IS_BASE_AUDIO_SRC (src), FALSE);
GST_OBJECT_LOCK (src);
result = src->priv->provide_clock;
GST_OBJECT_UNLOCK (src);
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
*/
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
*/
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)
{
GstBaseAudioSrc *src;
src = GST_BASE_AUDIO_SRC (object);
switch (prop_id) {
case PROP_BUFFER_TIME:
src->buffer_time = g_value_get_int64 (value);
break;
case PROP_LATENCY_TIME:
src->latency_time = g_value_get_int64 (value);
break;
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;
}
}
static void
gst_base_audio_src_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstBaseAudioSrc *src;
src = GST_BASE_AUDIO_SRC (object);
switch (prop_id) {
case PROP_BUFFER_TIME:
g_value_set_int64 (value, src->buffer_time);
break;
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;
}
}
static void
gst_base_audio_src_fixate (GstBaseSrc * bsrc, GstCaps * caps)
{
GstStructure *s;
s = gst_caps_get_structure (caps, 0);
/* fields for all formats */
gst_structure_fixate_field_nearest_int (s, "rate", GST_AUDIO_DEF_RATE);
gst_structure_fixate_field_nearest_int (s, "channels",
GST_AUDIO_DEF_CHANNELS);
gst_structure_fixate_field_string (s, "format", GST_AUDIO_DEF_FORMAT);
GST_BASE_SRC_CLASS (parent_class)->fixate (bsrc, caps);
}
static gboolean
gst_base_audio_src_setcaps (GstBaseSrc * bsrc, GstCaps * caps)
{
GstBaseAudioSrc *src = GST_BASE_AUDIO_SRC (bsrc);
GstRingBufferSpec *spec;
gint bpf, rate;
spec = &src->ringbuffer->spec;
spec->buffer_time = src->buffer_time;
spec->latency_time = src->latency_time;
GST_OBJECT_LOCK (src);
if (!gst_ring_buffer_parse_caps (spec, caps)) {
GST_OBJECT_UNLOCK (src);
goto parse_error;
}
bpf = GST_AUDIO_INFO_BPF (&spec->info);
rate = GST_AUDIO_INFO_RATE (&spec->info);
/* calculate suggested segsize and segtotal */
spec->segsize = rate * bpf * spec->latency_time / GST_MSECOND;
spec->segtotal = spec->buffer_time / spec->latency_time;
GST_OBJECT_UNLOCK (src);
GST_DEBUG ("release old ringbuffer");
gst_ring_buffer_release (src->ringbuffer);
gst_ring_buffer_debug_spec_buff (spec);
GST_DEBUG ("acquire new ringbuffer");
if (!gst_ring_buffer_acquire (src->ringbuffer, spec))
goto acquire_error;
/* calculate actual latency and buffer times */
spec->latency_time = spec->segsize * GST_MSECOND / (rate * bpf);
spec->buffer_time =
spec->segtotal * spec->segsize * GST_MSECOND / (rate * bpf);
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 */
parse_error:
{
GST_DEBUG ("could not parse caps");
return FALSE;
}
acquire_error:
{
GST_DEBUG ("could not acquire ringbuffer");
return FALSE;
}
}
static void
gst_base_audio_src_get_times (GstBaseSrc * bsrc, GstBuffer * buffer,
GstClockTime * start, GstClockTime * end)
{
/* no need to sync to a clock here, we schedule the samples based
* on our own clock for the moment. */
*start = GST_CLOCK_TIME_NONE;
*end = GST_CLOCK_TIME_NONE;
}
static gboolean
gst_base_audio_src_query (GstBaseSrc * bsrc, GstQuery * query)
{
GstBaseAudioSrc *src = GST_BASE_AUDIO_SRC (bsrc);
gboolean res = FALSE;
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_LATENCY:
{
GstClockTime min_latency, max_latency;
GstRingBufferSpec *spec;
gint bpf, rate;
GST_OBJECT_LOCK (src);
if (G_UNLIKELY (src->ringbuffer == NULL
|| src->ringbuffer->spec.info.rate == 0)) {
GST_OBJECT_UNLOCK (src);
goto done;
}
spec = &src->ringbuffer->spec;
rate = GST_AUDIO_INFO_RATE (&spec->info);
bpf = GST_AUDIO_INFO_BPF (&spec->info);
/* we have at least 1 segment of latency */
min_latency =
gst_util_uint64_scale_int (spec->segsize, GST_SECOND, rate * bpf);
/* we cannot delay more than the buffersize else we lose data */
max_latency =
gst_util_uint64_scale_int (spec->segtotal * spec->segsize, GST_SECOND,
rate * bpf);
GST_OBJECT_UNLOCK (src);
GST_DEBUG_OBJECT (src,
"report latency min %" GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
GST_TIME_ARGS (min_latency), GST_TIME_ARGS (max_latency));
/* we are always live, the min latency is 1 segment and the max latency is
* the complete buffer of segments. */
gst_query_set_latency (query, TRUE, min_latency, max_latency);
res = TRUE;
break;
}
case GST_QUERY_SCHEDULING:
{
/* we allow limited pull base operation of which the details
* will eventually exposed in an as of yet non-existing query.
* Basically pulling can be done on any number of bytes as long
* as the offset is -1 or sequentially increasing. */
gst_query_set_scheduling (query, TRUE, FALSE, TRUE, 1, -1, 1);
res = TRUE;
break;
}
default:
res = GST_BASE_SRC_CLASS (parent_class)->query (bsrc, query);
break;
}
done:
return res;
}
static gboolean
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 res;
}
/* get the next offset in the ringbuffer for reading samples.
* If the next sample is too far away, this function will position itself to the
* next most recent sample, creating discontinuity */
static guint64
gst_base_audio_src_get_offset (GstBaseAudioSrc * src)
{
guint64 sample;
gint readseg, segdone, segtotal, sps;
gint diff;
/* assume we can append to the previous sample */
sample = src->next_sample;
sps = src->ringbuffer->samples_per_seg;
segtotal = src->ringbuffer->spec.segtotal;
/* get the currently processed segment */
segdone = g_atomic_int_get (&src->ringbuffer->segdone)
- src->ringbuffer->segbase;
if (sample != -1) {
GST_DEBUG_OBJECT (src, "at segment %d and sample %" G_GUINT64_FORMAT,
segdone, sample);
/* figure out the segment and the offset inside the segment where
* the sample should be read from. */
readseg = sample / sps;
/* see how far away it is from the read segment, normally segdone (where new
* data is written in the ringbuffer) is bigger than readseg (where we are
* reading). */
diff = segdone - readseg;
if (diff >= segtotal) {
GST_DEBUG_OBJECT (src, "dropped, align to segment %d", segdone);
/* sample would be dropped, position to next playable position */
sample = ((guint64) (segdone)) * sps;
}
} else {
/* no previous sample, go to the current position */
GST_DEBUG_OBJECT (src, "first sample, align to current %d", segdone);
sample = ((guint64) (segdone)) * sps;
readseg = segdone;
}
GST_DEBUG_OBJECT (src,
"reading from %d, we are at %d, sample %" G_GUINT64_FORMAT, readseg,
segdone, sample);
return sample;
}
static GstFlowReturn
gst_base_audio_src_create (GstBaseSrc * bsrc, guint64 offset, guint length,
GstBuffer ** outbuf)
{
GstFlowReturn ret;
GstBaseAudioSrc *src = GST_BASE_AUDIO_SRC (bsrc);
GstBuffer *buf;
guchar *data, *ptr;
guint samples, total_samples;
guint64 sample;
gint bpf, rate;
GstRingBuffer *ringbuffer;
GstRingBufferSpec *spec;
guint read;
GstClockTime timestamp, duration;
GstClock *clock;
ringbuffer = src->ringbuffer;
spec = &ringbuffer->spec;
if (G_UNLIKELY (!gst_ring_buffer_is_acquired (ringbuffer)))
goto wrong_state;
bpf = GST_AUDIO_INFO_BPF (&spec->info);
rate = GST_AUDIO_INFO_RATE (&spec->info);
if ((length == 0 && bsrc->blocksize == 0) || length == -1)
/* no length given, use the default segment size */
length = spec->segsize;
else
/* make sure we round down to an integral number of samples */
length -= length % bpf;
/* figure out the offset in the ringbuffer */
if (G_UNLIKELY (offset != -1)) {
sample = offset / bpf;
/* if a specific offset was given it must be the next sequential
* offset we expect or we fail for now. */
if (src->next_sample != -1 && sample != src->next_sample)
goto wrong_offset;
} else {
/* calculate the sequentially next sample we need to read. This can jump and
* create a DISCONT. */
sample = gst_base_audio_src_get_offset (src);
}
GST_DEBUG_OBJECT (src, "reading from sample %" G_GUINT64_FORMAT " length %u",
sample, length);
/* get the number of samples to read */
total_samples = samples = length / bpf;
/* use the basesrc allocation code to use bufferpools or custom allocators */
ret = GST_BASE_SRC_CLASS (parent_class)->alloc (bsrc, offset, length, &buf);
if (G_UNLIKELY (ret != GST_FLOW_OK))
goto alloc_failed;
data = ptr = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
do {
read = gst_ring_buffer_read (ringbuffer, sample, ptr, samples);
GST_DEBUG_OBJECT (src, "read %u of %u", read, samples);
/* if we read all, we're done */
if (read == samples)
break;
/* else something interrupted us and we wait for playing again. */
GST_DEBUG_OBJECT (src, "wait playing");
if (gst_base_src_wait_playing (bsrc) != GST_FLOW_OK)
goto stopped;
GST_DEBUG_OBJECT (src, "continue playing");
/* read next samples */
sample += read;
samples -= read;
ptr += read * bpf;
} while (TRUE);
gst_buffer_unmap (buf, data, length);
/* mark discontinuity if needed */
if (G_UNLIKELY (sample != src->next_sample) && src->next_sample != -1) {
GST_WARNING_OBJECT (src,
"create DISCONT of %" G_GUINT64_FORMAT " samples at sample %"
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. 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);
}
src->next_sample = sample + samples;
/* get the normal timestamp to get the duration. */
timestamp = gst_util_uint64_scale_int (sample, GST_SECOND, rate);
duration = gst_util_uint64_scale_int (src->next_sample, GST_SECOND,
rate) - timestamp;
GST_OBJECT_LOCK (src);
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 last_read_segment;
gint segment_skew;
gint sps;
gint segments_written;
gint last_written_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_written_segment = segments_written - ringbuffer->segbase - 1;
/* 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, 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 */
last_read_segment = sample / sps;
/* the skew we have between running_time and the ringbuffertime (last written to) */
segment_skew = running_time_segment - last_written_segment;
GST_DEBUG_OBJECT (bsrc,
"\n running_time = %"
GST_TIME_FORMAT
"\n timestamp = %"
GST_TIME_FORMAT
"\n running_time_segment = %d"
"\n last_written_segment = %d"
"\n segment_skew (running time segment - last_written_segment) = %d"
"\n last_read_segment = %d",
GST_TIME_ARGS (running_time), GST_TIME_ARGS (timestamp),
running_time_segment, last_written_segment, segment_skew,
last_read_segment);
/* Resync the ringbuffer if:
*
* 1. 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"
*
* 2. 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 >= ringbuffer->spec.segtotal) ||
(last_read_segment == 0)) {
gint new_read_segment;
gint segment_diff;
guint64 new_sample;
/* the difference between running_time and the last written segment */
segment_diff = running_time_segment - last_written_segment;
/* advance the ringbuffer */
gst_ring_buffer_advance (ringbuffer, segment_diff);
/* we move the new read segment to the last known written segment */
new_read_segment =
g_atomic_int_get (&ringbuffer->segdone) - ringbuffer->segbase;
/* we calculate the new sample value */
new_sample = ((guint64) new_read_segment) * sps;
/* and get the relative time to this -> our new timestamp */
timestamp = gst_util_uint64_scale_int (new_sample, GST_SECOND, 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 (GST_CLOCK_DIFF (timestamp, base_time) < 0)
timestamp -= base_time;
else
timestamp = 0;
/* subtract latency */
latency = gst_util_uint64_scale_int (total_samples, GST_SECOND, 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 (GST_CLOCK_DIFF (timestamp, base_time) < 0) {
timestamp -= base_time;
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;
}
}
no_sync:
GST_OBJECT_UNLOCK (src);
GST_BUFFER_TIMESTAMP (buf) = timestamp;
GST_BUFFER_DURATION (buf) = duration;
GST_BUFFER_OFFSET (buf) = sample;
GST_BUFFER_OFFSET_END (buf) = sample + samples;
*outbuf = buf;
return GST_FLOW_OK;
/* ERRORS */
wrong_state:
{
GST_DEBUG_OBJECT (src, "ringbuffer in wrong state");
return GST_FLOW_WRONG_STATE;
}
wrong_offset:
{
GST_ELEMENT_ERROR (src, RESOURCE, SEEK,
(NULL), ("resource can only be operated on sequentially but offset %"
G_GUINT64_FORMAT " was given", offset));
return GST_FLOW_ERROR;
}
alloc_failed:
{
GST_DEBUG_OBJECT (src, "alloc failed: %s", gst_flow_get_name (ret));
return ret;
}
stopped:
{
gst_buffer_unref (buf);
GST_DEBUG_OBJECT (src, "ringbuffer stopped");
return GST_FLOW_WRONG_STATE;
}
}
/**
* gst_base_audio_src_create_ringbuffer:
* @src: a #GstBaseAudioSrc.
*
* Create and return the #GstRingBuffer for @src. This function will call the
* ::create_ringbuffer vmethod and will set @src as the parent of the returned
* buffer (see gst_object_set_parent()).
*
* Returns: The new ringbuffer of @src.
*/
GstRingBuffer *
gst_base_audio_src_create_ringbuffer (GstBaseAudioSrc * src)
{
GstBaseAudioSrcClass *bclass;
GstRingBuffer *buffer = NULL;
bclass = GST_BASE_AUDIO_SRC_GET_CLASS (src);
if (bclass->create_ringbuffer)
buffer = bclass->create_ringbuffer (src);
if (G_LIKELY (buffer))
gst_object_set_parent (GST_OBJECT_CAST (buffer), GST_OBJECT_CAST (src));
return buffer;
}
static GstStateChangeReturn
gst_base_audio_src_change_state (GstElement * element,
GstStateChange transition)
{
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
GstBaseAudioSrc *src = GST_BASE_AUDIO_SRC (element);
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;
case GST_STATE_CHANGE_READY_TO_PAUSED:
GST_DEBUG_OBJECT (src, "READY->PAUSED");
src->next_sample = -1;
gst_ring_buffer_set_flushing (src->ringbuffer, FALSE);
gst_ring_buffer_may_start (src->ringbuffer, FALSE);
/* Only post clock-provide messages if this is the clock that
* we've created. If the subclass has overriden it the subclass
* should post this messages whenever necessary */
if (src->clock && GST_IS_AUDIO_CLOCK (src->clock) &&
GST_AUDIO_CLOCK_CAST (src->clock)->func ==
(GstAudioClockGetTimeFunc) gst_base_audio_src_get_time)
gst_element_post_message (element,
gst_message_new_clock_provide (GST_OBJECT_CAST (element),
src->clock, TRUE));
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
GST_DEBUG_OBJECT (src, "PAUSED->PLAYING");
gst_ring_buffer_may_start (src->ringbuffer, TRUE);
break;
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
GST_DEBUG_OBJECT (src, "PLAYING->PAUSED");
gst_ring_buffer_may_start (src->ringbuffer, FALSE);
gst_ring_buffer_pause (src->ringbuffer);
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
GST_DEBUG_OBJECT (src, "PAUSED->READY");
/* Only post clock-lost messages if this is the clock that
* we've created. If the subclass has overriden it the subclass
* should post this messages whenever necessary */
if (src->clock && GST_IS_AUDIO_CLOCK (src->clock) &&
GST_AUDIO_CLOCK_CAST (src->clock)->func ==
(GstAudioClockGetTimeFunc) gst_base_audio_src_get_time)
gst_element_post_message (element,
gst_message_new_clock_lost (GST_OBJECT_CAST (element), src->clock));
gst_ring_buffer_set_flushing (src->ringbuffer, TRUE);
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_READY:
GST_DEBUG_OBJECT (src, "PAUSED->READY");
gst_ring_buffer_release (src->ringbuffer);
break;
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;
}
return ret;
/* ERRORS */
open_failed:
{
/* subclass must post a meaningfull error message */
GST_DEBUG_OBJECT (src, "open failed");
return GST_STATE_CHANGE_FAILURE;
}
}
Reference in a new issue View git blame Copy permalink