From 2ff63e563b21cac87489a0d989c3aa957d5f2fb9 Mon Sep 17 00:00:00 2001 From: Andy Wingo Date: Wed, 16 Jul 2003 16:08:13 +0000 Subject: actually recurse into sndfile if we are able big ladspa cleanups, mainly to comply with the buffer-frames caps proper... Original commit message from CVS: * actually recurse into sndfile if we are able * big ladspa cleanups, mainly to comply with the buffer-frames caps property, but also general cleanups - the samplerate prop is gone, if you want to set it explicitly (as in for get-based plugins) you need to use a filtered connection, just like with buffer-frames * big float2int and int2float changes for buffer-frames compatibility - I think it's quite a bit simpler * make the ossclock general, add it to gstaudio, and use it in sndfile as well i need to update mimetypes, but that's coming soon. there are some other plugins that don't support buffer-frames, i guess i need to get around to fixing them as well. --- gst-libs/gst/audio/audioclock.c | 194 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 194 insertions(+) create mode 100644 gst-libs/gst/audio/audioclock.c (limited to 'gst-libs/gst/audio/audioclock.c') diff --git a/gst-libs/gst/audio/audioclock.c b/gst-libs/gst/audio/audioclock.c new file mode 100644 index 00000000..342009ff --- /dev/null +++ b/gst-libs/gst/audio/audioclock.c @@ -0,0 +1,194 @@ +/* GStreamer + * Copyright (C) 1999,2000 Erik Walthinsen + * 2000 Wim Taymans + * + * audioclock.c: Clock for use by audio plugins + * + * 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. + */ + +#include "audioclock.h" + +static void gst_audio_clock_class_init (GstAudioClockClass *klass); +static void gst_audio_clock_init (GstAudioClock *clock); + +static GstClockTime gst_audio_clock_get_internal_time (GstClock *clock); +static GstClockReturn gst_audio_clock_id_wait_async (GstClock *clock, + GstClockEntry *entry); +static void gst_audio_clock_id_unschedule (GstClock *clock, + GstClockEntry *entry); + +static GstSystemClockClass *parent_class = NULL; +/* static guint gst_audio_clock_signals[LAST_SIGNAL] = { 0 }; */ + +GType +gst_audio_clock_get_type (void) +{ + static GType clock_type = 0; + + if (!clock_type) { + static const GTypeInfo clock_info = { + sizeof (GstAudioClockClass), + NULL, + NULL, + (GClassInitFunc) gst_audio_clock_class_init, + NULL, + NULL, + sizeof (GstAudioClock), + 4, + (GInstanceInitFunc) gst_audio_clock_init, + NULL + }; + clock_type = g_type_register_static (GST_TYPE_SYSTEM_CLOCK, "GstAudioClock", + &clock_info, 0); + } + return clock_type; +} + + +static void +gst_audio_clock_class_init (GstAudioClockClass *klass) +{ + GObjectClass *gobject_class; + GstObjectClass *gstobject_class; + GstClockClass *gstclock_class; + + gobject_class = (GObjectClass*) klass; + gstobject_class = (GstObjectClass*) klass; + gstclock_class = (GstClockClass*) klass; + + parent_class = g_type_class_ref (GST_TYPE_SYSTEM_CLOCK); + + gstclock_class->get_internal_time = gst_audio_clock_get_internal_time; + gstclock_class->wait_async = gst_audio_clock_id_wait_async; + gstclock_class->unschedule = gst_audio_clock_id_unschedule; +} + +static void +gst_audio_clock_init (GstAudioClock *clock) +{ + gst_object_set_name (GST_OBJECT (clock), "GstAudioClock"); + + clock->prev1 = 0; + clock->prev2 = 0; +} + +GstClock* +gst_audio_clock_new (gchar *name, GstAudioClockGetTimeFunc func, gpointer user_data) +{ + GstAudioClock *aclock = GST_AUDIO_CLOCK (g_object_new (GST_TYPE_AUDIO_CLOCK, NULL)); + + aclock->func = func; + aclock->user_data = user_data; + aclock->adjust = 0; + + return (GstClock*)aclock; +} + +void +gst_audio_clock_set_active (GstAudioClock *aclock, gboolean active) +{ + GTimeVal timeval; + GstClockTime time; + GstClockTime audiotime; + + g_get_current_time (&timeval); + time = GST_TIMEVAL_TO_TIME (timeval); + audiotime = aclock->func ((GstClock*)aclock, aclock->user_data); + + if (active) { + aclock->adjust = time - audiotime; + } + else { + aclock->adjust = audiotime - time; + } + + aclock->active = active; +} + +static GstClockTime +gst_audio_clock_get_internal_time (GstClock *clock) +{ + GstAudioClock *aclock = GST_AUDIO_CLOCK (clock); + + if (aclock->active) { + GstClockTime audiotime; + + audiotime = aclock->func (clock, aclock->user_data) + aclock->adjust; + + return audiotime; + } + else { + GstClockTime time; + GTimeVal timeval; + + g_get_current_time (&timeval); + time = GST_TIMEVAL_TO_TIME (timeval); + + return time; + } +} + +void +gst_audio_clock_update_time (GstAudioClock *aclock, GstClockTime time) +{ + /* I don't know of a purpose in updating these; perhaps they can be removed */ + aclock->prev2 = aclock->prev1; + aclock->prev1 = time; + + /* FIXME: the wait_async subsystem should be made threadsafe, but I don't want + * to lock and unlock a mutex on every iteration... */ + while (aclock->async_entries) { + GstClockEntry *entry = (GstClockEntry*)aclock->async_entries->data; + + if (entry->time > time) + break; + + entry->func ((GstClock*)aclock, time, entry, entry->user_data); + + aclock->async_entries = g_slist_delete_link (aclock->async_entries, + aclock->async_entries); + /* do I need to free the entry? */ + } +} + +static gint +compare_clock_entries (GstClockEntry *entry1, GstClockEntry *entry2) +{ + return entry1->time - entry2->time; +} + +static GstClockReturn +gst_audio_clock_id_wait_async (GstClock *clock, GstClockEntry *entry) +{ + GstAudioClock *aclock = (GstAudioClock*)clock; + + aclock->async_entries = g_slist_insert_sorted (aclock->async_entries, + entry, + (GCompareFunc)compare_clock_entries); + + /* is this the proper return val? */ + return GST_CLOCK_EARLY; +} + +static void +gst_audio_clock_id_unschedule (GstClock *clock, GstClockEntry *entry) +{ + GstAudioClock *aclock = (GstAudioClock*)clock; + + aclock->async_entries = g_slist_remove (aclock->async_entries, + entry); +} -- cgit v1.2.1