mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-11-29 21:21:12 +00:00
filter newlines out of GST_DEBUG statements to reflect new core behavior fixes to adder's caps, again
Original commit message from CVS: * filter newlines out of GST_DEBUG statements to reflect new core behavior * fixes to adder's caps, again
This commit is contained in:
parent
c12c39d37c
commit
ed9b628168
49 changed files with 398 additions and 398 deletions
|
@ -99,7 +99,7 @@ gst_play_have_type (GstElement *typefind, GstCaps *caps, GstElement *pipeline)
|
|||
GstElement *filesrc;
|
||||
GstElement *cache;
|
||||
|
||||
GST_DEBUG (0,"GstPipeline: play have type\n");
|
||||
GST_DEBUG (0,"GstPipeline: play have type");
|
||||
|
||||
gst_element_set_state (pipeline, GST_STATE_PAUSED);
|
||||
|
||||
|
|
|
@ -10,7 +10,7 @@ gst_play_have_type (GstElement *typefind, GstCaps *caps, GstElement *pipeline)
|
|||
GstElement *filesrc;
|
||||
GstElement *cache;
|
||||
|
||||
GST_DEBUG (0,"GstPipeline: play have type\n");
|
||||
GST_DEBUG (0,"GstPipeline: play have type");
|
||||
|
||||
gst_element_set_state (pipeline, GST_STATE_PAUSED);
|
||||
|
||||
|
|
|
@ -10,7 +10,7 @@ gst_play_have_type (GstElement *typefind, GstCaps *caps, GstElement *pipeline)
|
|||
GstElement *filesrc;
|
||||
GstElement *cache;
|
||||
|
||||
GST_DEBUG (0,"GstPipeline: play have type\n");
|
||||
GST_DEBUG (0,"GstPipeline: play have type");
|
||||
|
||||
gst_element_set_state (pipeline, GST_STATE_PAUSED);
|
||||
|
||||
|
|
|
@ -47,7 +47,7 @@ gst_play_typefind (GstBin *bin, GstElement *element)
|
|||
GstElement *pipeline;
|
||||
GstCaps *caps = NULL;
|
||||
|
||||
GST_DEBUG (0,"GstPipeline: typefind for element \"%s\"\n",
|
||||
GST_DEBUG (0,"GstPipeline: typefind for element \"%s\"",
|
||||
GST_ELEMENT_NAME(element));
|
||||
|
||||
pipeline = gst_pipeline_new ("autoplug_pipeline");
|
||||
|
@ -242,7 +242,7 @@ create_input_channel (int id, char* location)
|
|||
GstElement *new_element;
|
||||
GstElement *decoder;
|
||||
|
||||
GST_DEBUG (0, "c_i_p : creating channel with id %d for file %s\n",
|
||||
GST_DEBUG (0, "c_i_p : creating channel with id %d for file %s",
|
||||
id, location);
|
||||
|
||||
/* allocate channel */
|
||||
|
@ -256,7 +256,7 @@ create_input_channel (int id, char* location)
|
|||
|
||||
/* create channel */
|
||||
|
||||
GST_DEBUG (0, "c_i_p : creating pipeline\n");
|
||||
GST_DEBUG (0, "c_i_p : creating pipeline");
|
||||
|
||||
sprintf (buffer, "pipeline%d", id);
|
||||
channel->pipe = gst_bin_new (buffer);
|
||||
|
@ -264,13 +264,13 @@ create_input_channel (int id, char* location)
|
|||
|
||||
/* create elements */
|
||||
|
||||
GST_DEBUG(0, "c_i_p : creating filesrc\n");
|
||||
GST_DEBUG(0, "c_i_p : creating filesrc");
|
||||
|
||||
sprintf (buffer, "filesrc%d", id);
|
||||
channel->filesrc = gst_elementfactory_make ("filesrc", buffer);
|
||||
g_assert(channel->filesrc != NULL);
|
||||
|
||||
GST_DEBUG(0, "c_i_p : setting location\n");
|
||||
GST_DEBUG(0, "c_i_p : setting location");
|
||||
g_object_set(G_OBJECT(channel->filesrc),"location", location, NULL);
|
||||
|
||||
/* add filesrc to the bin before autoplug */
|
||||
|
|
|
@ -230,12 +230,12 @@ gst_autoplugcache_loop (GstElement *element)
|
|||
/* if we've been told to fire an empty signal (after a reset) */
|
||||
if (cache->fire_empty) {
|
||||
int oldstate = GST_STATE(cache);
|
||||
GST_DEBUG(0,"at front of cache, about to pull, but firing signal\n");
|
||||
GST_DEBUG(0,"at front of cache, about to pull, but firing signal");
|
||||
gst_object_ref (GST_OBJECT (cache));
|
||||
g_signal_emit (G_OBJECT(cache), gst_autoplugcache_signals[CACHE_EMPTY], 0, NULL);
|
||||
if (GST_STATE(cache) != oldstate) {
|
||||
gst_object_ref (GST_OBJECT (cache));
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "state changed during signal, aborting\n");
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "state changed during signal, aborting");
|
||||
gst_element_yield (cache);
|
||||
}
|
||||
gst_object_unref (GST_OBJECT (cache));
|
||||
|
@ -295,7 +295,7 @@ gst_autoplugcache_set_property (GObject *object, guint prop_id, const GValue *va
|
|||
switch (prop_id) {
|
||||
case ARG_CAPS_PROXY:
|
||||
cache->caps_proxy = g_value_get_boolean (value);
|
||||
GST_DEBUG(0,"caps_proxy is %d\n",cache->caps_proxy);
|
||||
GST_DEBUG(0,"caps_proxy is %d",cache->caps_proxy);
|
||||
if (cache->caps_proxy) {
|
||||
} else {
|
||||
}
|
||||
|
@ -303,7 +303,7 @@ GST_DEBUG(0,"caps_proxy is %d\n",cache->caps_proxy);
|
|||
case ARG_RESET:
|
||||
/* no idea why anyone would set this to FALSE, but just in case ;-) */
|
||||
if (g_value_get_boolean (value)) {
|
||||
GST_DEBUG(0,"resetting playout pointer\n");
|
||||
GST_DEBUG(0,"resetting playout pointer");
|
||||
/* reset the playout pointer to the begining again */
|
||||
cache->current_playout = cache->cache_start;
|
||||
/* now we can fire a signal when the cache runs dry */
|
||||
|
|
|
@ -167,7 +167,7 @@ gst_autoplugger_init (GstAutoplugger *autoplugger)
|
|||
autoplugger->cache = gst_elementfactory_make("autoplugcache", "unnamed_autoplugcache");
|
||||
g_return_if_fail (autoplugger->cache != NULL);
|
||||
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "turning on caps nego proxying in cache\n");
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "turning on caps nego proxying in cache");
|
||||
g_object_set(G_OBJECT(autoplugger->cache),"caps_proxy",TRUE,NULL);
|
||||
|
||||
/* attach signals to the cache */
|
||||
|
@ -247,7 +247,7 @@ gst_autoplugger_external_src_connected(GstPad *pad, GstPad *peerpad, GstAutoplug
|
|||
GST_INFO(GST_CAT_AUTOPLUG, "there are some caps on this pad's peer's padtemplate %s",
|
||||
gst_caps_get_mime(peertemplatecaps));
|
||||
autoplugger->sinktemplatecaps = peertemplatecaps;
|
||||
/* GST_DEBUG(GST_CAT_AUTOPLUG, "turning on caps nego proxying in cache\n"); */
|
||||
/* GST_DEBUG(GST_CAT_AUTOPLUG, "turning on caps nego proxying in cache"); */
|
||||
/* gtk_object_set(G_OBJECT(autoplugger->cache),"caps_proxy",TRUE,NULL);*/
|
||||
}
|
||||
}
|
||||
|
@ -276,20 +276,20 @@ gst_autoplugger_autoplug(GstAutoplugger *autoplugger,GstPad *srcpad,GstCaps *src
|
|||
GstPad *sinkpad;
|
||||
|
||||
sinkpad = GST_PAD(GST_PAD_PEER(srcpad));
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG,"disconnecting %s:%s and %s:%s to autoplug between them\n",
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG,"disconnecting %s:%s and %s:%s to autoplug between them",
|
||||
GST_DEBUG_PAD_NAME(srcpad),GST_DEBUG_PAD_NAME(sinkpad));
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG,"srcpadcaps are of type %s\n",gst_caps_get_mime(srccaps));
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG,"sinkpadcaps are of type %s\n",gst_caps_get_mime(sinkcaps));
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG,"srcpadcaps are of type %s",gst_caps_get_mime(srccaps));
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG,"sinkpadcaps are of type %s",gst_caps_get_mime(sinkcaps));
|
||||
|
||||
/* disconnect the pads */
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "disconnecting the pads that will be joined by an autobin\n");
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "disconnecting the pads that will be joined by an autobin");
|
||||
gst_pad_disconnect(srcpad,sinkpad);
|
||||
|
||||
if (!autoplugger->autoplug) {
|
||||
autoplugger->autoplug = gst_autoplugfactory_make("static");
|
||||
g_return_val_if_fail(autoplugger->autoplug != NULL, FALSE);
|
||||
}
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "building autoplugged bin between caps\n");
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "building autoplugged bin between caps");
|
||||
autoplugger->autobin = gst_autoplug_to_caps(autoplugger->autoplug,
|
||||
srccaps,sinkcaps,NULL);
|
||||
g_return_val_if_fail(autoplugger->autobin != NULL, FALSE);
|
||||
|
@ -298,20 +298,20 @@ gst_autoplugger_autoplug(GstAutoplugger *autoplugger,GstPad *srcpad,GstCaps *src
|
|||
gst_scheduler_show(GST_ELEMENT_SCHED(autoplugger));
|
||||
|
||||
/* FIXME this is a hack */
|
||||
/* GST_DEBUG(GST_CAT_AUTOPLUG, "copying failed caps to srcpad %s:%s to ensure renego\n",GST_DEBUG_PAD_NAME(autoplugger->cache_srcpad)); */
|
||||
/* GST_DEBUG(GST_CAT_AUTOPLUG, "copying failed caps to srcpad %s:%s to ensure renego",GST_DEBUG_PAD_NAME(autoplugger->cache_srcpad)); */
|
||||
/* gst_pad_set_caps(srcpad,srccaps); */
|
||||
|
||||
if (GST_PAD_CAPS(srcpad) == NULL) GST_DEBUG(GST_CAT_AUTOPLUG,"no caps on cache:src!\n");
|
||||
if (GST_PAD_CAPS(srcpad) == NULL) GST_DEBUG(GST_CAT_AUTOPLUG,"no caps on cache:src!");
|
||||
|
||||
/* attach the autoplugged bin */
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "attaching the autoplugged bin between the two pads\n");
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "attaching the autoplugged bin between the two pads");
|
||||
gst_pad_connect(srcpad,gst_element_get_pad(autoplugger->autobin,"sink"));
|
||||
gst_scheduler_show(GST_ELEMENT_SCHED(autoplugger));
|
||||
gst_pad_connect(gst_element_get_pad(autoplugger->autobin,"src_00"),sinkpad);
|
||||
gst_scheduler_show(GST_ELEMENT_SCHED(autoplugger));
|
||||
|
||||
/* FIXME try to force the renego */
|
||||
/* GST_DEBUG(GST_CAT_AUTOPLUG, "trying to force everyone to nego\n"); */
|
||||
/* GST_DEBUG(GST_CAT_AUTOPLUG, "trying to force everyone to nego"); */
|
||||
/* gst_pad_renegotiate(gst_element_get_pad(autoplugger->autobin,"sink")); */
|
||||
/* gst_pad_renegotiate(sinkpad); */
|
||||
|
||||
|
@ -408,18 +408,18 @@ gst_autoplugger_cache_empty(GstElement *element, GstAutoplugger *autoplugger)
|
|||
gst_element_set_state(GST_ELEMENT_SCHED(autoplugger)->parent,GST_STATE_PAUSED);
|
||||
|
||||
/* disconnect the cache from its peers */
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "disconnecting autoplugcache from its peers\n");
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "disconnecting autoplugcache from its peers");
|
||||
cache_sinkpad_peer = GST_PAD (GST_PAD_PEER(autoplugger->cache_sinkpad));
|
||||
cache_srcpad_peer = GST_PAD (GST_PAD_PEER(autoplugger->cache_srcpad));
|
||||
gst_pad_disconnect(cache_sinkpad_peer,autoplugger->cache_sinkpad);
|
||||
gst_pad_disconnect(autoplugger->cache_srcpad,cache_srcpad_peer);
|
||||
|
||||
/* remove the cache from self */
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "removing the cache from the autoplugger\n");
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "removing the cache from the autoplugger");
|
||||
gst_bin_remove (GST_BIN(autoplugger), autoplugger->cache);
|
||||
|
||||
/* connect the two pads */
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "reconnecting the autoplugcache's former peers\n");
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "reconnecting the autoplugcache's former peers");
|
||||
gst_pad_connect(cache_sinkpad_peer,cache_srcpad_peer);
|
||||
|
||||
autoplugger->paused--;
|
||||
|
@ -445,7 +445,7 @@ gst_scheduler_show(GST_ELEMENT_SCHED(autoplugger));
|
|||
gst_element_set_state(GST_ELEMENT_SCHED(autoplugger)->parent,GST_STATE_PAUSED);
|
||||
|
||||
/* first disconnect the typefind and shut it down */
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "disconnecting typefind from the cache\n");
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "disconnecting typefind from the cache");
|
||||
gst_pad_disconnect(autoplugger->cache_srcpad,autoplugger->typefind_sinkpad);
|
||||
gst_bin_remove(GST_BIN(autoplugger),autoplugger->typefind);
|
||||
|
||||
|
@ -462,25 +462,25 @@ gst_scheduler_show(GST_ELEMENT_SCHED(autoplugger));
|
|||
gst_bin_add(GST_BIN(autoplugger),autoplugger->autobin);
|
||||
|
||||
* // re-attach the srcpad's original peer to the cache *
|
||||
* GST_DEBUG(GST_CAT_AUTOPLUG, "reconnecting the cache to the downstream peer\n"); *
|
||||
* GST_DEBUG(GST_CAT_AUTOPLUG, "reconnecting the cache to the downstream peer"); *
|
||||
* gst_pad_connect(autoplugger->cache_srcpad,autoplugger->srcpadpeer); *
|
||||
|
||||
* attach the autoplugged bin *
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "attaching the autoplugged bin between cache and downstream peer\n");
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "attaching the autoplugged bin between cache and downstream peer");
|
||||
gst_pad_connect(autoplugger->cache_srcpad,gst_element_get_pad(autoplugger->autobin,"sink"));
|
||||
gst_pad_connect(gst_element_get_pad(autoplugger->autobin,"src_00"),autoplugger->srcpadpeer);
|
||||
*/
|
||||
|
||||
/* FIXME set the caps on the new connection
|
||||
* GST_DEBUG(GST_CAT_AUTOPLUG,"forcing caps on the typefound pad\n");
|
||||
* GST_DEBUG(GST_CAT_AUTOPLUG,"forcing caps on the typefound pad");
|
||||
* gst_pad_set_caps(autoplugger->cache_srcpad,caps);
|
||||
* reattach the original outside srcpad
|
||||
*/
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG,"re-attaching downstream peer to autoplugcache\n");
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG,"re-attaching downstream peer to autoplugcache");
|
||||
gst_pad_connect(autoplugger->cache_srcpad,autoplugger->srcpadpeer);
|
||||
|
||||
/* now reset the autoplugcache */
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "resetting the cache to send first buffer(s) again\n");
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "resetting the cache to send first buffer(s) again");
|
||||
g_object_set(G_OBJECT(autoplugger->cache),"reset",TRUE,NULL);
|
||||
|
||||
/* attach the cache_empty handler */
|
||||
|
@ -508,7 +508,7 @@ gst_autoplugger_cache_first_buffer(GstElement *element,GstBuffer *buf,GstAutoplu
|
|||
GST_INFO(GST_CAT_AUTOPLUG, "have no caps for the buffer, Danger Will Robinson!");
|
||||
|
||||
if (autoplugger->disable_nocaps) {
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "not dealing with lack of caps this time\n");
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "not dealing with lack of caps this time");
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -520,25 +520,25 @@ gst_scheduler_show(GST_ELEMENT_SCHED(autoplugger));
|
|||
gst_element_set_state(GST_ELEMENT_SCHED(autoplugger)->parent,GST_STATE_PAUSED);
|
||||
|
||||
/* detach the srcpad */
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "disconnecting cache from its downstream peer\n");
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "disconnecting cache from its downstream peer");
|
||||
autoplugger->srcpadpeer = GST_PAD(GST_PAD_PEER(autoplugger->cache_srcpad));
|
||||
gst_pad_disconnect(autoplugger->cache_srcpad,autoplugger->srcpadpeer);
|
||||
|
||||
/* instantiate the typefind and set up the signal handlers */
|
||||
if (!autoplugger->typefind) {
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "creating typefind and setting signal handler\n");
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "creating typefind and setting signal handler");
|
||||
autoplugger->typefind = gst_elementfactory_make("typefind","unnamed_typefind");
|
||||
autoplugger->typefind_sinkpad = gst_element_get_pad(autoplugger->typefind,"sink");
|
||||
g_signal_connect (G_OBJECT(autoplugger->typefind),"have_type",
|
||||
G_CALLBACK (gst_autoplugger_typefind_have_type), autoplugger);
|
||||
}
|
||||
/* add it to self and attach it */
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "adding typefind to self and connecting to cache\n");
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "adding typefind to self and connecting to cache");
|
||||
gst_bin_add(GST_BIN(autoplugger),autoplugger->typefind);
|
||||
gst_pad_connect(autoplugger->cache_srcpad,autoplugger->typefind_sinkpad);
|
||||
|
||||
/* bring the typefind into playing state */
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "setting typefind state to PLAYING\n");
|
||||
GST_DEBUG(GST_CAT_AUTOPLUG, "setting typefind state to PLAYING");
|
||||
gst_element_set_state(autoplugger->cache,GST_STATE_PLAYING);
|
||||
|
||||
autoplugger->paused--;
|
||||
|
|
|
@ -336,7 +336,7 @@ gst_autoplug_sp (GstCaps *srccaps, GstCaps *sinkcaps, GList *factories)
|
|||
/* check if we even have possible endpoints */
|
||||
if (bestnode == NULL)
|
||||
{
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "no factory found that could connect to sink caps\n");
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "no factory found that could connect to sink caps");
|
||||
g_list_free_list_and_elements (factory_nodes);
|
||||
return NULL;
|
||||
}
|
||||
|
@ -346,12 +346,12 @@ gst_autoplug_sp (GstCaps *srccaps, GstCaps *sinkcaps, GList *factories)
|
|||
{
|
||||
GList *nodes = factory_nodes;
|
||||
guint nextcost = GST_AUTOPLUG_MAX_COST; /* next cost to check */
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "iterating at current cost %d, bestnode %s at %d\n", curcost, GST_OBJECT_NAME (bestnode->fac), bestnode->cost);
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "iterating at current cost %d, bestnode %s at %d", curcost, GST_OBJECT_NAME (bestnode->fac), bestnode->cost);
|
||||
/* check if we already have a valid best connection to the sink */
|
||||
if (bestnode->cost <= curcost)
|
||||
{
|
||||
GList *ret;
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "found a way to connect via %s\n", GST_OBJECT_NAME ((GstObject *) bestnode->fac));
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "found a way to connect via %s", GST_OBJECT_NAME ((GstObject *) bestnode->fac));
|
||||
/* enter all factories into the return list */
|
||||
ret = g_list_prepend (NULL, bestnode->fac);
|
||||
bestnode = bestnode->prev;
|
||||
|
@ -405,7 +405,7 @@ gst_autoplug_sp (GstCaps *srccaps, GstCaps *sinkcaps, GList *factories)
|
|||
curcost = nextcost;
|
||||
}
|
||||
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "found no path from source caps to sink caps\n");
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "found no path from source caps to sink caps");
|
||||
g_list_free_list_and_elements (factory_nodes);
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
@ -233,7 +233,7 @@ gst_spider_request_new_pad (GstElement *element, GstPadTemplate *templ, const gc
|
|||
gst_bin_add (GST_BIN (element), GST_ELEMENT (identity));
|
||||
|
||||
returnpad = gst_element_add_ghost_pad (element, returnpad, padname);
|
||||
GST_DEBUG (GST_CAT_ELEMENT_PADS, "successuflly created requested pad %s:%s\n", GST_DEBUG_PAD_NAME (returnpad));
|
||||
GST_DEBUG (GST_CAT_ELEMENT_PADS, "successuflly created requested pad %s:%s", GST_DEBUG_PAD_NAME (returnpad));
|
||||
|
||||
return returnpad;
|
||||
}
|
||||
|
@ -314,7 +314,7 @@ gst_spider_connect_sometimes (GstElement *src, GstPad *pad, GstSpiderConnection
|
|||
|
||||
/* try to autoplug the elements */
|
||||
if (gst_spider_plug_from_srcpad (conn, pad) != GST_PAD_CONNECT_REFUSED) {
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "%s:%s was autoplugged to %s:%s, removing callback\n", GST_DEBUG_PAD_NAME (pad), GST_DEBUG_PAD_NAME (sinkpad));
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "%s:%s was autoplugged to %s:%s, removing callback", GST_DEBUG_PAD_NAME (pad), GST_DEBUG_PAD_NAME (sinkpad));
|
||||
g_signal_handler_disconnect (src, signal_id);
|
||||
signal_id = 0;
|
||||
}
|
||||
|
@ -351,7 +351,7 @@ gst_spider_connection_destroy (GstSpiderConnection *conn)
|
|||
static void
|
||||
gst_spider_connection_reset (GstSpiderConnection *conn, GstElement *to)
|
||||
{
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG, "resetting connection from %s to %s, currently at %s to %s\n", GST_ELEMENT_NAME (conn->sink),
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG, "resetting connection from %s to %s, currently at %s to %s", GST_ELEMENT_NAME (conn->sink),
|
||||
GST_ELEMENT_NAME (conn->src), GST_ELEMENT_NAME (conn->current), GST_ELEMENT_NAME (to));
|
||||
while ((conn->path != NULL) && ((GstElement *) conn->path->data != to))
|
||||
{
|
||||
|
@ -546,7 +546,7 @@ gst_spider_create_and_plug (GstSpiderConnection *conn, GList *plugpath)
|
|||
GstPadTemplate *templ = (GstPadTemplate *) templs->data;
|
||||
if ((GST_PADTEMPLATE_DIRECTION (templ) == GST_PAD_SRC) && (GST_PADTEMPLATE_PRESENCE(templ) == GST_PAD_SOMETIMES))
|
||||
{
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "adding callback to connect element %s to %s\n", GST_ELEMENT_NAME (conn->current), GST_ELEMENT_NAME (conn->src));
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "adding callback to connect element %s to %s", GST_ELEMENT_NAME (conn->current), GST_ELEMENT_NAME (conn->src));
|
||||
conn->signal_id = g_signal_connect (G_OBJECT (conn->current), "new_pad",
|
||||
G_CALLBACK (gst_spider_connect_sometimes), conn);
|
||||
g_list_free (plugpath);
|
||||
|
@ -554,11 +554,11 @@ gst_spider_create_and_plug (GstSpiderConnection *conn, GList *plugpath)
|
|||
}
|
||||
templs = g_list_next (templs);
|
||||
}
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "no chance to connect element %s to %s\n", GST_ELEMENT_NAME (conn->current), GST_ELEMENT_NAME (conn->src));
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "no chance to connect element %s to %s", GST_ELEMENT_NAME (conn->current), GST_ELEMENT_NAME (conn->src));
|
||||
g_list_free (plugpath);
|
||||
return GST_PAD_CONNECT_REFUSED;
|
||||
}
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "added element %s and attached it to element %s\n", GST_ELEMENT_NAME (element), GST_ELEMENT_NAME (conn->current));
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "added element %s and attached it to element %s", GST_ELEMENT_NAME (element), GST_ELEMENT_NAME (conn->current));
|
||||
gst_spider_connection_add (conn, element);
|
||||
if (plugpath != NULL)
|
||||
plugpath = g_list_delete_link (plugpath, plugpath);
|
||||
|
@ -618,7 +618,7 @@ gst_spider_plug_from_srcpad (GstSpiderConnection *conn, GstPad *srcpad)
|
|||
GstElement *startelement = conn->current;
|
||||
|
||||
g_assert ((GstElement *) GST_OBJECT_PARENT (srcpad) == conn->current);
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "trying to plug from %s:%s to %s\n", GST_DEBUG_PAD_NAME (srcpad), GST_ELEMENT_NAME (conn->src));
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "trying to plug from %s:%s to %s", GST_DEBUG_PAD_NAME (srcpad), GST_ELEMENT_NAME (conn->src));
|
||||
|
||||
/* find a path from src to sink */
|
||||
/* FIXME: make that if go away and work anyway */
|
||||
|
@ -640,10 +640,10 @@ gst_spider_plug_from_srcpad (GstSpiderConnection *conn, GstPad *srcpad)
|
|||
|
||||
/* if there is no way to plug: return */
|
||||
if (plugpath == NULL) {
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "no chance to plug from %s to %s\n", GST_ELEMENT_NAME (conn->current), GST_ELEMENT_NAME (conn->src));
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "no chance to plug from %s to %s", GST_ELEMENT_NAME (conn->current), GST_ELEMENT_NAME (conn->src));
|
||||
return GST_PAD_CONNECT_REFUSED;
|
||||
}
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "found a connection that needs %d elements\n", g_list_length (plugpath));
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "found a connection that needs %d elements", g_list_length (plugpath));
|
||||
|
||||
/* now remove non-needed elements from the beginning of the path
|
||||
* alter src to point to the new element where we need to start
|
||||
|
@ -656,7 +656,7 @@ gst_spider_plug_from_srcpad (GstSpiderConnection *conn, GstPad *srcpad)
|
|||
plugpath = g_list_delete_link (plugpath, plugpath);
|
||||
}
|
||||
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "%d elements must be inserted to establish the connection\n", g_list_length (plugpath));
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG_ATTEMPT, "%d elements must be inserted to establish the connection", g_list_length (plugpath));
|
||||
/* create the elements and plug them */
|
||||
result = gst_spider_create_and_plug (conn, plugpath);
|
||||
|
||||
|
|
|
@ -280,7 +280,7 @@ gst_spider_identity_request_new_pad (GstElement *element, GstPadTemplate *templ
|
|||
case GST_PAD_SINK:
|
||||
if (ident->sink != NULL) break;
|
||||
/* sink */
|
||||
GST_DEBUG(0, "element %s requests new sink pad\n", GST_ELEMENT_NAME(ident));
|
||||
GST_DEBUG(0, "element %s requests new sink pad", GST_ELEMENT_NAME(ident));
|
||||
ident->sink = gst_pad_new ("sink", GST_PAD_SINK);
|
||||
gst_element_add_pad (GST_ELEMENT (ident), ident->sink);
|
||||
gst_pad_set_connect_function (ident->sink, GST_DEBUG_FUNCPTR (gst_spider_identity_connect));
|
||||
|
@ -289,7 +289,7 @@ gst_spider_identity_request_new_pad (GstElement *element, GstPadTemplate *templ
|
|||
case GST_PAD_SRC:
|
||||
/* src */
|
||||
if (ident->src != NULL) break;
|
||||
GST_DEBUG(0, "element %s requests new src pad\n", GST_ELEMENT_NAME(ident));
|
||||
GST_DEBUG(0, "element %s requests new src pad", GST_ELEMENT_NAME(ident));
|
||||
ident->src = gst_pad_new ("src", GST_PAD_SRC);
|
||||
gst_element_add_pad (GST_ELEMENT (ident), ident->src);
|
||||
gst_pad_set_connect_function (ident->src, GST_DEBUG_FUNCPTR (gst_spider_identity_connect));
|
||||
|
@ -299,7 +299,7 @@ gst_spider_identity_request_new_pad (GstElement *element, GstPadTemplate *templ
|
|||
break;
|
||||
}
|
||||
|
||||
GST_DEBUG(0, "element %s requested a new pad but none could be created\n", GST_ELEMENT_NAME(ident));
|
||||
GST_DEBUG(0, "element %s requested a new pad but none could be created", GST_ELEMENT_NAME(ident));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -359,7 +359,7 @@ gst_spider_identity_start_typefinding (GstSpiderIdentity *ident)
|
|||
GstElement* typefind;
|
||||
gboolean restart = FALSE;
|
||||
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG, "element %s starts typefinding\n", GST_ELEMENT_NAME(ident));
|
||||
GST_DEBUG (GST_CAT_AUTOPLUG, "element %s starts typefinding", GST_ELEMENT_NAME(ident));
|
||||
if (GST_STATE (GST_ELEMENT_PARENT (ident)) == GST_STATE_PLAYING)
|
||||
{
|
||||
gst_element_set_state (GST_ELEMENT (GST_ELEMENT_PARENT (ident)), GST_STATE_PAUSED);
|
||||
|
@ -497,7 +497,7 @@ gst_spider_identity_sink_loop_typefinding (GstSpiderIdentity *ident)
|
|||
|
||||
/* add it to the end of the cache */
|
||||
gst_buffer_ref (buf);
|
||||
GST_DEBUG (0, "element %s adds buffer %p (size %d) to cache\n", GST_ELEMENT_NAME(ident), buf, GST_BUFFER_SIZE (buf));
|
||||
GST_DEBUG (0, "element %s adds buffer %p (size %d) to cache", GST_ELEMENT_NAME(ident), buf, GST_BUFFER_SIZE (buf));
|
||||
ident->cache_end = g_list_prepend (ident->cache_end, buf);
|
||||
if (ident->cache_start == NULL)
|
||||
ident->cache_start = ident->cache_end;
|
||||
|
@ -522,7 +522,7 @@ gst_spider_identity_sink_loop_emptycache (GstSpiderIdentity *ident)
|
|||
/* now check if we have more buffers to push */
|
||||
if (ident->cache_start == NULL)
|
||||
{
|
||||
GST_DEBUG(0, "cache from %s is empty, changing loop function\n", GST_ELEMENT_NAME(ident));
|
||||
GST_DEBUG(0, "cache from %s is empty, changing loop function", GST_ELEMENT_NAME(ident));
|
||||
/* free cache */
|
||||
g_list_free (ident->cache_end);
|
||||
ident->cache_end = NULL;
|
||||
|
|
|
@ -147,7 +147,7 @@ gst_autoplug_pads_autoplug_func (GstElement *src, GstPad *pad, GstElement *sink)
|
|||
GList *sinkpads;
|
||||
gboolean connected = FALSE;
|
||||
|
||||
GST_DEBUG (0,"gstpipeline: autoplug pad connect function for \"%s\" to \"%s\"\n",
|
||||
GST_DEBUG (0,"gstpipeline: autoplug pad connect function for \"%s\" to \"%s\"",
|
||||
GST_ELEMENT_NAME(src), GST_ELEMENT_NAME(sink));
|
||||
|
||||
sinkpads = gst_element_get_pad_list(sink);
|
||||
|
@ -162,20 +162,20 @@ gst_autoplug_pads_autoplug_func (GstElement *src, GstPad *pad, GstElement *sink)
|
|||
gst_pad_connect(pad, sinkpad);
|
||||
GST_DEBUG (0,"gstpipeline: autoconnect pad \"%s\" in element %s <-> ", GST_PAD_NAME (pad),
|
||||
GST_ELEMENT_NAME(src));
|
||||
GST_DEBUG (0,"pad \"%s\" in element %s\n", GST_PAD_NAME (sinkpad),
|
||||
GST_DEBUG (0,"pad \"%s\" in element %s", GST_PAD_NAME (sinkpad),
|
||||
GST_ELEMENT_NAME(sink));
|
||||
connected = TRUE;
|
||||
break;
|
||||
}
|
||||
else {
|
||||
GST_DEBUG (0,"pads incompatible %s, %s\n", GST_PAD_NAME (pad), GST_PAD_NAME (sinkpad));
|
||||
GST_DEBUG (0,"pads incompatible %s, %s", GST_PAD_NAME (pad), GST_PAD_NAME (sinkpad));
|
||||
}
|
||||
}
|
||||
sinkpads = g_list_next(sinkpads);
|
||||
}
|
||||
|
||||
if (!connected) {
|
||||
GST_DEBUG (0,"gstpipeline: no path to sinks for type\n");
|
||||
GST_DEBUG (0,"gstpipeline: no path to sinks for type");
|
||||
}
|
||||
return connected;
|
||||
}
|
||||
|
@ -192,7 +192,7 @@ autoplug_dynamic_pad (GstElement *element, GstPad *pad, gpointer data)
|
|||
dynamic_pad_struct *info = (dynamic_pad_struct *)data;
|
||||
GList *pads = gst_element_get_pad_list (element);
|
||||
|
||||
GST_DEBUG (0,"attempting to dynamically create a ghostpad for %s=%s\n", GST_ELEMENT_NAME (element),
|
||||
GST_DEBUG (0,"attempting to dynamically create a ghostpad for %s=%s", GST_ELEMENT_NAME (element),
|
||||
GST_PAD_NAME (pad));
|
||||
|
||||
while (pads) {
|
||||
|
@ -202,7 +202,7 @@ autoplug_dynamic_pad (GstElement *element, GstPad *pad, gpointer data)
|
|||
|
||||
if (gst_caps_check_compatibility (GST_PADTEMPLATE_CAPS (templ), info->endcap)) {
|
||||
gst_element_add_ghost_pad (info->result, pad, g_strdup_printf("src_%02d", info->i));
|
||||
GST_DEBUG (0,"gstpipeline: new dynamic pad %s\n", GST_PAD_NAME (pad));
|
||||
GST_DEBUG (0,"gstpipeline: new dynamic pad %s", GST_PAD_NAME (pad));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -226,7 +226,7 @@ gst_autoplug_pads_autoplug (GstElement *src, GstElement *sink)
|
|||
}
|
||||
|
||||
if (!connected) {
|
||||
GST_DEBUG (0,"gstpipeline: delaying pad connections for \"%s\" to \"%s\"\n",
|
||||
GST_DEBUG (0,"gstpipeline: delaying pad connections for \"%s\" to \"%s\"",
|
||||
GST_ELEMENT_NAME(src), GST_ELEMENT_NAME(sink));
|
||||
g_signal_connect (G_OBJECT(src), "new_pad",
|
||||
G_CALLBACK (gst_autoplug_pads_autoplug_func), sink);
|
||||
|
@ -366,7 +366,7 @@ gst_static_autoplug_to_caps (GstAutoplug *autoplug, GstCaps *srccaps, GstCaps *s
|
|||
}
|
||||
}
|
||||
|
||||
GST_DEBUG (0,"common factory \"%s\"\n", GST_OBJECT_NAME (factory));
|
||||
GST_DEBUG (0,"common factory \"%s\"", GST_OBJECT_NAME (factory));
|
||||
|
||||
/* it is likely that the plugin is not loaded yet. thus when it loads it
|
||||
* will replace the elementfactory that gst built from the cache, and the
|
||||
|
@ -428,10 +428,10 @@ differ:
|
|||
|
||||
factory = (GstElementFactory *)(factories[i]->data);
|
||||
|
||||
GST_DEBUG (0,"factory \"%s\"\n", GST_OBJECT_NAME (factory));
|
||||
GST_DEBUG (0,"factory \"%s\"", GST_OBJECT_NAME (factory));
|
||||
element = gst_elementfactory_create(factory, GST_OBJECT_NAME (factory));
|
||||
|
||||
GST_DEBUG (0,"adding element %s\n", GST_ELEMENT_NAME (element));
|
||||
GST_DEBUG (0,"adding element %s", GST_ELEMENT_NAME (element));
|
||||
gst_bin_add(GST_BIN(thebin), element);
|
||||
gst_autoplug_signal_new_object (GST_AUTOPLUG (autoplug), GST_OBJECT (element));
|
||||
|
||||
|
@ -452,7 +452,7 @@ differ:
|
|||
gboolean have_pad = FALSE;
|
||||
endcaps = g_list_next (endcaps);
|
||||
|
||||
GST_DEBUG (0,"attempting to create a ghostpad for %s\n", GST_ELEMENT_NAME (thesrcelement));
|
||||
GST_DEBUG (0,"attempting to create a ghostpad for %s", GST_ELEMENT_NAME (thesrcelement));
|
||||
|
||||
while (pads) {
|
||||
GstPad *pad = GST_PAD (pads->data);
|
||||
|
@ -472,7 +472,7 @@ differ:
|
|||
data->endcap = endcap;
|
||||
data->i = i;
|
||||
|
||||
GST_DEBUG (0,"delaying the creation of a ghostpad for %s\n", GST_ELEMENT_NAME (thesrcelement));
|
||||
GST_DEBUG (0,"delaying the creation of a ghostpad for %s", GST_ELEMENT_NAME (thesrcelement));
|
||||
g_signal_connect (G_OBJECT (thesrcelement), "new_pad",
|
||||
G_CALLBACK (autoplug_dynamic_pad), data);
|
||||
}
|
||||
|
|
|
@ -175,7 +175,7 @@ gst_autoplug_pads_autoplug_func (GstElement *src, GstPad *pad, GstElement *sink)
|
|||
gboolean connected = FALSE;
|
||||
GstElementState state = GST_STATE (gst_element_get_parent (src));
|
||||
|
||||
GST_DEBUG (0,"gstpipeline: autoplug pad connect function for %s %s:%s to \"%s\"\n",
|
||||
GST_DEBUG (0,"gstpipeline: autoplug pad connect function for %s %s:%s to \"%s\"",
|
||||
GST_ELEMENT_NAME (src), GST_DEBUG_PAD_NAME(pad), GST_ELEMENT_NAME(sink));
|
||||
|
||||
if (state == GST_STATE_PLAYING)
|
||||
|
@ -194,7 +194,7 @@ gst_autoplug_pads_autoplug_func (GstElement *src, GstPad *pad, GstElement *sink)
|
|||
break;
|
||||
}
|
||||
else {
|
||||
GST_DEBUG (0,"pads incompatible %s, %s\n", GST_PAD_NAME (pad), GST_PAD_NAME (sinkpad));
|
||||
GST_DEBUG (0,"pads incompatible %s, %s", GST_PAD_NAME (pad), GST_PAD_NAME (sinkpad));
|
||||
}
|
||||
}
|
||||
sinkpads = g_list_next(sinkpads);
|
||||
|
@ -204,7 +204,7 @@ gst_autoplug_pads_autoplug_func (GstElement *src, GstPad *pad, GstElement *sink)
|
|||
gst_element_set_state (GST_ELEMENT (gst_element_get_parent (src)), GST_STATE_PLAYING);
|
||||
|
||||
if (!connected) {
|
||||
GST_DEBUG (0,"gstpipeline: no path to sinks for type\n");
|
||||
GST_DEBUG (0,"gstpipeline: no path to sinks for type");
|
||||
}
|
||||
return connected;
|
||||
}
|
||||
|
@ -230,7 +230,7 @@ gst_autoplug_pads_autoplug (GstElement *src, GstElement *sink)
|
|||
}
|
||||
|
||||
if (!connected) {
|
||||
GST_DEBUG (0,"gstpipeline: delaying pad connections for \"%s\" to \"%s\"\n",
|
||||
GST_DEBUG (0,"gstpipeline: delaying pad connections for \"%s\" to \"%s\"",
|
||||
GST_ELEMENT_NAME(src), GST_ELEMENT_NAME(sink));
|
||||
g_signal_connect (G_OBJECT(src),"new_pad",
|
||||
G_CALLBACK (gst_autoplug_pads_autoplug_func), sink);
|
||||
|
@ -396,7 +396,7 @@ next:
|
|||
}
|
||||
}
|
||||
|
||||
GST_DEBUG (0,"common factory \"%s\"\n", GST_OBJECT_NAME (factory));
|
||||
GST_DEBUG (0,"common factory \"%s\"", GST_OBJECT_NAME (factory));
|
||||
|
||||
element = gst_elementfactory_create (factory, g_strdup (GST_OBJECT_NAME (factory)));
|
||||
gst_bin_add (GST_BIN(result), element);
|
||||
|
@ -456,7 +456,7 @@ differ:
|
|||
if (factories[i]) {
|
||||
factory = (GstElementFactory *)(factories[i]->data);
|
||||
|
||||
GST_DEBUG (0,"factory \"%s\"\n", GST_OBJECT_NAME (factory));
|
||||
GST_DEBUG (0,"factory \"%s\"", GST_OBJECT_NAME (factory));
|
||||
element = gst_elementfactory_create(factory, g_strdup (GST_OBJECT_NAME (factory)));
|
||||
}
|
||||
else {
|
||||
|
@ -472,11 +472,11 @@ differ:
|
|||
|
||||
use_thread = FALSE;
|
||||
|
||||
GST_DEBUG (0,"sugest new thread for \"%s\" %08x\n", GST_ELEMENT_NAME (element), GST_FLAGS(element));
|
||||
GST_DEBUG (0,"sugest new thread for \"%s\" %08x", GST_ELEMENT_NAME (element), GST_FLAGS(element));
|
||||
|
||||
/* create a new queue and add to the previous bin */
|
||||
queue = gst_elementfactory_make("queue", g_strconcat("queue_", GST_ELEMENT_NAME(element), NULL));
|
||||
GST_DEBUG (0,"adding element \"%s\"\n", GST_ELEMENT_NAME (element));
|
||||
GST_DEBUG (0,"adding element \"%s\"", GST_ELEMENT_NAME (element));
|
||||
|
||||
/* this will be the new bin for all following elements */
|
||||
thebin = gst_elementfactory_make("thread", g_strconcat("thread_", GST_ELEMENT_NAME(element), NULL));
|
||||
|
@ -488,17 +488,17 @@ differ:
|
|||
|
||||
gst_autoplug_pads_autoplug(thesrcelement, queue);
|
||||
|
||||
GST_DEBUG (0,"adding element %s\n", GST_ELEMENT_NAME (element));
|
||||
GST_DEBUG (0,"adding element %s", GST_ELEMENT_NAME (element));
|
||||
gst_bin_add(GST_BIN(thebin), element);
|
||||
gst_autoplug_signal_new_object (GST_AUTOPLUG (autoplug), GST_OBJECT (element));
|
||||
GST_DEBUG (0,"adding element %s\n", GST_ELEMENT_NAME (thebin));
|
||||
GST_DEBUG (0,"adding element %s", GST_ELEMENT_NAME (thebin));
|
||||
gst_bin_add(GST_BIN(current_bin), thebin);
|
||||
gst_autoplug_signal_new_object (GST_AUTOPLUG (autoplug), GST_OBJECT (thebin));
|
||||
thesrcelement = queue;
|
||||
}
|
||||
/* no thread needed, easy case */
|
||||
else {
|
||||
GST_DEBUG (0,"adding element %s\n", GST_ELEMENT_NAME (element));
|
||||
GST_DEBUG (0,"adding element %s", GST_ELEMENT_NAME (element));
|
||||
gst_bin_add(GST_BIN(thebin), element);
|
||||
gst_autoplug_signal_new_object (GST_AUTOPLUG (autoplug), GST_OBJECT (element));
|
||||
}
|
||||
|
|
|
@ -175,7 +175,7 @@ cothread_create (cothread_context *ctx)
|
|||
stack_end = (guchar *) ((gulong) sp & ~(STACK_SIZE - 1));
|
||||
|
||||
thread = (cothread_state *) (stack_end + ((slot - 1) * COTHREAD_STACKSIZE));
|
||||
GST_DEBUG (0, "new stack at %p\n", thread);
|
||||
GST_DEBUG (0, "new stack at %p", thread);
|
||||
|
||||
if (mmap ((void *) thread, COTHREAD_STACKSIZE,
|
||||
PROT_READ | PROT_WRITE | PROT_EXEC, MAP_FIXED | MAP_PRIVATE | MAP_ANON, -1, 0) == MAP_FAILED) {
|
||||
|
@ -298,7 +298,7 @@ cothread_stop (cothread_state * thread)
|
|||
cothread_state *
|
||||
cothread_main (cothread_context * ctx)
|
||||
{
|
||||
GST_DEBUG (0, "returning %p, the 0th cothread\n", ctx->threads[0]);
|
||||
GST_DEBUG (0, "returning %p, the 0th cothread", ctx->threads[0]);
|
||||
return ctx->threads[0];
|
||||
}
|
||||
|
||||
|
@ -474,21 +474,21 @@ cothread_switch (cothread_state * thread)
|
|||
#endif
|
||||
enter = setjmp (current->jmp);
|
||||
if (enter != 0) {
|
||||
GST_DEBUG (0, "enter thread #%d %d %p<->%p (%d)\n", current->threadnum, enter,
|
||||
GST_DEBUG (0, "enter thread #%d %d %p<->%p (%d)", current->threadnum, enter,
|
||||
current->sp, current->top_sp, (char*)current->top_sp - (char*)current->sp);
|
||||
return;
|
||||
}
|
||||
GST_DEBUG (0, "exit thread #%d %d %p<->%p (%d)\n", current->threadnum, enter,
|
||||
GST_DEBUG (0, "exit thread #%d %d %p<->%p (%d)", current->threadnum, enter,
|
||||
current->sp, current->top_sp, (char*)current->top_sp - (char*)current->sp);
|
||||
enter = 1;
|
||||
|
||||
if (current->flags & COTHREAD_DESTROYED)
|
||||
cothread_destroy (current);
|
||||
|
||||
GST_DEBUG (0, "set stack to %p\n", thread->sp);
|
||||
GST_DEBUG (0, "set stack to %p", thread->sp);
|
||||
/* restore stack pointer and other stuff of new cothread */
|
||||
if (thread->flags & COTHREAD_STARTED) {
|
||||
GST_DEBUG (0, "in thread \n");
|
||||
GST_DEBUG (0, "in thread ");
|
||||
/* switch to it */
|
||||
longjmp (thread->jmp, 1);
|
||||
}
|
||||
|
@ -497,7 +497,7 @@ cothread_switch (cothread_state * thread)
|
|||
GST_ARCH_SET_SP (thread->sp);
|
||||
/* start it */
|
||||
GST_ARCH_CALL (cothread_stub);
|
||||
GST_DEBUG (0, "exit thread \n");
|
||||
GST_DEBUG (0, "exit thread ");
|
||||
ctx->current = 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -122,7 +122,7 @@ gst_fdsink_chain (GstPad *pad, GstBuffer *buf)
|
|||
g_return_if_fail (fdsink->fd >= 0);
|
||||
|
||||
if (GST_BUFFER_DATA (buf)) {
|
||||
GST_DEBUG (0,"writing %d bytes to file descriptor %d\n",GST_BUFFER_SIZE (buf), fdsink->fd);
|
||||
GST_DEBUG (0,"writing %d bytes to file descriptor %d",GST_BUFFER_SIZE (buf), fdsink->fd);
|
||||
write (fdsink->fd, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
|
||||
}
|
||||
|
||||
|
|
|
@ -559,7 +559,7 @@ gst_filesrc_open_file (GstFileSrc *src)
|
|||
{
|
||||
g_return_val_if_fail (!GST_FLAG_IS_SET (src ,GST_FILESRC_OPEN), FALSE);
|
||||
|
||||
GST_DEBUG(0, "opening file %s\n",src->filename);
|
||||
GST_DEBUG(0, "opening file %s",src->filename);
|
||||
|
||||
/* open the file */
|
||||
src->fd = open (src->filename, O_RDONLY);
|
||||
|
|
|
@ -140,7 +140,7 @@ gst_pipefilter_handle_event (GstPad *pad, GstEvent *event)
|
|||
|
||||
pipefilter = GST_PIPEFILTER (gst_pad_get_parent (pad));
|
||||
|
||||
GST_DEBUG (0,"pipefilter: %s received event\n", GST_ELEMENT_NAME (pipefilter));
|
||||
GST_DEBUG (0,"pipefilter: %s received event", GST_ELEMENT_NAME (pipefilter));
|
||||
if (close (pipefilter->fdin[1]) < 0)
|
||||
perror("close");
|
||||
if (close (pipefilter->fdout[0]) < 0)
|
||||
|
@ -170,9 +170,9 @@ gst_pipefilter_get (GstPad *pad)
|
|||
g_return_val_if_fail(GST_BUFFER_DATA(newbuf) != NULL, NULL);
|
||||
|
||||
/* read it in from the file */
|
||||
GST_DEBUG (0,"attemting to read %ld bytes\n", pipefilter->bytes_per_read);
|
||||
GST_DEBUG (0,"attemting to read %ld bytes", pipefilter->bytes_per_read);
|
||||
readbytes = read(pipefilter->fdout[0], GST_BUFFER_DATA(newbuf), pipefilter->bytes_per_read);
|
||||
GST_DEBUG (0,"read %ld bytes\n", readbytes);
|
||||
GST_DEBUG (0,"read %ld bytes", readbytes);
|
||||
if (readbytes < 0) {
|
||||
perror("read");
|
||||
gst_element_error(GST_ELEMENT(pipefilter),"reading");
|
||||
|
@ -208,9 +208,9 @@ gst_pipefilter_chain (GstPad *pad,GstBuffer *buf)
|
|||
data = GST_BUFFER_DATA(buf);
|
||||
size = GST_BUFFER_SIZE(buf);
|
||||
|
||||
GST_DEBUG (0,"attemting to write %ld bytes\n", size);
|
||||
GST_DEBUG (0,"attemting to write %ld bytes", size);
|
||||
writebytes = write(pipefilter->fdin[1],data,size);
|
||||
GST_DEBUG (0,"written %ld bytes\n", writebytes);
|
||||
GST_DEBUG (0,"written %ld bytes", writebytes);
|
||||
if (writebytes < 0) {
|
||||
perror("write");
|
||||
gst_element_error(GST_ELEMENT(pipefilter),"writing");
|
||||
|
|
|
@ -293,7 +293,7 @@ gst_autoplugfactory_find (const gchar *name)
|
|||
|
||||
g_return_val_if_fail(name != NULL, NULL);
|
||||
|
||||
GST_DEBUG (0,"gstautoplug: find \"%s\"\n", name);
|
||||
GST_DEBUG (0,"gstautoplug: find \"%s\"", name);
|
||||
|
||||
walk = _gst_autoplugfactories;
|
||||
while (walk) {
|
||||
|
|
14
gst/gstbin.c
14
gst/gstbin.c
|
@ -187,7 +187,7 @@ static void
|
|||
gst_bin_distribute_clock (GstBin *bin, GList *needing, GstClock *clock)
|
||||
{
|
||||
while (needing) {
|
||||
GST_DEBUG (GST_CAT_CLOCK, "setting clock on %s\n", GST_ELEMENT_NAME (needing->data));
|
||||
GST_DEBUG (GST_CAT_CLOCK, "setting clock on %s", GST_ELEMENT_NAME (needing->data));
|
||||
gst_element_set_clock (GST_ELEMENT (needing->data), clock);
|
||||
|
||||
needing = g_list_next (needing);
|
||||
|
@ -209,7 +209,7 @@ gst_bin_distribute_clocks (GstBin *bin)
|
|||
clock = gst_element_get_clock (GST_ELEMENT (providing->data));
|
||||
}
|
||||
else {
|
||||
GST_DEBUG (GST_CAT_CLOCK, "no clock provided, using default clock\n");
|
||||
GST_DEBUG (GST_CAT_CLOCK, "no clock provided, using default clock");
|
||||
clock = gst_system_clock_obtain ();
|
||||
}
|
||||
|
||||
|
@ -382,7 +382,7 @@ gst_bin_add (GstBin * bin, GstElement * element)
|
|||
g_return_if_fail (element != NULL);
|
||||
g_return_if_fail (GST_IS_ELEMENT (element));
|
||||
|
||||
GST_DEBUG (GST_CAT_PARENTAGE, "adding element \"%s\" to bin \"%s\"\n",
|
||||
GST_DEBUG (GST_CAT_PARENTAGE, "adding element \"%s\" to bin \"%s\"",
|
||||
GST_ELEMENT_NAME (element), GST_ELEMENT_NAME (bin));
|
||||
|
||||
/* must be not be in PLAYING state in order to modify bin */
|
||||
|
@ -550,7 +550,7 @@ gst_bin_change_state (GstElement * element)
|
|||
switch (gst_element_set_state (child, pending)) {
|
||||
case GST_STATE_FAILURE:
|
||||
GST_STATE_PENDING (element) = GST_STATE_VOID_PENDING;
|
||||
GST_DEBUG (GST_CAT_STATES, "child '%s' failed to go to state %d(%s)\n",
|
||||
GST_DEBUG (GST_CAT_STATES, "child '%s' failed to go to state %d(%s)",
|
||||
GST_ELEMENT_NAME (child), pending, gst_element_statename (pending));
|
||||
|
||||
gst_element_set_state (child, old_state);
|
||||
|
@ -562,7 +562,7 @@ gst_bin_change_state (GstElement * element)
|
|||
}
|
||||
break;
|
||||
case GST_STATE_ASYNC:
|
||||
GST_DEBUG (GST_CAT_STATES, "child '%s' is changing state asynchronously\n",
|
||||
GST_DEBUG (GST_CAT_STATES, "child '%s' is changing state asynchronously",
|
||||
GST_ELEMENT_NAME (child));
|
||||
have_async = TRUE;
|
||||
break;
|
||||
|
@ -663,7 +663,7 @@ gst_bin_set_state_type (GstBin * bin, GstElementState state, GType type)
|
|||
{
|
||||
GstBinClass *oclass;
|
||||
|
||||
GST_DEBUG (GST_CAT_STATES, "gst_bin_set_state_type(\"%s\",%d,%s)\n",
|
||||
GST_DEBUG (GST_CAT_STATES, "gst_bin_set_state_type(\"%s\",%d,%s)",
|
||||
GST_ELEMENT_NAME (bin), state, G_OBJECT_TYPE_NAME (type));
|
||||
|
||||
g_return_val_if_fail (bin != NULL, FALSE);
|
||||
|
@ -683,7 +683,7 @@ gst_bin_dispose (GObject * object)
|
|||
GList *children, *orig;
|
||||
GstElement *child;
|
||||
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "dispose\n");
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "dispose");
|
||||
|
||||
if (gst_element_get_state (GST_ELEMENT (object)) == GST_STATE_PLAYING)
|
||||
gst_element_set_state (GST_ELEMENT (object), GST_STATE_PAUSED);
|
||||
|
|
|
@ -59,7 +59,7 @@ gst_buffer_pool_new (void)
|
|||
GstBufferPool *pool;
|
||||
|
||||
pool = g_new0 (GstBufferPool, 1);
|
||||
GST_DEBUG (GST_CAT_BUFFER,"allocating new buffer pool %p\n", pool);
|
||||
GST_DEBUG (GST_CAT_BUFFER,"allocating new buffer pool %p", pool);
|
||||
|
||||
/* all hooks and user data set to NULL or 0 by g_new0 */
|
||||
|
||||
|
@ -84,7 +84,7 @@ gst_buffer_pool_ref (GstBufferPool *pool)
|
|||
{
|
||||
g_return_if_fail (pool != NULL);
|
||||
|
||||
GST_DEBUG(GST_CAT_BUFFER,"referencing buffer pool %p from %d\n", pool, GST_BUFFER_POOL_REFCOUNT(pool));
|
||||
GST_DEBUG(GST_CAT_BUFFER,"referencing buffer pool %p from %d", pool, GST_BUFFER_POOL_REFCOUNT(pool));
|
||||
|
||||
#ifdef HAVE_ATOMIC_H
|
||||
atomic_inc (&(pool->refcount));
|
||||
|
@ -135,7 +135,7 @@ gst_buffer_pool_unref (GstBufferPool *pool)
|
|||
|
||||
g_return_if_fail (pool != NULL);
|
||||
|
||||
GST_DEBUG(GST_CAT_BUFFER, "unreferencing buffer pool %p from %d\n", pool, GST_BUFFER_POOL_REFCOUNT(pool));
|
||||
GST_DEBUG(GST_CAT_BUFFER, "unreferencing buffer pool %p from %d", pool, GST_BUFFER_POOL_REFCOUNT(pool));
|
||||
|
||||
#ifdef HAVE_ATOMIC_H
|
||||
g_return_if_fail (atomic_read (&(pool->refcount)) > 0);
|
||||
|
@ -332,7 +332,7 @@ gst_buffer_pool_get_default (guint buffer_size, guint pool_size)
|
|||
g_hash_table_insert(_default_pools,GINT_TO_POINTER(real_buffer_size),pool);
|
||||
g_mutex_unlock (_default_pool_lock);
|
||||
|
||||
GST_DEBUG(GST_CAT_BUFFER,"new buffer pool %p bytes:%d size:%d\n", pool, real_buffer_size, pool_size);
|
||||
GST_DEBUG(GST_CAT_BUFFER,"new buffer pool %p bytes:%d size:%d", pool, real_buffer_size, pool_size);
|
||||
|
||||
return pool;
|
||||
}
|
||||
|
@ -381,7 +381,7 @@ gst_buffer_pool_default_destroy_hook (GstBufferPool *pool, gpointer user_data)
|
|||
GstBufferPoolDefault *def = (GstBufferPoolDefault*) user_data;
|
||||
GMemChunk *data_chunk = def->mem_chunk;
|
||||
|
||||
GST_DEBUG(GST_CAT_BUFFER,"destroying default buffer pool %p\n", pool);
|
||||
GST_DEBUG(GST_CAT_BUFFER,"destroying default buffer pool %p", pool);
|
||||
|
||||
g_mutex_free (pool->lock);
|
||||
g_mem_chunk_reset(data_chunk);
|
||||
|
|
|
@ -155,13 +155,13 @@ gst_caps_debug (GstCaps *caps, const gchar *label)
|
|||
{
|
||||
GST_DEBUG_ENTER ("caps debug: %s", label);
|
||||
while (caps) {
|
||||
GST_DEBUG (GST_CAT_CAPS, "caps: %p %s %s\n", caps, caps->name, gst_caps_get_mime (caps));
|
||||
GST_DEBUG (GST_CAT_CAPS, "caps: %p %s %s", caps, caps->name, gst_caps_get_mime (caps));
|
||||
|
||||
if (caps->properties) {
|
||||
gst_props_debug (caps->properties);
|
||||
}
|
||||
else {
|
||||
GST_DEBUG (GST_CAT_CAPS, "no properties\n");
|
||||
GST_DEBUG (GST_CAT_CAPS, "no properties");
|
||||
}
|
||||
|
||||
caps = caps->next;
|
||||
|
@ -561,7 +561,7 @@ static gboolean
|
|||
gst_caps_check_compatibility_func (GstCaps *fromcaps, GstCaps *tocaps)
|
||||
{
|
||||
if (fromcaps->id != tocaps->id) {
|
||||
GST_DEBUG (GST_CAT_CAPS,"mime types differ (%s to %s)\n",
|
||||
GST_DEBUG (GST_CAT_CAPS,"mime types differ (%s to %s)",
|
||||
gst_type_find_by_id (fromcaps->id)->mime,
|
||||
gst_type_find_by_id (tocaps->id)->mime);
|
||||
return FALSE;
|
||||
|
@ -572,13 +572,13 @@ gst_caps_check_compatibility_func (GstCaps *fromcaps, GstCaps *tocaps)
|
|||
return gst_props_check_compatibility (fromcaps->properties, tocaps->properties);
|
||||
}
|
||||
else {
|
||||
GST_DEBUG (GST_CAT_CAPS,"no source caps\n");
|
||||
GST_DEBUG (GST_CAT_CAPS,"no source caps");
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
else {
|
||||
/* assume it accepts everything */
|
||||
GST_DEBUG (GST_CAT_CAPS,"no caps\n");
|
||||
GST_DEBUG (GST_CAT_CAPS,"no caps");
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
@ -597,17 +597,17 @@ gst_caps_check_compatibility (GstCaps *fromcaps, GstCaps *tocaps)
|
|||
{
|
||||
if (fromcaps == NULL) {
|
||||
if (tocaps == NULL) {
|
||||
GST_DEBUG (GST_CAT_CAPS,"no caps\n");
|
||||
GST_DEBUG (GST_CAT_CAPS,"no caps");
|
||||
return TRUE;
|
||||
}
|
||||
else {
|
||||
GST_DEBUG (GST_CAT_CAPS,"no source but destination caps\n");
|
||||
GST_DEBUG (GST_CAT_CAPS,"no source but destination caps");
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (tocaps == NULL) {
|
||||
GST_DEBUG (GST_CAT_CAPS,"source caps and no destination caps\n");
|
||||
GST_DEBUG (GST_CAT_CAPS,"source caps and no destination caps");
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
@ -633,7 +633,7 @@ gst_caps_intersect_func (GstCaps *caps1, GstCaps *caps2)
|
|||
GstProps *props;
|
||||
|
||||
if (caps1->id != caps2->id) {
|
||||
GST_DEBUG (GST_CAT_CAPS,"mime types differ (%s to %s)\n",
|
||||
GST_DEBUG (GST_CAT_CAPS,"mime types differ (%s to %s)",
|
||||
gst_type_find_by_id (caps1->id)->mime,
|
||||
gst_type_find_by_id (caps2->id)->mime);
|
||||
return NULL;
|
||||
|
@ -670,11 +670,11 @@ gst_caps_intersect (GstCaps *caps1, GstCaps *caps2)
|
|||
GstCaps *result = NULL, *walk = NULL;
|
||||
|
||||
if (caps1 == NULL) {
|
||||
GST_DEBUG (GST_CAT_CAPS, "first caps is NULL, return other caps\n");
|
||||
GST_DEBUG (GST_CAT_CAPS, "first caps is NULL, return other caps");
|
||||
return gst_caps_copy (caps2);
|
||||
}
|
||||
if (caps2 == NULL) {
|
||||
GST_DEBUG (GST_CAT_CAPS, "second caps is NULL, return other caps\n");
|
||||
GST_DEBUG (GST_CAT_CAPS, "second caps is NULL, return other caps");
|
||||
return gst_caps_copy (caps1);
|
||||
}
|
||||
|
||||
|
|
|
@ -342,7 +342,7 @@ gst_element_add_pad (GstElement *element, GstPad *pad)
|
|||
g_return_if_fail (gst_object_check_uniqueness (element->pads, GST_PAD_NAME(pad)) == TRUE);
|
||||
|
||||
/* set the pad's parent */
|
||||
GST_DEBUG (GST_CAT_ELEMENT_PADS,"setting parent of pad '%s' to '%s'\n",
|
||||
GST_DEBUG (GST_CAT_ELEMENT_PADS,"setting parent of pad '%s' to '%s'",
|
||||
GST_PAD_NAME (pad), GST_ELEMENT_NAME (element));
|
||||
gst_object_set_parent (GST_OBJECT (pad), GST_OBJECT (element));
|
||||
|
||||
|
@ -419,19 +419,19 @@ gst_element_add_ghost_pad (GstElement *element, GstPad *pad, gchar *name)
|
|||
/* then check to see if there's already a pad by that name here */
|
||||
g_return_val_if_fail (gst_object_check_uniqueness (element->pads, name) == TRUE, NULL);
|
||||
|
||||
GST_DEBUG(GST_CAT_ELEMENT_PADS,"creating new ghost pad called %s, from pad %s:%s\n",
|
||||
GST_DEBUG(GST_CAT_ELEMENT_PADS,"creating new ghost pad called %s, from pad %s:%s",
|
||||
name,GST_DEBUG_PAD_NAME(pad));
|
||||
ghostpad = gst_ghost_pad_new (name, pad);
|
||||
|
||||
/* add it to the list */
|
||||
GST_DEBUG(GST_CAT_ELEMENT_PADS,"adding ghost pad %s to element %s\n",
|
||||
GST_DEBUG(GST_CAT_ELEMENT_PADS,"adding ghost pad %s to element %s",
|
||||
name, GST_ELEMENT_NAME (element));
|
||||
element->pads = g_list_append (element->pads, ghostpad);
|
||||
element->numpads++;
|
||||
/* set the parent of the ghostpad */
|
||||
gst_object_set_parent (GST_OBJECT (ghostpad), GST_OBJECT (element));
|
||||
|
||||
GST_DEBUG(GST_CAT_ELEMENT_PADS,"added ghostpad %s:%s\n",GST_DEBUG_PAD_NAME(ghostpad));
|
||||
GST_DEBUG(GST_CAT_ELEMENT_PADS,"added ghostpad %s:%s",GST_DEBUG_PAD_NAME(ghostpad));
|
||||
|
||||
/* emit the NEW_GHOST_PAD signal */
|
||||
g_signal_emit (G_OBJECT (element), gst_element_signals[NEW_PAD], 0, ghostpad);
|
||||
|
@ -606,7 +606,7 @@ gst_element_get_padtemplate_by_compatible (GstElement *element, GstPadTemplate *
|
|||
GstPadTemplate *newtempl = NULL;
|
||||
GList *padlist;
|
||||
|
||||
GST_DEBUG(GST_CAT_ELEMENT_PADS,"gst_element_get_padtemplate_by_compatible()\n");
|
||||
GST_DEBUG(GST_CAT_ELEMENT_PADS,"gst_element_get_padtemplate_by_compatible()");
|
||||
|
||||
g_return_val_if_fail (element != NULL, NULL);
|
||||
g_return_val_if_fail (GST_IS_ELEMENT (element), NULL);
|
||||
|
@ -623,19 +623,19 @@ gst_element_get_padtemplate_by_compatible (GstElement *element, GstPadTemplate *
|
|||
* Check direction (must be opposite)
|
||||
* Check caps
|
||||
*/
|
||||
GST_DEBUG(GST_CAT_CAPS,"checking direction and caps\n");
|
||||
GST_DEBUG(GST_CAT_CAPS,"checking direction and caps");
|
||||
if (padtempl->direction == GST_PAD_SRC &&
|
||||
compattempl->direction == GST_PAD_SINK) {
|
||||
GST_DEBUG(GST_CAT_CAPS,"compatible direction: found src pad template\n");
|
||||
GST_DEBUG(GST_CAT_CAPS,"compatible direction: found src pad template");
|
||||
compat = gst_caps_check_compatibility(GST_PADTEMPLATE_CAPS (padtempl),
|
||||
GST_PADTEMPLATE_CAPS (compattempl));
|
||||
GST_DEBUG(GST_CAT_CAPS,"caps are %scompatible\n", (compat?"":"not "));
|
||||
GST_DEBUG(GST_CAT_CAPS,"caps are %scompatible", (compat?"":"not "));
|
||||
} else if (padtempl->direction == GST_PAD_SINK &&
|
||||
compattempl->direction == GST_PAD_SRC) {
|
||||
GST_DEBUG(GST_CAT_CAPS,"compatible direction: found sink pad template\n");
|
||||
GST_DEBUG(GST_CAT_CAPS,"compatible direction: found sink pad template");
|
||||
compat = gst_caps_check_compatibility(GST_PADTEMPLATE_CAPS (compattempl),
|
||||
GST_PADTEMPLATE_CAPS (padtempl));
|
||||
GST_DEBUG(GST_CAT_CAPS,"caps are %scompatible\n", (compat?"":"not "));
|
||||
GST_DEBUG(GST_CAT_CAPS,"caps are %scompatible", (compat?"":"not "));
|
||||
}
|
||||
|
||||
if (compat) {
|
||||
|
@ -872,7 +872,7 @@ gst_element_connect_elements_filtered (GstElement *src, GstElement *dest,
|
|||
g_return_val_if_fail (dest != NULL, FALSE);
|
||||
g_return_val_if_fail (GST_IS_ELEMENT(dest), FALSE);
|
||||
|
||||
GST_DEBUG (GST_CAT_ELEMENT_PADS, "attempting to connect element %s to element %s\n", GST_ELEMENT_NAME (src), GST_ELEMENT_NAME (dest));
|
||||
GST_DEBUG (GST_CAT_ELEMENT_PADS, "attempting to connect element %s to element %s", GST_ELEMENT_NAME (src), GST_ELEMENT_NAME (dest));
|
||||
|
||||
/* loop through the existing pads in the source */
|
||||
srcpads = gst_element_get_pad_list (src);
|
||||
|
@ -885,7 +885,7 @@ gst_element_connect_elements_filtered (GstElement *src, GstElement *dest,
|
|||
(GST_PAD_PEER (srcpad) == NULL)) {
|
||||
destpad = gst_element_get_compatible_pad_filtered (dest, srcpad, filtercaps);
|
||||
if (destpad && gst_pad_connect_filtered (srcpad, destpad, filtercaps)) {
|
||||
GST_DEBUG (GST_CAT_ELEMENT_PADS, "connected pad %s:%s to pad %s:%s\n", GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (destpad));
|
||||
GST_DEBUG (GST_CAT_ELEMENT_PADS, "connected pad %s:%s to pad %s:%s", GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (destpad));
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
@ -899,7 +899,7 @@ gst_element_connect_elements_filtered (GstElement *src, GstElement *dest,
|
|||
(GST_PAD_PEER (destpad) == NULL)) {
|
||||
srcpad = gst_element_get_compatible_pad_filtered (src, destpad, filtercaps);
|
||||
if (srcpad && gst_pad_connect_filtered (srcpad, destpad, filtercaps)) {
|
||||
GST_DEBUG (GST_CAT_ELEMENT_PADS, "connected pad %s:%s to pad %s:%s\n", GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (destpad));
|
||||
GST_DEBUG (GST_CAT_ELEMENT_PADS, "connected pad %s:%s to pad %s:%s", GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (destpad));
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
@ -907,7 +907,7 @@ gst_element_connect_elements_filtered (GstElement *src, GstElement *dest,
|
|||
}
|
||||
}
|
||||
|
||||
GST_DEBUG (GST_CAT_ELEMENT_PADS, "we might have request pads on both sides, checking...\n");
|
||||
GST_DEBUG (GST_CAT_ELEMENT_PADS, "we might have request pads on both sides, checking...");
|
||||
srctempls = gst_element_get_padtemplate_list (src);
|
||||
desttempls = gst_element_get_padtemplate_list (dest);
|
||||
|
||||
|
@ -923,7 +923,7 @@ gst_element_connect_elements_filtered (GstElement *src, GstElement *dest,
|
|||
srcpad = gst_element_request_pad_by_name (src, srctempl->name_template);
|
||||
destpad = gst_element_request_pad_by_name (dest, desttempl->name_template);
|
||||
if (gst_pad_connect_filtered (srcpad, destpad, filtercaps)) {
|
||||
GST_DEBUG (GST_CAT_ELEMENT_PADS, "connected pad %s:%s to pad %s:%s\n",
|
||||
GST_DEBUG (GST_CAT_ELEMENT_PADS, "connected pad %s:%s to pad %s:%s",
|
||||
GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (destpad));
|
||||
return TRUE;
|
||||
}
|
||||
|
@ -936,7 +936,7 @@ gst_element_connect_elements_filtered (GstElement *src, GstElement *dest,
|
|||
}
|
||||
}
|
||||
|
||||
GST_DEBUG (GST_CAT_ELEMENT_PADS, "no connection possible from %s to %s\n", GST_ELEMENT_NAME (src), GST_ELEMENT_NAME (dest));
|
||||
GST_DEBUG (GST_CAT_ELEMENT_PADS, "no connection possible from %s to %s", GST_ELEMENT_NAME (src), GST_ELEMENT_NAME (dest));
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
|
@ -1133,7 +1133,7 @@ gst_element_error_func (GstElement* element, GstElement *source, gchar *errormsg
|
|||
{
|
||||
/* tell the parent */
|
||||
if (GST_OBJECT_PARENT (element)) {
|
||||
GST_DEBUG (GST_CAT_EVENT, "forwarding error \"%s\" from %s to %s\n", errormsg,
|
||||
GST_DEBUG (GST_CAT_EVENT, "forwarding error \"%s\" from %s to %s", errormsg,
|
||||
GST_ELEMENT_NAME (element), GST_OBJECT_NAME (GST_OBJECT_PARENT (element)));
|
||||
|
||||
gst_object_ref (GST_OBJECT (element));
|
||||
|
@ -1493,7 +1493,7 @@ gst_element_dispose (GObject *object)
|
|||
pad = GST_PAD (pads->data);
|
||||
|
||||
if (GST_PAD_PEER (pad)) {
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "disconnecting pad '%s'\n",
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "disconnecting pad '%s'",
|
||||
GST_OBJECT_NAME (GST_OBJECT (GST_PAD (GST_PAD_PEER (pad)))));
|
||||
gst_pad_disconnect (pad, GST_PAD (GST_PAD_PEER (pad)));
|
||||
}
|
||||
|
@ -1750,7 +1750,7 @@ gst_element_set_eos (GstElement *element)
|
|||
{
|
||||
g_return_if_fail (GST_IS_ELEMENT (element));
|
||||
|
||||
GST_DEBUG (GST_CAT_EVENT, "setting EOS on element %s\n", GST_OBJECT_NAME (element));
|
||||
GST_DEBUG (GST_CAT_EVENT, "setting EOS on element %s", GST_OBJECT_NAME (element));
|
||||
|
||||
gst_element_set_state (element, GST_STATE_PAUSED);
|
||||
|
||||
|
|
|
@ -122,7 +122,7 @@ gst_elementfactory_find (const gchar *name)
|
|||
}
|
||||
|
||||
/* this should be an ERROR */
|
||||
GST_DEBUG (GST_CAT_ELEMENTFACTORY,"no such elementfactory \"%s\"\n", name);
|
||||
GST_DEBUG (GST_CAT_ELEMENTFACTORY,"no such elementfactory \"%s\"", name);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -223,7 +223,7 @@ gst_elementfactory_create (GstElementFactory *factory,
|
|||
|
||||
g_return_val_if_fail(factory != NULL, NULL);
|
||||
|
||||
GST_DEBUG (GST_CAT_ELEMENTFACTORY,"creating element from factory \"%s\" with name \"%s\" and type %d\n",
|
||||
GST_DEBUG (GST_CAT_ELEMENTFACTORY,"creating element from factory \"%s\" with name \"%s\" and type %d",
|
||||
GST_OBJECT_NAME (factory), name, (gint) factory->type);
|
||||
|
||||
if (!gst_plugin_feature_ensure_loaded (GST_PLUGIN_FEATURE (factory)))
|
||||
|
@ -242,7 +242,7 @@ gst_elementfactory_create (GstElementFactory *factory,
|
|||
/* attempt to set the elemenfactory class pointer if necessary */
|
||||
oclass = GST_ELEMENT_CLASS(G_OBJECT_GET_CLASS(element));
|
||||
if (oclass->elementfactory == NULL) {
|
||||
GST_DEBUG (GST_CAT_ELEMENTFACTORY,"class %s\n", GST_OBJECT_NAME (factory));
|
||||
GST_DEBUG (GST_CAT_ELEMENTFACTORY,"class %s", GST_OBJECT_NAME (factory));
|
||||
oclass->elementfactory = factory;
|
||||
|
||||
/* copy pad template pointers to the element class, allow for custom padtemplates */
|
||||
|
@ -274,7 +274,7 @@ gst_elementfactory_make (const gchar *factoryname, const gchar *name)
|
|||
|
||||
g_return_val_if_fail (factoryname != NULL, NULL);
|
||||
|
||||
GST_DEBUG (GST_CAT_ELEMENTFACTORY, "gstelementfactory: make \"%s\" \"%s\"\n", factoryname, name);
|
||||
GST_DEBUG (GST_CAT_ELEMENTFACTORY, "gstelementfactory: make \"%s\" \"%s\"", factoryname, name);
|
||||
|
||||
/* gst_plugin_load_elementfactory(factoryname); */
|
||||
factory = gst_elementfactory_find(factoryname);
|
||||
|
|
|
@ -507,7 +507,7 @@ void __cyg_profile_func_enter(void *this_fn,void *call_site)
|
|||
gchar *name = _gst_debug_nameof_funcptr (this_fn);
|
||||
gchar *site = _gst_debug_nameof_funcptr (call_site);
|
||||
|
||||
GST_DEBUG(GST_CAT_CALL_TRACE, "entering function %s from %s\n", name, site);
|
||||
GST_DEBUG(GST_CAT_CALL_TRACE, "entering function %s from %s", name, site);
|
||||
stack_trace = g_slist_prepend (stack_trace, g_strdup_printf ("%8p in %s from %p (%s)", this_fn, name, call_site, site));
|
||||
|
||||
g_free (name);
|
||||
|
@ -519,7 +519,7 @@ void __cyg_profile_func_exit(void *this_fn,void *call_site)
|
|||
{
|
||||
gchar *name = _gst_debug_nameof_funcptr (this_fn);
|
||||
|
||||
GST_DEBUG(GST_CAT_CALL_TRACE, "leaving function %s\n", name);
|
||||
GST_DEBUG(GST_CAT_CALL_TRACE, "leaving function %s", name);
|
||||
g_free (stack_trace->data);
|
||||
stack_trace = g_slist_delete_link (stack_trace, stack_trace);
|
||||
|
||||
|
|
|
@ -165,11 +165,11 @@ G_GNUC_UNUSED static gchar *_debug_string = NULL;
|
|||
"''", GST_OBJECT_NAME (pad)
|
||||
|
||||
#ifdef GST_DEBUG_COLOR
|
||||
#define GST_DEBUG_ENTER(format, args...) GST_DEBUG( 31 , format ": \033[00;37mentering\033[00m\n" , ##args )
|
||||
#define GST_DEBUG_LEAVE(format, args...) GST_DEBUG( 31 , format ": \033[00;37mleaving\033[00m\n" , ##args )
|
||||
#define GST_DEBUG_ENTER(format, args...) GST_DEBUG( 31 , format ": \033[00;37mentering\033[00m" , ##args )
|
||||
#define GST_DEBUG_LEAVE(format, args...) GST_DEBUG( 31 , format ": \033[00;37mleaving\033[00m" , ##args )
|
||||
#else
|
||||
#define GST_DEBUG_ENTER(format, args...) GST_DEBUG( 31 , format ": entering\n" , ##args )
|
||||
#define GST_DEBUG_LEAVE(format, args...) GST_DEBUG( 31 , format ": leaving\n" , ##args )
|
||||
#define GST_DEBUG_ENTER(format, args...) GST_DEBUG( 31 , format ": entering" , ##args )
|
||||
#define GST_DEBUG_LEAVE(format, args...) GST_DEBUG( 31 , format ": leaving" , ##args )
|
||||
#endif
|
||||
|
||||
|
||||
|
|
|
@ -168,7 +168,7 @@ gst_object_ref (GstObject *object)
|
|||
{
|
||||
g_return_val_if_fail (GST_IS_OBJECT (object), NULL);
|
||||
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "ref '%s' %d->%d\n",GST_OBJECT_NAME(object),
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "ref '%s' %d->%d",GST_OBJECT_NAME(object),
|
||||
G_OBJECT(object)->ref_count,G_OBJECT(object)->ref_count+1);
|
||||
|
||||
g_object_ref (G_OBJECT (object));
|
||||
|
@ -188,7 +188,7 @@ gst_object_unref (GstObject *object)
|
|||
{
|
||||
g_return_if_fail (GST_IS_OBJECT (object));
|
||||
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "unref '%s' %d->%d\n",GST_OBJECT_NAME(object),
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "unref '%s' %d->%d",GST_OBJECT_NAME(object),
|
||||
G_OBJECT(object)->ref_count,G_OBJECT(object)->ref_count-1);
|
||||
|
||||
g_object_unref (G_OBJECT (object));
|
||||
|
@ -209,7 +209,7 @@ gst_object_sink (GstObject *object)
|
|||
g_return_if_fail (object != NULL);
|
||||
g_return_if_fail (GST_IS_OBJECT (object));
|
||||
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "sink '%s'\n",GST_OBJECT_NAME(object));
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "sink '%s'",GST_OBJECT_NAME(object));
|
||||
if (GST_OBJECT_FLOATING (object))
|
||||
{
|
||||
GST_FLAG_UNSET (object, GST_FLOATING);
|
||||
|
@ -229,7 +229,7 @@ gst_object_destroy (GstObject *object)
|
|||
g_return_if_fail (object != NULL);
|
||||
g_return_if_fail (GST_IS_OBJECT (object));
|
||||
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "destroy '%s'\n",GST_OBJECT_NAME(object));
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "destroy '%s'",GST_OBJECT_NAME(object));
|
||||
if (!GST_OBJECT_DESTROYED (object))
|
||||
{
|
||||
/* need to hold a reference count around all class method
|
||||
|
@ -242,7 +242,7 @@ gst_object_destroy (GstObject *object)
|
|||
static void
|
||||
gst_object_dispose (GObject *object)
|
||||
{
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "dispose '%s'\n",GST_OBJECT_NAME(object));
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "dispose '%s'",GST_OBJECT_NAME(object));
|
||||
GST_FLAG_SET (GST_OBJECT (object), GST_DESTROYED);
|
||||
GST_OBJECT_PARENT (object) = NULL;
|
||||
|
||||
|
@ -255,7 +255,7 @@ gst_object_finalize (GObject *object)
|
|||
{
|
||||
GstObject *gstobject = GST_OBJECT (object);
|
||||
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "finalize '%s'\n",GST_OBJECT_NAME(object));
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "finalize '%s'",GST_OBJECT_NAME(object));
|
||||
|
||||
g_signal_handlers_destroy (object);
|
||||
|
||||
|
@ -397,7 +397,7 @@ gst_object_unparent (GstObject *object)
|
|||
if (object->parent == NULL)
|
||||
return;
|
||||
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "unparent '%s'\n",GST_OBJECT_NAME(object));
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "unparent '%s'",GST_OBJECT_NAME(object));
|
||||
|
||||
object->parent = NULL;
|
||||
gst_object_unref (object);
|
||||
|
@ -631,7 +631,7 @@ gst_object_dispatch_properties_changed (GObject *object,
|
|||
while (gst_object)
|
||||
{
|
||||
/* need own category? */
|
||||
GST_DEBUG (GST_CAT_EVENT, "deep notification from %s to %s\n", GST_OBJECT_NAME (object), GST_OBJECT_NAME (gst_object));
|
||||
GST_DEBUG (GST_CAT_EVENT, "deep notification from %s to %s", GST_OBJECT_NAME (object), GST_OBJECT_NAME (gst_object));
|
||||
for (i = 0; i < n_pspecs; i++)
|
||||
g_signal_emit (gst_object, gst_object_signals[DEEP_NOTIFY], g_quark_from_string (pspecs[i]->name), (GstObject *) object, pspecs[i]);
|
||||
|
||||
|
|
74
gst/gstpad.c
74
gst/gstpad.c
|
@ -228,10 +228,10 @@ gst_real_pad_set_property (GObject *object, guint prop_id, const GValue *value,
|
|||
switch (prop_id) {
|
||||
case REAL_ARG_ACTIVE:
|
||||
if (g_value_get_boolean (value)) {
|
||||
GST_DEBUG (GST_CAT_PADS, "activating pad %s:%s\n", GST_DEBUG_PAD_NAME (object));
|
||||
GST_DEBUG (GST_CAT_PADS, "activating pad %s:%s", GST_DEBUG_PAD_NAME (object));
|
||||
GST_FLAG_UNSET (object, GST_PAD_DISABLED);
|
||||
} else {
|
||||
GST_DEBUG (GST_CAT_PADS, "de-activating pad %s:%s\n", GST_DEBUG_PAD_NAME (object));
|
||||
GST_DEBUG (GST_CAT_PADS, "de-activating pad %s:%s", GST_DEBUG_PAD_NAME (object));
|
||||
GST_FLAG_SET (object, GST_PAD_DISABLED);
|
||||
}
|
||||
g_signal_emit (G_OBJECT (object), gst_real_pad_signals[REAL_SET_ACTIVE], 0,
|
||||
|
@ -375,7 +375,7 @@ gst_pad_set_chain_function (GstPad *pad,
|
|||
g_return_if_fail (GST_IS_REAL_PAD (pad));
|
||||
|
||||
GST_RPAD_CHAINFUNC(pad) = chain;
|
||||
GST_DEBUG (GST_CAT_PADS, "chainfunc for %s:%s set to %s\n",
|
||||
GST_DEBUG (GST_CAT_PADS, "chainfunc for %s:%s set to %s",
|
||||
GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (chain));
|
||||
}
|
||||
|
||||
|
@ -394,7 +394,7 @@ gst_pad_set_get_function (GstPad *pad,
|
|||
g_return_if_fail (GST_IS_REAL_PAD (pad));
|
||||
|
||||
GST_RPAD_GETFUNC(pad) = get;
|
||||
GST_DEBUG (GST_CAT_PADS, "getfunc for %s:%s set to %s\n",
|
||||
GST_DEBUG (GST_CAT_PADS, "getfunc for %s:%s set to %s",
|
||||
GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (get));
|
||||
}
|
||||
|
||||
|
@ -413,7 +413,7 @@ gst_pad_set_event_function (GstPad *pad,
|
|||
g_return_if_fail (GST_IS_REAL_PAD (pad));
|
||||
|
||||
GST_RPAD_EVENTFUNC(pad) = event;
|
||||
GST_DEBUG (GST_CAT_PADS, "eventfunc for %s:%s set to %s\n",
|
||||
GST_DEBUG (GST_CAT_PADS, "eventfunc for %s:%s set to %s",
|
||||
GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (event));
|
||||
}
|
||||
|
||||
|
@ -432,7 +432,7 @@ gst_pad_set_getregion_function (GstPad *pad,
|
|||
g_return_if_fail (GST_IS_REAL_PAD (pad));
|
||||
|
||||
GST_RPAD_GETREGIONFUNC(pad) = getregion;
|
||||
GST_DEBUG (GST_CAT_PADS, "getregionfunc for %s:%s set to %s\n",
|
||||
GST_DEBUG (GST_CAT_PADS, "getregionfunc for %s:%s set to %s",
|
||||
GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (getregion));
|
||||
}
|
||||
|
||||
|
@ -452,7 +452,7 @@ gst_pad_set_connect_function (GstPad *pad,
|
|||
g_return_if_fail (GST_IS_REAL_PAD (pad));
|
||||
|
||||
GST_RPAD_CONNECTFUNC (pad) = connect;
|
||||
GST_DEBUG (GST_CAT_PADS, "connectfunc for %s:%s set to %s\n",
|
||||
GST_DEBUG (GST_CAT_PADS, "connectfunc for %s:%s set to %s",
|
||||
GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (connect));
|
||||
}
|
||||
|
||||
|
@ -471,7 +471,7 @@ gst_pad_set_getcaps_function (GstPad *pad,
|
|||
g_return_if_fail (GST_IS_REAL_PAD (pad));
|
||||
|
||||
GST_RPAD_GETCAPSFUNC (pad) = getcaps;
|
||||
GST_DEBUG (GST_CAT_PADS, "getcapsfunc for %s:%s set to %s\n",
|
||||
GST_DEBUG (GST_CAT_PADS, "getcapsfunc for %s:%s set to %s",
|
||||
GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (getcaps));
|
||||
}
|
||||
/**
|
||||
|
@ -489,7 +489,7 @@ gst_pad_set_bufferpool_function (GstPad *pad,
|
|||
g_return_if_fail (GST_IS_REAL_PAD (pad));
|
||||
|
||||
GST_RPAD_BUFFERPOOLFUNC (pad) = bufpool;
|
||||
GST_DEBUG (GST_CAT_PADS, "bufferpoolfunc for %s:%s set to %s\n",
|
||||
GST_DEBUG (GST_CAT_PADS, "bufferpoolfunc for %s:%s set to %s",
|
||||
GST_DEBUG_PAD_NAME (pad), GST_DEBUG_FUNCPTR_NAME (bufpool));
|
||||
}
|
||||
|
||||
|
@ -497,11 +497,11 @@ static void
|
|||
gst_pad_push_func(GstPad *pad, GstBuffer *buf)
|
||||
{
|
||||
if (GST_RPAD_CHAINFUNC (GST_RPAD_PEER (pad)) != NULL) {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling chain function %s\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling chain function %s",
|
||||
GST_DEBUG_FUNCPTR_NAME (GST_RPAD_CHAINFUNC (GST_RPAD_PEER (pad))));
|
||||
(GST_RPAD_CHAINFUNC (GST_RPAD_PEER (pad))) (pad, buf);
|
||||
} else {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "default pad_push handler in place, no chain function\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "default pad_push handler in place, no chain function");
|
||||
g_warning ("(internal error) default pad_push in place for pad %s:%s but it has no chain function",
|
||||
GST_DEBUG_PAD_NAME (pad));
|
||||
}
|
||||
|
@ -720,7 +720,7 @@ gst_pad_connect_filtered (GstPad *srcpad, GstPad *sinkpad, GstCaps *filtercaps)
|
|||
|
||||
/* try to negotiate the pads, we don't need to clear the caps here */
|
||||
if (!gst_pad_try_reconnect_filtered_func (realsrc, realsink, filtercaps, FALSE)) {
|
||||
GST_DEBUG (GST_CAT_CAPS, "pads cannot connect\n");
|
||||
GST_DEBUG (GST_CAT_CAPS, "pads cannot connect");
|
||||
|
||||
GST_RPAD_PEER (realsrc) = NULL;
|
||||
GST_RPAD_PEER (realsink) = NULL;
|
||||
|
@ -968,7 +968,7 @@ gst_pad_try_set_caps_func (GstRealPad *pad, GstCaps *caps, gboolean notify)
|
|||
* negotiation */
|
||||
if (parent && GST_STATE (parent) < GST_STATE_READY)
|
||||
{
|
||||
GST_DEBUG (GST_CAT_CAPS, "parent %s of pad %s:%s is not ready\n",
|
||||
GST_DEBUG (GST_CAT_CAPS, "parent %s of pad %s:%s is not ready",
|
||||
GST_ELEMENT_NAME (parent), GST_DEBUG_PAD_NAME (pad));
|
||||
return GST_PAD_CONNECT_DELAYED;
|
||||
}
|
||||
|
@ -1183,7 +1183,7 @@ gst_pad_try_reconnect_filtered_func (GstRealPad *srcpad, GstRealPad *sinkpad, Gs
|
|||
GST_RPAD_APPFILTER (realsrc) = filtercaps;
|
||||
}
|
||||
}
|
||||
GST_DEBUG (GST_CAT_CAPS, "setting filter for connection to:\n");
|
||||
GST_DEBUG (GST_CAT_CAPS, "setting filter for connection to:");
|
||||
gst_caps_debug (intersection, "filter for connection");
|
||||
|
||||
/* both the app filter and the filter, while stored on both peer pads, are the
|
||||
|
@ -1363,22 +1363,22 @@ gst_pad_get_caps (GstPad *pad)
|
|||
|
||||
realpad = GST_PAD_REALIZE (pad);
|
||||
|
||||
GST_DEBUG (GST_CAT_CAPS, "get pad caps of %s:%s (%p)\n",
|
||||
GST_DEBUG (GST_CAT_CAPS, "get pad caps of %s:%s (%p)",
|
||||
GST_DEBUG_PAD_NAME (realpad), realpad);
|
||||
|
||||
if (GST_PAD_CAPS (realpad)) {
|
||||
GST_DEBUG (GST_CAT_CAPS, "using pad real caps\n");
|
||||
GST_DEBUG (GST_CAT_CAPS, "using pad real caps");
|
||||
return GST_PAD_CAPS (realpad);
|
||||
}
|
||||
else if GST_RPAD_GETCAPSFUNC (realpad) {
|
||||
GST_DEBUG (GST_CAT_CAPS, "using pad get function\n");
|
||||
GST_DEBUG (GST_CAT_CAPS, "using pad get function");
|
||||
return GST_RPAD_GETCAPSFUNC (realpad) (GST_PAD_CAST (realpad), NULL);
|
||||
}
|
||||
else if (GST_PAD_PADTEMPLATE (realpad)) {
|
||||
GST_DEBUG (GST_CAT_CAPS, "using pad template\n");
|
||||
GST_DEBUG (GST_CAT_CAPS, "using pad template");
|
||||
return GST_PADTEMPLATE_CAPS (GST_PAD_PADTEMPLATE (realpad));
|
||||
}
|
||||
GST_DEBUG (GST_CAT_CAPS, "pad has no caps\n");
|
||||
GST_DEBUG (GST_CAT_CAPS, "pad has no caps");
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
@ -1454,7 +1454,7 @@ gst_pad_check_compatibility (GstPad *srcpad, GstPad *sinkpad)
|
|||
}
|
||||
}
|
||||
else {
|
||||
GST_DEBUG (GST_CAT_PADS, "could not check capabilities of pads (%s:%s) and (%s:%s) %p %p\n",
|
||||
GST_DEBUG (GST_CAT_PADS, "could not check capabilities of pads (%s:%s) and (%s:%s) %p %p",
|
||||
GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad),
|
||||
GST_PAD_CAPS (srcpad), GST_PAD_CAPS (sinkpad));
|
||||
return TRUE;
|
||||
|
@ -1493,7 +1493,7 @@ gst_pad_get_allowed_caps (GstPad *pad)
|
|||
g_return_val_if_fail (pad != NULL, NULL);
|
||||
g_return_val_if_fail (GST_IS_PAD (pad), NULL);
|
||||
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "get allowed caps of %s:%s\n", GST_DEBUG_PAD_NAME (pad));
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "get allowed caps of %s:%s", GST_DEBUG_PAD_NAME (pad));
|
||||
|
||||
return gst_caps_copy (GST_RPAD_FILTER (pad));
|
||||
}
|
||||
|
@ -1515,7 +1515,7 @@ gst_pad_recalc_allowed_caps (GstPad *pad)
|
|||
g_return_val_if_fail (pad != NULL, FALSE);
|
||||
g_return_val_if_fail (GST_IS_PAD (pad), FALSE);
|
||||
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "set allowed caps of %s:%s\n", GST_DEBUG_PAD_NAME (pad));
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "set allowed caps of %s:%s", GST_DEBUG_PAD_NAME (pad));
|
||||
|
||||
peer = GST_RPAD_PEER (pad);
|
||||
if (peer)
|
||||
|
@ -1549,11 +1549,11 @@ gst_pad_get_bufferpool (GstPad *pad)
|
|||
GST_DEBUG_ENTER ("(%s:%s)", GST_DEBUG_PAD_NAME (pad));
|
||||
|
||||
if (peer->bufferpoolfunc) {
|
||||
GST_DEBUG (GST_CAT_PADS, "calling bufferpoolfunc &%s (@%p) of peer pad %s:%s\n",
|
||||
GST_DEBUG (GST_CAT_PADS, "calling bufferpoolfunc &%s (@%p) of peer pad %s:%s",
|
||||
GST_DEBUG_FUNCPTR_NAME (peer->bufferpoolfunc), &peer->bufferpoolfunc, GST_DEBUG_PAD_NAME (((GstPad*) peer)));
|
||||
return (peer->bufferpoolfunc) (((GstPad*) peer));
|
||||
} else {
|
||||
GST_DEBUG (GST_CAT_PADS, "no bufferpoolfunc for peer pad %s:%s at %p\n",
|
||||
GST_DEBUG (GST_CAT_PADS, "no bufferpoolfunc for peer pad %s:%s at %p",
|
||||
GST_DEBUG_PAD_NAME (((GstPad*) peer)), &peer->bufferpoolfunc);
|
||||
return NULL;
|
||||
}
|
||||
|
@ -1568,10 +1568,10 @@ gst_real_pad_dispose (GObject *object)
|
|||
* It has to have a parent to be connected and a parent would hold a reference */
|
||||
g_assert (GST_PAD_PEER (pad) == NULL);
|
||||
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "dispose %s:%s\n", GST_DEBUG_PAD_NAME(pad));
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "dispose %s:%s", GST_DEBUG_PAD_NAME(pad));
|
||||
|
||||
if (GST_PAD_PADTEMPLATE (pad)){
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "unreffing padtemplate'%s'\n", GST_OBJECT_NAME (GST_PAD_PADTEMPLATE (pad)));
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "unreffing padtemplate'%s'", GST_OBJECT_NAME (GST_PAD_PADTEMPLATE (pad)));
|
||||
gst_object_unref (GST_OBJECT (GST_PAD_PADTEMPLATE (pad)));
|
||||
GST_PAD_PADTEMPLATE (pad) = NULL;
|
||||
}
|
||||
|
@ -1586,7 +1586,7 @@ gst_real_pad_dispose (GObject *object)
|
|||
GstPad *ghostpad = GST_PAD (ghostpads->data);
|
||||
|
||||
if (GST_IS_ELEMENT (GST_OBJECT_PARENT (ghostpad))){
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "removing ghost pad from element '%s'\n",
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "removing ghost pad from element '%s'",
|
||||
GST_OBJECT_NAME (GST_OBJECT_PARENT (ghostpad)));
|
||||
|
||||
gst_element_remove_ghost_pad (GST_ELEMENT (GST_OBJECT_PARENT (ghostpad)), GST_PAD (ghostpad));
|
||||
|
@ -1598,7 +1598,7 @@ gst_real_pad_dispose (GObject *object)
|
|||
}
|
||||
|
||||
if (GST_IS_ELEMENT (GST_OBJECT_PARENT (pad))){
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "removing pad from element '%s'\n",
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "removing pad from element '%s'",
|
||||
GST_OBJECT_NAME (GST_OBJECT (GST_ELEMENT (GST_OBJECT_PARENT (pad)))));
|
||||
|
||||
gst_element_remove_pad (GST_ELEMENT (GST_OBJECT_PARENT (pad)), pad);
|
||||
|
@ -1751,7 +1751,7 @@ gst_pad_push (GstPad *pad, GstBuffer *buf)
|
|||
else {
|
||||
if (peer->chainhandler) {
|
||||
if (buf) {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling chainhandler &%s of peer pad %s:%s\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling chainhandler &%s of peer pad %s:%s",
|
||||
GST_DEBUG_FUNCPTR_NAME (peer->chainhandler), GST_DEBUG_PAD_NAME (GST_PAD (peer)));
|
||||
(peer->chainhandler) (GST_PAD_CAST (peer), buf);
|
||||
return;
|
||||
|
@ -1803,7 +1803,7 @@ gst_pad_pull (GstPad *pad)
|
|||
if (peer->gethandler) {
|
||||
GstBuffer *buf;
|
||||
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling gethandler %s of peer pad %s:%s\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling gethandler %s of peer pad %s:%s",
|
||||
GST_DEBUG_FUNCPTR_NAME (peer->gethandler), GST_DEBUG_PAD_NAME (peer));
|
||||
|
||||
buf = (peer->gethandler) (GST_PAD_CAST (peer));
|
||||
|
@ -1857,11 +1857,11 @@ gst_pad_pullregion (GstPad *pad, GstRegionType type, guint64 offset, guint64 len
|
|||
GST_DEBUG_ENTER("(%s:%s,%d,%lld,%lld)",GST_DEBUG_PAD_NAME(pad),type,offset,len);
|
||||
|
||||
if (peer->pullregionfunc) {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling pullregionfunc &%s of peer pad %s:%s\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling pullregionfunc &%s of peer pad %s:%s",
|
||||
GST_DEBUG_FUNCPTR_NAME (peer->pullregionfunc), GST_DEBUG_PAD_NAME(GST_PAD_CAST (peer)));
|
||||
result = (peer->pullregionfunc) (GST_PAD_CAST (peer), type, offset, len);
|
||||
} else {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW,"no pullregionfunc\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW,"no pullregionfunc");
|
||||
result = NULL;
|
||||
break;
|
||||
}
|
||||
|
@ -2122,7 +2122,7 @@ gst_padtemplate_save_thyself (GstPadTemplate *templ, xmlNodePtr parent)
|
|||
xmlNodePtr subtree;
|
||||
guchar *presence;
|
||||
|
||||
GST_DEBUG (GST_CAT_XML,"saving padtemplate %s\n", templ->name_template);
|
||||
GST_DEBUG (GST_CAT_XML,"saving padtemplate %s", templ->name_template);
|
||||
|
||||
xmlNewChild(parent,NULL,"nametemplate", templ->name_template);
|
||||
xmlNewChild(parent,NULL,"direction", (templ->direction == GST_PAD_SINK? "sink":"src"));
|
||||
|
@ -2322,7 +2322,7 @@ gst_ghost_pad_new (gchar *name,
|
|||
|
||||
/* FIXME need to ref the real pad here... ? */
|
||||
|
||||
GST_DEBUG (GST_CAT_PADS, "created ghost pad \"%s\"\n", name);
|
||||
GST_DEBUG (GST_CAT_PADS, "created ghost pad \"%s\"", name);
|
||||
|
||||
return GST_PAD (ghostpad);
|
||||
}
|
||||
|
@ -2397,17 +2397,17 @@ gst_pad_send_event (GstPad *pad, GstEvent *event)
|
|||
if (GST_EVENT_SRC (event) == NULL)
|
||||
GST_EVENT_SRC (event) = gst_object_ref (GST_OBJECT (pad));
|
||||
|
||||
GST_DEBUG (GST_CAT_EVENT, "have event %d on pad %s:%s\n",
|
||||
GST_DEBUG (GST_CAT_EVENT, "have event %d on pad %s:%s",
|
||||
GST_EVENT_TYPE (event), GST_DEBUG_PAD_NAME (pad));
|
||||
|
||||
if (GST_RPAD_EVENTFUNC (pad))
|
||||
handled = GST_RPAD_EVENTFUNC (pad) (pad, event);
|
||||
else {
|
||||
GST_DEBUG(GST_CAT_EVENT, "there's no event function for pad %s:%s\n", GST_DEBUG_PAD_NAME (pad));
|
||||
GST_DEBUG(GST_CAT_EVENT, "there's no event function for pad %s:%s", GST_DEBUG_PAD_NAME (pad));
|
||||
}
|
||||
|
||||
if (!handled) {
|
||||
GST_DEBUG(GST_CAT_EVENT, "proceeding with default event behavior here\n");
|
||||
GST_DEBUG(GST_CAT_EVENT, "proceeding with default event behavior here");
|
||||
gst_pad_event_default (pad, event);
|
||||
handled = TRUE;
|
||||
}
|
||||
|
|
|
@ -151,10 +151,10 @@ gst_parse_launchv_recurse (const gchar **argv, GstBin * parent, gst_parse_priv *
|
|||
|
||||
*ptr = '\0'; /* it was a '.' before */
|
||||
|
||||
GST_DEBUG (0, "have pad for element %s\n", element_name);
|
||||
GST_DEBUG (0, "have pad for element %s", element_name);
|
||||
new = gst_bin_get_by_name_recurse_up (parent, element_name);
|
||||
if (!new) {
|
||||
GST_DEBUG (0, "element %s does not exist! trying to continue\n", element_name);
|
||||
GST_DEBUG (0, "element %s does not exist! trying to continue", element_name);
|
||||
} else {
|
||||
previous = new;
|
||||
srcpadname = ptr + 1;
|
||||
|
@ -162,7 +162,7 @@ gst_parse_launchv_recurse (const gchar **argv, GstBin * parent, gst_parse_priv *
|
|||
}
|
||||
}
|
||||
|
||||
GST_DEBUG (0, "have srcpad %s, sinkpad %s\n", srcpadname, sinkpadname);
|
||||
GST_DEBUG (0, "have srcpad %s, sinkpad %s", srcpadname, sinkpadname);
|
||||
|
||||
g_slist_free (srcpads);
|
||||
srcpads = NULL;
|
||||
|
@ -193,9 +193,9 @@ gst_parse_launchv_recurse (const gchar **argv, GstBin * parent, gst_parse_priv *
|
|||
numsrcpads++;
|
||||
}
|
||||
if (!temppad) {
|
||||
GST_DEBUG (0, "NO SUCH pad %s in element %s\n", tempname, GST_ELEMENT_NAME (previous));
|
||||
GST_DEBUG (0, "NO SUCH pad %s in element %s", tempname, GST_ELEMENT_NAME (previous));
|
||||
} else {
|
||||
GST_DEBUG (0, "have src pad %s:%s\n", GST_DEBUG_PAD_NAME (temppad));
|
||||
GST_DEBUG (0, "have src pad %s:%s", GST_DEBUG_PAD_NAME (temppad));
|
||||
}
|
||||
|
||||
/* if there is no more commas in srcpadname then we're done */
|
||||
|
@ -205,14 +205,14 @@ gst_parse_launchv_recurse (const gchar **argv, GstBin * parent, gst_parse_priv *
|
|||
}
|
||||
} else {
|
||||
/* check through the list to find the first src pad */
|
||||
GST_DEBUG (0, "CHECKING element %s for pad named %s\n", GST_ELEMENT_NAME (previous),
|
||||
GST_DEBUG (0, "CHECKING element %s for pad named %s", GST_ELEMENT_NAME (previous),
|
||||
srcpadname);
|
||||
pads = gst_element_get_pad_list (previous);
|
||||
while (pads) {
|
||||
temppad = GST_PARSE_LISTPAD (pads);
|
||||
GST_DEBUG (0, "have pad %s:%s\n", GST_DEBUG_PAD_NAME (temppad));
|
||||
GST_DEBUG (0, "have pad %s:%s", GST_DEBUG_PAD_NAME (temppad));
|
||||
if (GST_IS_GHOST_PAD (temppad))
|
||||
GST_DEBUG (0, "it's a ghost pad\n");
|
||||
GST_DEBUG (0, "it's a ghost pad");
|
||||
if (gst_pad_get_direction (temppad) == GST_PAD_SRC) {
|
||||
srcpads = g_slist_append (srcpads, temppad);
|
||||
numsrcpads++;
|
||||
|
@ -221,9 +221,9 @@ gst_parse_launchv_recurse (const gchar **argv, GstBin * parent, gst_parse_priv *
|
|||
pads = g_list_next (pads);
|
||||
}
|
||||
if (!srcpads)
|
||||
GST_DEBUG (0, "error, can't find a src pad!!!\n");
|
||||
GST_DEBUG (0, "error, can't find a src pad!!!");
|
||||
else
|
||||
GST_DEBUG (0, "have src pad %s:%s\n", GST_DEBUG_PAD_NAME (GST_PARSE_LISTPAD (srcpads)));
|
||||
GST_DEBUG (0, "have src pad %s:%s", GST_DEBUG_PAD_NAME (GST_PARSE_LISTPAD (srcpads)));
|
||||
}
|
||||
} else if (strchr (arg, '=')) {
|
||||
gchar *propname;
|
||||
|
@ -239,7 +239,7 @@ gst_parse_launchv_recurse (const gchar **argv, GstBin * parent, gst_parse_priv *
|
|||
propval = pos + 1;
|
||||
|
||||
/* use g_object_set in the future when gst_util_{set|get} go away */
|
||||
GST_DEBUG (0, "attempting to set property '%s' to '%s' on element '%s'\n",
|
||||
GST_DEBUG (0, "attempting to set property '%s' to '%s' on element '%s'",
|
||||
propname, propval, GST_ELEMENT_NAME (previous));
|
||||
gst_util_set_object_arg (G_OBJECT (previous), propname, propval);
|
||||
g_free (propname);
|
||||
|
@ -287,7 +287,7 @@ gst_parse_launchv_recurse (const gchar **argv, GstBin * parent, gst_parse_priv *
|
|||
fprintf (stderr, "Couldn't create a bin!\n");
|
||||
return GST_PARSE_ERROR_CREATING_ELEMENT;
|
||||
}
|
||||
GST_DEBUG (0, "CREATED bin %s\n", GST_ELEMENT_NAME (element));
|
||||
GST_DEBUG (0, "CREATED bin %s", GST_ELEMENT_NAME (element));
|
||||
} else if (arg[0] == '{') {
|
||||
/* create a thread and add it to the current parent */
|
||||
priv->threadcount++;
|
||||
|
@ -296,7 +296,7 @@ gst_parse_launchv_recurse (const gchar **argv, GstBin * parent, gst_parse_priv *
|
|||
fprintf (stderr, "Couldn't create a thread!\n");
|
||||
return GST_PARSE_ERROR_CREATING_ELEMENT;
|
||||
}
|
||||
GST_DEBUG (0, "CREATED thread %s\n", GST_ELEMENT_NAME (element));
|
||||
GST_DEBUG (0, "CREATED thread %s", GST_ELEMENT_NAME (element));
|
||||
} else {
|
||||
fprintf (stderr, "Illegal argument: %s\n", arg);
|
||||
return GST_PARSE_ERROR_CREATING_ELEMENT;
|
||||
|
@ -328,7 +328,7 @@ gst_parse_launchv_recurse (const gchar **argv, GstBin * parent, gst_parse_priv *
|
|||
return GST_PARSE_ERROR_NOSUCH_ELEMENT;
|
||||
}
|
||||
|
||||
GST_DEBUG (0, "CREATED element %s\n", GST_ELEMENT_NAME (element));
|
||||
GST_DEBUG (0, "CREATED element %s", GST_ELEMENT_NAME (element));
|
||||
gst_bin_add (GST_BIN (parent), element);
|
||||
}
|
||||
|
||||
|
@ -362,9 +362,9 @@ gst_parse_launchv_recurse (const gchar **argv, GstBin * parent, gst_parse_priv *
|
|||
numsinkpads++;
|
||||
}
|
||||
if (!temppad) {
|
||||
GST_DEBUG (0, "NO SUCH pad %s in element %s\n", tempname, GST_ELEMENT_NAME (element));
|
||||
GST_DEBUG (0, "NO SUCH pad %s in element %s", tempname, GST_ELEMENT_NAME (element));
|
||||
} else {
|
||||
GST_DEBUG (0, "have sink pad %s:%s\n", GST_DEBUG_PAD_NAME (temppad));
|
||||
GST_DEBUG (0, "have sink pad %s:%s", GST_DEBUG_PAD_NAME (temppad));
|
||||
}
|
||||
|
||||
/* if there is no more commas in sinkpadname then we're done */
|
||||
|
@ -387,9 +387,9 @@ gst_parse_launchv_recurse (const gchar **argv, GstBin * parent, gst_parse_priv *
|
|||
}
|
||||
|
||||
if (!sinkpads)
|
||||
GST_DEBUG (0, "can't find a sink pad for element\n");
|
||||
GST_DEBUG (0, "can't find a sink pad for element");
|
||||
else
|
||||
GST_DEBUG (0, "have sink pad %s:%s\n", GST_DEBUG_PAD_NAME (GST_PARSE_LISTPAD (sinkpads)));
|
||||
GST_DEBUG (0, "have sink pad %s:%s", GST_DEBUG_PAD_NAME (GST_PARSE_LISTPAD (sinkpads)));
|
||||
|
||||
if (!srcpads && sinkpads && previous && srcpadname) {
|
||||
dyn_connect *connect = g_malloc (sizeof (dyn_connect));
|
||||
|
@ -398,14 +398,14 @@ gst_parse_launchv_recurse (const gchar **argv, GstBin * parent, gst_parse_priv *
|
|||
connect->target = GST_PARSE_LISTPAD (sinkpads);
|
||||
connect->pipeline = GST_ELEMENT (parent);
|
||||
|
||||
GST_DEBUG (0, "SETTING UP dynamic connection %s:%s and %s:%s\n",
|
||||
GST_DEBUG (0, "SETTING UP dynamic connection %s:%s and %s:%s",
|
||||
gst_element_get_name (previous),
|
||||
srcpadname, GST_DEBUG_PAD_NAME (GST_PARSE_LISTPAD (sinkpads)));
|
||||
|
||||
g_signal_connect (G_OBJECT (previous), "new_pad", G_CALLBACK (dynamic_connect), connect);
|
||||
} else {
|
||||
for (j = 0; (j < numsrcpads) && (j < numsinkpads); j++) {
|
||||
GST_DEBUG (0, "CONNECTING %s:%s and %s:%s\n",
|
||||
GST_DEBUG (0, "CONNECTING %s:%s and %s:%s",
|
||||
GST_DEBUG_PAD_NAME (GST_PARSE_LISTPAD (g_slist_nth (srcpads, j))),
|
||||
GST_DEBUG_PAD_NAME (GST_PARSE_LISTPAD (g_slist_nth (sinkpads, j))));
|
||||
if (!gst_pad_connect (GST_PARSE_LISTPAD (g_slist_nth (srcpads, j)),
|
||||
|
@ -437,7 +437,7 @@ gst_parse_launchv_recurse (const gchar **argv, GstBin * parent, gst_parse_priv *
|
|||
else if (gst_pad_get_direction (temppad) == GST_PAD_SINK) {
|
||||
gst_element_add_ghost_pad (GST_ELEMENT (parent), temppad,
|
||||
g_strdup_printf ("%s-ghost", GST_PAD_NAME (temppad)));
|
||||
GST_DEBUG (0, "GHOSTED %s:%s to %s as %s-ghost\n",
|
||||
GST_DEBUG (0, "GHOSTED %s:%s to %s as %s-ghost",
|
||||
GST_DEBUG_PAD_NAME (temppad), GST_ELEMENT_NAME (GST_ELEMENT (parent)),
|
||||
GST_PAD_NAME (temppad));
|
||||
}
|
||||
|
@ -463,7 +463,7 @@ gst_parse_launchv_recurse (const gchar **argv, GstBin * parent, gst_parse_priv *
|
|||
else if (gst_pad_get_direction (temppad) == GST_PAD_SRC) {
|
||||
gst_element_add_ghost_pad (GST_ELEMENT (parent), temppad,
|
||||
g_strdup_printf ("%s-ghost", GST_PAD_NAME (temppad)));
|
||||
GST_DEBUG (0, "GHOSTED %s:%s to %s as %s-ghost\n",
|
||||
GST_DEBUG (0, "GHOSTED %s:%s to %s as %s-ghost",
|
||||
GST_DEBUG_PAD_NAME (temppad), GST_ELEMENT_NAME (parent), GST_PAD_NAME (temppad));
|
||||
}
|
||||
}
|
||||
|
@ -589,7 +589,7 @@ gst_parse_launch (const gchar * pipeline_description)
|
|||
/* now allocate the new argv array, with room for NULL termination */
|
||||
argvn = g_new0 (char *, newargc + 1);
|
||||
|
||||
GST_DEBUG (0, "got %d args\n", newargc);
|
||||
GST_DEBUG (0, "got %d args", newargc);
|
||||
|
||||
/* reverse the list and put the strings in the new array */
|
||||
i = newargc;
|
||||
|
@ -601,7 +601,7 @@ gst_parse_launch (const gchar * pipeline_description)
|
|||
|
||||
/* print them out */
|
||||
while (argvn[i++]) {
|
||||
GST_DEBUG (0, "arg %d is: %s\n", i-1, argvn[i-1]);
|
||||
GST_DEBUG (0, "arg %d is: %s", i-1, argvn[i-1]);
|
||||
}
|
||||
|
||||
/* do it! */
|
||||
|
|
|
@ -125,7 +125,7 @@ gst_plugin_feature_ensure_loaded (GstPluginFeature *feature)
|
|||
GstPlugin *plugin = (GstPlugin *) (feature->manager);
|
||||
|
||||
if (plugin && !gst_plugin_is_loaded (plugin)) {
|
||||
GST_DEBUG (GST_CAT_PLUGIN_LOADING, "loading plugin %s for feature\n", plugin->name);
|
||||
GST_DEBUG (GST_CAT_PLUGIN_LOADING, "loading plugin %s for feature", plugin->name);
|
||||
|
||||
return gst_plugin_load_plugin (plugin);
|
||||
}
|
||||
|
|
|
@ -58,30 +58,30 @@ gst_props_debug_entry (GstPropsEntry *entry)
|
|||
|
||||
switch (entry->propstype) {
|
||||
case GST_PROPS_INT_ID:
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "%s: int %d\n", name, entry->data.int_data);
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "%s: int %d", name, entry->data.int_data);
|
||||
break;
|
||||
case GST_PROPS_FLOAT_ID:
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "%s: float %f\n", name, entry->data.float_data);
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "%s: float %f", name, entry->data.float_data);
|
||||
break;
|
||||
case GST_PROPS_FOURCC_ID:
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "%s: fourcc %4.4s\n", name, (gchar*)&entry->data.fourcc_data);
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "%s: fourcc %4.4s", name, (gchar*)&entry->data.fourcc_data);
|
||||
break;
|
||||
case GST_PROPS_BOOL_ID:
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "%s: bool %d\n", name, entry->data.bool_data);
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "%s: bool %d", name, entry->data.bool_data);
|
||||
break;
|
||||
case GST_PROPS_STRING_ID:
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "%s: string %s\n", name, entry->data.string_data.string);
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "%s: string %s", name, entry->data.string_data.string);
|
||||
break;
|
||||
case GST_PROPS_INT_RANGE_ID:
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "%s: int range %d-%d\n", name, entry->data.int_range_data.min,
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "%s: int range %d-%d", name, entry->data.int_range_data.min,
|
||||
entry->data.int_range_data.max);
|
||||
break;
|
||||
case GST_PROPS_FLOAT_RANGE_ID:
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "%s: float range %f-%f\n", name, entry->data.float_range_data.min,
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "%s: float range %f-%f", name, entry->data.float_range_data.min,
|
||||
entry->data.float_range_data.max);
|
||||
break;
|
||||
case GST_PROPS_LIST_ID:
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "[list]\n");
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "[list]");
|
||||
{
|
||||
GList *entries = entry->data.list_data.entries;
|
||||
|
||||
|
@ -884,7 +884,7 @@ gst_props_entry_check_list_compatibility (GstPropsEntry *entry1, GstPropsEntry *
|
|||
static gboolean
|
||||
gst_props_entry_check_compatibility (GstPropsEntry *entry1, GstPropsEntry *entry2)
|
||||
{
|
||||
GST_DEBUG (GST_CAT_PROPERTIES,"compare: %s %s\n", g_quark_to_string (entry1->propid),
|
||||
GST_DEBUG (GST_CAT_PROPERTIES,"compare: %s %s", g_quark_to_string (entry1->propid),
|
||||
g_quark_to_string (entry2->propid));
|
||||
|
||||
if (entry2->propstype == GST_PROPS_LIST_ID && entry1->propstype != GST_PROPS_LIST_ID) {
|
||||
|
@ -931,7 +931,7 @@ gst_props_entry_check_compatibility (GstPropsEntry *entry1, GstPropsEntry *entry
|
|||
switch (entry2->propstype) {
|
||||
/* b <---> a */
|
||||
case GST_PROPS_FOURCC_ID:
|
||||
GST_DEBUG(GST_CAT_PROPERTIES,"\"%4.4s\" <--> \"%4.4s\" ?\n",
|
||||
GST_DEBUG(GST_CAT_PROPERTIES,"\"%4.4s\" <--> \"%4.4s\" ?",
|
||||
(char*) &entry2->data.fourcc_data, (char*) &entry1->data.fourcc_data);
|
||||
return (entry2->data.fourcc_data == entry1->data.fourcc_data);
|
||||
default:
|
||||
|
@ -942,13 +942,13 @@ gst_props_entry_check_compatibility (GstPropsEntry *entry1, GstPropsEntry *entry
|
|||
switch (entry2->propstype) {
|
||||
/* b <---> a - d */
|
||||
case GST_PROPS_INT_RANGE_ID:
|
||||
GST_DEBUG(GST_CAT_PROPERTIES,"%d <= %d <= %d ?\n",entry2->data.int_range_data.min,
|
||||
GST_DEBUG(GST_CAT_PROPERTIES,"%d <= %d <= %d ?",entry2->data.int_range_data.min,
|
||||
entry1->data.int_data,entry2->data.int_range_data.max);
|
||||
return (entry2->data.int_range_data.min <= entry1->data.int_data &&
|
||||
entry2->data.int_range_data.max >= entry1->data.int_data);
|
||||
/* b <---> a */
|
||||
case GST_PROPS_INT_ID:
|
||||
GST_DEBUG(GST_CAT_PROPERTIES,"%d == %d ?\n",entry1->data.int_data,entry2->data.int_data);
|
||||
GST_DEBUG(GST_CAT_PROPERTIES,"%d == %d ?",entry1->data.int_data,entry2->data.int_data);
|
||||
return (entry2->data.int_data == entry1->data.int_data);
|
||||
default:
|
||||
break;
|
||||
|
@ -979,7 +979,7 @@ gst_props_entry_check_compatibility (GstPropsEntry *entry1, GstPropsEntry *entry
|
|||
switch (entry2->propstype) {
|
||||
/* t <---> t */
|
||||
case GST_PROPS_STRING_ID:
|
||||
GST_DEBUG(GST_CAT_PROPERTIES,"\"%s\" <--> \"%s\" ?\n",
|
||||
GST_DEBUG(GST_CAT_PROPERTIES,"\"%s\" <--> \"%s\" ?",
|
||||
entry2->data.string_data.string, entry1->data.string_data.string);
|
||||
return (!strcmp (entry2->data.string_data.string, entry1->data.string_data.string));
|
||||
default:
|
||||
|
@ -1038,7 +1038,7 @@ gst_props_check_compatibility (GstProps *fromprops, GstProps *toprops)
|
|||
|
||||
if (!gst_props_entry_check_compatibility (entry1, entry2)) {
|
||||
compatible = FALSE;
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "%s are not compatible: \n",
|
||||
GST_DEBUG (GST_CAT_PROPERTIES, "%s are not compatible: ",
|
||||
g_quark_to_string (entry1->propid));
|
||||
}
|
||||
|
||||
|
@ -1280,7 +1280,7 @@ gst_props_intersect (GstProps *props1, GstProps *props2)
|
|||
while (entry1->propid < entry2->propid) {
|
||||
GstPropsEntry *toadd;
|
||||
|
||||
GST_DEBUG (GST_CAT_PROPERTIES,"source is more specific in \"%s\"\n", g_quark_to_string (entry1->propid));
|
||||
GST_DEBUG (GST_CAT_PROPERTIES,"source is more specific in \"%s\"", g_quark_to_string (entry1->propid));
|
||||
|
||||
toadd = gst_props_entry_copy (entry1);
|
||||
if (GST_PROPS_ENTRY_IS_VARIABLE (toadd))
|
||||
|
|
|
@ -484,7 +484,7 @@ gst_schedulerfactory_find (const gchar *name)
|
|||
|
||||
g_return_val_if_fail(name != NULL, NULL);
|
||||
|
||||
GST_DEBUG (0,"gstscheduler: find \"%s\"\n", name);
|
||||
GST_DEBUG (0,"gstscheduler: find \"%s\"", name);
|
||||
|
||||
walk = _gst_schedulerfactories;
|
||||
while (walk) {
|
||||
|
|
|
@ -136,7 +136,7 @@ gst_thread_init (GstThread *thread)
|
|||
const gchar *schedname;
|
||||
GstScheduler *scheduler;
|
||||
|
||||
GST_DEBUG (GST_CAT_THREAD, "initializing thread\n");
|
||||
GST_DEBUG (GST_CAT_THREAD, "initializing thread");
|
||||
|
||||
/* we're a manager by default */
|
||||
GST_FLAG_SET (thread, GST_BIN_FLAG_MANAGER);
|
||||
|
@ -162,7 +162,7 @@ gst_thread_dispose (GObject *object)
|
|||
{
|
||||
GstThread *thread = GST_THREAD (object);
|
||||
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "dispose\n");
|
||||
GST_DEBUG (GST_CAT_REFCOUNTING, "dispose");
|
||||
|
||||
g_mutex_free (thread->lock);
|
||||
g_cond_free (thread->cond);
|
||||
|
@ -360,13 +360,13 @@ gst_thread_change_state (GstElement * element)
|
|||
continue; /* deal with case where there's no peer */
|
||||
|
||||
if (!GST_FLAG_IS_SET (peerelement, GST_ELEMENT_DECOUPLED)) {
|
||||
GST_DEBUG (GST_CAT_THREAD, "peer element isn't DECOUPLED\n");
|
||||
GST_DEBUG (GST_CAT_THREAD, "peer element isn't DECOUPLED");
|
||||
continue;
|
||||
}
|
||||
|
||||
/* FIXME this needs to go away eventually */
|
||||
if (!GST_IS_QUEUE (peerelement)) {
|
||||
GST_DEBUG (GST_CAT_THREAD, "peer element isn't a Queue\n");
|
||||
GST_DEBUG (GST_CAT_THREAD, "peer element isn't a Queue");
|
||||
continue;
|
||||
}
|
||||
|
||||
|
@ -593,7 +593,7 @@ static void
|
|||
gst_thread_restore_thyself (GstObject *object,
|
||||
xmlNodePtr self)
|
||||
{
|
||||
GST_DEBUG (GST_CAT_THREAD,"gstthread: restore\n");
|
||||
GST_DEBUG (GST_CAT_THREAD,"gstthread: restore");
|
||||
|
||||
if (GST_OBJECT_CLASS (parent_class)->restore_thyself)
|
||||
GST_OBJECT_CLASS (parent_class)->restore_thyself (object, self);
|
||||
|
|
|
@ -72,7 +72,7 @@ gst_timecache_group_new(guint groupnum)
|
|||
tcgroup->minlocation = 0LL;
|
||||
tcgroup->maxlocation = 0LL;
|
||||
|
||||
GST_DEBUG(0, "created new timecache group %d\n",groupnum);
|
||||
GST_DEBUG(0, "created new timecache group %d",groupnum);
|
||||
|
||||
return tcgroup;
|
||||
}
|
||||
|
@ -83,7 +83,7 @@ gst_timecache_init (GstTimeCache *tc)
|
|||
tc->curgroup = gst_timecache_group_new(0);
|
||||
tc->maxgroup = 0;
|
||||
tc->groups = g_list_prepend(NULL, tc->curgroup);
|
||||
GST_DEBUG(0, "created new timecache\n");
|
||||
GST_DEBUG(0, "created new timecache");
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -131,7 +131,7 @@ gst_timecache_new_group(GstTimeCache *tc)
|
|||
{
|
||||
tc->curgroup = gst_timecache_group_new(++tc->maxgroup);
|
||||
tc->groups = g_list_append(tc->groups,tc->curgroup);
|
||||
GST_DEBUG(0, "created new group %d in timecache\n",tc->maxgroup);
|
||||
GST_DEBUG(0, "created new group %d in timecache",tc->maxgroup);
|
||||
return tc->maxgroup;
|
||||
}
|
||||
|
||||
|
@ -162,13 +162,13 @@ gst_timecache_set_group(GstTimeCache *tc, gint groupnum)
|
|||
list = g_list_next(list);
|
||||
if (tcgroup->groupnum == groupnum) {
|
||||
tc->curgroup = tcgroup;
|
||||
GST_DEBUG(0, "switched to timecache group %d\n", tcgroup->groupnum);
|
||||
GST_DEBUG(0, "switched to timecache group %d", tcgroup->groupnum);
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
/* couldn't find the group in question */
|
||||
GST_DEBUG(0, "couldn't find timecache group %d\n",groupnum);
|
||||
GST_DEBUG(0, "couldn't find timecache group %d",groupnum);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
|
@ -225,7 +225,7 @@ gst_timecache_add_entry (GstTimeCache *tc, guint64 location, gint64 timestamp)
|
|||
if (tc->curgroup->minlocation > location) tc->curgroup->minlocation = location;
|
||||
if (tc->curgroup->maxlocation < location) tc->curgroup->maxlocation = location;
|
||||
|
||||
GST_DEBUG(0, "added entry to timecache group %d\n",tc->curgroup->groupnum);
|
||||
GST_DEBUG(0, "added entry to timecache group %d",tc->curgroup->groupnum);
|
||||
}
|
||||
|
||||
static gint
|
||||
|
@ -255,7 +255,7 @@ gst_timecache_find_location (GstTimeCache *tc, guint64 location, gint64 *timesta
|
|||
|
||||
/* first check to see if it's in the current group */
|
||||
if ((tc->curgroup->minlocation <= location) && (location <= tc->curgroup->maxlocation)) {
|
||||
GST_DEBUG(0, "location %Ld is in group %d\n",location,tc->curgroup->groupnum);
|
||||
GST_DEBUG(0, "location %Ld is in group %d",location,tc->curgroup->groupnum);
|
||||
list = g_list_find_custom(tc->curgroup->entries,&location,(GCompareFunc)_gst_timecache_find_location);
|
||||
if (list) entry = (GstTimeCacheEntry *)(list->data);
|
||||
if (entry) *timestamp = entry->timestamp;
|
||||
|
@ -296,7 +296,7 @@ gst_timecache_find_timestamp (GstTimeCache *tc, gint64 timestamp, guint64 *locat
|
|||
|
||||
/* first check to see if it's in the current group */
|
||||
if ((tc->curgroup->mintimestamp <= timestamp) && (timestamp <= tc->curgroup->maxtimestamp)) {
|
||||
GST_DEBUG(0, "timestamp %Ld may be in group %d\n",timestamp,tc->curgroup->groupnum);
|
||||
GST_DEBUG(0, "timestamp %Ld may be in group %d",timestamp,tc->curgroup->groupnum);
|
||||
entries = g_list_find_custom(tc->curgroup->entries,×tamp,(GCompareFunc)_gst_timecache_find_timestamp);
|
||||
if (entries) entry = (GstTimeCacheEntry *)(entries->data);
|
||||
if (entry) {
|
||||
|
@ -311,7 +311,7 @@ gst_timecache_find_timestamp (GstTimeCache *tc, gint64 timestamp, guint64 *locat
|
|||
groups = g_list_next(groups);
|
||||
|
||||
if ((group->mintimestamp <= timestamp) && (timestamp <= group->maxtimestamp)) {
|
||||
GST_DEBUG(0, "timestamp %Ld may be in group %d\n",timestamp,group->groupnum);
|
||||
GST_DEBUG(0, "timestamp %Ld may be in group %d",timestamp,group->groupnum);
|
||||
entries = g_list_find_custom(group->entries,×tamp,(GCompareFunc)_gst_timecache_find_timestamp);
|
||||
if (entries) entry = (GstTimeCacheEntry *)(entries->data);
|
||||
if (entry) {
|
||||
|
|
|
@ -178,7 +178,7 @@ gst_type_register (GstTypeFactory *factory)
|
|||
|
||||
/* if there is no existing typefind function, try to use new one */
|
||||
}
|
||||
GST_DEBUG (GST_CAT_TYPES,"gsttype: %s(%p) gave new mime type '%s', id %d\n",
|
||||
GST_DEBUG (GST_CAT_TYPES,"gsttype: %s(%p) gave new mime type '%s', id %d",
|
||||
GST_OBJECT_NAME (factory), factory, type->mime, type->id);
|
||||
type->factories = g_slist_prepend (type->factories, factory);
|
||||
|
||||
|
@ -196,12 +196,12 @@ gst_type_find_by_mime_func (const gchar *mime)
|
|||
g_return_val_if_fail (mime != NULL, 0);
|
||||
|
||||
walk = _gst_types;
|
||||
/* GST_DEBUG (GST_CAT_TYPES,"searching for '%s'\n",mime); */
|
||||
/* GST_DEBUG (GST_CAT_TYPES,"searching for '%s'",mime); */
|
||||
mimelen = strlen (mime);
|
||||
while (walk) {
|
||||
type = (GstType *)walk->data;
|
||||
search = type->mime;
|
||||
/* GST_DEBUG (GST_CAT_TYPES,"checking against '%s'\n",search); */
|
||||
/* GST_DEBUG (GST_CAT_TYPES,"checking against '%s'",search); */
|
||||
typelen = strlen (search);
|
||||
while ((search - type->mime) < typelen) {
|
||||
found = strstr (search, mime);
|
||||
|
@ -344,7 +344,7 @@ gst_type_typefind_dummy (GstBuffer *buffer, gpointer priv)
|
|||
{
|
||||
GstTypeFactory *factory = (GstTypeFactory *)priv;
|
||||
|
||||
GST_DEBUG (GST_CAT_TYPES,"gsttype: need to load typefind function for %s\n", factory->mime);
|
||||
GST_DEBUG (GST_CAT_TYPES,"gsttype: need to load typefind function for %s", factory->mime);
|
||||
|
||||
if (gst_plugin_feature_ensure_loaded (GST_PLUGIN_FEATURE (factory))) {
|
||||
if (factory->typefindfunc) {
|
||||
|
|
|
@ -165,7 +165,7 @@ gst_typefind_chain (GstPad *pad, GstBuffer *buf)
|
|||
g_return_if_fail (buf != NULL);
|
||||
|
||||
typefind = GST_TYPEFIND (GST_OBJECT_PARENT (pad));
|
||||
GST_DEBUG (0,"got buffer of %d bytes in '%s'\n",
|
||||
GST_DEBUG (0,"got buffer of %d bytes in '%s'",
|
||||
GST_BUFFER_SIZE (buf), GST_OBJECT_NAME (typefind));
|
||||
|
||||
type_list = gst_type_get_list ();
|
||||
|
@ -181,9 +181,9 @@ gst_typefind_chain (GstPad *pad, GstBuffer *buf)
|
|||
GstTypeFindFunc typefindfunc = (GstTypeFindFunc)factory->typefindfunc;
|
||||
GstCaps *caps;
|
||||
|
||||
GST_DEBUG (0,"try type :%d \"%s\"\n", type->id, type->mime);
|
||||
GST_DEBUG (0,"try type :%d \"%s\"", type->id, type->mime);
|
||||
if (typefindfunc && (caps = typefindfunc (buf, factory))) {
|
||||
GST_DEBUG (0,"found type :%d \"%s\" \"%s\"\n", caps->id, type->mime,
|
||||
GST_DEBUG (0,"found type :%d \"%s\" \"%s\"", caps->id, type->mime,
|
||||
gst_caps_get_name (caps));
|
||||
typefind->caps = caps;
|
||||
|
||||
|
@ -197,7 +197,7 @@ gst_typefind_chain (GstPad *pad, GstBuffer *buf)
|
|||
g_signal_emit (G_OBJECT (typefind), gst_typefind_signals[HAVE_TYPE], 0,
|
||||
typefind->caps);
|
||||
/* if (GST_STATE(typefind) != oldstate) {
|
||||
GST_DEBUG(0, "state changed during signal, aborting\n");
|
||||
GST_DEBUG(0, "state changed during signal, aborting");
|
||||
gst_element_interrupt (GST_ELEMENT (typefind));
|
||||
} */
|
||||
gst_object_unref (GST_OBJECT (typefind));
|
||||
|
|
|
@ -263,7 +263,7 @@ gst_util_set_value_from_string(GValue *value, const gchar *value_str)
|
|||
g_return_if_fail(value != NULL);
|
||||
g_return_if_fail(value_str != NULL);
|
||||
|
||||
GST_DEBUG(GST_CAT_PARAMS, "parsing '%s' to type %s\n", value_str, g_type_name(G_VALUE_TYPE(value)));
|
||||
GST_DEBUG(GST_CAT_PARAMS, "parsing '%s' to type %s", value_str, g_type_name(G_VALUE_TYPE(value)));
|
||||
|
||||
switch (G_VALUE_TYPE(value)) {
|
||||
case G_TYPE_STRING:
|
||||
|
@ -350,7 +350,7 @@ gst_util_set_object_arg (GObject * object, const gchar * name, const gchar * val
|
|||
return;
|
||||
}
|
||||
|
||||
GST_DEBUG (0, "paramspec->flags is %d, paramspec->value_type is %d\n",
|
||||
GST_DEBUG (0, "paramspec->flags is %d, paramspec->value_type is %d",
|
||||
paramspec->flags, (gint) paramspec->value_type);
|
||||
|
||||
if (paramspec->flags & G_PARAM_WRITABLE) {
|
||||
|
|
|
@ -345,14 +345,14 @@ gst_xml_get_element (GstXML *xml, const guchar *name)
|
|||
g_return_val_if_fail(xml != NULL, NULL);
|
||||
g_return_val_if_fail(name != NULL, NULL);
|
||||
|
||||
GST_DEBUG (0,"gstxml: getting element \"%s\"\n", name);
|
||||
GST_DEBUG (0,"gstxml: getting element \"%s\"", name);
|
||||
|
||||
topelements = gst_xml_get_topelements (xml);
|
||||
|
||||
while (topelements) {
|
||||
GstElement *top = GST_ELEMENT (topelements->data);
|
||||
|
||||
GST_DEBUG (0,"gstxml: getting element \"%s\"\n", name);
|
||||
GST_DEBUG (0,"gstxml: getting element \"%s\"", name);
|
||||
if (!strcmp (GST_ELEMENT_NAME (top), name)) {
|
||||
return top;
|
||||
}
|
||||
|
|
|
@ -225,10 +225,10 @@ gst_basic_scheduler_loopfunc_wrapper (int argc, char *argv[])
|
|||
GST_DEBUG_ENTER ("(%d,'%s')", argc, name);
|
||||
|
||||
do {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling loopfunc %s for element %s\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling loopfunc %s for element %s",
|
||||
GST_DEBUG_FUNCPTR_NAME (element->loopfunc), name);
|
||||
(element->loopfunc) (element);
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "element %s ended loop function\n", name);
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "element %s ended loop function", name);
|
||||
|
||||
} while (!GST_ELEMENT_IS_COTHREAD_STOPPING (element));
|
||||
GST_FLAG_UNSET (element, GST_ELEMENT_COTHREAD_STOPPING);
|
||||
|
@ -245,7 +245,7 @@ gst_basic_scheduler_chain_wrapper (int argc, char *argv[])
|
|||
|
||||
GST_DEBUG_ENTER ("(\"%s\")", name);
|
||||
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "stepping through pads\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "stepping through pads");
|
||||
|
||||
do {
|
||||
GList *pads = element->pads;
|
||||
|
@ -263,7 +263,7 @@ gst_basic_scheduler_chain_wrapper (int argc, char *argv[])
|
|||
if (GST_RPAD_DIRECTION (realpad) == GST_PAD_SINK) {
|
||||
GstBuffer *buf;
|
||||
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "pulling data from %s:%s\n", name, GST_PAD_NAME (pad));
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "pulling data from %s:%s", name, GST_PAD_NAME (pad));
|
||||
buf = gst_pad_pull (pad);
|
||||
if (buf) {
|
||||
if (GST_IS_EVENT (buf) && !GST_ELEMENT_IS_EVENT_AWARE (element)) {
|
||||
|
@ -271,10 +271,10 @@ gst_basic_scheduler_chain_wrapper (int argc, char *argv[])
|
|||
gst_pad_send_event (pad, GST_EVENT (buf));
|
||||
}
|
||||
else {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling chain function of %s:%s\n", name,
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling chain function of %s:%s", name,
|
||||
GST_PAD_NAME (pad));
|
||||
GST_RPAD_CHAINFUNC (realpad) (pad, buf);
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling chain function of element %s done\n", name);
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling chain function of element %s done", name);
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
@ -312,7 +312,7 @@ gst_basic_scheduler_src_wrapper (int argc, char *argv[])
|
|||
|
||||
pads = g_list_next (pads);
|
||||
if (GST_RPAD_DIRECTION (realpad) == GST_PAD_SRC) {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling _getfunc for %s:%s\n", GST_DEBUG_PAD_NAME (realpad));
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling _getfunc for %s:%s", GST_DEBUG_PAD_NAME (realpad));
|
||||
if (realpad->regiontype != GST_REGION_VOID) {
|
||||
g_return_val_if_fail (GST_RPAD_GETREGIONFUNC (realpad) != NULL, 0);
|
||||
/* if (GST_RPAD_GETREGIONFUNC(realpad) == NULL) */
|
||||
|
@ -331,7 +331,7 @@ gst_basic_scheduler_src_wrapper (int argc, char *argv[])
|
|||
buf = GST_RPAD_GETFUNC (realpad) (GST_PAD_CAST (realpad));
|
||||
}
|
||||
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling gst_pad_push on pad %s:%s\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling gst_pad_push on pad %s:%s",
|
||||
GST_DEBUG_PAD_NAME (realpad));
|
||||
gst_pad_push (GST_PAD_CAST (realpad), buf);
|
||||
}
|
||||
|
@ -351,20 +351,20 @@ gst_basic_scheduler_chainhandler_proxy (GstPad * pad, GstBuffer * buf)
|
|||
gint loop_count = 100;
|
||||
|
||||
GST_DEBUG_ENTER ("(%s:%s)", GST_DEBUG_PAD_NAME (pad));
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "putting buffer %p in peer \"%s:%s\"'s pen\n", buf,
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "putting buffer %p in peer \"%s:%s\"'s pen", buf,
|
||||
GST_DEBUG_PAD_NAME (peer));
|
||||
|
||||
/*
|
||||
* loop until the bufferpen is empty so we can fill it up again
|
||||
*/
|
||||
while (GST_RPAD_BUFPEN (GST_RPAD_PEER (pad)) != NULL && --loop_count) {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to %p to empty bufpen %d\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to %p to empty bufpen %d",
|
||||
GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)), loop_count);
|
||||
cothread_switch (GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)));
|
||||
|
||||
/* we may no longer be the same pad, check. */
|
||||
if (GST_RPAD_PEER (peer) != (GstRealPad *) pad) {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "new pad in mid-switch!\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "new pad in mid-switch!");
|
||||
pad = (GstPad *) GST_RPAD_PEER (peer);
|
||||
}
|
||||
}
|
||||
|
@ -377,11 +377,11 @@ gst_basic_scheduler_chainhandler_proxy (GstPad * pad, GstBuffer * buf)
|
|||
g_assert (GST_RPAD_BUFPEN (GST_RPAD_PEER (pad)) == NULL);
|
||||
/* now fill the bufferpen and switch so it can be consumed */
|
||||
GST_RPAD_BUFPEN (GST_RPAD_PEER (pad)) = buf;
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to %p\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to %p",
|
||||
GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)));
|
||||
cothread_switch (GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)));
|
||||
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "done switching\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "done switching");
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -389,18 +389,18 @@ gst_basic_scheduler_select_proxy (GstPad * pad, GstBuffer * buf)
|
|||
{
|
||||
GST_DEBUG_ENTER ("(%s:%s)", GST_DEBUG_PAD_NAME (pad));
|
||||
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "putting buffer %p in peer's pen\n", buf);
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "putting buffer %p in peer's pen", buf);
|
||||
|
||||
g_assert (GST_RPAD_BUFPEN (GST_RPAD_PEER (pad)) == NULL);
|
||||
/* now fill the bufferpen and switch so it can be consumed */
|
||||
GST_RPAD_BUFPEN (GST_RPAD_PEER (pad)) = buf;
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to %p\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to %p",
|
||||
GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)));
|
||||
GST_ELEMENT (GST_PAD_PARENT (pad))->select_pad = pad;
|
||||
|
||||
cothread_switch (GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)));
|
||||
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "done switching\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "done switching");
|
||||
}
|
||||
|
||||
|
||||
|
@ -415,18 +415,18 @@ gst_basic_scheduler_gethandler_proxy (GstPad * pad)
|
|||
/* FIXME this should be bounded */
|
||||
/* we will loop switching to the peer until it's filled up the bufferpen */
|
||||
while (GST_RPAD_BUFPEN (pad) == NULL) {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to \"%s\": %p to fill bufpen\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to \"%s\": %p to fill bufpen",
|
||||
GST_ELEMENT_NAME (GST_ELEMENT (GST_PAD_PARENT (pad))),
|
||||
GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)));
|
||||
cothread_switch (GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)));
|
||||
|
||||
/* we may no longer be the same pad, check. */
|
||||
if (GST_RPAD_PEER (peer) != (GstRealPad *) pad) {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "new pad in mid-switch!\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "new pad in mid-switch!");
|
||||
pad = (GstPad *) GST_RPAD_PEER (peer);
|
||||
}
|
||||
}
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "done switching\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "done switching");
|
||||
|
||||
/* now grab the buffer from the pen, clear the pen, and return the buffer */
|
||||
buf = GST_RPAD_BUFPEN (pad);
|
||||
|
@ -451,17 +451,17 @@ gst_basic_scheduler_pullregionfunc_proxy (GstPad * pad, GstRegionType type, guin
|
|||
/* FIXME this should be bounded */
|
||||
/* we will loop switching to the peer until it's filled up the bufferpen */
|
||||
while (GST_RPAD_BUFPEN (pad) == NULL) {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to %p to fill bufpen\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to %p to fill bufpen",
|
||||
GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)));
|
||||
cothread_switch (GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)));
|
||||
|
||||
/* we may no longer be the same pad, check. */
|
||||
if (GST_RPAD_PEER (peer) != (GstRealPad *) pad) {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "new pad in mid-switch!\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "new pad in mid-switch!");
|
||||
pad = (GstPad *) GST_RPAD_PEER (peer);
|
||||
}
|
||||
}
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "done switching\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "done switching");
|
||||
|
||||
/* now grab the buffer from the pen, clear the pen, and return the buffer */
|
||||
buf = GST_RPAD_BUFPEN (pad);
|
||||
|
@ -479,7 +479,7 @@ gst_basic_scheduler_cothreaded_chain (GstBin * bin, GstSchedulerChain * chain)
|
|||
GList *pads;
|
||||
GstPad *pad;
|
||||
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "chain is using COTHREADS\n");
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "chain is using COTHREADS");
|
||||
|
||||
g_assert (GST_BIN_THREADCONTEXT (bin) != NULL);
|
||||
|
||||
|
@ -499,7 +499,7 @@ gst_basic_scheduler_cothreaded_chain (GstBin * bin, GstSchedulerChain * chain)
|
|||
/* if the element has a loopfunc... */
|
||||
if (element->loopfunc != NULL) {
|
||||
wrapper_function = GST_DEBUG_FUNCPTR (gst_basic_scheduler_loopfunc_wrapper);
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "element '%s' is a loop-based\n", GST_ELEMENT_NAME (element));
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "element '%s' is a loop-based", GST_ELEMENT_NAME (element));
|
||||
}
|
||||
else {
|
||||
/* otherwise we need to decide what kind of cothread */
|
||||
|
@ -508,12 +508,12 @@ gst_basic_scheduler_cothreaded_chain (GstBin * bin, GstSchedulerChain * chain)
|
|||
/* if it doesn't have any sinks, it must be a source (duh) */
|
||||
if (element->numsinkpads == 0) {
|
||||
wrapper_function = GST_DEBUG_FUNCPTR (gst_basic_scheduler_src_wrapper);
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "element '%s' is a source, using _src_wrapper\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "element '%s' is a source, using _src_wrapper",
|
||||
GST_ELEMENT_NAME (element));
|
||||
}
|
||||
else {
|
||||
wrapper_function = GST_DEBUG_FUNCPTR (gst_basic_scheduler_chain_wrapper);
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "element '%s' is a filter, using _chain_wrapper\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "element '%s' is a filter, using _chain_wrapper",
|
||||
GST_ELEMENT_NAME (element));
|
||||
}
|
||||
}
|
||||
|
@ -546,12 +546,12 @@ gst_basic_scheduler_cothreaded_chain (GstBin * bin, GstSchedulerChain * chain)
|
|||
|
||||
/* set the chain proxies */
|
||||
if (GST_RPAD_DIRECTION (pad) == GST_PAD_SINK) {
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "copying chain function into push proxy for %s:%s\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "copying chain function into push proxy for %s:%s",
|
||||
GST_DEBUG_PAD_NAME (pad));
|
||||
GST_RPAD_CHAINHANDLER (pad) = GST_RPAD_CHAINFUNC (pad);
|
||||
}
|
||||
else {
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "copying get function into pull proxy for %s:%s\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "copying get function into pull proxy for %s:%s",
|
||||
GST_DEBUG_PAD_NAME (pad));
|
||||
GST_RPAD_GETHANDLER (pad) = GST_RPAD_GETFUNC (pad);
|
||||
GST_RPAD_PULLREGIONFUNC (pad) = GST_RPAD_GETREGIONFUNC (pad);
|
||||
|
@ -561,12 +561,12 @@ gst_basic_scheduler_cothreaded_chain (GstBin * bin, GstSchedulerChain * chain)
|
|||
/* otherwise we really are a cothread */
|
||||
else {
|
||||
if (gst_pad_get_direction (pad) == GST_PAD_SINK) {
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "setting cothreaded push proxy for sinkpad %s:%s\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "setting cothreaded push proxy for sinkpad %s:%s",
|
||||
GST_DEBUG_PAD_NAME (pad));
|
||||
GST_RPAD_CHAINHANDLER (pad) = GST_DEBUG_FUNCPTR (gst_basic_scheduler_chainhandler_proxy);
|
||||
}
|
||||
else {
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "setting cothreaded pull proxy for srcpad %s:%s\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "setting cothreaded pull proxy for srcpad %s:%s",
|
||||
GST_DEBUG_PAD_NAME (pad));
|
||||
GST_RPAD_GETHANDLER (pad) = GST_DEBUG_FUNCPTR (gst_basic_scheduler_gethandler_proxy);
|
||||
GST_RPAD_PULLREGIONFUNC (pad) = GST_DEBUG_FUNCPTR (gst_basic_scheduler_pullregionfunc_proxy);
|
||||
|
@ -584,12 +584,12 @@ gst_basic_scheduler_cothreaded_chain (GstBin * bin, GstSchedulerChain * chain)
|
|||
GST_ELEMENT_NAME (element), NULL);
|
||||
return FALSE;
|
||||
}
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "created cothread %p for '%s'\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "created cothread %p for '%s'",
|
||||
GST_ELEMENT_THREADSTATE (element),
|
||||
GST_ELEMENT_NAME (element));
|
||||
}
|
||||
cothread_setfunc (GST_ELEMENT_THREADSTATE (element), wrapper_function, 0, (char **) element);
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "set wrapper function for '%s' to &%s\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "set wrapper function for '%s' to &%s",
|
||||
GST_ELEMENT_NAME (element), GST_DEBUG_FUNCPTR_NAME (wrapper_function));
|
||||
}
|
||||
}
|
||||
|
@ -836,21 +836,21 @@ gst_basic_scheduler_chain_recursive_add (GstSchedulerChain * chain, GstElement *
|
|||
/* add the element to the chain */
|
||||
gst_basic_scheduler_chain_add_element (chain, element);
|
||||
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "recursing on element \"%s\"\n", GST_ELEMENT_NAME (element));
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "recursing on element \"%s\"", GST_ELEMENT_NAME (element));
|
||||
/* now go through all the pads and see which peers can be added */
|
||||
pads = element->pads;
|
||||
while (pads) {
|
||||
pad = GST_PAD (pads->data);
|
||||
pads = g_list_next (pads);
|
||||
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "have pad %s:%s, checking for valid peer\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "have pad %s:%s, checking for valid peer",
|
||||
GST_DEBUG_PAD_NAME (pad));
|
||||
/* if the peer exists and could be in the same chain */
|
||||
if (GST_PAD_PEER (pad)) {
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "has peer %s:%s\n", GST_DEBUG_PAD_NAME (GST_PAD_PEER (pad)));
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "has peer %s:%s", GST_DEBUG_PAD_NAME (GST_PAD_PEER (pad)));
|
||||
peerelement = GST_PAD_PARENT (GST_PAD_PEER (pad));
|
||||
if (GST_ELEMENT_SCHED (GST_PAD_PARENT (pad)) == GST_ELEMENT_SCHED (peerelement)) {
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "peer \"%s\" is valid for same chain\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "peer \"%s\" is valid for same chain",
|
||||
GST_ELEMENT_NAME (peerelement));
|
||||
/* if it's not already in a chain, add it to this one */
|
||||
if (gst_basic_scheduler_find_chain (chain->sched, peerelement) == NULL) {
|
||||
|
@ -871,7 +871,7 @@ gst_basic_scheduler_setup (GstScheduler *sched)
|
|||
|
||||
/* first create thread context */
|
||||
if (GST_BIN_THREADCONTEXT (bin) == NULL) {
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "initializing cothread context\n");
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "initializing cothread context");
|
||||
GST_BIN_THREADCONTEXT (bin) = cothread_context_init ();
|
||||
}
|
||||
}
|
||||
|
@ -1103,7 +1103,7 @@ gst_basic_scheduler_pad_connect (GstScheduler * sched, GstPad *srcpad, GstPad *s
|
|||
|
||||
GST_INFO (GST_CAT_SCHEDULING, "have pad connected callback on %s:%s to %s:%s",
|
||||
GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "srcpad sched is %p, sinkpad sched is %p\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "srcpad sched is %p, sinkpad sched is %p",
|
||||
GST_ELEMENT_SCHED (srcelement), GST_ELEMENT_SCHED (sinkelement));
|
||||
|
||||
if (GST_ELEMENT_SCHED (srcelement) == GST_ELEMENT_SCHED (sinkelement)) {
|
||||
|
@ -1224,22 +1224,22 @@ gst_basic_scheduler_iterate (GstScheduler * sched)
|
|||
|
||||
/* all we really have to do is switch to the first child */
|
||||
/* FIXME this should be lots more intelligent about where to start */
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "starting iteration via cothreads\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "starting iteration via cothreads");
|
||||
|
||||
if (chain->elements) {
|
||||
entry = NULL; /*MattH ADDED?*/
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "there are %d elements in this chain\n", chain->num_elements);
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "there are %d elements in this chain", chain->num_elements);
|
||||
elements = chain->elements;
|
||||
while (elements) {
|
||||
entry = GST_ELEMENT_CAST (elements->data);
|
||||
elements = g_list_next (elements);
|
||||
if (GST_FLAG_IS_SET (entry, GST_ELEMENT_DECOUPLED)) {
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "entry \"%s\" is DECOUPLED, skipping\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "entry \"%s\" is DECOUPLED, skipping",
|
||||
GST_ELEMENT_NAME (entry));
|
||||
entry = NULL;
|
||||
}
|
||||
else if (GST_FLAG_IS_SET (entry, GST_ELEMENT_INFINITE_LOOP)) {
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "entry \"%s\" is not valid, skipping\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "entry \"%s\" is not valid, skipping",
|
||||
GST_ELEMENT_NAME (entry));
|
||||
entry = NULL;
|
||||
}
|
||||
|
@ -1251,7 +1251,7 @@ gst_basic_scheduler_iterate (GstScheduler * sched)
|
|||
|
||||
GST_FLAG_SET (entry, GST_ELEMENT_COTHREAD_STOPPING);
|
||||
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "set COTHREAD_STOPPING flag on \"%s\"(@%p)\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "set COTHREAD_STOPPING flag on \"%s\"(@%p)",
|
||||
GST_ELEMENT_NAME (entry), entry);
|
||||
if (GST_ELEMENT_THREADSTATE (entry)) {
|
||||
cothread_switch (GST_ELEMENT_THREADSTATE (entry));
|
||||
|
@ -1260,7 +1260,7 @@ gst_basic_scheduler_iterate (GstScheduler * sched)
|
|||
return GST_SCHEDULER_STATE_RUNNING;
|
||||
}
|
||||
else {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "cothread switch not possible, element has no threadstate\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "cothread switch not possible, element has no threadstate");
|
||||
return GST_SCHEDULER_STATE_ERROR;
|
||||
}
|
||||
|
||||
|
@ -1272,7 +1272,7 @@ gst_basic_scheduler_iterate (GstScheduler * sched)
|
|||
* if it was, return to gstthread.c::gst_thread_main_loop() to
|
||||
* execute the state change.
|
||||
*/
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "cothread switch ended or interrupted\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "cothread switch ended or interrupted");
|
||||
|
||||
if (state != GST_SCHEDULER_STATE_RUNNING) {
|
||||
GST_INFO (GST_CAT_DATAFLOW, "scheduler is not running, in state %d", state);
|
||||
|
@ -1290,7 +1290,7 @@ gst_basic_scheduler_iterate (GstScheduler * sched)
|
|||
}
|
||||
}
|
||||
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "leaving (%s)\n", GST_ELEMENT_NAME (bin));
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "leaving (%s)", GST_ELEMENT_NAME (bin));
|
||||
if (scheduled == 0) {
|
||||
GST_INFO (GST_CAT_DATAFLOW, "nothing was scheduled, return STOPPED");
|
||||
return GST_SCHEDULER_STATE_STOPPED;
|
||||
|
|
|
@ -226,7 +226,7 @@ static inline cothread* sched_create (GstStandardScheduler *scheduler, GstElemen
|
|||
{
|
||||
cothread *ret = NULL;
|
||||
|
||||
GST_DEBUG (GST_CAT_COTHREADS, "calling cothread_create (%p, %d, %p, %p)\n", func, 1, element, scheduler->main);
|
||||
GST_DEBUG (GST_CAT_COTHREADS, "calling cothread_create (%p, %d, %p, %p)", func, 1, element, scheduler->main);
|
||||
|
||||
ret = cothread_create (func, 1, (void**) element, scheduler->main);
|
||||
|
||||
|
@ -240,7 +240,7 @@ static inline void sched_switch (cothread *to)
|
|||
cothread *from = cothread_self ();
|
||||
|
||||
if (from == to) {
|
||||
GST_DEBUG (GST_CAT_COTHREAD_SWITCH, "trying to switch to the same cothread (%p), not allowed\n",
|
||||
GST_DEBUG (GST_CAT_COTHREAD_SWITCH, "trying to switch to the same cothread (%p), not allowed",
|
||||
to);
|
||||
g_assert_not_reached ();
|
||||
}
|
||||
|
@ -259,10 +259,10 @@ gst_standard_scheduler_loopfunc_wrapper (int argc, char *argv[])
|
|||
GST_DEBUG_ENTER ("(%d,'%s')", argc, name);
|
||||
|
||||
do {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling loopfunc %s for element %s\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling loopfunc %s for element %s",
|
||||
GST_DEBUG_FUNCPTR_NAME (element->loopfunc), name);
|
||||
(element->loopfunc) (element);
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "element %s ended loop function\n", name);
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "element %s ended loop function", name);
|
||||
|
||||
} while (!GST_ELEMENT_IS_COTHREAD_STOPPING (element));
|
||||
GST_FLAG_UNSET (element, GST_ELEMENT_COTHREAD_STOPPING);
|
||||
|
@ -279,7 +279,7 @@ gst_standard_scheduler_chain_wrapper (int argc, char *argv[])
|
|||
|
||||
GST_DEBUG_ENTER ("(\"%s\")", name);
|
||||
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "stepping through pads\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "stepping through pads");
|
||||
|
||||
do {
|
||||
GList *pads = element->pads;
|
||||
|
@ -297,7 +297,7 @@ gst_standard_scheduler_chain_wrapper (int argc, char *argv[])
|
|||
if (GST_RPAD_DIRECTION (realpad) == GST_PAD_SINK) {
|
||||
GstBuffer *buf;
|
||||
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "pulling data from %s:%s\n", name, GST_PAD_NAME (pad));
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "pulling data from %s:%s", name, GST_PAD_NAME (pad));
|
||||
buf = gst_pad_pull (pad);
|
||||
if (buf) {
|
||||
if (GST_IS_EVENT (buf) && !GST_ELEMENT_IS_EVENT_AWARE (element)) {
|
||||
|
@ -305,10 +305,10 @@ gst_standard_scheduler_chain_wrapper (int argc, char *argv[])
|
|||
gst_pad_send_event (pad, GST_EVENT (buf));
|
||||
}
|
||||
else {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling chain function of %s:%s\n", name,
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling chain function of %s:%s", name,
|
||||
GST_PAD_NAME (pad));
|
||||
GST_RPAD_CHAINFUNC (realpad) (pad, buf);
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling chain function of element %s done\n", name);
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling chain function of element %s done", name);
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
@ -346,7 +346,7 @@ gst_standard_scheduler_src_wrapper (int argc, char *argv[])
|
|||
|
||||
pads = g_list_next (pads);
|
||||
if (GST_RPAD_DIRECTION (realpad) == GST_PAD_SRC) {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling _getfunc for %s:%s\n", GST_DEBUG_PAD_NAME (realpad));
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling _getfunc for %s:%s", GST_DEBUG_PAD_NAME (realpad));
|
||||
if (realpad->regiontype != GST_REGION_VOID) {
|
||||
g_return_val_if_fail (GST_RPAD_GETREGIONFUNC (realpad) != NULL, 0);
|
||||
/* if (GST_RPAD_GETREGIONFUNC(realpad) == NULL) */
|
||||
|
@ -365,7 +365,7 @@ gst_standard_scheduler_src_wrapper (int argc, char *argv[])
|
|||
buf = GST_RPAD_GETFUNC (realpad) (GST_PAD_CAST (realpad));
|
||||
}
|
||||
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling gst_pad_push on pad %s:%s\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "calling gst_pad_push on pad %s:%s",
|
||||
GST_DEBUG_PAD_NAME (realpad));
|
||||
gst_pad_push (GST_PAD_CAST (realpad), buf);
|
||||
}
|
||||
|
@ -385,20 +385,20 @@ gst_standard_scheduler_chainhandler_proxy (GstPad * pad, GstBuffer * buf)
|
|||
gint loop_count = 100;
|
||||
|
||||
GST_DEBUG_ENTER ("(%s:%s)", GST_DEBUG_PAD_NAME (pad));
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "putting buffer %p in peer \"%s:%s\"'s pen\n", buf,
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "putting buffer %p in peer \"%s:%s\"'s pen", buf,
|
||||
GST_DEBUG_PAD_NAME (peer));
|
||||
|
||||
/*
|
||||
* loop until the bufferpen is empty so we can fill it up again
|
||||
*/
|
||||
while (GST_RPAD_BUFPEN (GST_RPAD_PEER (pad)) != NULL && --loop_count) {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to %p to empty bufpen %d\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to %p to empty bufpen %d",
|
||||
GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)), loop_count);
|
||||
sched_switch (GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)));
|
||||
|
||||
/* we may no longer be the same pad, check. */
|
||||
if (GST_RPAD_PEER (peer) != (GstRealPad *) pad) {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "new pad in mid-switch!\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "new pad in mid-switch!");
|
||||
pad = (GstPad *) GST_RPAD_PEER (peer);
|
||||
}
|
||||
}
|
||||
|
@ -411,11 +411,11 @@ gst_standard_scheduler_chainhandler_proxy (GstPad * pad, GstBuffer * buf)
|
|||
g_assert (GST_RPAD_BUFPEN (GST_RPAD_PEER (pad)) == NULL);
|
||||
/* now fill the bufferpen and switch so it can be consumed */
|
||||
GST_RPAD_BUFPEN (GST_RPAD_PEER (pad)) = buf;
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to %p\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to %p",
|
||||
GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)));
|
||||
sched_switch (GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)));
|
||||
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "done switching\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "done switching");
|
||||
}
|
||||
|
||||
static GstBuffer *
|
||||
|
@ -429,18 +429,18 @@ gst_standard_scheduler_gethandler_proxy (GstPad * pad)
|
|||
/* FIXME this should be bounded */
|
||||
/* we will loop switching to the peer until it's filled up the bufferpen */
|
||||
while (GST_RPAD_BUFPEN (pad) == NULL) {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to \"%s\": %p to fill bufpen\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to \"%s\": %p to fill bufpen",
|
||||
GST_ELEMENT_NAME (GST_ELEMENT (GST_PAD_PARENT (pad))),
|
||||
GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)));
|
||||
sched_switch (GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)));
|
||||
|
||||
/* we may no longer be the same pad, check. */
|
||||
if (GST_RPAD_PEER (peer) != (GstRealPad *) pad) {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "new pad in mid-switch!\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "new pad in mid-switch!");
|
||||
pad = (GstPad *) GST_RPAD_PEER (peer);
|
||||
}
|
||||
}
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "done switching\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "done switching");
|
||||
|
||||
/* now grab the buffer from the pen, clear the pen, and return the buffer */
|
||||
buf = GST_RPAD_BUFPEN (pad);
|
||||
|
@ -465,17 +465,17 @@ gst_standard_scheduler_pullregionfunc_proxy (GstPad * pad, GstRegionType type, g
|
|||
/* FIXME this should be bounded */
|
||||
/* we will loop switching to the peer until it's filled up the bufferpen */
|
||||
while (GST_RPAD_BUFPEN (pad) == NULL) {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to %p to fill bufpen\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "switching to %p to fill bufpen",
|
||||
GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)));
|
||||
sched_switch (GST_ELEMENT_THREADSTATE (GST_PAD_PARENT (pad)));
|
||||
|
||||
/* we may no longer be the same pad, check. */
|
||||
if (GST_RPAD_PEER (peer) != (GstRealPad *) pad) {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "new pad in mid-switch!\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "new pad in mid-switch!");
|
||||
pad = (GstPad *) GST_RPAD_PEER (peer);
|
||||
}
|
||||
}
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "done switching\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "done switching");
|
||||
|
||||
/* now grab the buffer from the pen, clear the pen, and return the buffer */
|
||||
buf = GST_RPAD_BUFPEN (pad);
|
||||
|
@ -493,7 +493,7 @@ gst_standard_scheduler_cothreaded_chain (GstBin * bin, GstSchedulerChain * chain
|
|||
GList *pads;
|
||||
GstPad *pad;
|
||||
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "chain is using COTHREADS\n");
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "chain is using COTHREADS");
|
||||
|
||||
/* walk through all the chain's elements */
|
||||
elements = chain->elements;
|
||||
|
@ -511,7 +511,7 @@ gst_standard_scheduler_cothreaded_chain (GstBin * bin, GstSchedulerChain * chain
|
|||
/* if the element has a loopfunc... */
|
||||
if (element->loopfunc != NULL) {
|
||||
wrapper_function = GST_DEBUG_FUNCPTR (gst_standard_scheduler_loopfunc_wrapper);
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "element '%s' is a loop-based\n", GST_ELEMENT_NAME (element));
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "element '%s' is a loop-based", GST_ELEMENT_NAME (element));
|
||||
}
|
||||
else {
|
||||
/* otherwise we need to decide what kind of cothread */
|
||||
|
@ -520,12 +520,12 @@ gst_standard_scheduler_cothreaded_chain (GstBin * bin, GstSchedulerChain * chain
|
|||
/* if it doesn't have any sinks, it must be a source (duh) */
|
||||
if (element->numsinkpads == 0) {
|
||||
wrapper_function = GST_DEBUG_FUNCPTR (gst_standard_scheduler_src_wrapper);
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "element '%s' is a source, using _src_wrapper\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "element '%s' is a source, using _src_wrapper",
|
||||
GST_ELEMENT_NAME (element));
|
||||
}
|
||||
else {
|
||||
wrapper_function = GST_DEBUG_FUNCPTR (gst_standard_scheduler_chain_wrapper);
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "element '%s' is a filter, using _chain_wrapper\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "element '%s' is a filter, using _chain_wrapper",
|
||||
GST_ELEMENT_NAME (element));
|
||||
}
|
||||
}
|
||||
|
@ -558,12 +558,12 @@ gst_standard_scheduler_cothreaded_chain (GstBin * bin, GstSchedulerChain * chain
|
|||
|
||||
/* set the chain proxies */
|
||||
if (GST_RPAD_DIRECTION (pad) == GST_PAD_SINK) {
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "copying chain function into push proxy for %s:%s\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "copying chain function into push proxy for %s:%s",
|
||||
GST_DEBUG_PAD_NAME (pad));
|
||||
GST_RPAD_CHAINHANDLER (pad) = GST_RPAD_CHAINFUNC (pad);
|
||||
}
|
||||
else {
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "copying get function into pull proxy for %s:%s\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "copying get function into pull proxy for %s:%s",
|
||||
GST_DEBUG_PAD_NAME (pad));
|
||||
GST_RPAD_GETHANDLER (pad) = GST_RPAD_GETFUNC (pad);
|
||||
GST_RPAD_PULLREGIONFUNC (pad) = GST_RPAD_GETREGIONFUNC (pad);
|
||||
|
@ -573,12 +573,12 @@ gst_standard_scheduler_cothreaded_chain (GstBin * bin, GstSchedulerChain * chain
|
|||
/* otherwise we really are a cothread */
|
||||
else {
|
||||
if (gst_pad_get_direction (pad) == GST_PAD_SINK) {
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "setting cothreaded push proxy for sinkpad %s:%s\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "setting cothreaded push proxy for sinkpad %s:%s",
|
||||
GST_DEBUG_PAD_NAME (pad));
|
||||
GST_RPAD_CHAINHANDLER (pad) = GST_DEBUG_FUNCPTR (gst_standard_scheduler_chainhandler_proxy);
|
||||
}
|
||||
else {
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "setting cothreaded pull proxy for srcpad %s:%s\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "setting cothreaded pull proxy for srcpad %s:%s",
|
||||
GST_DEBUG_PAD_NAME (pad));
|
||||
GST_RPAD_GETHANDLER (pad) = GST_DEBUG_FUNCPTR (gst_standard_scheduler_gethandler_proxy);
|
||||
GST_RPAD_PULLREGIONFUNC (pad) = GST_DEBUG_FUNCPTR (gst_standard_scheduler_pullregionfunc_proxy);
|
||||
|
@ -595,12 +595,12 @@ gst_standard_scheduler_cothreaded_chain (GstBin * bin, GstSchedulerChain * chain
|
|||
GST_ELEMENT_NAME (element), NULL);
|
||||
return FALSE;
|
||||
}
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "created cothread %p for '%s'\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "created cothread %p for '%s'",
|
||||
GST_ELEMENT_THREADSTATE (element),
|
||||
GST_ELEMENT_NAME (element));
|
||||
} else {
|
||||
cothread_reset (GST_ELEMENT_THREADSTATE (element), wrapper_function, 1, (void **) element, chain->sched->main);
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "set wrapper function for '%s' to &%s\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "set wrapper function for '%s' to &%s",
|
||||
GST_ELEMENT_NAME (element), GST_DEBUG_FUNCPTR_NAME (wrapper_function));
|
||||
}
|
||||
}
|
||||
|
@ -847,21 +847,21 @@ gst_standard_scheduler_chain_recursive_add (GstSchedulerChain * chain, GstElemen
|
|||
/* add the element to the chain */
|
||||
gst_standard_scheduler_chain_add_element (chain, element);
|
||||
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "recursing on element \"%s\"\n", GST_ELEMENT_NAME (element));
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "recursing on element \"%s\"", GST_ELEMENT_NAME (element));
|
||||
/* now go through all the pads and see which peers can be added */
|
||||
pads = element->pads;
|
||||
while (pads) {
|
||||
pad = GST_PAD (pads->data);
|
||||
pads = g_list_next (pads);
|
||||
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "have pad %s:%s, checking for valid peer\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "have pad %s:%s, checking for valid peer",
|
||||
GST_DEBUG_PAD_NAME (pad));
|
||||
/* if the peer exists and could be in the same chain */
|
||||
if (GST_PAD_PEER (pad)) {
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "has peer %s:%s\n", GST_DEBUG_PAD_NAME (GST_PAD_PEER (pad)));
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "has peer %s:%s", GST_DEBUG_PAD_NAME (GST_PAD_PEER (pad)));
|
||||
peerelement = GST_PAD_PARENT (GST_PAD_PEER (pad));
|
||||
if (GST_ELEMENT_SCHED (GST_PAD_PARENT (pad)) == GST_ELEMENT_SCHED (peerelement)) {
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "peer \"%s\" is valid for same chain\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "peer \"%s\" is valid for same chain",
|
||||
GST_ELEMENT_NAME (peerelement));
|
||||
/* if it's not already in a chain, add it to this one */
|
||||
if (gst_standard_scheduler_find_chain (chain->sched, peerelement) == NULL) {
|
||||
|
@ -1094,7 +1094,7 @@ gst_standard_scheduler_pad_connect (GstScheduler * sched, GstPad *srcpad, GstPad
|
|||
|
||||
GST_INFO (GST_CAT_SCHEDULING, "have pad connected callback on %s:%s to %s:%s",
|
||||
GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "srcpad sched is %p, sinkpad sched is %p\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "srcpad sched is %p, sinkpad sched is %p",
|
||||
GST_ELEMENT_SCHED (srcelement), GST_ELEMENT_SCHED (sinkelement));
|
||||
|
||||
if (GST_ELEMENT_SCHED (srcelement) == GST_ELEMENT_SCHED (sinkelement)) {
|
||||
|
@ -1177,22 +1177,22 @@ gst_standard_scheduler_iterate (GstScheduler * sched)
|
|||
|
||||
/* all we really have to do is switch to the first child */
|
||||
/* FIXME this should be lots more intelligent about where to start */
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "starting iteration via cothreads\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "starting iteration via cothreads");
|
||||
|
||||
if (chain->elements) {
|
||||
entry = NULL; /*MattH ADDED?*/
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "there are %d elements in this chain\n", chain->num_elements);
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "there are %d elements in this chain", chain->num_elements);
|
||||
elements = chain->elements;
|
||||
while (elements) {
|
||||
entry = GST_ELEMENT_CAST (elements->data);
|
||||
elements = g_list_next (elements);
|
||||
if (GST_FLAG_IS_SET (entry, GST_ELEMENT_DECOUPLED)) {
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "entry \"%s\" is DECOUPLED, skipping\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "entry \"%s\" is DECOUPLED, skipping",
|
||||
GST_ELEMENT_NAME (entry));
|
||||
entry = NULL;
|
||||
}
|
||||
else if (GST_FLAG_IS_SET (entry, GST_ELEMENT_INFINITE_LOOP)) {
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "entry \"%s\" is not valid, skipping\n",
|
||||
GST_DEBUG (GST_CAT_SCHEDULING, "entry \"%s\" is not valid, skipping",
|
||||
GST_ELEMENT_NAME (entry));
|
||||
entry = NULL;
|
||||
}
|
||||
|
@ -1204,7 +1204,7 @@ gst_standard_scheduler_iterate (GstScheduler * sched)
|
|||
|
||||
GST_FLAG_SET (entry, GST_ELEMENT_COTHREAD_STOPPING);
|
||||
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "set COTHREAD_STOPPING flag on \"%s\"(@%p)\n",
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "set COTHREAD_STOPPING flag on \"%s\"(@%p)",
|
||||
GST_ELEMENT_NAME (entry), entry);
|
||||
if (GST_ELEMENT_THREADSTATE (entry)) {
|
||||
sched_switch (GST_ELEMENT_THREADSTATE (entry));
|
||||
|
@ -1213,7 +1213,7 @@ gst_standard_scheduler_iterate (GstScheduler * sched)
|
|||
return GST_SCHEDULER_STATE_RUNNING;
|
||||
}
|
||||
else {
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "cothread switch not possible, element has no threadstate\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "cothread switch not possible, element has no threadstate");
|
||||
return GST_SCHEDULER_STATE_ERROR;
|
||||
}
|
||||
|
||||
|
@ -1225,7 +1225,7 @@ gst_standard_scheduler_iterate (GstScheduler * sched)
|
|||
* if it was, return to gstthread.c::gst_thread_main_loop() to
|
||||
* execute the state change.
|
||||
*/
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "cothread switch ended or interrupted\n");
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "cothread switch ended or interrupted");
|
||||
|
||||
if (state != GST_SCHEDULER_STATE_RUNNING) {
|
||||
GST_INFO (GST_CAT_DATAFLOW, "scheduler is not running, in state %d", state);
|
||||
|
@ -1243,7 +1243,7 @@ gst_standard_scheduler_iterate (GstScheduler * sched)
|
|||
}
|
||||
}
|
||||
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "leaving (%s)\n", GST_ELEMENT_NAME (bin));
|
||||
GST_DEBUG (GST_CAT_DATAFLOW, "leaving (%s)", GST_ELEMENT_NAME (bin));
|
||||
if (scheduled == 0) {
|
||||
GST_INFO (GST_CAT_DATAFLOW, "nothing was scheduled, return STOPPED");
|
||||
return GST_SCHEDULER_STATE_STOPPED;
|
||||
|
|
|
@ -38,7 +38,7 @@ plugin_init (GModule *module, GstPlugin *plugin)
|
|||
|
||||
factory = gst_typefactory_new (&_definitions[i]);
|
||||
gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
|
||||
GST_DEBUG(0, "added factory #%d '%s'\n", i, _definitions[i].name);
|
||||
GST_DEBUG(0, "added factory #%d '%s'", i, _definitions[i].name);
|
||||
i++;
|
||||
}
|
||||
|
||||
|
|
|
@ -164,19 +164,19 @@ gst_dparam_set_property (GObject *object, guint prop_id, const GValue *value, GP
|
|||
|
||||
switch (prop_id) {
|
||||
case ARG_VALUE_FLOAT:
|
||||
GST_DEBUG(GST_CAT_PARAMS, "setting value from %f to %f\n", dparam->value_float, g_value_get_float (value));
|
||||
GST_DEBUG(GST_CAT_PARAMS, "setting value from %f to %f", dparam->value_float, g_value_get_float (value));
|
||||
dparam->value_float = g_value_get_float (value);
|
||||
GST_DPARAM_READY_FOR_UPDATE(dparam) = TRUE;
|
||||
break;
|
||||
|
||||
case ARG_VALUE_INT:
|
||||
GST_DEBUG(GST_CAT_PARAMS, "setting value from %d to %d\n", dparam->value_int, g_value_get_int (value));
|
||||
GST_DEBUG(GST_CAT_PARAMS, "setting value from %d to %d", dparam->value_int, g_value_get_int (value));
|
||||
dparam->value_int = g_value_get_int (value);
|
||||
GST_DPARAM_READY_FOR_UPDATE(dparam) = TRUE;
|
||||
break;
|
||||
|
||||
case ARG_VALUE_INT64:
|
||||
GST_DEBUG(GST_CAT_PARAMS, "setting value from %lld to %lld\n", dparam->value_int64, g_value_get_int64 (value));
|
||||
GST_DEBUG(GST_CAT_PARAMS, "setting value from %lld to %lld", dparam->value_int64, g_value_get_int64 (value));
|
||||
dparam->value_int64 = g_value_get_int (value);
|
||||
GST_DPARAM_READY_FOR_UPDATE(dparam) = TRUE;
|
||||
break;
|
||||
|
@ -193,7 +193,7 @@ gst_dparam_do_update_default (GstDParam *dparam, gint64 timestamp, GValue *value
|
|||
GST_DPARAM_LOCK(dparam);
|
||||
|
||||
g_return_if_fail (G_VALUE_TYPE(value) == GST_DPARAM_TYPE(dparam));
|
||||
GST_DEBUG(GST_CAT_PARAMS, "updating value for %s(%p)\n",GST_DPARAM_NAME (dparam),dparam);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "updating value for %s(%p)",GST_DPARAM_NAME (dparam),dparam);
|
||||
|
||||
switch (G_VALUE_TYPE(value)) {
|
||||
case G_TYPE_FLOAT:
|
||||
|
@ -252,7 +252,7 @@ gst_dparam_attach (GstDParam *dparam, GstDParamManager *manager, GParamSpec *par
|
|||
GST_DPARAM_MANAGER(dparam) = manager;
|
||||
dparam->is_log = is_log;
|
||||
dparam->is_rate = is_rate;
|
||||
GST_DEBUG(GST_CAT_PARAMS, "attaching %s to dparam %p\n",GST_DPARAM_NAME (dparam),dparam);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "attaching %s to dparam %p",GST_DPARAM_NAME (dparam),dparam);
|
||||
|
||||
}
|
||||
|
||||
|
@ -269,7 +269,7 @@ gst_dparam_detach (GstDParam *dparam)
|
|||
g_return_if_fail (dparam != NULL);
|
||||
g_return_if_fail (GST_IS_DPARAM (dparam));
|
||||
|
||||
GST_DEBUG(GST_CAT_PARAMS, "detaching %s from dparam %p\n",GST_DPARAM_NAME (dparam),dparam);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "detaching %s from dparam %p",GST_DPARAM_NAME (dparam),dparam);
|
||||
|
||||
GST_DPARAM_NAME(dparam) = NULL;
|
||||
GST_DPARAM_PARAM_SPEC(dparam) = NULL;
|
||||
|
|
|
@ -157,7 +157,7 @@ gst_dpsmooth_set_property (GObject *object, guint prop_id, const GValue *value,
|
|||
|
||||
case ARG_SLOPE_TIME:
|
||||
dpsmooth->slope_time = g_value_get_int64 (value);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "dpsmooth->slope_time:%lld\n",dpsmooth->slope_time);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "dpsmooth->slope_time:%lld",dpsmooth->slope_time);
|
||||
GST_DPARAM_READY_FOR_UPDATE(dparam) = TRUE;
|
||||
break;
|
||||
|
||||
|
@ -208,20 +208,20 @@ gst_dpsmooth_time_since_last_update(GstDParam *dparam, gint64 timestamp)
|
|||
last_update_diff = timestamp - dpsmooth->last_update_timestamp;
|
||||
time_diff = MIN(dpsmooth->update_period, last_update_diff);
|
||||
|
||||
GST_DEBUG(GST_CAT_PARAMS, "last_update_diff:%lld\n",last_update_diff);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "time_diff:%lld\n",time_diff);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "last_update_diff:%lld",last_update_diff);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "time_diff:%lld",time_diff);
|
||||
|
||||
dpsmooth->last_update_timestamp = GST_DPARAM_NEXT_UPDATE_TIMESTAMP(dparam);
|
||||
if(GST_DPARAM_NEXT_UPDATE_TIMESTAMP(dparam) <= timestamp && dpsmooth->update_period > 0LL){
|
||||
|
||||
GST_DEBUG(GST_CAT_PARAMS, "dpsmooth->update_period:%lld\n",dpsmooth->update_period);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "dpsmooth->update_period:%lld",dpsmooth->update_period);
|
||||
num_update_periods = last_update_diff / dpsmooth->update_period;
|
||||
|
||||
GST_DEBUG(GST_CAT_PARAMS, "num_update_periods:%lld\n",num_update_periods);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "num_update_periods:%lld",num_update_periods);
|
||||
|
||||
GST_DPARAM_NEXT_UPDATE_TIMESTAMP(dparam) = dpsmooth->update_period * (num_update_periods + 1LL);
|
||||
}
|
||||
GST_DEBUG(GST_CAT_PARAMS, "last:%lld current:%lld next:%lld\n",
|
||||
GST_DEBUG(GST_CAT_PARAMS, "last:%lld current:%lld next:%lld",
|
||||
dpsmooth->last_update_timestamp, timestamp, GST_DPARAM_NEXT_UPDATE_TIMESTAMP(dparam));
|
||||
return time_diff;
|
||||
}
|
||||
|
@ -248,7 +248,7 @@ gst_dpsmooth_do_update_float (GstDParam *dparam, gint64 timestamp, GValue *value
|
|||
|
||||
max_change = time_ratio * dpsmooth->slope_delta_float;
|
||||
|
||||
GST_DEBUG(GST_CAT_PARAMS, "target:%f current:%f max_change:%f \n",
|
||||
GST_DEBUG(GST_CAT_PARAMS, "target:%f current:%f max_change:%f ",
|
||||
target, current, max_change);
|
||||
|
||||
if (GST_DPARAM_IS_LOG(dparam)){
|
||||
|
@ -262,8 +262,8 @@ gst_dpsmooth_do_update_float (GstDParam *dparam, gint64 timestamp, GValue *value
|
|||
current_log = log(current);
|
||||
current_diff = ABS(current_log - log(target));
|
||||
|
||||
GST_DEBUG(GST_CAT_PARAMS, "current_log:%f\n",current_log);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "current_diff:%f\n",current_diff);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "current_log:%f",current_log);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "current_diff:%f",current_diff);
|
||||
|
||||
if (current_diff > max_change)
|
||||
final_val = (target < current) ? exp(current_log-max_change) : exp(current_log+max_change);
|
||||
|
@ -285,7 +285,7 @@ gst_dpsmooth_do_update_float (GstDParam *dparam, gint64 timestamp, GValue *value
|
|||
g_value_set_float(value, final_val);
|
||||
|
||||
|
||||
GST_DEBUG(GST_CAT_PARAMS, "target:%f current:%f final:%f actual:%f\n", target, current, final_val, g_value_get_float(value));
|
||||
GST_DEBUG(GST_CAT_PARAMS, "target:%f current:%f final:%f actual:%f", target, current, final_val, g_value_get_float(value));
|
||||
|
||||
GST_DPARAM_UNLOCK(dparam);
|
||||
}
|
||||
|
|
|
@ -160,7 +160,7 @@ gst_dpman_add_required_dparam_callback (GstDParamManager *dpman,
|
|||
|
||||
g_return_val_if_fail (dpwrap != NULL, FALSE);
|
||||
|
||||
GST_DEBUG(GST_CAT_PARAMS,"adding required callback dparam '%s'\n", g_param_spec_get_name(param_spec));
|
||||
GST_DEBUG(GST_CAT_PARAMS,"adding required callback dparam '%s'", g_param_spec_get_name(param_spec));
|
||||
|
||||
dpwrap->update_func = update_func;
|
||||
dpwrap->update_data = update_data;
|
||||
|
@ -192,7 +192,7 @@ gst_dpman_add_required_dparam_direct (GstDParamManager *dpman,
|
|||
|
||||
g_return_val_if_fail (dpwrap != NULL, FALSE);
|
||||
|
||||
GST_DEBUG(GST_CAT_PARAMS,"adding required direct dparam '%s'\n", g_param_spec_get_name(param_spec));
|
||||
GST_DEBUG(GST_CAT_PARAMS,"adding required direct dparam '%s'", g_param_spec_get_name(param_spec));
|
||||
|
||||
dpwrap->update_data = update_data;
|
||||
|
||||
|
@ -224,7 +224,7 @@ gst_dpman_add_required_dparam_array (GstDParamManager *dpman,
|
|||
|
||||
g_return_val_if_fail (dpwrap != NULL, FALSE);
|
||||
|
||||
GST_DEBUG(GST_CAT_PARAMS,"adding required array dparam '%s'\n", g_param_spec_get_name(param_spec));
|
||||
GST_DEBUG(GST_CAT_PARAMS,"adding required array dparam '%s'", g_param_spec_get_name(param_spec));
|
||||
|
||||
dpwrap->update_data = update_data;
|
||||
|
||||
|
@ -251,7 +251,7 @@ gst_dpman_remove_required_dparam (GstDParamManager *dpman, gchar *dparam_name)
|
|||
g_return_if_fail(dpwrap != NULL);
|
||||
g_return_if_fail(dpwrap->dparam == NULL);
|
||||
|
||||
GST_DEBUG(GST_CAT_PARAMS, "removing required dparam: %s\n", dparam_name);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "removing required dparam: %s", dparam_name);
|
||||
|
||||
g_hash_table_remove(GST_DPMAN_DPARAMS(dpman), dparam_name);
|
||||
GST_DPMAN_DPARAMS_LIST(dpman) = g_slist_remove(GST_DPMAN_DPARAMS_LIST(dpman), dpwrap);
|
||||
|
@ -428,7 +428,7 @@ gst_dpman_register_mode (GstDParamManagerClass *klass,
|
|||
mode->teardownfunc = teardownfunc;
|
||||
|
||||
g_hash_table_insert(klass->modes, modename, mode);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "mode '%s' registered\n", modename);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "mode '%s' registered", modename);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -454,11 +454,11 @@ gst_dpman_set_mode(GstDParamManager *dpman, gchar *modename)
|
|||
g_return_val_if_fail (mode != NULL, FALSE);
|
||||
|
||||
if (GST_DPMAN_MODE(dpman) == mode) {
|
||||
GST_DEBUG(GST_CAT_PARAMS, "mode %s already set\n", modename);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "mode %s already set", modename);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
GST_DEBUG(GST_CAT_PARAMS, "setting mode to %s\n", modename);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "setting mode to %s", modename);
|
||||
if (GST_DPMAN_MODE(dpman) && GST_DPMAN_TEARDOWNFUNC(dpman)){
|
||||
GST_DPMAN_TEARDOWNFUNC(dpman)(dpman);
|
||||
}
|
||||
|
@ -581,7 +581,7 @@ gst_dpman_state_change (GstElement *element, gint old_state, gint new_state, Gst
|
|||
g_return_if_fail (GST_IS_DPMAN (dpman));
|
||||
|
||||
if (new_state == GST_STATE_PLAYING){
|
||||
GST_DEBUG(GST_CAT_PARAMS, "initialising params\n");
|
||||
GST_DEBUG(GST_CAT_PARAMS, "initialising params");
|
||||
|
||||
/* force all params to be updated */
|
||||
dwraps = GST_DPMAN_DPARAMS_LIST(dpman);
|
||||
|
@ -609,7 +609,7 @@ gst_dpman_caps_changed (GstPad *pad, GstCaps *caps, GstDParamManager *dpman)
|
|||
|
||||
GST_DPMAN_RATE(dpman) = gst_caps_get_int (caps, "rate");
|
||||
|
||||
GST_DEBUG(GST_CAT_PARAMS, "got caps change %d\n", GST_DPMAN_RATE(dpman));
|
||||
GST_DEBUG(GST_CAT_PARAMS, "got caps change %d", GST_DPMAN_RATE(dpman));
|
||||
}
|
||||
|
||||
static guint
|
||||
|
@ -636,7 +636,7 @@ gst_dpman_preprocess_synchronous(GstDParamManager *dpman, guint frames, gint64 t
|
|||
/* direct method - set the value directly in the struct of the element */
|
||||
case GST_DPMAN_DIRECT:
|
||||
GST_DPARAM_DO_UPDATE(dparam, timestamp, dpwrap->value);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "doing direct update\n");
|
||||
GST_DEBUG(GST_CAT_PARAMS, "doing direct update");
|
||||
switch (G_VALUE_TYPE(dpwrap->value)){
|
||||
case G_TYPE_INT:
|
||||
*(gint*)dpwrap->update_data = g_value_get_int(dpwrap->value);
|
||||
|
@ -655,14 +655,14 @@ gst_dpman_preprocess_synchronous(GstDParamManager *dpman, guint frames, gint64 t
|
|||
/* callback method - call the element's callback so it can do what it likes */
|
||||
case GST_DPMAN_CALLBACK:
|
||||
GST_DPARAM_DO_UPDATE(dparam, timestamp, dpwrap->value);
|
||||
GST_DEBUG(GST_CAT_PARAMS, "doing callback update\n");
|
||||
GST_DEBUG(GST_CAT_PARAMS, "doing callback update");
|
||||
GST_DPMAN_DO_UPDATE(dpwrap);
|
||||
break;
|
||||
|
||||
/* array method - generate an array of the right size */
|
||||
/* with each value being the same (in synchronous update mode) */
|
||||
case GST_DPMAN_ARRAY:
|
||||
GST_DEBUG(GST_CAT_PARAMS, "doing array update\n");
|
||||
GST_DEBUG(GST_CAT_PARAMS, "doing array update");
|
||||
switch (G_VALUE_TYPE(dpwrap->value)){
|
||||
case G_TYPE_INT:
|
||||
break;
|
||||
|
|
|
@ -50,7 +50,7 @@ unsigned long _gst_get1bit_int(gst_getbits_t *gb, unsigned long bits) {
|
|||
gb->ptr += (gb->bits>>3);
|
||||
gb->bits &= 0x7;
|
||||
|
||||
GST_DEBUG (0,"getbits%ld, %08x\n", bits, rval);
|
||||
GST_DEBUG (0,"getbits%ld, %08x", bits, rval);
|
||||
return rval>>7;
|
||||
}
|
||||
|
||||
|
@ -68,7 +68,7 @@ unsigned long _gst_getbits_int(gst_getbits_t *gb, unsigned long bits) {
|
|||
gb->ptr += (gb->bits>>3);
|
||||
gb->bits &= 0x7;
|
||||
|
||||
GST_DEBUG (0,"getbits%ld, %08lx\n", bits, rval);
|
||||
GST_DEBUG (0,"getbits%ld, %08lx", bits, rval);
|
||||
return rval;
|
||||
}
|
||||
|
||||
|
@ -84,7 +84,7 @@ unsigned long _gst_getbits_fast_int(gst_getbits_t *gb, unsigned long bits) {
|
|||
gb->ptr += (gb->bits>>3);
|
||||
gb->bits &= 0x7;
|
||||
|
||||
GST_DEBUG (0,"getbits%ld, %08lx\n", bits, rval);
|
||||
GST_DEBUG (0,"getbits%ld, %08lx", bits, rval);
|
||||
return rval;
|
||||
}
|
||||
|
||||
|
@ -97,7 +97,7 @@ unsigned long _gst_showbits_int(gst_getbits_t *gb, unsigned long bits) {
|
|||
rval <<= gb->bits;
|
||||
rval >>= (32-bits);
|
||||
|
||||
GST_DEBUG (0,"showbits%ld, %08lx\n", bits, rval);
|
||||
GST_DEBUG (0,"showbits%ld, %08lx", bits, rval);
|
||||
return rval;
|
||||
}
|
||||
|
||||
|
@ -105,7 +105,7 @@ void _gst_flushbits_int(gst_getbits_t *gb, unsigned long bits) {
|
|||
gb->bits += bits;
|
||||
gb->ptr += (gb->bits>>3);
|
||||
gb->bits &= 0x7;
|
||||
GST_DEBUG (0,"flushbits%ld\n", bits);
|
||||
GST_DEBUG (0,"flushbits%ld", bits);
|
||||
}
|
||||
|
||||
void _gst_getbits_back_int(gst_getbits_t *gb, unsigned long bits) {
|
||||
|
|
|
@ -122,7 +122,7 @@ gst_fdsink_chain (GstPad *pad, GstBuffer *buf)
|
|||
g_return_if_fail (fdsink->fd >= 0);
|
||||
|
||||
if (GST_BUFFER_DATA (buf)) {
|
||||
GST_DEBUG (0,"writing %d bytes to file descriptor %d\n",GST_BUFFER_SIZE (buf), fdsink->fd);
|
||||
GST_DEBUG (0,"writing %d bytes to file descriptor %d",GST_BUFFER_SIZE (buf), fdsink->fd);
|
||||
write (fdsink->fd, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
|
||||
}
|
||||
|
||||
|
|
|
@ -559,7 +559,7 @@ gst_filesrc_open_file (GstFileSrc *src)
|
|||
{
|
||||
g_return_val_if_fail (!GST_FLAG_IS_SET (src ,GST_FILESRC_OPEN), FALSE);
|
||||
|
||||
GST_DEBUG(0, "opening file %s\n",src->filename);
|
||||
GST_DEBUG(0, "opening file %s",src->filename);
|
||||
|
||||
/* open the file */
|
||||
src->fd = open (src->filename, O_RDONLY);
|
||||
|
|
|
@ -140,7 +140,7 @@ gst_pipefilter_handle_event (GstPad *pad, GstEvent *event)
|
|||
|
||||
pipefilter = GST_PIPEFILTER (gst_pad_get_parent (pad));
|
||||
|
||||
GST_DEBUG (0,"pipefilter: %s received event\n", GST_ELEMENT_NAME (pipefilter));
|
||||
GST_DEBUG (0,"pipefilter: %s received event", GST_ELEMENT_NAME (pipefilter));
|
||||
if (close (pipefilter->fdin[1]) < 0)
|
||||
perror("close");
|
||||
if (close (pipefilter->fdout[0]) < 0)
|
||||
|
@ -170,9 +170,9 @@ gst_pipefilter_get (GstPad *pad)
|
|||
g_return_val_if_fail(GST_BUFFER_DATA(newbuf) != NULL, NULL);
|
||||
|
||||
/* read it in from the file */
|
||||
GST_DEBUG (0,"attemting to read %ld bytes\n", pipefilter->bytes_per_read);
|
||||
GST_DEBUG (0,"attemting to read %ld bytes", pipefilter->bytes_per_read);
|
||||
readbytes = read(pipefilter->fdout[0], GST_BUFFER_DATA(newbuf), pipefilter->bytes_per_read);
|
||||
GST_DEBUG (0,"read %ld bytes\n", readbytes);
|
||||
GST_DEBUG (0,"read %ld bytes", readbytes);
|
||||
if (readbytes < 0) {
|
||||
perror("read");
|
||||
gst_element_error(GST_ELEMENT(pipefilter),"reading");
|
||||
|
@ -208,9 +208,9 @@ gst_pipefilter_chain (GstPad *pad,GstBuffer *buf)
|
|||
data = GST_BUFFER_DATA(buf);
|
||||
size = GST_BUFFER_SIZE(buf);
|
||||
|
||||
GST_DEBUG (0,"attemting to write %ld bytes\n", size);
|
||||
GST_DEBUG (0,"attemting to write %ld bytes", size);
|
||||
writebytes = write(pipefilter->fdin[1],data,size);
|
||||
GST_DEBUG (0,"written %ld bytes\n", writebytes);
|
||||
GST_DEBUG (0,"written %ld bytes", writebytes);
|
||||
if (writebytes < 0) {
|
||||
perror("write");
|
||||
gst_element_error(GST_ELEMENT(pipefilter),"writing");
|
||||
|
|
|
@ -10,7 +10,7 @@ gst_play_have_type (GstElement *typefind, GstCaps *caps, GstElement *pipeline)
|
|||
GstElement *filesrc;
|
||||
GstElement *cache;
|
||||
|
||||
GST_DEBUG (0,"GstPipeline: play have type\n");
|
||||
GST_DEBUG (0,"GstPipeline: play have type");
|
||||
|
||||
gst_element_set_state (pipeline, GST_STATE_PAUSED);
|
||||
|
||||
|
|
|
@ -10,7 +10,7 @@ gst_play_have_type (GstElement *typefind, GstCaps *caps, GstElement *pipeline)
|
|||
GstElement *filesrc;
|
||||
GstElement *cache;
|
||||
|
||||
GST_DEBUG (0,"GstPipeline: play have type\n");
|
||||
GST_DEBUG (0,"GstPipeline: play have type");
|
||||
|
||||
gst_element_set_state (pipeline, GST_STATE_PAUSED);
|
||||
|
||||
|
|
|
@ -47,7 +47,7 @@ gst_play_typefind (GstBin *bin, GstElement *element)
|
|||
GstElement *pipeline;
|
||||
GstCaps *caps = NULL;
|
||||
|
||||
GST_DEBUG (0,"GstPipeline: typefind for element \"%s\"\n",
|
||||
GST_DEBUG (0,"GstPipeline: typefind for element \"%s\"",
|
||||
GST_ELEMENT_NAME(element));
|
||||
|
||||
pipeline = gst_pipeline_new ("autoplug_pipeline");
|
||||
|
@ -242,7 +242,7 @@ create_input_channel (int id, char* location)
|
|||
GstElement *new_element;
|
||||
GstElement *decoder;
|
||||
|
||||
GST_DEBUG (0, "c_i_p : creating channel with id %d for file %s\n",
|
||||
GST_DEBUG (0, "c_i_p : creating channel with id %d for file %s",
|
||||
id, location);
|
||||
|
||||
/* allocate channel */
|
||||
|
@ -256,7 +256,7 @@ create_input_channel (int id, char* location)
|
|||
|
||||
/* create channel */
|
||||
|
||||
GST_DEBUG (0, "c_i_p : creating pipeline\n");
|
||||
GST_DEBUG (0, "c_i_p : creating pipeline");
|
||||
|
||||
sprintf (buffer, "pipeline%d", id);
|
||||
channel->pipe = gst_bin_new (buffer);
|
||||
|
@ -264,13 +264,13 @@ create_input_channel (int id, char* location)
|
|||
|
||||
/* create elements */
|
||||
|
||||
GST_DEBUG(0, "c_i_p : creating filesrc\n");
|
||||
GST_DEBUG(0, "c_i_p : creating filesrc");
|
||||
|
||||
sprintf (buffer, "filesrc%d", id);
|
||||
channel->filesrc = gst_elementfactory_make ("filesrc", buffer);
|
||||
g_assert(channel->filesrc != NULL);
|
||||
|
||||
GST_DEBUG(0, "c_i_p : setting location\n");
|
||||
GST_DEBUG(0, "c_i_p : setting location");
|
||||
g_object_set(G_OBJECT(channel->filesrc),"location", location, NULL);
|
||||
|
||||
/* add filesrc to the bin before autoplug */
|
||||
|
|
|
@ -42,7 +42,7 @@ int main(int argc,char *argv[]) {
|
|||
xmlNewChild (factorynode, NULL, "name", gst_object_get_name (GST_OBJECT (factory)));
|
||||
|
||||
element = gst_elementfactory_create(factory,"element");
|
||||
GST_DEBUG(GST_CAT_PLUGIN_LOADING, "adding factory %s\n",
|
||||
GST_DEBUG(GST_CAT_PLUGIN_LOADING, "adding factory %s",
|
||||
gst_object_get_name (GST_OBJECT (factory)));
|
||||
if (element == NULL) {
|
||||
fprintf(stderr,"couldn't construct element from factory %s\n",
|
||||
|
|
Loading…
Reference in a new issue