mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2025-01-18 05:16:05 +00:00
Code Issues 1 Projects Releases Wiki Activity

gst/gstpipeline.c: Automatically PAUSE and RESUME a pipeline when a flushing seek is performed.

Browse source 
Original commit message from CVS:
* gst/gstpipeline.c: (do_pipeline_seek), (gst_pipeline_send_event):
Automatically PAUSE and RESUME a pipeline when a flushing seek
is performed.
Removed old files.
This commit is contained in:
Wim Taymans 2005-09-19 16:32:44 +00:00
parent 7e031e25c0
commit 2bd297144f
5 changed files with 49 additions and 364 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
ChangeLog
View file

@ -1,3 +1,9 @@
2005-09-19 Wim Taymans <wim@fluendo.com>
* gst/gstpipeline.c: (do_pipeline_seek), (gst_pipeline_send_event):
Automatically PAUSE and RESUME a pipeline when a flushing seek
is performed.
2005-09-19 Andy Wingo <wingo@pobox.com>
* gst/gstregistry.h: Spacing fixen.

2
gst/gstmessage.h
View file

@ -76,7 +76,7 @@ typedef enum
#define GST_MESSAGE_TRACE_NAME "GstMessage"
#define GST_TYPE_MESSAGE (gst_message_get_type())
#define GST_TYPE_MESSAGE (gst_message_get_type())
#define GST_IS_MESSAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_MESSAGE))
#define GST_IS_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_MESSAGE))
#define GST_MESSAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_MESSAGE, GstMessageClass))

59
gst/gstpipeline.c
View file

@ -197,37 +197,62 @@ gst_pipeline_get_property (GObject * object, guint prop_id,
GST_UNLOCK (pipeline);
}
/* sending an event on the pipeline pauses the pipeline if it
* was playing.
*/
static gboolean
gst_pipeline_send_event (GstElement * element, GstEvent * event)
do_pipeline_seek (GstElement * element, GstEvent * event)
{
gboolean was_playing;
gdouble rate;
GstSeekFlags flags;
gboolean flush;
gboolean was_playing = FALSE;
gboolean res;
GstState state;
GstEventType event_type = GST_EVENT_TYPE (event);
GTimeVal timeout;
/* need to call _get_state() since a bin state is only updated
* with this call. */
GST_TIME_TO_TIMEVAL (0, timeout);
gst_event_parse_seek (event, &rate, NULL, &flags, NULL, NULL, NULL, NULL);
gst_element_get_state (element, &state, NULL, &timeout);
was_playing = state == GST_STATE_PLAYING;
flush = flags & GST_SEEK_FLAG_FLUSH;
if (flush) {
GstState state;
GTimeVal timeout;
GST_TIME_TO_TIMEVAL (0, timeout);
/* need to call _get_state() since a bin state is only updated
* with this call. */
gst_element_get_state (element, &state, NULL, &timeout);
was_playing = state == GST_STATE_PLAYING;
if (event_type == GST_EVENT_SEEK) {
if (was_playing)
gst_element_set_state (element, GST_STATE_PAUSED);
}
res = GST_ELEMENT_CLASS (parent_class)->send_event (element, event);
if (res && event_type == GST_EVENT_SEEK) {
/* need to set the stream time to the seek time */
if (flush && res) {
/* need to reset the stream time to 0 after a flushing seek */
gst_pipeline_set_new_stream_time (GST_PIPELINE (element), 0);
if (was_playing)
if (was_playing) {
/* and continue playing */
gst_element_set_state (element, GST_STATE_PLAYING);
}
}
return res;
}
/* sending a seek event on the pipeline pauses the pipeline if it
* was playing.
*/
static gboolean
gst_pipeline_send_event (GstElement * element, GstEvent * event)
{
gboolean res;
GstEventType event_type = GST_EVENT_TYPE (event);
switch (event_type) {
case GST_EVENT_SEEK:
res = do_pipeline_seek (element, event);
break;
default:
res = GST_ELEMENT_CLASS (parent_class)->send_event (element, event);
break;
}
return res;

266
gst/gstprobe.c
View file

@ -1,266 +0,0 @@
/* GStreamer
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wim.taymans@chello.be>
*
* gstprobe.h: Header for GstProbe object
*
* 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 "gst_private.h"
#include "gstprobe.h"
static GstProbe *
_gst_probe_copy (const GstProbe * src)
{
return gst_probe_new (src->single_shot, src->callback, src->user_data);
}
GType
gst_probe_get_type (void)
{
static GType gst_probe_type = 0;
if (!gst_probe_type) {
gst_probe_type = g_boxed_type_register_static ("GstProbe",
(GBoxedCopyFunc) _gst_probe_copy, (GBoxedFreeFunc) gst_probe_destroy);
}
return gst_probe_type;
}
/**
* gst_probe_new:
* @single_shot: TRUE if a single shot probe is required
* @callback: the function to call when the probe is triggered
* @user_data: data passed to the callback function
*
* Create a new probe with the specified parameters. The single shot
* probe will be fired only once. It is the responsability of the
* application to free the single probe after it has been fired.
*
* Returns: a new #GstProbe.
*/
GstProbe *
gst_probe_new (gboolean single_shot,
GstProbeCallback callback, gpointer user_data)
{
GstProbe *probe;
g_return_val_if_fail (callback, NULL);
probe = g_new0 (GstProbe, 1);
probe->single_shot = single_shot;
probe->callback = callback;
probe->user_data = user_data;
GST_CAT_DEBUG (GST_CAT_PROBE, "created probe %p", probe);
return probe;
}
/**
* gst_probe_destroy:
* @probe: The probe to destroy
*
* Free the memory associated with the probe.
*/
void
gst_probe_destroy (GstProbe * probe)
{
g_return_if_fail (probe);
#ifdef USE_POISONING
memset (probe, 0xff, sizeof (*probe));
#endif
g_free (probe);
}
/**
* gst_probe_perform:
* @probe: The probe to trigger
* @mini_object: the GstMiniObject that triggered the probe.
*
* Perform the callback associated with the given probe.
*
* Returns: the result of the probe callback function.
*/
gboolean
gst_probe_perform (GstProbe * probe, GstMiniObject ** mini_object)
{
gboolean res = TRUE;
g_return_val_if_fail (probe, res);
GST_CAT_DEBUG (GST_CAT_PROBE, "performing probe %p", probe);
if (probe->callback)
res = probe->callback (probe, mini_object, probe->user_data);
return res;
}
/**
* gst_probe_dispatcher_new:
*
* Create a new probe dispatcher
*
* Returns: a new probe dispatcher.
*/
GstProbeDispatcher *
gst_probe_dispatcher_new (void)
{
GstProbeDispatcher *disp;
disp = g_new0 (GstProbeDispatcher, 1);
gst_probe_dispatcher_init (disp);
return disp;
}
/**
* gst_probe_dispatcher_destroy:
* @disp: the dispatcher to destroy
*
* Free the memory allocated by the probe dispatcher. All pending
* probes are removed first.
*/
void
gst_probe_dispatcher_destroy (GstProbeDispatcher * disp)
{
g_return_if_fail (disp);
#ifdef USE_POISONING
memset (disp, 0xff, sizeof (*disp));
#endif
/* FIXME, free pending probes */
g_free (disp);
}
/**
* gst_probe_dispatcher_init:
* @disp: the dispatcher to initialize
*
* Initialize the dispatcher. Useful for statically allocated probe
* dispatchers.
*/
void
gst_probe_dispatcher_init (GstProbeDispatcher * disp)
{
g_return_if_fail (disp);
disp->active = TRUE;
disp->probes = NULL;
}
/**
* gst_probe_dispatcher_set_active:
* @disp: the dispatcher to activate
* @active: boolean to indicate activation or deactivation
*
* Activate or deactivate the given dispatcher
* dispatchers.
*/
void
gst_probe_dispatcher_set_active (GstProbeDispatcher * disp, gboolean active)
{
g_return_if_fail (disp);
disp->active = active;
}
/**
* gst_probe_dispatcher_add_probe:
* @disp: the dispatcher to add the probe to
* @probe: the probe to add to the dispatcher
*
* Adds the given probe to the dispatcher.
*/
void
gst_probe_dispatcher_add_probe (GstProbeDispatcher * disp, GstProbe * probe)
{
g_return_if_fail (disp);
g_return_if_fail (probe);
GST_CAT_DEBUG (GST_CAT_PROBE, "adding probe %p to dispatcher %p", probe,
disp);
disp->probes = g_slist_prepend (disp->probes, probe);
}
/**
* gst_probe_dispatcher_remove_probe:
* @disp: the dispatcher to remove the probe from
* @probe: the probe to remove from the dispatcher
*
* Removes the given probe from the dispatcher.
*/
void
gst_probe_dispatcher_remove_probe (GstProbeDispatcher * disp, GstProbe * probe)
{
g_return_if_fail (disp);
g_return_if_fail (probe);
GST_CAT_DEBUG (GST_CAT_PROBE, "removing probe %p from dispatcher %p",
probe, disp);
disp->probes = g_slist_remove (disp->probes, probe);
}
/**
* gst_probe_dispatcher_dispatch:
* @disp: the dispatcher to dispatch
* @data: the data that triggered the dispatch
*
* Trigger all registered probes on the given dispatcher.
*
* Returns: TRUE if all callbacks returned TRUE.
*/
gboolean
gst_probe_dispatcher_dispatch (GstProbeDispatcher * disp, GstMiniObject ** data)
{
GSList *walk;
gboolean res = TRUE;
g_return_val_if_fail (disp, res);
GST_CAT_DEBUG (GST_CAT_PROBE, "dispatching data %p on dispatcher %p",
*data, disp);
walk = disp->probes;
while (walk) {
GstProbe *probe = (GstProbe *) walk->data;
walk = g_slist_next (walk);
res &= gst_probe_perform (probe, data);
/* it might have disappeared in the callback */
if (disp->active &&
g_slist_find (disp->probes, probe) && probe->single_shot) {
disp->probes = g_slist_remove (disp->probes, probe);
/* do not free the probe here as it cannot be made threadsafe */
//gst_probe_destroy (probe);
}
}
return res;
}

80
gst/gstprobe.h
View file

@ -1,80 +0,0 @@
/* GStreamer
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wim.taymans@chello.be>
*
* gstprobe.h: Header for GstProbe object
*
* 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.
*/
#ifndef __GST_PROBE_H__
#define __GST_PROBE_H__
#include <glib.h>
#include <gst/gstminiobject.h>
G_BEGIN_DECLS
#define GST_TYPE_PROBE (gst_probe_get_type())
#define GST_PROBE(object) ((GstProbe *) object)
typedef struct _GstProbe GstProbe;
GType gst_probe_get_type (void);
/* the callback should return FALSE if the data should be discarded */
typedef gboolean (*GstProbeCallback) (GstProbe *probe,
GstMiniObject **data,
gpointer user_data);
struct _GstProbe {
gboolean single_shot;
GstProbeCallback callback;
gpointer user_data;
};
GstProbe* gst_probe_new (gboolean single_shot,
GstProbeCallback callback,
gpointer user_data);
void gst_probe_destroy (GstProbe *probe);
gboolean gst_probe_perform (GstProbe *probe, GstMiniObject **mini_object);
typedef struct _GstProbeDispatcher GstProbeDispatcher;
struct _GstProbeDispatcher {
gboolean active;
GSList *probes;
};
GstProbeDispatcher* gst_probe_dispatcher_new (void);
void gst_probe_dispatcher_destroy (GstProbeDispatcher *disp);
void gst_probe_dispatcher_init (GstProbeDispatcher *disp);
void gst_probe_dispatcher_set_active (GstProbeDispatcher *disp, gboolean active);
void gst_probe_dispatcher_add_probe (GstProbeDispatcher *disp, GstProbe *probe);
void gst_probe_dispatcher_remove_probe (GstProbeDispatcher *disp, GstProbe *probe);
gboolean gst_probe_dispatcher_dispatch (GstProbeDispatcher *disp, GstMiniObject **data);
G_END_DECLS
#endif /* __GST_PROBE_H__ */