+2004-03-15 Thomas Vander Stichele <thomas at apestaart dot org>
+
+ * *.c,*.h: don't mix tabs and spaces
+
2004-03-15 Johan Dahlin <johan@gnome.org>
* gst/schedulers/gstoptimalscheduler.c
BonoboUIComponent *uic;
GstPlay *play;
-} control_data_t;
+}
+control_data_t;
/*
* This callback is invoked when the BonoboControl object
{
control_data_t *control_data;
GtkFileSelection *selector;
-} file_select_struct;
+}
+file_select_struct;
static void
filename_selected (GtkButton * ok, gpointer user_data)
data->control_data = control_data;
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->
- ok_button), "clicked", GTK_SIGNAL_FUNC (filename_selected), data);
+ ok_button), "clicked", GTK_SIGNAL_FUNC (filename_selected), data);
gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->
- ok_button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ ok_button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy),
(gpointer) file_selector);
gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->
- cancel_button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ cancel_button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy),
(gpointer) file_selector);
gtk_widget_show (file_selector);
node = bonobo_ui_node_from_string (ui);
bonobo_ui_util_translate_ui (node);
bonobo_ui_util_fixup_help (control_data->uic, node,
- DATADIR, "gstmediaplay");
+ DATADIR, "gstmediaplay");
bonobo_ui_component_set_tree (control_data->uic, "/", node, NULL);
gboolean cut_start_signalled = FALSE;
gboolean cut_stop_signalled = FALSE;
-int id = 0; /* increment this for each new cut */
+int id = 0; /* increment this for each new cut */
GstElement *main_bin;
GstElement *audiosrc;
GstElement *queue;
ct = localtime (&seconds);
/* sprintf (buffer, "/news/incoming/audio/cutter.%06d.wav", id); */
sprintf (buffer,
- "/news/incoming/audio/cutter.%04d%02d%02d.%02d%02d%02d.wav",
- ct->tm_year + 1900, ct->tm_mon, ct->tm_mday, ct->tm_hour, ct->tm_min,
- ct->tm_sec);
+ "/news/incoming/audio/cutter.%04d%02d%02d.%02d%02d%02d.wav",
+ ct->tm_year + 1900, ct->tm_mon, ct->tm_mday, ct->tm_hour, ct->tm_min,
+ ct->tm_sec);
}
g_print ("DEBUG: cut_start: setting new location to %s\n", buffer);
g_object_set (G_OBJECT (disksink), "location", buffer, NULL);
return -1;
}
- pipeline =
- (GstElement *)
+ pipeline = (GstElement *)
gst_parse_launch ("filesrc name=my_filesrc ! mad ! osssink", &error);
if (!pipeline) {
fprintf (stderr, "Parse error: %s", error->message);
char buffer[20];
- GList *input_channels; /* structure holding all the input channels */
+ GList *input_channels; /* structure holding all the input channels */
input_channel_t *channel_in;
GstElement *adder;
GstElement *audiosink;
- GstPad *pad; /* to request pads for the adder */
+ GstPad *pad; /* to request pads for the adder */
gst_init (&argc, &argv);
/* first song gets special treatment for end style */
env_register_cp (channel_in->volenv, 0.0, 1.0);
} else {
- env_register_cp (channel_in->volenv, 0.0, 0.0000001); /* start muted */
- env_register_cp (channel_in->volenv, i * 10.0 - 15.0, 0.0000001); /* start fade in */
+ env_register_cp (channel_in->volenv, 0.0, 0.0000001); /* start muted */
+ env_register_cp (channel_in->volenv, i * 10.0 - 15.0, 0.0000001); /* start fade in */
env_register_cp (channel_in->volenv, i * 10.0 - 10.0, 1.0);
}
- env_register_cp (channel_in->volenv, i * 10.0 - 5.0, 1.0); /* end of full level */
+ env_register_cp (channel_in->volenv, i * 10.0 - 5.0, 1.0); /* end of full level */
if (i != num_channels) {
- env_register_cp (channel_in->volenv, i * 10.0, 0.0000001); /* fade to black */
- env_register_cp (channel_in->volenv, num_channels * 10.0 - 5.0, 0.0000001); /* start fade in */
+ env_register_cp (channel_in->volenv, i * 10.0, 0.0000001); /* fade to black */
+ env_register_cp (channel_in->volenv, num_channels * 10.0 - 5.0, 0.0000001); /* start fade in */
}
- env_register_cp (channel_in->volenv, num_channels * 10.0, 1.0 / num_channels); /* to end level */
+ env_register_cp (channel_in->volenv, num_channels * 10.0, 1.0 / num_channels); /* to end level */
#ifndef GST_DISABLE_LOADSAVE
gst_xml_write_file (GST_ELEMENT (main_bin), fopen ("mixer.xml", "w"));
input_channel_t *channel;
- char buffer[20]; /* hold the names */
+ char buffer[20]; /* hold the names */
/* GstAutoplug *autoplug;
GstCaps *srccaps; */
* can have. They can be quite complex, but for this example plugin
* they are rather simple.
*/
-GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink", /* The name of the pad */
- GST_PAD_SINK, /* Direction of the pad */
- GST_PAD_ALWAYS, /* The pad exists for every instance */
- GST_STATIC_CAPS ("unknown/unknown, " /* The MIME media type */
- "foo:int=1, " /* an integer property */
- "bar:boolean=true, " /* a boolean property */
- "baz:int={ 1, 3 }" /* a list of values */
+GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink", /* The name of the pad */
+ GST_PAD_SINK, /* Direction of the pad */
+ GST_PAD_ALWAYS, /* The pad exists for every instance */
+ GST_STATIC_CAPS ("unknown/unknown, " /* The MIME media type */
+ "foo:int=1, " /* an integer property */
+ "bar:boolean=true, " /* a boolean property */
+ "baz:int={ 1, 3 }" /* a list of values */
)
);
0,
(GInstanceInitFunc) gst_example_init,
};
+
example_type =
- g_type_register_static (GST_TYPE_ELEMENT, "GstExample", &example_info,
- 0);
+ g_type_register_static (GST_TYPE_ELEMENT, "GstExample", &example_info,
+ 0);
}
return example_type;
}
/* Here we add an argument to the object. This argument is an integer,
* and can be both read and written.
*/
- g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ACTIVE, g_param_spec_int ("active", "active", "active", G_MININT, G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
+ g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ACTIVE, g_param_spec_int ("active", "active", "active", G_MININT, G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
/* Here we add a signal to the object. This is avery useless signal
* called asdf. The signal will also pass a pointer to the listeners
/* Then copy the data in the incoming buffer into the new buffer. */
memcpy (GST_BUFFER_DATA (outbuf), GST_BUFFER_DATA (buf),
- GST_BUFFER_SIZE (outbuf));
+ GST_BUFFER_SIZE (outbuf));
/* we don't need the incomming buffer anymore so we unref it. When we are
* the last plugin with a handle to the buffer, its memory will be freed */
* when compared to similar plugins and the GType identifier.
*/
if (!gst_element_register (plugin, "example", GST_RANK_MARGINAL,
- GST_TYPE_EXAMPLE))
+ GST_TYPE_EXAMPLE))
return FALSE;
/* Now we can return successfully. */
* The symbol pointing to this structure is the only symbol looked up when
* loading the plugin.
*/
-GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, /* The major version of the core that this was built with */
- GST_VERSION_MINOR, /* The minor version of the core that this was built with */
- "example", /* The name of the plugin. This must be unique: plugins with
- * the same name will be assumed to be identical, and only
- * one will be loaded. */
- "an example plugin", /* a short description of the plugin in English */
- plugin_init, /* Pointer to the initialisation function for the plugin. */
- "0.1", /* The version number of the plugin */
- "LGPL", /* ieffective license the plugin can be shipped with. Must be
- * valid for all libraries it links to, too. */
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, /* The major version of the core that this was built with */
+ GST_VERSION_MINOR, /* The minor version of the core that this was built with */
+ "example", /* The name of the plugin. This must be unique: plugins with
+ * the same name will be assumed to be identical, and only
+ * one will be loaded. */
+ "an example plugin", /* a short description of the plugin in English */
+ plugin_init, /* Pointer to the initialisation function for the plugin. */
+ "0.1", /* The version number of the plugin */
+ "LGPL", /* ieffective license the plugin can be shipped with. Must be
+ * valid for all libraries it links to, too. */
"my nifty plugin package",
/* package this plugin belongs to. */
"http://www.mydomain.com"
g_assert (filesink);
/* set the filenames */
- filename = g_strdup_printf ("%s.temp", argv[1]); /* easy solution */
+ filename = g_strdup_printf ("%s.temp", argv[1]); /* easy solution */
g_object_set (G_OBJECT (filesrc), "location", argv[1], NULL);
g_object_set (G_OBJECT (filesink), "location", filename, NULL);
g_assert (filesink);
/* set the filenames */
- filename = g_strdup_printf ("%s.ogg", argv[1]); /* easy solution */
+ filename = g_strdup_printf ("%s.ogg", argv[1]); /* easy solution */
g_object_set (G_OBJECT (filesrc), "location", argv[1], NULL);
g_object_set (G_OBJECT (filesink), "location", filename, NULL);
g_free (filename);
xmlNodePtr nodes = children->xmlChildrenNode;
while (nodes) {
- if (!strcmp (nodes->name, "text")) {
- gchar *name = g_strdup (xmlNodeGetContent (nodes));
+ if (!strcmp (nodes->name, "text")) {
+ gchar *name = g_strdup (xmlNodeGetContent (nodes));
- g_print ("object %s loaded with comment '%s'\n",
- gst_object_get_name (object), name);
- }
- nodes = nodes->next;
+ g_print ("object %s loaded with comment '%s'\n",
+ gst_object_get_name (object), name);
+ }
+ nodes = nodes->next;
}
}
children = children->next;
while (templs) {
if ((GST_PAD_TEMPLATE_DIRECTION (templs->data) == GST_PAD_SINK) &&
- gst_autoplug_caps_intersect (src,
- GST_PAD_TEMPLATE_CAPS (templs->data))) {
+ gst_autoplug_caps_intersect (src,
+ GST_PAD_TEMPLATE_CAPS (templs->data))) {
return GST_PAD_TEMPLATE (templs->data);
}
templs = g_list_next (templs);
GstCaps *caps = GST_PAD_TEMPLATE_CAPS (templs->data);
if ((GST_PAD_TEMPLATE_DIRECTION (templs->data) == GST_PAD_SRC) &&
- gst_autoplug_caps_intersect (caps, sink)) {
+ gst_autoplug_caps_intersect (caps, sink)) {
return GST_PAD_TEMPLATE (templs->data);
}
templs = g_list_next (templs);
GstPadTemplate *desttemp = (GstPadTemplate *) desttemps->data;
if (srctemp->direction == GST_PAD_SRC &&
- desttemp->direction == GST_PAD_SINK) {
- if (gst_autoplug_caps_intersect (gst_pad_template_get_caps (srctemp),
- gst_pad_template_get_caps (desttemp))) {
- GST_DEBUG ("factory \"%s\" can connect with factory \"%s\"",
- GST_OBJECT_NAME (src), GST_OBJECT_NAME (dest));
- return desttemp;
- }
+ desttemp->direction == GST_PAD_SINK) {
+ if (gst_autoplug_caps_intersect (gst_pad_template_get_caps (srctemp),
+ gst_pad_template_get_caps (desttemp))) {
+ GST_DEBUG ("factory \"%s\" can connect with factory \"%s\"",
+ GST_OBJECT_NAME (src), GST_OBJECT_NAME (dest));
+ return desttemp;
+ }
}
desttemps = g_list_next (desttemps);
while (factories) {
/* if you want it faster do src/sink check at once, don't call two functions */
if (gst_autoplug_factory_has_src (factories->data)
- && gst_autoplug_factory_has_sink (factories->data))
+ && gst_autoplug_factory_has_sink (factories->data))
ret = g_list_prepend (ret, factories->data);
factories = g_list_next (factories);
}
gboolean have_sink = FALSE;
while (templs) {
- if (GST_PAD_TEMPLATE_DIRECTION (templs->data) == GST_PAD_SRC) {
- have_src = TRUE;
- }
- if ((GST_PAD_TEMPLATE_DIRECTION (templs->data) == GST_PAD_SINK)
- && (GST_PAD_TEMPLATE_CAPS (templs->data) != NULL)) {
- have_sink = TRUE;
- }
- if (have_src && have_sink) {
- ret = g_list_prepend (ret, factory);
- break;
- }
- templs = g_list_next (templs);
+ if (GST_PAD_TEMPLATE_DIRECTION (templs->data) == GST_PAD_SRC) {
+ have_src = TRUE;
+ }
+ if ((GST_PAD_TEMPLATE_DIRECTION (templs->data) == GST_PAD_SINK)
+ && (GST_PAD_TEMPLATE_CAPS (templs->data) != NULL)) {
+ have_sink = TRUE;
+ }
+ if (have_src && have_sink) {
+ ret = g_list_prepend (ret, factory);
+ break;
+ }
+ templs = g_list_next (templs);
}
}
factories = g_list_next (factories);
while (templs) {
if (GST_PAD_TEMPLATE_DIRECTION (templs->data) == dir) {
- count++;
+ count++;
}
if (count > maxtemplates)
- break;
+ break;
templs = g_list_next (templs);
}
if (count <= maxtemplates)
GList * factories)
{
GList *factory_nodes = NULL;
- guint curcost = GST_AUTOPLUG_MAX_COST; /* below this cost, there is no path */
- GstAutoplugNode *bestnode = NULL; /* best (unconnected) endpoint currently */
+ guint curcost = GST_AUTOPLUG_MAX_COST; /* below this cost, there is no path */
+ GstAutoplugNode *bestnode = NULL; /* best (unconnected) endpoint currently */
g_return_val_if_fail (srccaps != NULL, NULL);
g_return_val_if_fail (sinkcaps != NULL, NULL);
GST_DEBUG ("trying with %s", node->fac->details.longname);
node->templ = gst_autoplug_can_connect_src (node->fac, srccaps);
node->cost = (node->templ ? gst_autoplug_get_cost (node->fac)
- : GST_AUTOPLUG_MAX_COST);
+ : GST_AUTOPLUG_MAX_COST);
node->endpoint = gst_autoplug_can_connect_sink (node->fac, sinkcaps);
if (node->templ && node->endpoint)
GST_DEBUG ("%s makes connection possible", node->fac->details.longname);
else
GST_DEBUG ("direct connection with %s not possible",
- node->fac->details.longname);
+ node->fac->details.longname);
if ((node->endpoint != NULL) &&
- ((bestnode == NULL) || (node->cost < bestnode->cost))) {
+ ((bestnode == NULL) || (node->cost < bestnode->cost))) {
bestnode = node;
}
factory_nodes = g_list_prepend (factory_nodes, node);
/* iterate until we found the best path */
while (curcost < GST_AUTOPLUG_MAX_COST) {
GList *nodes = factory_nodes;
- guint nextcost = GST_AUTOPLUG_MAX_COST; /* next cost to check */
+ guint nextcost = GST_AUTOPLUG_MAX_COST; /* next cost to check */
GST_DEBUG ("iterating at current cost %d, bestnode %s at %d", curcost,
- GST_OBJECT_NAME (bestnode->fac), bestnode->cost);
+ 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 ("found a way to connect via %s",
- GST_OBJECT_NAME ((GstObject *) bestnode->fac));
+ GST_OBJECT_NAME ((GstObject *) bestnode->fac));
/* enter all factories into the return list */
ret = g_list_prepend (NULL, bestnode->fac);
bestnode = bestnode->prev;
while (bestnode != NULL) {
- ret = g_list_prepend (ret, bestnode->fac);
- bestnode = bestnode->prev;
+ ret = g_list_prepend (ret, bestnode->fac);
+ bestnode = bestnode->prev;
}
g_list_free_list_and_elements (factory_nodes);
return ret;
*/
while (nodes) {
if (((GstAutoplugNode *) nodes->data)->cost == curcost) {
- /* now check all elements if we got a shorter path */
- GList *sinknodes = factory_nodes;
- GstAutoplugNode *srcnode = (GstAutoplugNode *) nodes->data;
-
- while (sinknodes) {
- GstAutoplugNode *sinknode = (GstAutoplugNode *) sinknodes->data;
- GstPadTemplate *templ;
-
- if ((sinknode->cost >
- srcnode->cost + gst_autoplug_get_cost (sinknode->fac))
- && (templ =
- gst_autoplug_can_match (srcnode->fac, sinknode->fac))) {
- /* we got a shorter path
- * now enter that path to that node */
- sinknode->prev = srcnode;
- sinknode->templ = templ;
- sinknode->cost =
- srcnode->cost + gst_autoplug_get_cost (sinknode->fac);
- /* make sure to set which cost to view next */
- nextcost = (nextcost > sinknode->cost) ? sinknode->cost : nextcost;
- /* did we get a new best node? */
- if (sinknode->endpoint && (sinknode->cost < bestnode->cost)) {
- bestnode = sinknode;
- }
- }
- sinknodes = g_list_next (sinknodes);
- }
- /* FIXME: for speed remove the item we just iterated with from the factory_nodes
- * but don't free it yet and don't forget to free it.
- */
+ /* now check all elements if we got a shorter path */
+ GList *sinknodes = factory_nodes;
+ GstAutoplugNode *srcnode = (GstAutoplugNode *) nodes->data;
+
+ while (sinknodes) {
+ GstAutoplugNode *sinknode = (GstAutoplugNode *) sinknodes->data;
+ GstPadTemplate *templ;
+
+ if ((sinknode->cost >
+ srcnode->cost + gst_autoplug_get_cost (sinknode->fac))
+ && (templ = gst_autoplug_can_match (srcnode->fac, sinknode->fac))) {
+ /* we got a shorter path
+ * now enter that path to that node */
+ sinknode->prev = srcnode;
+ sinknode->templ = templ;
+ sinknode->cost =
+ srcnode->cost + gst_autoplug_get_cost (sinknode->fac);
+ /* make sure to set which cost to view next */
+ nextcost = (nextcost > sinknode->cost) ? sinknode->cost : nextcost;
+ /* did we get a new best node? */
+ if (sinknode->endpoint && (sinknode->cost < bestnode->cost)) {
+ bestnode = sinknode;
+ }
+ }
+ sinknodes = g_list_next (sinknodes);
+ }
+ /* FIXME: for speed remove the item we just iterated with from the factory_nodes
+ * but don't free it yet and don't forget to free it.
+ */
}
nodes = g_list_next (nodes);
}
0,
(GInstanceInitFunc) gst_spider_init,
};
+
spider_type =
- g_type_register_static (GST_TYPE_BIN, "GstSpider", &spider_info, 0);
+ g_type_register_static (GST_TYPE_BIN, "GstSpider", &spider_info, 0);
}
return spider_type;
}
/* properties */
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FACTORIES,
g_param_spec_pointer ("factories", "allowed factories",
- "allowed factories for autoplugging", G_PARAM_READWRITE));
+ "allowed factories for autoplugging", G_PARAM_READWRITE));
gobject_class->set_property = gst_spider_set_property;
gobject_class->get_property = gst_spider_get_property;
case ARG_FACTORIES:
list = (GList *) g_value_get_pointer (value);
while (list) {
- g_return_if_fail (list->data != NULL);
- g_return_if_fail (GST_IS_ELEMENT_FACTORY (list->data));
- list = g_list_next (list);
+ g_return_if_fail (list->data != NULL);
+ g_return_if_fail (GST_IS_ELEMENT_FACTORY (list->data));
+ list = g_list_next (list);
}
g_list_free (spider->factories);
spider->factories = (GList *) g_value_get_pointer (value);
/* try to autoplug the elements */
if (gst_spider_plug_from_srcpad (conn, pad) != GST_PAD_LINK_REFUSED) {
GST_DEBUG ("%s:%s was autoplugged to %s:%s, removing callback",
- GST_DEBUG_PAD_NAME (pad), GST_DEBUG_PAD_NAME (conn->src->sink));
+ GST_DEBUG_PAD_NAME (pad), GST_DEBUG_PAD_NAME (conn->src->sink));
g_signal_handler_disconnect (src, signal_id);
signal_id = 0;
}
factories = spider->factories;
while (factories) {
- if ((padtemp =
- gst_autoplug_can_connect_src (factories->data, src_caps))) {
- const GstCaps *caps = gst_pad_template_get_caps (padtemp);
-
- GST_DEBUG ("can connect src to pad template: %" GST_PTR_FORMAT, caps);
- found = TRUE;
- }
- factories = factories->next;
+ if ((padtemp =
+ gst_autoplug_can_connect_src (factories->data, src_caps))) {
+ const GstCaps *caps = gst_pad_template_get_caps (padtemp);
+
+ GST_DEBUG ("can connect src to pad template: %" GST_PTR_FORMAT, caps);
+ found = TRUE;
+ }
+ factories = factories->next;
}
if (!found) {
- const char *mime;
+ const char *mime;
- mime = gst_structure_get_name (gst_caps_get_structure (src_caps, 0));
+ mime = gst_structure_get_name (gst_caps_get_structure (src_caps, 0));
- GST_ELEMENT_ERROR (spider, STREAM, CODEC_NOT_FOUND,
- (_("There is no element present to handle the stream's mime type %s."), mime), (NULL));
- gst_caps_free (src_caps);
- return;
+ GST_ELEMENT_ERROR (spider, STREAM, CODEC_NOT_FOUND,
+ (_("There is no element present to handle the stream's mime type %s."), mime), (NULL));
+ gst_caps_free (src_caps);
+ return;
}
}
gst_caps_free (src_caps);
if (dir != GST_PAD_DIRECTION (otherpad)) {
/* we only link to plugged in elements */
if (peer->plugged == TRUE) {
- /* plug in the right direction */
- if (dir == GST_PAD_SINK) {
- conn = gst_spider_link_get (peer);
- } else {
- conn = gst_spider_link_get (ident);
- }
- if ((GstElement *) spider->sink_ident == conn->current) {
- gst_spider_plug (conn);
- }
+ /* plug in the right direction */
+ if (dir == GST_PAD_SINK) {
+ conn = gst_spider_link_get (peer);
+ } else {
+ conn = gst_spider_link_get (ident);
+ }
+ if ((GstElement *) spider->sink_ident == conn->current) {
+ gst_spider_plug (conn);
+ }
}
}
padlist = g_list_next (padlist);
templist = g_list_last (plugpath);
element = (GstElement *) conn->src;
while ((plugpath != NULL)
- && (element =
- gst_spider_find_element_to_plug (element,
- (GstElementFactory *) plugpath->data, GST_PAD_SINK))) {
+ && (element =
+ gst_spider_find_element_to_plug (element,
+ (GstElementFactory *) plugpath->data, GST_PAD_SINK))) {
GList *cur = templist;
endelements = g_list_prepend (endelements, element);
/* do the linking */
while (conn->current != (GstElement *) (endelements ==
- NULL ? conn->src : endelements->data)) {
+ NULL ? conn->src : endelements->data)) {
/* get sink element to plug, src is conn->current */
if (plugpath == NULL) {
element =
- (GstElement *) (endelements == NULL ? conn->src : endelements->data);
+ (GstElement *) (endelements == NULL ? conn->src : endelements->data);
} else {
element =
- gst_element_factory_create ((GstElementFactory *) plugpath->data,
- NULL);
+ gst_element_factory_create ((GstElementFactory *) plugpath->data,
+ NULL);
GST_DEBUG
- ("Adding element %s of type %s and syncing state with autoplugger",
- GST_ELEMENT_NAME (element), GST_PLUGIN_FEATURE_NAME (plugpath->data));
+ ("Adding element %s of type %s and syncing state with autoplugger",
+ GST_ELEMENT_NAME (element), GST_PLUGIN_FEATURE_NAME (plugpath->data));
gst_bin_add (GST_BIN (spider), element);
}
/* insert and link new element */
/* remove element that couldn't be linked, if it wasn't the endpoint */
if (element != (GstElement *) conn->src)
- gst_bin_remove (GST_BIN (spider), element);
+ gst_bin_remove (GST_BIN (spider), element);
while (templs) {
- GstPadTemplate *templ = (GstPadTemplate *) templs->data;
-
- if ((GST_PAD_TEMPLATE_DIRECTION (templ) == GST_PAD_SRC)
- && (GST_PAD_TEMPLATE_PRESENCE (templ) == GST_PAD_SOMETIMES)) {
- GST_DEBUG ("adding callback to link 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_link_sometimes), conn);
- g_list_free (plugpath);
- return GST_PAD_LINK_DELAYED;
- }
- templs = g_list_next (templs);
+ GstPadTemplate *templ = (GstPadTemplate *) templs->data;
+
+ if ((GST_PAD_TEMPLATE_DIRECTION (templ) == GST_PAD_SRC)
+ && (GST_PAD_TEMPLATE_PRESENCE (templ) == GST_PAD_SOMETIMES)) {
+ GST_DEBUG ("adding callback to link 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_link_sometimes), conn);
+ g_list_free (plugpath);
+ return GST_PAD_LINK_DELAYED;
+ }
+ templs = g_list_next (templs);
}
GST_DEBUG ("no chance to link element %s to %s",
- GST_ELEMENT_NAME (conn->current), GST_ELEMENT_NAME (conn->src));
+ GST_ELEMENT_NAME (conn->current), GST_ELEMENT_NAME (conn->src));
g_list_free (plugpath);
return GST_PAD_LINK_REFUSED;
}
GST_DEBUG ("added element %s and attached it to element %s",
- GST_ELEMENT_NAME (element), GST_ELEMENT_NAME (conn->current));
+ GST_ELEMENT_NAME (element), GST_ELEMENT_NAME (conn->current));
gst_spider_link_add (conn, element);
if (plugpath != NULL)
plugpath = g_list_delete_link (plugpath, plugpath);
/* is the pad on the right side and is it linked? */
if ((GST_PAD_DIRECTION (pad) == dir)
- && (pad = (GstPad *) (GST_RPAD_PEER (pad)))) {
+ && (pad = (GstPad *) (GST_RPAD_PEER (pad)))) {
/* is the element the pad is linked to of the right type? */
GstElement *element = GST_PAD_PARENT (pad);
if (G_TYPE_FROM_INSTANCE (element) ==
- gst_element_factory_get_element_type (fac)) {
- return element;
+ gst_element_factory_get_element_type (fac)) {
+ return element;
}
}
padlist = g_list_next (padlist);
/* see if they match already */
if (gst_pad_link (srcpad, conn->src->sink)) {
GST_DEBUG ("%s:%s and %s:%s can link directly",
- GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (conn->src->sink));
+ GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (conn->src->sink));
gst_pad_unlink (srcpad, conn->src->sink);
gst_spider_create_and_plug (conn, NULL);
return GST_PAD_LINK_OK;
/* if there is no way to plug: return */
if (plugpath == NULL) {
GST_DEBUG ("no chance to plug from %s to %s",
- GST_ELEMENT_NAME (conn->current), GST_ELEMENT_NAME (conn->src));
+ GST_ELEMENT_NAME (conn->current), GST_ELEMENT_NAME (conn->src));
return GST_PAD_LINK_REFUSED;
}
GST_DEBUG ("found a link that needs %d elements", g_list_length (plugpath));
element = conn->current;
while ((plugpath != NULL)
&& (element =
- gst_spider_find_element_to_plug (element,
- (GstElementFactory *) plugpath->data, GST_PAD_SRC))) {
+ gst_spider_find_element_to_plug (element,
+ (GstElementFactory *) plugpath->data, GST_PAD_SRC))) {
gst_spider_link_add (conn, element);
plugpath = g_list_delete_link (plugpath, plugpath);
}
"spider autoplugging element");
if (!gst_element_register (plugin, "spider", GST_RANK_SECONDARY,
- GST_TYPE_SPIDER))
+ GST_TYPE_SPIDER))
return FALSE;
if (!gst_element_register (plugin, "spideridentity", GST_RANK_NONE,
- GST_TYPE_SPIDER_IDENTITY))
+ GST_TYPE_SPIDER_IDENTITY))
return FALSE;
return TRUE;
0,
(GInstanceInitFunc) gst_spider_identity_init,
};
+
spider_identity_type =
- g_type_register_static (GST_TYPE_ELEMENT, "GstSpiderIdentity",
- &spider_identity_info, 0);
+ g_type_register_static (GST_TYPE_ELEMENT, "GstSpiderIdentity",
+ &spider_identity_info, 0);
GST_DEBUG_CATEGORY_INIT (gst_spider_identity_debug, "spideridentity", 0,
- "spider autoplugging proxy element");
+ "spider autoplugging proxy element");
}
return spider_identity_type;
}
GList *list = spider->links;
while (list) {
- GstSpiderConnection *conn = (GstSpiderConnection *) list->data;
-
- list = g_list_next (list);
- if (conn->current != (GstElement *) conn->src) {
- GST_DEBUG ("sending EOS to unconnected element %s from %s",
- GST_ELEMENT_NAME (conn->src), GST_ELEMENT_NAME (ident));
- gst_pad_push (conn->src->src,
- GST_DATA (GST_BUFFER (gst_event_new (GST_EVENT_EOS))));
- gst_element_set_eos (GST_ELEMENT (conn->src));
- }
+ GstSpiderConnection *conn = (GstSpiderConnection *) list->data;
+
+ list = g_list_next (list);
+ if (conn->current != (GstElement *) conn->src) {
+ GST_DEBUG ("sending EOS to unconnected element %s from %s",
+ GST_ELEMENT_NAME (conn->src), GST_ELEMENT_NAME (ident));
+ gst_pad_push (conn->src->src,
+ GST_DATA (GST_BUFFER (gst_event_new (GST_EVENT_EOS))));
+ gst_element_set_eos (GST_ELEMENT (conn->src));
+ }
}
}
/* end hack for current event stuff here */
GstSpiderIdentity *ret =
(GstSpiderIdentity *) gst_element_factory_make ("spideridentity", name);
/* set the right functions */
- gst_element_set_loop_function (GST_ELEMENT (ret),
- (GstElementLoopFunction)
+ gst_element_set_loop_function (GST_ELEMENT (ret), (GstElementLoopFunction)
GST_DEBUG_FUNCPTR (gst_spider_identity_src_loop));
return ret;
(GstSpiderIdentity *) gst_element_factory_make ("spideridentity", name);
/* set the right functions */
- gst_element_set_loop_function (GST_ELEMENT (ret),
- (GstElementLoopFunction)
+ gst_element_set_loop_function (GST_ELEMENT (ret), (GstElementLoopFunction)
GST_DEBUG_FUNCPTR (gst_spider_identity_dumb_loop));
return ret;
GstCaps *ret = gst_pad_get_allowed_caps (otherpad);
if (ident->caps) {
- GstCaps *ret2 = gst_caps_intersect (ident->caps, ret);
+ GstCaps *ret2 = gst_caps_intersect (ident->caps, ret);
- gst_caps_free (ret);
- ret = ret2;
+ gst_caps_free (ret);
+ ret = ret2;
}
return ret;
}
switch (GST_PAD_TEMPLATE_DIRECTION (templ)) {
case GST_PAD_SINK:
if (ident->sink != NULL)
- break;
+ break;
/* sink */
GST_DEBUG ("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_link_function (ident->sink,
- GST_DEBUG_FUNCPTR (gst_spider_identity_link));
+ GST_DEBUG_FUNCPTR (gst_spider_identity_link));
gst_pad_set_getcaps_function (ident->sink,
- GST_DEBUG_FUNCPTR (gst_spider_identity_getcaps));
+ GST_DEBUG_FUNCPTR (gst_spider_identity_getcaps));
return ident->sink;
case GST_PAD_SRC:
/* src */
if (ident->src != NULL)
- break;
+ break;
GST_DEBUG ("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_link_function (ident->src,
- GST_DEBUG_FUNCPTR (gst_spider_identity_link));
+ GST_DEBUG_FUNCPTR (gst_spider_identity_link));
gst_pad_set_getcaps_function (ident->src,
- GST_DEBUG_FUNCPTR (gst_spider_identity_getcaps));
+ GST_DEBUG_FUNCPTR (gst_spider_identity_getcaps));
gst_pad_set_event_function (ident->src,
- GST_DEBUG_FUNCPTR (gst_spider_identity_handle_src_event));
+ GST_DEBUG_FUNCPTR (gst_spider_identity_handle_src_event));
return ident->src;
default:
break;
/* start typefinding or plugging */
if ((GST_RPAD_PEER (ident->sink) != NULL)
- && (GST_RPAD_PEER (ident->src) == NULL)) {
- GstCaps *caps =
- gst_pad_get_caps ((GstPad *) GST_PAD_PEER (ident->sink));
- if (gst_caps_is_any (caps) || gst_caps_is_empty (caps)) {
- gst_spider_identity_start_type_finding (ident);
- gst_caps_free (caps);
- break;
- } else {
- gst_spider_identity_plug (ident);
- }
- gst_caps_free (caps);
+ && (GST_RPAD_PEER (ident->src) == NULL)) {
+ GstCaps *caps =
+ gst_pad_get_caps ((GstPad *) GST_PAD_PEER (ident->sink));
+ if (gst_caps_is_any (caps) || gst_caps_is_empty (caps)) {
+ gst_spider_identity_start_type_finding (ident);
+ gst_caps_free (caps);
+ break;
+ } else {
+ gst_spider_identity_plug (ident);
+ }
+ gst_caps_free (caps);
}
/* autoplug on src */
if ((GST_RPAD_PEER (ident->src) != NULL)
- && (GST_RPAD_PEER (ident->sink) == NULL)) {
- gst_spider_identity_plug (ident);
+ && (GST_RPAD_PEER (ident->sink) == NULL)) {
+ gst_spider_identity_plug (ident);
}
default:
break;
GST_DEBUG ("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);
+ GST_STATE_PAUSED);
restart = TRUE;
}
- gst_element_set_loop_function (GST_ELEMENT (ident),
- (GstElementLoopFunction)
+ gst_element_set_loop_function (GST_ELEMENT (ident), (GstElementLoopFunction)
GST_DEBUG_FUNCPTR (gst_spider_identity_sink_loop_type_finding));
if (restart) {
gst_element_set_state (GST_ELEMENT (GST_ELEMENT_PARENT (ident)),
- GST_STATE_PLAYING);
+ GST_STATE_PLAYING);
}
}
/* we don't want a loop function if we're plugged */
if (ident->sink && GST_PAD_PEER (ident->sink)) {
- gst_element_set_loop_function (GST_ELEMENT (ident),
- (GstElementLoopFunction)
- GST_DEBUG_FUNCPTR (gst_spider_identity_dumb_loop));
+ gst_element_set_loop_function (GST_ELEMENT (ident), (GstElementLoopFunction)
+ GST_DEBUG_FUNCPTR (gst_spider_identity_dumb_loop));
gst_spider_identity_dumb_loop (ident);
return;
}
GstBuffer *buffer;
guint best_probability;
GstCaps *caps;
-} SpiderTypeFind;
+}
+SpiderTypeFind;
guint8 *
spider_find_peek (gpointer data, gint64 offset, guint size)
{
GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (walk->data);
GST_DEBUG ("trying typefind function %s",
- GST_PLUGIN_FEATURE_NAME (factory));
+ GST_PLUGIN_FEATURE_NAME (factory));
gst_type_find_factory_call_function (factory, &gst_find);
if (find.best_probability >= GST_TYPE_FIND_MAXIMUM)
goto plug;
end:
/* remove loop function */
- gst_element_set_loop_function (GST_ELEMENT (ident),
- (GstElementLoopFunction)
+ gst_element_set_loop_function (GST_ELEMENT (ident), (GstElementLoopFunction)
GST_DEBUG_FUNCPTR (gst_spider_identity_dumb_loop));
/* push the buffer */
while (templs) {
if (GST_PAD_TEMPLATE_DIRECTION (templs->data) == dir) {
- count++;
+ count++;
}
if (count > maxtemplates)
- break;
+ break;
templs = g_list_next (templs);
}
if (count <= maxtemplates)
property_change_callback (GObject * object, GstObject * orig,
GParamSpec * pspec)
{
- GValue value = { 0, }; /* the important thing is that value.type = 0 */
+ GValue value = { 0, }; /* the important thing is that value.type = 0 */
gchar *str = 0;
if (pspec->flags & G_PARAM_READABLE) {
/* link objects */
if (!(gst_element_link (filesrc, decoder) &&
- gst_element_link (decoder, osssink) &&
- gst_element_link (decoder, videosink))) {
+ gst_element_link (decoder, osssink) &&
+ gst_element_link (decoder, videosink))) {
g_print ("the pipeline could not be linked\n");
exit (-4);
}
struct _cothread_context
{
- cothread_state *cothreads[COTHREAD_MAXTHREADS]; /* array of cothread states */
+ cothread_state *cothreads[COTHREAD_MAXTHREADS]; /* array of cothread states */
int ncothreads;
int current;
unsigned long stack_top;
cothread_context_init (void)
{
char __csf;
- void *current_stack_frame = &__csf; /* Get pointer inside current stack frame */
+ void *current_stack_frame = &__csf; /* Get pointer inside current stack frame */
cothread_context *ctx;
/* if there already is a cotread context for this thread,
ctx = g_static_private_get (&_cothread_ctx_key);
if (ctx) {
GST_CAT_INFO (GST_CAT_COTHREADS,
- "returning private _cothread_ctx_key %p", ctx);
+ "returning private _cothread_ctx_key %p", ctx);
return ctx;
}
if (ctx->cothreads[slot] == NULL)
break;
else if (ctx->cothreads[slot]->flags & COTHREAD_DESTROYED &&
- slot != ctx->current) {
+ slot != ctx->current) {
cothread_destroy (ctx->cothreads[slot]);
break;
}
unsigned long ptr;
for (ptr = ctx->stack_top - 4096; ptr > (unsigned long) cothread;
- ptr -= 4096) {
+ ptr -= 4096) {
GST_CAT_DEBUG (GST_CAT_COTHREADS, "touching location 0x%08lx", ptr);
*(volatile unsigned int *) ptr = *(volatile unsigned int *) ptr;
GST_CAT_DEBUG (GST_CAT_COTHREADS, "ok (0x%08x)", *(unsigned int *) ptr);
cothread->func (cothread->argc, cothread->argv);
GST_CAT_DEBUG (GST_CAT_COTHREADS, "cothread[%d] thread->func exited",
- ctx->current);
+ ctx->current);
GST_CAT_DEBUG (GST_CAT_COTHREADS, "sp=%p", current_stack_frame);
GST_CAT_DEBUG (GST_CAT_COTHREADS, "ctx=%p current=%p", ctx,
- cothread_get_current_context ());
+ cothread_get_current_context ());
g_assert (ctx == cothread_get_current_context ());
g_assert (ctx->current != 0);
enter = setjmp (current->jmp);
if (enter != 0) {
GST_CAT_DEBUG (GST_CAT_COTHREADS,
- "enter cothread #%d %d sp=%p jmpbuf=%p",
- current->cothreadnum, enter, current->sp, current->jmp);
+ "enter cothread #%d %d sp=%p jmpbuf=%p",
+ current->cothreadnum, enter, current->sp, current->jmp);
return;
}
GST_CAT_DEBUG (GST_CAT_COTHREADS, "exit cothread #%d %d sp=%p jmpbuf=%p",
{AGGREGATOR_CHAIN, "4", "Chain Based"},
{0, NULL, NULL},
};
+
if (!aggregator_sched_type) {
aggregator_sched_type =
- g_enum_register_static ("GstAggregatorSched", aggregator_sched);
+ g_enum_register_static ("GstAggregatorSched", aggregator_sched);
}
return aggregator_sched_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NUM_PADS,
g_param_spec_int ("num_pads", "Num pads", "The number of source pads",
- 0, G_MAXINT, 0, G_PARAM_READABLE));
+ 0, G_MAXINT, 0, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SILENT,
g_param_spec_boolean ("silent", "Silent", "Don't produce messages",
- FALSE, G_PARAM_READWRITE));
+ FALSE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SCHED,
g_param_spec_enum ("sched", "Scheduling",
- "The type of scheduling this element should use",
- GST_TYPE_AGGREGATOR_SCHED, AGGREGATOR_CHAIN, G_PARAM_READWRITE));
+ "The type of scheduling this element should use",
+ GST_TYPE_AGGREGATOR_SCHED, AGGREGATOR_CHAIN, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LAST_MESSAGE,
g_param_spec_string ("last_message", "Last message",
- "The current state of the element", NULL, G_PARAM_READABLE));
+ "The current state of the element", NULL, G_PARAM_READABLE));
gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_aggregator_set_property);
gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_aggregator_get_property);
if (AGGREGATOR_IS_LOOP_BASED (aggregator)) {
gst_element_set_loop_function (GST_ELEMENT (aggregator),
- GST_DEBUG_FUNCPTR (gst_aggregator_loop));
+ GST_DEBUG_FUNCPTR (gst_aggregator_loop));
} else {
gst_element_set_loop_function (GST_ELEMENT (aggregator), NULL);
}
g_free (aggregator->last_message);
aggregator->last_message =
- g_strdup_printf ("%10.10s ******* (%s:%s)a (%d bytes, %"
- G_GUINT64_FORMAT ")", debug, GST_DEBUG_PAD_NAME (pad),
- GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf));
+ g_strdup_printf ("%10.10s ******* (%s:%s)a (%d bytes, %"
+ G_GUINT64_FORMAT ")", debug, GST_DEBUG_PAD_NAME (pad),
+ GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf));
g_object_notify (G_OBJECT (aggregator), "last_message");
}
* and that the peer pad is also enabled.
*/
if (GST_PAD_IS_USABLE (pad)) {
- buf = GST_BUFFER (gst_pad_pull (pad));
- debug = "loop";
+ buf = GST_BUFFER (gst_pad_pull (pad));
+ debug = "loop";
- /* then push it forward */
- gst_aggregator_push (aggregator, pad, buf, debug);
+ /* then push it forward */
+ gst_aggregator_push (aggregator, pad, buf, debug);
}
}
} else {
g_printerr ("BUFFERS in store:\n");
while (walk) {
g_print ("%15" G_GUINT64_FORMAT " - %7u\n", GST_BUFFER_OFFSET (walk->data),
- GST_BUFFER_SIZE (walk->data));
+ GST_BUFFER_SIZE (walk->data));
walk = g_list_next (walk);
}
g_printerr ("\n");
store->buffers && GST_BUFFER_OFFSET_IS_VALID (store->buffers->data)) {
/* we assumed valid offsets, but suddenly they are not anymore */
GST_DEBUG_OBJECT (store,
- "attempting to add buffer %p with invalid offset to store with valid offset, abort",
- buffer);
+ "attempting to add buffer %p with invalid offset to store with valid offset, abort",
+ buffer);
return FALSE;
} else if (!store->buffers
|| !GST_BUFFER_OFFSET_IS_VALID (store->buffers->data)) {
/* the starting buffer had an invalid offset, in that case we assume continuous buffers */
GST_LOG_OBJECT (store, "adding buffer %p with invalid offset and size %u",
- buffer, GST_BUFFER_SIZE (buffer));
+ buffer, GST_BUFFER_SIZE (buffer));
gst_data_ref (GST_DATA (buffer));
store->buffers = g_list_append (store->buffers, buffer);
return TRUE;
g_assert (GST_BUFFER_OFFSET_IS_VALID (buffer));
GST_LOG_OBJECT (store,
- "attempting to add buffer %p with offset %" G_GUINT64_FORMAT
- " and size %u", buffer, GST_BUFFER_OFFSET (buffer),
- GST_BUFFER_SIZE (buffer));
+ "attempting to add buffer %p with offset %" G_GUINT64_FORMAT
+ " and size %u", buffer, GST_BUFFER_OFFSET (buffer),
+ GST_BUFFER_SIZE (buffer));
/* we keep a sorted list of non-overlapping buffers */
walk = store->buffers;
while (walk) {
current_list = walk;
walk = g_list_next (walk);
if (GST_BUFFER_OFFSET (current) < GST_BUFFER_OFFSET (buffer)) {
- continue;
+ continue;
} else if (GST_BUFFER_OFFSET (current) == GST_BUFFER_OFFSET (buffer)) {
- guint needed_size;
-
- if (walk) {
- needed_size = MIN (GST_BUFFER_SIZE (buffer),
- GST_BUFFER_OFFSET (walk->data) - GST_BUFFER_OFFSET (current));
- } else {
- needed_size = GST_BUFFER_SIZE (buffer);
- }
- if (needed_size <= GST_BUFFER_SIZE (current)) {
- buffer = NULL;
- break;
- } else {
- if (needed_size < GST_BUFFER_SIZE (buffer)) {
- /* need to create subbuffer to not have overlapping data */
- GstBuffer *sub = gst_buffer_create_sub (buffer, 0, needed_size);
-
- g_assert (sub);
- buffer = sub;
- } else {
- gst_data_ref (GST_DATA (buffer));
- }
- /* replace current buffer with new one */
- GST_INFO_OBJECT (store,
- "replacing buffer %p with buffer %p with offset %" G_GINT64_FORMAT
- " and size %u", current_list->data, buffer,
- GST_BUFFER_OFFSET (buffer), GST_BUFFER_SIZE (buffer));
- gst_data_unref (GST_DATA (current_list->data));
- current_list->data = buffer;
- buffer = NULL;
- break;
- }
+ guint needed_size;
+
+ if (walk) {
+ needed_size = MIN (GST_BUFFER_SIZE (buffer),
+ GST_BUFFER_OFFSET (walk->data) - GST_BUFFER_OFFSET (current));
+ } else {
+ needed_size = GST_BUFFER_SIZE (buffer);
+ }
+ if (needed_size <= GST_BUFFER_SIZE (current)) {
+ buffer = NULL;
+ break;
+ } else {
+ if (needed_size < GST_BUFFER_SIZE (buffer)) {
+ /* need to create subbuffer to not have overlapping data */
+ GstBuffer *sub = gst_buffer_create_sub (buffer, 0, needed_size);
+
+ g_assert (sub);
+ buffer = sub;
+ } else {
+ gst_data_ref (GST_DATA (buffer));
+ }
+ /* replace current buffer with new one */
+ GST_INFO_OBJECT (store,
+ "replacing buffer %p with buffer %p with offset %" G_GINT64_FORMAT
+ " and size %u", current_list->data, buffer,
+ GST_BUFFER_OFFSET (buffer), GST_BUFFER_SIZE (buffer));
+ gst_data_unref (GST_DATA (current_list->data));
+ current_list->data = buffer;
+ buffer = NULL;
+ break;
+ }
} else if (GST_BUFFER_OFFSET (current) > GST_BUFFER_OFFSET (buffer)) {
- GList *previous = g_list_previous (current_list);
- guint64 start_offset = previous ?
- GST_BUFFER_OFFSET (previous->data) +
- GST_BUFFER_SIZE (previous->data) : 0;
-
- if (start_offset == GST_BUFFER_OFFSET (current)) {
- buffer = NULL;
- break;
- } else {
- /* we have data to insert */
- if (start_offset > GST_BUFFER_OFFSET (buffer) ||
- GST_BUFFER_OFFSET (buffer) + GST_BUFFER_SIZE (buffer) >
- GST_BUFFER_OFFSET (current)) {
- GstBuffer *sub;
-
- /* need a subbuffer */
- start_offset = GST_BUFFER_OFFSET (buffer) > start_offset ? 0 :
- start_offset - GST_BUFFER_OFFSET (buffer);
- sub = gst_buffer_create_sub (buffer, start_offset,
- MIN (GST_BUFFER_SIZE (buffer),
- GST_BUFFER_OFFSET (current) - start_offset -
- GST_BUFFER_OFFSET (buffer)));
- g_assert (sub);
- GST_BUFFER_OFFSET (sub) = start_offset + GST_BUFFER_OFFSET (buffer);
- buffer = sub;
- } else {
- gst_data_ref (GST_DATA (buffer));
- }
- GST_INFO_OBJECT (store,
- "adding buffer %p with offset %" G_GINT64_FORMAT " and size %u",
- buffer, GST_BUFFER_OFFSET (buffer), GST_BUFFER_SIZE (buffer));
- store->buffers =
- g_list_insert_before (store->buffers, current_list, buffer);
- buffer = NULL;
- break;
- }
+ GList *previous = g_list_previous (current_list);
+ guint64 start_offset = previous ?
+ GST_BUFFER_OFFSET (previous->data) +
+ GST_BUFFER_SIZE (previous->data) : 0;
+
+ if (start_offset == GST_BUFFER_OFFSET (current)) {
+ buffer = NULL;
+ break;
+ } else {
+ /* we have data to insert */
+ if (start_offset > GST_BUFFER_OFFSET (buffer) ||
+ GST_BUFFER_OFFSET (buffer) + GST_BUFFER_SIZE (buffer) >
+ GST_BUFFER_OFFSET (current)) {
+ GstBuffer *sub;
+
+ /* need a subbuffer */
+ start_offset = GST_BUFFER_OFFSET (buffer) > start_offset ? 0 :
+ start_offset - GST_BUFFER_OFFSET (buffer);
+ sub = gst_buffer_create_sub (buffer, start_offset,
+ MIN (GST_BUFFER_SIZE (buffer),
+ GST_BUFFER_OFFSET (current) - start_offset -
+ GST_BUFFER_OFFSET (buffer)));
+ g_assert (sub);
+ GST_BUFFER_OFFSET (sub) = start_offset + GST_BUFFER_OFFSET (buffer);
+ buffer = sub;
+ } else {
+ gst_data_ref (GST_DATA (buffer));
+ }
+ GST_INFO_OBJECT (store,
+ "adding buffer %p with offset %" G_GINT64_FORMAT " and size %u",
+ buffer, GST_BUFFER_OFFSET (buffer), GST_BUFFER_SIZE (buffer));
+ store->buffers =
+ g_list_insert_before (store->buffers, current_list, buffer);
+ buffer = NULL;
+ break;
+ }
}
}
if (buffer) {
gst_data_ref (GST_DATA (buffer));
GST_INFO_OBJECT (store,
- "adding buffer %p with offset %" G_GINT64_FORMAT " and size %u",
- buffer, GST_BUFFER_OFFSET (buffer), GST_BUFFER_SIZE (buffer));
+ "adding buffer %p with offset %" G_GINT64_FORMAT " and size %u",
+ buffer, GST_BUFFER_OFFSET (buffer), GST_BUFFER_SIZE (buffer));
if (current_list) {
- g_list_append (current_list, buffer);
+ g_list_append (current_list, buffer);
} else {
- g_assert (store->buffers == NULL);
- store->buffers = g_list_prepend (NULL, buffer);
+ g_assert (store->buffers == NULL);
+ store->buffers = g_list_prepend (NULL, buffer);
}
}
return TRUE;
do_nothing_loop (); */
} else if (cur_offset == offset && GST_BUFFER_SIZE (current) == size) {
GST_LOG_OBJECT (store,
- "found matching buffer %p for offset %" G_GUINT64_FORMAT
- " and size %u", current, offset, size);
+ "found matching buffer %p for offset %" G_GUINT64_FORMAT
+ " and size %u", current, offset, size);
ret = current;
gst_data_ref (GST_DATA (ret));
GST_LOG_OBJECT (store, "refcount %d", GST_DATA_REFCOUNT_VALUE (ret));
break;
} else if (cur_offset + GST_BUFFER_SIZE (current) > offset) {
if (cur_offset + GST_BUFFER_SIZE (current) >= offset + size) {
- ret = gst_buffer_create_sub (current, offset - cur_offset, size);
- GST_LOG_OBJECT (store,
- "created subbuffer %p from buffer %p for offset %llu and size %u",
- ret, current, offset, size);
- break;
+ ret = gst_buffer_create_sub (current, offset - cur_offset, size);
+ GST_LOG_OBJECT (store,
+ "created subbuffer %p from buffer %p for offset %llu and size %u",
+ ret, current, offset, size);
+ break;
}
/* uh, the requested data spans some buffers */
ret = gst_buffer_new_and_alloc (size);
GST_LOG_OBJECT (store, "created buffer %p for offset %" G_GUINT64_FORMAT
- " and size %u, will fill with data now", ret, offset, size);
+ " and size %u, will fill with data now", ret, offset, size);
data = GST_BUFFER_DATA (ret);
tmp = GST_BUFFER_SIZE (current) - offset + cur_offset;
memcpy (data, GST_BUFFER_DATA (current) + offset - cur_offset, tmp);
data += tmp;
size -= tmp;
while (size) {
- if (walk == NULL ||
- (have_offset &&
- GST_BUFFER_OFFSET (current) + GST_BUFFER_SIZE (current) !=
- GST_BUFFER_OFFSET (walk->data))) {
- GST_DEBUG_OBJECT (store,
- "not all data for offset %" G_GUINT64_FORMAT
- " and remaining size %u available, aborting", offset, size);
- gst_data_unref (GST_DATA (ret));
- ret = NULL;
- goto out;
- }
- current = GST_BUFFER (walk->data);
- walk = g_list_next (walk);
- tmp = MIN (GST_BUFFER_SIZE (current), size);
- memcpy (data, GST_BUFFER_DATA (current), tmp);
- data += tmp;
- size -= tmp;
+ if (walk == NULL ||
+ (have_offset &&
+ GST_BUFFER_OFFSET (current) + GST_BUFFER_SIZE (current) !=
+ GST_BUFFER_OFFSET (walk->data))) {
+ GST_DEBUG_OBJECT (store,
+ "not all data for offset %" G_GUINT64_FORMAT
+ " and remaining size %u available, aborting", offset, size);
+ gst_data_unref (GST_DATA (ret));
+ ret = NULL;
+ goto out;
+ }
+ current = GST_BUFFER (walk->data);
+ walk = g_list_next (walk);
+ tmp = MIN (GST_BUFFER_SIZE (current), size);
+ memcpy (data, GST_BUFFER_DATA (current), tmp);
+ data += tmp;
+ size -= tmp;
}
}
if (!have_offset) {
}
while (walk) {
if (have_offset && counting &&
- cur_offset + GST_BUFFER_SIZE (current) !=
- GST_BUFFER_OFFSET (walk->data)) {
+ cur_offset + GST_BUFFER_SIZE (current) !=
+ GST_BUFFER_OFFSET (walk->data)) {
break;
}
current = GST_BUFFER (walk->data);
ret += GST_BUFFER_SIZE (current);
} else {
if (cur_offset > offset)
- return 0;
+ return 0;
if (cur_offset + GST_BUFFER_SIZE (current) > offset) {
- /* we have at least some bytes */
- ret = cur_offset + GST_BUFFER_SIZE (current) - offset;
- counting = TRUE;
+ /* we have at least some bytes */
+ ret = cur_offset + GST_BUFFER_SIZE (current) - offset;
+ counting = TRUE;
}
}
if (!have_offset) {
while ((*my_elements).name) {
if (!gst_element_register (plugin, (*my_elements).name, (*my_elements).rank,
- ((*my_elements).type) ()))
+ ((*my_elements).type) ()))
return FALSE;
my_elements++;
}
static GEnumValue fakesink_state_error[] = {
{FAKESINK_STATE_ERROR_NONE, "0", "No state change errors"},
{FAKESINK_STATE_ERROR_NULL_READY, "1",
- "Fail state change from NULL to READY"},
+ "Fail state change from NULL to READY"},
{FAKESINK_STATE_ERROR_READY_PAUSED, "2",
- "Fail state change from READY to PAUSED"},
+ "Fail state change from READY to PAUSED"},
{FAKESINK_STATE_ERROR_PAUSED_PLAYING, "3",
- "Fail state change from PAUSED to PLAYING"},
+ "Fail state change from PAUSED to PLAYING"},
{FAKESINK_STATE_ERROR_PLAYING_PAUSED, "4",
- "Fail state change from PLAYING to PAUSED"},
+ "Fail state change from PLAYING to PAUSED"},
{FAKESINK_STATE_ERROR_PAUSED_READY, "5",
- "Fail state change from PAUSED to READY"},
+ "Fail state change from PAUSED to READY"},
{FAKESINK_STATE_ERROR_READY_NULL, "6",
- "Fail state change from READY to NULL"},
+ "Fail state change from READY to NULL"},
{0, NULL, NULL},
};
+
if (!fakesink_state_error_type) {
fakesink_state_error_type =
- g_enum_register_static ("GstFakeSinkStateError", fakesink_state_error);
+ g_enum_register_static ("GstFakeSinkStateError", fakesink_state_error);
}
return fakesink_state_error_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NUM_SINKS,
g_param_spec_int ("num_sinks", "Number of sinks",
- "The number of sinkpads", 1, G_MAXINT, 1, G_PARAM_READABLE));
+ "The number of sinkpads", 1, G_MAXINT, 1, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_STATE_ERROR,
g_param_spec_enum ("state_error", "State Error",
- "Generate a state change error", GST_TYPE_FAKESINK_STATE_ERROR,
- FAKESINK_STATE_ERROR_NONE, G_PARAM_READWRITE));
+ "Generate a state change error", GST_TYPE_FAKESINK_STATE_ERROR,
+ FAKESINK_STATE_ERROR_NONE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LAST_MESSAGE,
g_param_spec_string ("last_message", "Last Message",
- "The message describing current status", NULL, G_PARAM_READABLE));
+ "The message describing current status", NULL, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SYNC,
g_param_spec_boolean ("sync", "Sync", "Sync on the clock", FALSE,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SIGNAL_HANDOFFS,
g_param_spec_boolean ("signal-handoffs", "Signal handoffs",
- "Send a signal before unreffing the buffer", FALSE,
- G_PARAM_READWRITE));
+ "Send a signal before unreffing the buffer", FALSE,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SILENT,
g_param_spec_boolean ("silent", "Silent",
- "Don't produce last_message events", FALSE, G_PARAM_READWRITE));
+ "Don't produce last_message events", FALSE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DUMP,
g_param_spec_boolean ("dump", "Dump", "Dump received bytes to stdout",
- FALSE, G_PARAM_READWRITE));
+ FALSE, G_PARAM_READWRITE));
gst_fakesink_signals[SIGNAL_HANDOFF] =
g_signal_new ("handoff", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
g_free (fakesink->last_message);
fakesink->last_message =
- g_strdup_printf ("chain ******* (%s:%s)E (type: %d) %p",
- GST_DEBUG_PAD_NAME (pad), GST_EVENT_TYPE (event), event);
+ g_strdup_printf ("chain ******* (%s:%s)E (type: %d) %p",
+ GST_DEBUG_PAD_NAME (pad), GST_EVENT_TYPE (event), event);
g_object_notify (G_OBJECT (fakesink), "last_message");
}
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_DISCONTINUOUS:
- if (fakesink->sync && fakesink->clock) {
- gint64 value = GST_EVENT_DISCONT_OFFSET (event, 0).value;
+ if (fakesink->sync && fakesink->clock) {
+ gint64 value = GST_EVENT_DISCONT_OFFSET (event, 0).value;
- gst_element_set_time (GST_ELEMENT (fakesink), value);
- }
+ gst_element_set_time (GST_ELEMENT (fakesink), value);
+ }
default:
- gst_pad_event_default (pad, event);
- break;
+ gst_pad_event_default (pad, event);
+ break;
}
return;
}
g_free (fakesink->last_message);
fakesink->last_message =
- g_strdup_printf ("chain ******* (%s:%s)< (%d bytes, timestamp: %"
- G_GINT64_FORMAT ", duration: %" G_GINT64_FORMAT ", offset: %"
- G_GINT64_FORMAT ", flags: %d) %p", GST_DEBUG_PAD_NAME (pad),
- GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf),
- GST_BUFFER_DURATION (buf), GST_BUFFER_OFFSET (buf),
- GST_BUFFER_FLAGS (buf), buf);
+ g_strdup_printf ("chain ******* (%s:%s)< (%d bytes, timestamp: %"
+ G_GINT64_FORMAT ", duration: %" G_GINT64_FORMAT ", offset: %"
+ G_GINT64_FORMAT ", flags: %d) %p", GST_DEBUG_PAD_NAME (pad),
+ GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf),
+ GST_BUFFER_DURATION (buf), GST_BUFFER_OFFSET (buf),
+ GST_BUFFER_FLAGS (buf), buf);
g_object_notify (G_OBJECT (fakesink), "last_message");
}
if (fakesink->signal_handoffs)
g_signal_emit (G_OBJECT (fakesink), gst_fakesink_signals[SIGNAL_HANDOFF], 0,
- buf, pad);
+ buf, pad);
if (fakesink->dump) {
gst_util_dump_mem (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
switch (GST_STATE_TRANSITION (element)) {
case GST_STATE_NULL_TO_READY:
if (fakesink->state_error == FAKESINK_STATE_ERROR_NULL_READY)
- goto error;
+ goto error;
break;
case GST_STATE_READY_TO_PAUSED:
if (fakesink->state_error == FAKESINK_STATE_ERROR_READY_PAUSED)
- goto error;
+ goto error;
break;
case GST_STATE_PAUSED_TO_PLAYING:
if (fakesink->state_error == FAKESINK_STATE_ERROR_PAUSED_PLAYING)
- goto error;
+ goto error;
break;
case GST_STATE_PLAYING_TO_PAUSED:
if (fakesink->state_error == FAKESINK_STATE_ERROR_PLAYING_PAUSED)
- goto error;
+ goto error;
break;
case GST_STATE_PAUSED_TO_READY:
if (fakesink->state_error == FAKESINK_STATE_ERROR_PAUSED_READY)
- goto error;
+ goto error;
break;
case GST_STATE_READY_TO_NULL:
if (fakesink->state_error == FAKESINK_STATE_ERROR_READY_NULL)
- goto error;
+ goto error;
g_free (fakesink->last_message);
fakesink->last_message = NULL;
break;
{FAKESRC_GET_ALWAYS_SUCEEDS, "8", "'_get' Always succeeds"},
{0, NULL, NULL},
};
+
if (!fakesrc_output_type) {
fakesrc_output_type =
- g_enum_register_static ("GstFakeSrcOutput", fakesrc_output);
+ g_enum_register_static ("GstFakeSrcOutput", fakesrc_output);
}
return fakesrc_output_type;
}
{FAKESRC_DATA_SUBBUFFER, "2", "Subbuffer data"},
{0, NULL, NULL},
};
+
if (!fakesrc_data_type) {
fakesrc_data_type = g_enum_register_static ("GstFakeSrcData", fakesrc_data);
}
{FAKESRC_SIZETYPE_NULL, "1", "Send empty buffers"},
{FAKESRC_SIZETYPE_FIXED, "2", "Fixed size buffers (sizemax sized)"},
{FAKESRC_SIZETYPE_RANDOM, "3",
- "Random sized buffers (sizemin <= size <= sizemax)"},
+ "Random sized buffers (sizemin <= size <= sizemax)"},
{0, NULL, NULL},
};
+
if (!fakesrc_sizetype_type) {
fakesrc_sizetype_type =
- g_enum_register_static ("GstFakeSrcSizeType", fakesrc_sizetype);
+ g_enum_register_static ("GstFakeSrcSizeType", fakesrc_sizetype);
}
return fakesrc_sizetype_type;
}
{FAKESRC_FILLTYPE_RANDOM, "3", "Fill buffers with random crap"},
{FAKESRC_FILLTYPE_PATTERN, "4", "Fill buffers with pattern 0x00 -> 0xff"},
{FAKESRC_FILLTYPE_PATTERN_CONT, "5",
- "Fill buffers with pattern 0x00 -> 0xff that spans buffers"},
+ "Fill buffers with pattern 0x00 -> 0xff that spans buffers"},
{0, NULL, NULL},
};
+
if (!fakesrc_filltype_type) {
fakesrc_filltype_type =
- g_enum_register_static ("GstFakeSrcFillType", fakesrc_filltype);
+ g_enum_register_static ("GstFakeSrcFillType", fakesrc_filltype);
}
return fakesrc_filltype_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NUM_SOURCES,
g_param_spec_int ("num-sources", "num-sources", "Number of sources",
- 1, G_MAXINT, 1, G_PARAM_READABLE));
+ 1, G_MAXINT, 1, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOOP_BASED,
g_param_spec_boolean ("loop-based", "loop-based",
- "Enable loop-based operation", FALSE, G_PARAM_READWRITE));
+ "Enable loop-based operation", FALSE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_OUTPUT,
g_param_spec_enum ("output", "output", "Output method (currently unused)",
- GST_TYPE_FAKESRC_OUTPUT, FAKESRC_FIRST_LAST_LOOP, G_PARAM_READWRITE));
+ GST_TYPE_FAKESRC_OUTPUT, FAKESRC_FIRST_LAST_LOOP, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DATA,
g_param_spec_enum ("data", "data", "Data allocation method",
- GST_TYPE_FAKESRC_DATA, FAKESRC_DATA_ALLOCATE, G_PARAM_READWRITE));
+ GST_TYPE_FAKESRC_DATA, FAKESRC_DATA_ALLOCATE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SIZETYPE,
g_param_spec_enum ("sizetype", "sizetype",
- "How to determine buffer sizes", GST_TYPE_FAKESRC_SIZETYPE,
- FAKESRC_SIZETYPE_NULL, G_PARAM_READWRITE));
+ "How to determine buffer sizes", GST_TYPE_FAKESRC_SIZETYPE,
+ FAKESRC_SIZETYPE_NULL, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SIZEMIN,
g_param_spec_int ("sizemin", "sizemin", "Minimum buffer size", 0,
- G_MAXINT, DEFAULT_SIZEMIN, G_PARAM_READWRITE));
+ G_MAXINT, DEFAULT_SIZEMIN, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SIZEMAX,
g_param_spec_int ("sizemax", "sizemax", "Maximum buffer size", 0,
- G_MAXINT, DEFAULT_SIZEMAX, G_PARAM_READWRITE));
+ G_MAXINT, DEFAULT_SIZEMAX, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PARENTSIZE,
g_param_spec_int ("parentsize", "parentsize",
- "Size of parent buffer for sub-buffered allocation", 0, G_MAXINT,
- DEFAULT_PARENTSIZE, G_PARAM_READWRITE));
+ "Size of parent buffer for sub-buffered allocation", 0, G_MAXINT,
+ DEFAULT_PARENTSIZE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FILLTYPE,
g_param_spec_enum ("filltype", "filltype",
- "How to fill the buffer, if at all", GST_TYPE_FAKESRC_FILLTYPE,
- FAKESRC_FILLTYPE_NULL, G_PARAM_READWRITE));
+ "How to fill the buffer, if at all", GST_TYPE_FAKESRC_FILLTYPE,
+ FAKESRC_FILLTYPE_NULL, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PATTERN,
g_param_spec_string ("pattern", "pattern", "pattern", NULL,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NUM_BUFFERS,
g_param_spec_int ("num-buffers", "num-buffers",
- "Number of buffers to output before sending EOS", G_MININT, G_MAXINT,
- 0, G_PARAM_READWRITE));
+ "Number of buffers to output before sending EOS", G_MININT, G_MAXINT,
+ 0, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_EOS,
g_param_spec_boolean ("eos", "eos", "Send out the EOS event?", TRUE,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LAST_MESSAGE,
g_param_spec_string ("last-message", "last-message",
- "The last status message", NULL, G_PARAM_READABLE));
+ "The last status message", NULL, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SILENT,
g_param_spec_boolean ("silent", "Silent",
- "Don't produce last_message events", FALSE, G_PARAM_READWRITE));
+ "Don't produce last_message events", FALSE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SIGNAL_HANDOFFS,
g_param_spec_boolean ("signal-handoffs", "Signal handoffs",
- "Send a signal before pushing the buffer", FALSE, G_PARAM_READWRITE));
+ "Send a signal before pushing the buffer", FALSE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DUMP,
g_param_spec_boolean ("dump", "Dump", "Dump produced bytes to stdout",
- FALSE, G_PARAM_READWRITE));
+ FALSE, G_PARAM_READWRITE));
gst_fakesrc_signals[SIGNAL_HANDOFF] =
g_signal_new ("handoff", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
GST_FORMAT_DEFAULT,
0,
};
+
return formats;
}
GST_QUERY_SEGMENT_END,
0,
};
+
return types;
}
{GST_EVENT_FLUSH, 0},
{0, 0},
};
+
return masks;
}
src->buffer_count = GST_EVENT_SEEK_OFFSET (event);
if (!GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_FLUSH) {
- break;
+ break;
}
/* else we do a flush too */
case GST_EVENT_SEEK_SEGMENT:
src->segment_end = GST_EVENT_SEEK_ENDOFFSET (event);
src->buffer_count = src->segment_start;
src->segment_loop =
- GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_SEGMENT_LOOP;
+ GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_SEGMENT_LOOP;
break;
case GST_EVENT_FLUSH:
src->need_flush = TRUE;
if (src->loop_based) {
gst_element_set_loop_function (GST_ELEMENT (src),
- GST_DEBUG_FUNCPTR (gst_fakesrc_loop));
+ GST_DEBUG_FUNCPTR (gst_fakesrc_loop));
} else {
gst_element_set_loop_function (GST_ELEMENT (src), NULL);
}
src->data = g_value_get_enum (value);
if (src->data == FAKESRC_DATA_SUBBUFFER) {
- if (!src->parent)
- gst_fakesrc_alloc_parent (src);
+ if (!src->parent)
+ gst_fakesrc_alloc_parent (src);
} else {
- if (src->parent) {
- gst_buffer_unref (src->parent);
- src->parent = NULL;
- }
+ if (src->parent) {
+ gst_buffer_unref (src->parent);
+ src->parent = NULL;
+ }
}
break;
case ARG_SIZETYPE:
guint8 *ptr = GST_BUFFER_DATA (buf);
for (i = GST_BUFFER_SIZE (buf); i; i--) {
- *ptr++ = (gint8) ((255.0) * rand () / (RAND_MAX));
+ *ptr++ = (gint8) ((255.0) * rand () / (RAND_MAX));
}
break;
}
guint8 *ptr = GST_BUFFER_DATA (buf);
for (i = GST_BUFFER_SIZE (buf); i; i--) {
- *ptr++ = src->pattern_byte++;
+ *ptr++ = src->pattern_byte++;
}
break;
}
if (size != 0) {
switch (src->filltype) {
case FAKESRC_FILLTYPE_NOTHING:
- GST_BUFFER_DATA (buf) = g_malloc (size);
- break;
+ GST_BUFFER_DATA (buf) = g_malloc (size);
+ break;
case FAKESRC_FILLTYPE_NULL:
- GST_BUFFER_DATA (buf) = g_malloc0 (size);
- break;
+ GST_BUFFER_DATA (buf) = g_malloc0 (size);
+ break;
case FAKESRC_FILLTYPE_RANDOM:
case FAKESRC_FILLTYPE_PATTERN:
case FAKESRC_FILLTYPE_PATTERN_CONT:
default:
- GST_BUFFER_DATA (buf) = g_malloc (size);
- gst_fakesrc_prepare_buffer (src, buf);
- break;
+ GST_BUFFER_DATA (buf) = g_malloc (size);
+ gst_fakesrc_prepare_buffer (src, buf);
+ break;
}
}
break;
case FAKESRC_SIZETYPE_RANDOM:
size =
- src->sizemin +
- (guint8) (((gfloat) src->sizemax) * rand () / (RAND_MAX +
- (gfloat) src->sizemin));
+ src->sizemin +
+ (guint8) (((gfloat) src->sizemax) * rand () / (RAND_MAX +
+ (gfloat) src->sizemin));
break;
case FAKESRC_SIZETYPE_NULL:
default:
case FAKESRC_DATA_SUBBUFFER:
/* see if we have a parent to subbuffer */
if (!src->parent) {
- gst_fakesrc_alloc_parent (src);
- g_assert (src->parent);
+ gst_fakesrc_alloc_parent (src);
+ g_assert (src->parent);
}
/* see if it's large enough */
if ((GST_BUFFER_SIZE (src->parent) - src->parentoffset) >= size) {
- buf = gst_buffer_create_sub (src->parent, src->parentoffset, size);
- src->parentoffset += size;
+ buf = gst_buffer_create_sub (src->parent, src->parentoffset, size);
+ src->parentoffset += size;
} else {
- /* the parent is useless now */
- gst_buffer_unref (src->parent);
- src->parent = NULL;
- /* try again (this will allocate a new parent) */
- return gst_fakesrc_create_buffer (src);
+ /* the parent is useless now */
+ gst_buffer_unref (src->parent);
+ src->parent = NULL;
+ /* try again (this will allocate a new parent) */
+ return gst_fakesrc_create_buffer (src);
}
gst_fakesrc_prepare_buffer (src, buf);
break;
g_free (src->last_message);
src->last_message =
- g_strdup_printf ("get ******* (%s:%s)> (%d bytes, %"
- G_GUINT64_FORMAT " ) %p", GST_DEBUG_PAD_NAME (pad),
- GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf), buf);
+ g_strdup_printf ("get ******* (%s:%s)> (%d bytes, %"
+ G_GUINT64_FORMAT " ) %p", GST_DEBUG_PAD_NAME (pad),
+ GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf), buf);
g_object_notify (G_OBJECT (src), "last_message");
}
if (src->signal_handoffs) {
GST_LOG_OBJECT (src, "pre handoff emit");
g_signal_emit (G_OBJECT (src), gst_fakesrc_signals[SIGNAL_HANDOFF], 0,
- buf, pad);
+ buf, pad);
GST_LOG_OBJECT (src, "post handoff emit");
}
break;
case GST_STATE_PAUSED_TO_READY:
if (fakesrc->parent) {
- gst_buffer_unref (fakesrc->parent);
- fakesrc->parent = NULL;
+ gst_buffer_unref (fakesrc->parent);
+ fakesrc->parent = NULL;
}
g_free (fakesrc->last_message);
fakesrc->last_message = NULL;
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FD,
g_param_spec_int ("fd", "fd", "An open file descriptor to write to",
- 0, G_MAXINT, 1, G_PARAM_READWRITE));
+ 0, G_MAXINT, 1, G_PARAM_READWRITE));
gobject_class->set_property = gst_fdsink_set_property;
gobject_class->get_property = gst_fdsink_get_property;
if (GST_BUFFER_DATA (buf)) {
GST_DEBUG ("writing %d bytes to file descriptor %d", GST_BUFFER_SIZE (buf),
- fdsink->fd);
+ fdsink->fd);
write (fdsink->fd, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FD,
g_param_spec_int ("fd", "fd", "An open file descriptor to read from",
- 0, G_MAXINT, 0, G_PARAM_READWRITE));
+ 0, G_MAXINT, 0, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BLOCKSIZE,
g_param_spec_ulong ("blocksize", "Block size",
- "Size in bytes to read per buffer", 1, G_MAXULONG, DEFAULT_BLOCKSIZE,
- G_PARAM_READWRITE));
+ "Size in bytes to read per buffer", 1, G_MAXULONG, DEFAULT_BLOCKSIZE,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TIMEOUT,
g_param_spec_uint64 ("timeout", "Timeout", "Read timeout in nanoseconds",
- 0, G_MAXUINT64, 0, G_PARAM_READWRITE));
+ 0, G_MAXUINT64, 0, G_PARAM_READWRITE));
gst_fdsrc_signals[SIGNAL_TIMEOUT] =
g_signal_new ("timeout", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
do {
retval = select (1, &readfds, NULL, NULL, tp);
- } while (retval == -1 && errno == EINTR); /* retry if interrupted */
+ } while (retval == -1 && errno == EINTR); /* retry if interrupted */
if (retval == -1) {
GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL),
- ("select on file descriptor: %s.", g_strerror (errno)));
+ ("select on file descriptor: %s.", g_strerror (errno)));
gst_element_set_eos (GST_ELEMENT (src));
return GST_DATA (gst_event_new (GST_EVENT_EOS));
} else if (retval == 0) {
do {
readbytes = read (src->fd, GST_BUFFER_DATA (buf), src->blocksize);
- } while (readbytes == -1 && errno == EINTR); /* retry if interrupted */
+ } while (readbytes == -1 && errno == EINTR); /* retry if interrupted */
if (readbytes > 0) {
GST_BUFFER_OFFSET (buf) = src->curoffset;
return GST_DATA (gst_event_new (GST_EVENT_EOS));
} else {
GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL),
- ("read on file descriptor: %s.", g_strerror (errno)));
+ ("read on file descriptor: %s.", g_strerror (errno)));
gst_element_set_eos (GST_ELEMENT (src));
return GST_DATA (gst_event_new (GST_EVENT_EOS));
}
GST_FORMAT_BYTES,
0,
};
+
return formats;
}
GST_QUERY_POSITION,
0
};
+
return types;
}
NULL,
NULL
};
+
g_type_add_interface_static (filesink_type, GST_TYPE_URI_HANDLER,
&urihandler_info);
GST_DEBUG_CATEGORY_INIT (gst_filesink_debug, "filesink", 0,
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOCATION,
g_param_spec_string ("location", "File Location",
- "Location of the file to write", NULL, G_PARAM_READWRITE));
+ "Location of the file to write", NULL, G_PARAM_READWRITE));
gst_filesink_signals[SIGNAL_HANDOFF] =
g_signal_new ("handoff", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
/* open the file */
if (sink->filename == NULL || sink->filename[0] == '\0') {
GST_ELEMENT_ERROR (sink, RESOURCE, NOT_FOUND,
- (_("No file name specified for writing.")), (NULL));
+ (_("No file name specified for writing.")), (NULL));
return FALSE;
}
sink->file = fopen (sink->filename, "w");
if (sink->file == NULL) {
GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_WRITE,
- (_("Could not open file \"%s\" for writing."), sink->filename),
- GST_ERROR_SYSTEM);
+ (_("Could not open file \"%s\" for writing."), sink->filename),
+ GST_ERROR_SYSTEM);
return FALSE;
}
if (fclose (sink->file) != 0) {
GST_ELEMENT_ERROR (sink, RESOURCE, CLOSE,
- (_("Error closing file \"%s\"."), sink->filename), GST_ERROR_SYSTEM);
+ (_("Error closing file \"%s\"."), sink->filename), GST_ERROR_SYSTEM);
} else {
GST_FLAG_UNSET (sink, GST_FILESINK_OPEN);
}
switch (type) {
case GST_QUERY_TOTAL:
switch (*format) {
- case GST_FORMAT_BYTES:
- if (GST_FLAG_IS_SET (GST_ELEMENT (sink), GST_FILESINK_OPEN)) {
- *value = sink->data_written; /* FIXME - doesn't the kernel provide
- such a function? */
- break;
- }
- default:
- return FALSE;
+ case GST_FORMAT_BYTES:
+ if (GST_FLAG_IS_SET (GST_ELEMENT (sink), GST_FILESINK_OPEN)) {
+ *value = sink->data_written; /* FIXME - doesn't the kernel provide
+ such a function? */
+ break;
+ }
+ default:
+ return FALSE;
}
break;
case GST_QUERY_POSITION:
switch (*format) {
- case GST_FORMAT_BYTES:
- if (GST_FLAG_IS_SET (GST_ELEMENT (sink), GST_FILESINK_OPEN)) {
- *value = ftell (sink->file);
- break;
- }
- default:
- return FALSE;
+ case GST_FORMAT_BYTES:
+ if (GST_FLAG_IS_SET (GST_ELEMENT (sink), GST_FILESINK_OPEN)) {
+ *value = ftell (sink->file);
+ break;
+ }
+ default:
+ return FALSE;
}
break;
default:
switch (type) {
case GST_EVENT_SEEK:
g_return_val_if_fail (GST_EVENT_SEEK_FORMAT (event) == GST_FORMAT_BYTES,
- FALSE);
+ FALSE);
if (GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_FLUSH)
- if (fflush (filesink->file))
- GST_ELEMENT_ERROR (filesink, RESOURCE, WRITE,
- (_("Error while writing to file \"%s\"."), filesink->filename),
- GST_ERROR_SYSTEM);
+ if (fflush (filesink->file))
+ GST_ELEMENT_ERROR (filesink, RESOURCE, WRITE,
+ (_("Error while writing to file \"%s\"."), filesink->filename),
+ GST_ERROR_SYSTEM);
switch (GST_EVENT_SEEK_METHOD (event)) {
- case GST_SEEK_METHOD_SET:
- fseek (filesink->file, GST_EVENT_SEEK_OFFSET (event), SEEK_SET);
- break;
- case GST_SEEK_METHOD_CUR:
- fseek (filesink->file, GST_EVENT_SEEK_OFFSET (event), SEEK_CUR);
- break;
- case GST_SEEK_METHOD_END:
- fseek (filesink->file, GST_EVENT_SEEK_OFFSET (event), SEEK_END);
- break;
- default:
- g_warning ("unknown seek method!");
- break;
+ case GST_SEEK_METHOD_SET:
+ fseek (filesink->file, GST_EVENT_SEEK_OFFSET (event), SEEK_SET);
+ break;
+ case GST_SEEK_METHOD_CUR:
+ fseek (filesink->file, GST_EVENT_SEEK_OFFSET (event), SEEK_CUR);
+ break;
+ case GST_SEEK_METHOD_END:
+ fseek (filesink->file, GST_EVENT_SEEK_OFFSET (event), SEEK_END);
+ break;
+ default:
+ g_warning ("unknown seek method!");
+ break;
}
break;
case GST_EVENT_DISCONTINUOUS:
gint64 offset;
if (gst_event_discont_get_value (event, GST_FORMAT_BYTES, &offset))
- fseek (filesink->file, offset, SEEK_SET);
+ fseek (filesink->file, offset, SEEK_SET);
gst_event_unref (event);
break;
}
case GST_EVENT_FLUSH:
if (fflush (filesink->file)) {
- GST_ELEMENT_ERROR (filesink, RESOURCE, WRITE,
- (_("Error while writing to file \"%s\"."), filesink->filename),
- GST_ERROR_SYSTEM);
+ GST_ELEMENT_ERROR (filesink, RESOURCE, WRITE,
+ (_("Error while writing to file \"%s\"."), filesink->filename),
+ GST_ERROR_SYSTEM);
}
break;
case GST_EVENT_EOS:
back_pending = filesink->data_written - ftell (filesink->file);
while (bytes_written < GST_BUFFER_SIZE (buf)) {
size_t wrote = fwrite (GST_BUFFER_DATA (buf) + bytes_written, 1,
- GST_BUFFER_SIZE (buf) - bytes_written,
- filesink->file);
+ GST_BUFFER_SIZE (buf) - bytes_written,
+ filesink->file);
if (wrote <= 0) {
- GST_ELEMENT_ERROR (filesink, RESOURCE, WRITE,
- (_("Error while writing to file \"%s\"."), filesink->filename),
- ("Only %d of %d bytes written: %s",
- bytes_written, GST_BUFFER_SIZE (buf), strerror (errno)));
- break;
+ GST_ELEMENT_ERROR (filesink, RESOURCE, WRITE,
+ (_("Error while writing to file \"%s\"."), filesink->filename),
+ ("Only %d of %d bytes written: %s",
+ bytes_written, GST_BUFFER_SIZE (buf), strerror (errno)));
+ break;
}
bytes_written += wrote;
}
switch (GST_STATE_TRANSITION (element)) {
case GST_STATE_PAUSED_TO_READY:
if (GST_FLAG_IS_SET (element, GST_FILESINK_OPEN))
- gst_filesink_close_file (GST_FILESINK (element));
+ gst_filesink_close_file (GST_FILESINK (element));
break;
case GST_STATE_READY_TO_PAUSED:
if (!GST_FLAG_IS_SET (element, GST_FILESINK_OPEN)) {
- if (!gst_filesink_open_file (GST_FILESINK (element)))
- return GST_STATE_FAILURE;
+ if (!gst_filesink_open_file (GST_FILESINK (element)))
+ return GST_STATE_FAILURE;
}
break;
}
gst_filesink_uri_get_protocols (void)
{
static gchar *protocols[] = { "file", NULL };
+
return protocols;
}
static const gchar *
{
static const GstEventMask masks[] = {
{GST_EVENT_SEEK, GST_SEEK_METHOD_CUR |
- GST_SEEK_METHOD_SET | GST_SEEK_METHOD_END | GST_SEEK_FLAG_FLUSH},
+ GST_SEEK_METHOD_SET | GST_SEEK_METHOD_END | GST_SEEK_FLAG_FLUSH},
{GST_EVENT_FLUSH, 0},
{GST_EVENT_SIZE, 0},
{0, 0}
};
+
return masks;
}
GST_QUERY_POSITION,
0
};
+
return types;
}
GST_FORMAT_BYTES,
0,
};
+
return formats;
}
NULL,
NULL
};
+
g_type_add_interface_static (filesrc_type, GST_TYPE_URI_HANDLER,
&urihandler_info);
GST_DEBUG_CATEGORY_INIT (gst_filesrc_debug, "filesrc", 0, "filesrc element");
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FD,
g_param_spec_int ("fd", "File-descriptor",
- "File-descriptor for the file being mmap()d", 0, G_MAXINT, 0,
- G_PARAM_READABLE));
+ "File-descriptor for the file being mmap()d", 0, G_MAXINT, 0,
+ G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOCATION,
g_param_spec_string ("location", "File Location",
- "Location of the file to read", NULL, G_PARAM_READWRITE));
+ "Location of the file to read", NULL, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BLOCKSIZE,
g_param_spec_ulong ("blocksize", "Block size",
- "Size in bytes to read per buffer", 1, G_MAXULONG, DEFAULT_BLOCKSIZE,
- G_PARAM_READWRITE));
+ "Size in bytes to read per buffer", 1, G_MAXULONG, DEFAULT_BLOCKSIZE,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MMAPSIZE,
g_param_spec_ulong ("mmapsize", "mmap() Block Size",
- "Size in bytes of mmap()d regions", 0, G_MAXULONG, DEFAULT_MMAPSIZE,
- G_PARAM_READWRITE));
+ "Size in bytes of mmap()d regions", 0, G_MAXULONG, DEFAULT_MMAPSIZE,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TOUCH,
g_param_spec_boolean ("touch", "Touch read data",
- "Touch data to force disk read", FALSE, G_PARAM_READWRITE));
+ "Touch data to force disk read", FALSE, G_PARAM_READWRITE));
gobject_class->dispose = gst_filesrc_dispose;
gobject_class->set_property = gst_filesrc_set_property;
src->touch = FALSE;
src->mapbuf = NULL;
- src->mapsize = DEFAULT_MMAPSIZE; /* default is 4MB */
+ src->mapsize = DEFAULT_MMAPSIZE; /* default is 4MB */
src->seek_happened = FALSE;
}
break;
case ARG_MMAPSIZE:
if ((src->mapsize % src->pagesize) == 0) {
- src->mapsize = g_value_get_ulong (value);
- g_object_notify (G_OBJECT (src), "mmapsize");
+ src->mapsize = g_value_get_ulong (value);
+ g_object_notify (G_OBJECT (src), "mmapsize");
} else {
- GST_INFO_OBJECT (src,
- "invalid mapsize, must be a multiple of pagesize, which is %d",
- src->pagesize);
+ GST_INFO_OBJECT (src,
+ "invalid mapsize, must be a multiple of pagesize, which is %d",
+ src->pagesize);
}
break;
case ARG_TOUCH:
return NULL;
} else if (mmapregion == MAP_FAILED) {
GST_WARNING_OBJECT (src, "mmap (0x%08lx, %d, 0x%llx) failed: %s",
- (unsigned long) size, src->fd, offset, strerror (errno));
+ (unsigned long) size, src->fd, offset, strerror (errno));
return NULL;
}
GST_LOG_OBJECT (src, "mapped region %08lx+%08lx from file into memory at %p",
mapbase = offset - mod;
mapsize =
- ((size + mod + src->pagesize - 1) / src->pagesize) * src->pagesize;
+ ((size + mod + src->pagesize - 1) / src->pagesize) * src->pagesize;
/* printf("not on page boundaries, resizing map to %d+%d\n",mapbase,mapsize);*/
map = gst_filesrc_map_region (src, mapbase, mapsize);
if (map == NULL)
/* calculate end pointers so we don't have to do so repeatedly later */
readsize = src->block_size;
- readend = src->curoffset + src->block_size; /* note this is the byte *after* the read */
+ readend = src->curoffset + src->block_size; /* note this is the byte *after* the read */
mapstart = GST_BUFFER_OFFSET (src->mapbuf);
mapsize = GST_BUFFER_SIZE (src->mapbuf);
- mapend = mapstart + mapsize; /* note this is the byte *after* the map */
+ mapend = mapstart + mapsize; /* note this is the byte *after* the map */
/* check to see if we're going to overflow the end of the file */
if (readend > src->filelen) {
/* ('cause by definition if readend is in the buffer, so's readstart) */
if (readend <= mapend) {
GST_LOG_OBJECT (src,
- "read buf %llu+%d lives in current mapbuf %lld+%d, creating subbuffer of mapbuf",
- src->curoffset, (int) readsize, mapstart, mapsize);
+ "read buf %llu+%d lives in current mapbuf %lld+%d, creating subbuffer of mapbuf",
+ src->curoffset, (int) readsize, mapstart, mapsize);
buf =
- gst_buffer_create_sub (src->mapbuf, src->curoffset - mapstart,
- readsize);
+ gst_buffer_create_sub (src->mapbuf, src->curoffset - mapstart,
+ readsize);
GST_BUFFER_OFFSET (buf) = src->curoffset;
/* if the start actually is within the current mmap region, map an overlap buffer */
} else if (src->curoffset < mapend) {
GST_LOG_OBJECT (src,
- "read buf %llu+%d starts in mapbuf %d+%d but ends outside, creating new mmap",
- (unsigned long long) src->curoffset, (gint) readsize, (gint) mapstart,
- (gint) mapsize);
+ "read buf %llu+%d starts in mapbuf %d+%d but ends outside, creating new mmap",
+ (unsigned long long) src->curoffset, (gint) readsize, (gint) mapstart,
+ (gint) mapsize);
buf = gst_filesrc_map_small_region (src, src->curoffset, readsize);
if (buf == NULL)
- return NULL;
+ return NULL;
}
/* the only other option is that buffer is totally outside, which means we search for it */
/* or the read buffer fully contains the current mmap region */
/* either way, it's really not relevant, we just create a new region anyway */
GST_LOG_OBJECT (src,
- "read buf %llu+%d starts before mapbuf %d+%d, but overlaps it",
- (unsigned long long) src->curoffset, (gint) readsize, (gint) mapstart,
- (gint) mapsize);
+ "read buf %llu+%d starts before mapbuf %d+%d, but overlaps it",
+ (unsigned long long) src->curoffset, (gint) readsize, (gint) mapstart,
+ (gint) mapsize);
buf = gst_filesrc_map_small_region (src, src->curoffset, readsize);
if (buf == NULL)
return NULL;
if (buf == NULL) {
/* first check to see if there's a map that covers the right region already */
GST_LOG_OBJECT (src, "searching for mapbuf to cover %llu+%d",
- src->curoffset, (int) readsize);
+ src->curoffset, (int) readsize);
/* if the read buffer crosses a mmap region boundary, create a one-off region */
if ((src->curoffset / src->mapsize) != (readend / src->mapsize)) {
GST_LOG_OBJECT (src,
- "read buf %llu+%d crosses a %d-byte boundary, creating a one-off",
- src->curoffset, (int) readsize, (int) src->mapsize);
+ "read buf %llu+%d crosses a %d-byte boundary, creating a one-off",
+ src->curoffset, (int) readsize, (int) src->mapsize);
buf = gst_filesrc_map_small_region (src, src->curoffset, readsize);
if (buf == NULL)
- return NULL;
+ return NULL;
/* otherwise we will create a new mmap region and set it to the default */
} else {
off_t nextmap = src->curoffset - (src->curoffset % src->mapsize);
GST_LOG_OBJECT (src,
- "read buf %llu+%d in new mapbuf at %llu+%d, mapping and subbuffering",
- src->curoffset, readsize, nextmap, src->mapsize);
+ "read buf %llu+%d in new mapbuf at %llu+%d, mapping and subbuffering",
+ src->curoffset, readsize, nextmap, src->mapsize);
/* first, we're done with the old mapbuf */
gst_buffer_unref (src->mapbuf);
mapsize = src->mapsize;
/* double the mapsize as long as the readsize is smaller */
while (readsize - (src->curoffset - nextmap) > mapsize) {
- GST_LOG_OBJECT (src, "readsize smaller then mapsize %08x %d",
- readsize, (int) mapsize);
- mapsize <<= 1;
+ GST_LOG_OBJECT (src, "readsize smaller then mapsize %08x %d",
+ readsize, (int) mapsize);
+ mapsize <<= 1;
}
/* create a new one */
src->mapbuf = gst_filesrc_map_region (src, nextmap, mapsize);
if (src->mapbuf == NULL)
- return NULL;
+ return NULL;
/* subbuffer it */
buf =
- gst_buffer_create_sub (src->mapbuf, src->curoffset - nextmap,
- readsize);
+ gst_buffer_create_sub (src->mapbuf, src->curoffset - nextmap,
+ readsize);
GST_BUFFER_OFFSET (buf) =
- GST_BUFFER_OFFSET (src->mapbuf) + src->curoffset - nextmap;
+ GST_BUFFER_OFFSET (src->mapbuf) + src->curoffset - nextmap;
}
}
readsize = src->block_size;
if (src->curoffset + readsize > src->filelen) {
if (!gst_filesrc_check_filesize (src)
- || src->curoffset + readsize > src->filelen) {
+ || src->curoffset + readsize > src->filelen) {
readsize = src->filelen - src->curoffset;
}
}
}
if (ret < readsize) {
GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL),
- ("unexpected end of file."));
+ ("unexpected end of file."));
return NULL;
}
src->seek_happened = FALSE;
GST_DEBUG_OBJECT (src, "sending discont");
event =
- gst_event_new_discontinuous (FALSE, GST_FORMAT_BYTES, src->curoffset,
- NULL);
+ gst_event_new_discontinuous (FALSE, GST_FORMAT_BYTES, src->curoffset,
+ NULL);
return GST_DATA (event);
}
if (src->curoffset == src->filelen) {
if (!gst_filesrc_check_filesize (src) || src->curoffset >= src->filelen) {
GST_DEBUG_OBJECT (src, "eos %" G_GINT64_FORMAT " %" G_GINT64_FORMAT,
- src->curoffset, src->filelen);
+ src->curoffset, src->filelen);
gst_element_set_eos (GST_ELEMENT (src));
return GST_DATA (gst_event_new (GST_EVENT_EOS));
}
if (src->filename == NULL || src->filename[0] == '\0') {
GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND,
- (_("No file name specified for reading.")), (NULL));
+ (_("No file name specified for reading.")), (NULL));
return FALSE;
}
GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND, (NULL), (NULL));
else
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
- (_("Could not open file \"%s\" for reading."), src->filename),
- GST_ERROR_SYSTEM);
+ (_("Could not open file \"%s\" for reading."), src->filename),
+ GST_ERROR_SYSTEM);
return FALSE;
} else {
/* check if it is a regular file, otherwise bail out */
if (!S_ISREG (stat_results.st_mode)) {
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
- (_("File \"%s\" isn't a regular file."), src->filename), (NULL));
+ (_("File \"%s\" isn't a regular file."), src->filename), (NULL));
close (src->fd);
return FALSE;
}
break;
case GST_STATE_READY_TO_PAUSED:
if (!GST_FLAG_IS_SET (element, GST_FILESRC_OPEN)) {
- if (!gst_filesrc_open_file (GST_FILESRC (element)))
- return GST_STATE_FAILURE;
+ if (!gst_filesrc_open_file (GST_FILESRC (element)))
+ return GST_STATE_FAILURE;
}
break;
case GST_STATE_PAUSED_TO_READY:
if (GST_FLAG_IS_SET (element, GST_FILESRC_OPEN))
- gst_filesrc_close_file (GST_FILESRC (element));
+ gst_filesrc_close_file (GST_FILESRC (element));
src->seek_happened = TRUE;
break;
default:
switch (type) {
case GST_QUERY_TOTAL:
if (*format != GST_FORMAT_BYTES) {
- return FALSE;
+ return FALSE;
}
gst_filesrc_check_filesize (src);
*value = src->filelen;
break;
case GST_QUERY_POSITION:
switch (*format) {
- case GST_FORMAT_BYTES:
- *value = src->curoffset;
- break;
- case GST_FORMAT_PERCENT:
- if (src->filelen == 0)
- return FALSE;
- *value = src->curoffset * GST_FORMAT_PERCENT_MAX / src->filelen;
- break;
- default:
- return FALSE;
+ case GST_FORMAT_BYTES:
+ *value = src->curoffset;
+ break;
+ case GST_FORMAT_PERCENT:
+ if (src->filelen == 0)
+ return FALSE;
+ *value = src->curoffset * GST_FORMAT_PERCENT_MAX / src->filelen;
+ break;
+ default:
+ return FALSE;
}
break;
default:
gint64 offset;
if (GST_EVENT_SEEK_FORMAT (event) != GST_FORMAT_BYTES) {
- goto error;
+ goto error;
}
offset = GST_EVENT_SEEK_OFFSET (event);
switch (GST_EVENT_SEEK_METHOD (event)) {
- case GST_SEEK_METHOD_SET:
- if (offset > src->filelen && (!gst_filesrc_check_filesize (src)
- || offset > src->filelen)) {
- goto error;
- }
- src->curoffset = offset;
- GST_DEBUG_OBJECT (src, "seek set pending to %" G_GINT64_FORMAT,
- src->curoffset);
- break;
- case GST_SEEK_METHOD_CUR:
- if (offset + src->curoffset > src->filelen)
- if (!gst_filesrc_check_filesize (src)
- || offset + src->curoffset > src->filelen)
- goto error;
- src->curoffset += offset;
- GST_DEBUG_OBJECT (src, "seek cur pending to %" G_GINT64_FORMAT,
- src->curoffset);
- break;
- case GST_SEEK_METHOD_END:
- if (ABS (offset) > src->filelen) {
- if (!gst_filesrc_check_filesize (src)
- || ABS (offset) > src->filelen)
- goto error;
- goto error;
- }
- src->curoffset = src->filelen - ABS (offset);
- GST_DEBUG_OBJECT (src, "seek end pending to %" G_GINT64_FORMAT,
- src->curoffset);
- break;
- default:
- goto error;
- break;
+ case GST_SEEK_METHOD_SET:
+ if (offset > src->filelen && (!gst_filesrc_check_filesize (src)
+ || offset > src->filelen)) {
+ goto error;
+ }
+ src->curoffset = offset;
+ GST_DEBUG_OBJECT (src, "seek set pending to %" G_GINT64_FORMAT,
+ src->curoffset);
+ break;
+ case GST_SEEK_METHOD_CUR:
+ if (offset + src->curoffset > src->filelen)
+ if (!gst_filesrc_check_filesize (src)
+ || offset + src->curoffset > src->filelen)
+ goto error;
+ src->curoffset += offset;
+ GST_DEBUG_OBJECT (src, "seek cur pending to %" G_GINT64_FORMAT,
+ src->curoffset);
+ break;
+ case GST_SEEK_METHOD_END:
+ if (ABS (offset) > src->filelen) {
+ if (!gst_filesrc_check_filesize (src)
+ || ABS (offset) > src->filelen)
+ goto error;
+ goto error;
+ }
+ src->curoffset = src->filelen - ABS (offset);
+ GST_DEBUG_OBJECT (src, "seek end pending to %" G_GINT64_FORMAT,
+ src->curoffset);
+ break;
+ default:
+ goto error;
+ break;
}
src->seek_happened = TRUE;
src->need_flush = GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_FLUSH;
}
case GST_EVENT_SIZE:
if (GST_EVENT_SIZE_FORMAT (event) != GST_FORMAT_BYTES) {
- goto error;
+ goto error;
}
src->block_size = GST_EVENT_SIZE_VALUE (event);
g_object_notify (G_OBJECT (src), "blocksize");
gst_filesrc_uri_get_protocols (void)
{
static gchar *protocols[] = { "file", NULL };
+
return protocols;
}
static const gchar *
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOOP_BASED,
g_param_spec_boolean ("loop-based", "Loop-based",
- "Set to TRUE to use loop-based rather than chain-based scheduling",
- TRUE, G_PARAM_READWRITE));
+ "Set to TRUE to use loop-based rather than chain-based scheduling",
+ TRUE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SLEEP_TIME,
g_param_spec_uint ("sleep-time", "Sleep time",
- "Microseconds to sleep between processing", 0, G_MAXUINT, 0,
- G_PARAM_READWRITE));
+ "Microseconds to sleep between processing", 0, G_MAXUINT, 0,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DUPLICATE,
g_param_spec_uint ("duplicate", "Duplicate Buffers",
- "Push the buffers N times", 0, G_MAXUINT, 1, G_PARAM_READWRITE));
+ "Push the buffers N times", 0, G_MAXUINT, 1, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ERROR_AFTER,
g_param_spec_int ("error_after", "Error After", "Error after N buffers",
- G_MININT, G_MAXINT, -1, G_PARAM_READWRITE));
+ G_MININT, G_MAXINT, -1, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DROP_PROBABILITY,
g_param_spec_float ("drop_probability", "Drop Probability",
- "The Probability a buffer is dropped", 0.0, 1.0, 0.0,
- G_PARAM_READWRITE));
+ "The Probability a buffer is dropped", 0.0, 1.0, 0.0,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SILENT,
g_param_spec_boolean ("silent", "silent", "silent", FALSE,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LAST_MESSAGE,
g_param_spec_string ("last-message", "last-message", "last-message", NULL,
- G_PARAM_READABLE));
+ G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DUMP,
g_param_spec_boolean ("dump", "Dump", "Dump buffer contents", FALSE,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE));
gst_identity_signals[SIGNAL_HANDOFF] =
g_signal_new ("handoff", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
if (identity->error_after == 0) {
gst_buffer_unref (buf);
GST_ELEMENT_ERROR (identity, CORE, FAILED,
- (_("Failed after iterations as requested.")), (NULL));
+ (_("Failed after iterations as requested.")), (NULL));
return;
}
}
if (identity->drop_probability > 0.0) {
if ((gfloat) (1.0 * rand () / (RAND_MAX)) < identity->drop_probability) {
if (identity->last_message != NULL) {
- g_free (identity->last_message);
+ g_free (identity->last_message);
}
identity->last_message =
- g_strdup_printf ("dropping ******* (%s:%s)i (%d bytes, %"
- G_GINT64_FORMAT ")", GST_DEBUG_PAD_NAME (identity->sinkpad),
- GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf));
+ g_strdup_printf ("dropping ******* (%s:%s)i (%d bytes, %"
+ G_GINT64_FORMAT ")", GST_DEBUG_PAD_NAME (identity->sinkpad),
+ GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf));
g_object_notify (G_OBJECT (identity), "last-message");
gst_buffer_unref (buf);
return;
if (!identity->silent) {
g_free (identity->last_message);
identity->last_message =
- g_strdup_printf ("chain ******* (%s:%s)i (%d bytes, %"
- G_GINT64_FORMAT ")", GST_DEBUG_PAD_NAME (identity->sinkpad),
- GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf));
+ g_strdup_printf ("chain ******* (%s:%s)i (%d bytes, %"
+ G_GINT64_FORMAT ")", GST_DEBUG_PAD_NAME (identity->sinkpad),
+ GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf));
g_object_notify (G_OBJECT (identity), "last-message");
}
g_signal_emit (G_OBJECT (identity), gst_identity_signals[SIGNAL_HANDOFF], 0,
- buf);
+ buf);
if (i > 1)
gst_buffer_ref (buf);
case ARG_LOOP_BASED:
identity->loop_based = g_value_get_boolean (value);
if (identity->loop_based) {
- gst_element_set_loop_function (GST_ELEMENT (identity),
- gst_identity_loop);
- gst_pad_set_chain_function (identity->sinkpad, NULL);
+ gst_element_set_loop_function (GST_ELEMENT (identity),
+ gst_identity_loop);
+ gst_pad_set_chain_function (identity->sinkpad, NULL);
} else {
- gst_pad_set_chain_function (identity->sinkpad, gst_identity_chain);
- gst_element_set_loop_function (GST_ELEMENT (identity), NULL);
+ gst_pad_set_chain_function (identity->sinkpad, gst_identity_chain);
+ gst_element_set_loop_function (GST_ELEMENT (identity), NULL);
}
break;
case ARG_SLEEP_TIME:
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MD5,
g_param_spec_string ("md5", "md5", "current value of the md5 sum",
- "", G_PARAM_READABLE));
+ "", G_PARAM_READABLE));
gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_md5sink_change_state);
}
guchar *md5string = g_malloc0 (33);
for (i = 0; i < 16; ++i)
- sprintf (md5string + i * 2, "%02x", sink->md5[i]);
+ sprintf (md5string + i * 2, "%02x", sink->md5[i]);
g_value_set_string (value, md5string);
g_free (md5string);
}
G_STRUCT_OFFSET (GstMultiFileSrcClass, new_file), NULL, NULL,
g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
- g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOCATIONS, g_param_spec_pointer ("locations", "locations", "locations", G_PARAM_READWRITE)); /* CHECKME */
+ g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOCATIONS, g_param_spec_pointer ("locations", "locations", "locations", G_PARAM_READWRITE)); /* CHECKME */
gobject_class->set_property = gst_multifilesrc_set_property;
gobject_class->get_property = gst_multifilesrc_get_property;
/* clear the filename if we get a NULL */
if (g_value_get_pointer (value) == NULL) {
- gst_element_set_state (GST_ELEMENT (object), GST_STATE_NULL);
- src->listptr = NULL;
- /* otherwise set the new filenames */
+ gst_element_set_state (GST_ELEMENT (object), GST_STATE_NULL);
+ src->listptr = NULL;
+ /* otherwise set the new filenames */
} else {
- src->listptr = g_value_get_pointer (value);
+ src->listptr = g_value_get_pointer (value);
}
break;
default:
if (src->currentfilename == NULL || src->currentfilename[0] == '\0') {
GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND,
- (_("No file name specified for reading.")), (NULL));
+ (_("No file name specified for reading.")), (NULL));
return FALSE;
}
src->fd = open ((const char *) src->currentfilename, O_RDONLY);
if (src->fd < 0) {
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
- (_("Could not open file \"%s\" for reading."), src->currentfilename),
- GST_ERROR_SYSTEM);
+ (_("Could not open file \"%s\" for reading."), src->currentfilename),
+ GST_ERROR_SYSTEM);
return FALSE;
} else {
if (src->map == NULL) {
close (src->fd);
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY, (NULL),
- ("mmap call failed."));
+ ("mmap call failed."));
return FALSE;
}
GST_FLAG_SET (src, GST_MULTIFILESRC_OPEN);
gobject_class->set_property = gst_pipefilter_set_property;
gobject_class->get_property = gst_pipefilter_get_property;
- g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_COMMAND, g_param_spec_string ("command", "command", "command", NULL, G_PARAM_READWRITE)); /* CHECKME */
+ g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_COMMAND, g_param_spec_string ("command", "command", "command", NULL, G_PARAM_READWRITE)); /* CHECKME */
gstelement_class->change_state = gst_pipefilter_change_state;
}
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
if (close (pipefilter->fdin[1]) < 0)
- perror ("close");
+ perror ("close");
if (close (pipefilter->fdout[0]) < 0)
- perror ("close");
+ perror ("close");
break;
default:
break;
close (src->fdin[1]);
close (src->fdout[0]);
/* child */
- dup2 (src->fdin[0], STDIN_FILENO); /* set the childs input stream */
- dup2 (src->fdout[1], STDOUT_FILENO); /* set the childs output stream */
+ dup2 (src->fdin[0], STDIN_FILENO); /* set the childs input stream */
+ dup2 (src->fdout[1], STDOUT_FILENO); /* set the childs output stream */
execvp (src->command[0], &src->command[0]);
/* will only be reached if execvp has an error */
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY, (NULL), GST_ERROR_SYSTEM);
} else {
if (!GST_FLAG_IS_SET (element, GST_PIPEFILTER_OPEN)) {
if (!gst_pipefilter_open_file (GST_PIPEFILTER (element)))
- return GST_STATE_FAILURE;
+ return GST_STATE_FAILURE;
}
}
GstPad *sinkpad;
GstPad *srcpad;
GstBuffer *buffer;
-} GstShaperConnection;
+}
+GstShaperConnection;
GstStaticPadTemplate shaper_src_template = GST_STATIC_PAD_TEMPLATE ("src%d",
GST_PAD_SRC,
{SHAPER_POLICY_BUFFERSIZE, "2", "sync on buffer size"},
{0, NULL, NULL},
};
+
if (!shaper_policy_type) {
shaper_policy_type =
- g_enum_register_static ("GstShaperPolicy", shaper_policy);
+ g_enum_register_static ("GstShaperPolicy", shaper_policy);
}
return shaper_policy_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_POLICY,
g_param_spec_enum ("policy", "Policy", "Shaper policy",
- GST_TYPE_SHAPER_POLICY, SHAPER_POLICY_TIMESTAMPS, G_PARAM_READWRITE));
+ GST_TYPE_SHAPER_POLICY, SHAPER_POLICY_TIMESTAMPS, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SILENT,
g_param_spec_boolean ("silent", "silent", "silent",
- FALSE, G_PARAM_READWRITE));
+ FALSE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LAST_MESSAGE,
g_param_spec_string ("last-message", "last-message", "last-message",
- NULL, G_PARAM_READABLE));
+ NULL, G_PARAM_READABLE));
gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_shaper_set_property);
gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_shaper_get_property);
/* events are simply pushed ASAP */
if (GST_IS_EVENT (buffer)) {
- /* save event type as it will be unreffed after the next push */
- GstEventType type = GST_EVENT_TYPE (buffer);
-
- gst_pad_push (connection->srcpad, GST_DATA (buffer));
-
- switch (type) {
- /* on EOS we disable the pad so that we don't pull on
- * it again and never get more data */
- case GST_EVENT_EOS:
- gst_pad_set_active (connection->sinkpad, FALSE);
- break;
- default:
- break;
- }
+ /* save event type as it will be unreffed after the next push */
+ GstEventType type = GST_EVENT_TYPE (buffer);
+
+ gst_pad_push (connection->srcpad, GST_DATA (buffer));
+
+ switch (type) {
+ /* on EOS we disable the pad so that we don't pull on
+ * it again and never get more data */
+ case GST_EVENT_EOS:
+ gst_pad_set_active (connection->sinkpad, FALSE);
+ break;
+ default:
+ break;
+ }
} else {
- /* we store the buffer */
- connection->buffer = buffer;
+ /* we store the buffer */
+ connection->buffer = buffer;
}
}
/* FIXME policy stuff goes here */
/* find connection with lowest timestamp */
if (min == NULL || (connection->buffer != NULL &&
- (GST_BUFFER_TIMESTAMP (connection->buffer) <
- GST_BUFFER_TIMESTAMP (min->buffer)))) {
+ (GST_BUFFER_TIMESTAMP (connection->buffer) <
+ GST_BUFFER_TIMESTAMP (min->buffer)))) {
min = connection;
}
connections = g_slist_next (connections);
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BUFFERS,
g_param_spec_int64 ("buffers", "buffers", "total buffers count",
- 0, G_MAXINT64, 0, G_PARAM_READABLE));
+ 0, G_MAXINT64, 0, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BYTES,
g_param_spec_int64 ("bytes", "bytes", "total bytes count",
- 0, G_MAXINT64, 0, G_PARAM_READABLE));
+ 0, G_MAXINT64, 0, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_EVENTS,
g_param_spec_int64 ("events", "events", "total event count",
- 0, G_MAXINT64, 0, G_PARAM_READABLE));
+ 0, G_MAXINT64, 0, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass),
ARG_BUFFER_UPDATE_FREQ, g_param_spec_int64 ("buffer_update_freq",
- "buffer update freq", "buffer update frequency", 0, G_MAXINT64, 0,
- G_PARAM_READWRITE));
+ "buffer update freq", "buffer update frequency", 0, G_MAXINT64, 0,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass),
ARG_BYTES_UPDATE_FREQ, g_param_spec_int64 ("bytes_update_freq",
- "bytes update freq", "bytes update frequency", 0, G_MAXINT64, 0,
- G_PARAM_READWRITE));
+ "bytes update freq", "bytes update frequency", 0, G_MAXINT64, 0,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass),
ARG_EVENT_UPDATE_FREQ, g_param_spec_int64 ("event_update_freq",
- "event update freq", "event update frequency", 0, G_MAXINT64, 0,
- G_PARAM_READWRITE));
+ "event update freq", "event update frequency", 0, G_MAXINT64, 0,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_UPDATE_ON_EOS,
g_param_spec_boolean ("update_on_eos", "update on EOS",
- "update on EOS event", TRUE, G_PARAM_READWRITE));
+ "update on EOS event", TRUE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_UPDATE,
g_param_spec_boolean ("update", "update", "update", TRUE,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SILENT,
g_param_spec_boolean ("silent", "silent", "silent", TRUE,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE));
gst_statistics_signals[SIGNAL_UPDATE] =
g_signal_new ("update", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
if (GST_EVENT_TYPE (event) == GST_EVENT_EOS) {
gst_element_set_eos (GST_ELEMENT (statistics));
if (statistics->update_on_eos) {
- update = TRUE;
+ update = TRUE;
}
}
if (statistics->update_freq.events) {
statistics->update_count.events += 1;
if (statistics->update_count.events == statistics->update_freq.events) {
- statistics->update_count.events = 0;
- update = TRUE;
+ statistics->update_count.events = 0;
+ update = TRUE;
}
}
} else {
if (statistics->update_freq.buffers) {
statistics->update_count.buffers += 1;
if (statistics->update_count.buffers == statistics->update_freq.buffers) {
- statistics->update_count.buffers = 0;
- update = TRUE;
+ statistics->update_count.buffers = 0;
+ update = TRUE;
}
}
if (statistics->update_freq.bytes) {
statistics->update_count.bytes += GST_BUFFER_SIZE (buf);
if (statistics->update_count.bytes >= statistics->update_freq.bytes) {
- statistics->update_count.bytes = 0;
- update = TRUE;
+ statistics->update_count.bytes = 0;
+ update = TRUE;
}
}
}
if (statistics->update) {
GST_DEBUG ("[%s]: pre update emit", GST_ELEMENT_NAME (statistics));
g_signal_emit (G_OBJECT (statistics),
- gst_statistics_signals[SIGNAL_UPDATE], 0);
+ gst_statistics_signals[SIGNAL_UPDATE], 0);
GST_DEBUG ("[%s]: post update emit", GST_ELEMENT_NAME (statistics));
}
if (!statistics->silent) {
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NUM_PADS,
g_param_spec_int ("num_pads", "num_pads", "num_pads",
- 0, G_MAXINT, 0, G_PARAM_READABLE));
+ 0, G_MAXINT, 0, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SILENT,
g_param_spec_boolean ("silent", "silent", "silent",
- TRUE, G_PARAM_CONSTRUCT | G_PARAM_READWRITE));
+ TRUE, G_PARAM_CONSTRUCT | G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LAST_MESSAGE,
g_param_spec_string ("last_message", "last_message", "last_message",
- NULL, G_PARAM_READABLE));
+ NULL, G_PARAM_READABLE));
gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_tee_set_property);
g_assert (GST_IS_PAD (pad));
- return strcmp (name, gst_pad_get_name (pad)); /* returns 0 if match */
+ return strcmp (name, gst_pad_get_name (pad)); /* returns 0 if match */
}
static GstPad *
while (!name) {
name = g_strdup_printf ("src%d", i);
if (g_list_find_custom ((GList *) pads, (gconstpointer) name,
- name_pad_compare) != NULL) {
+ name_pad_compare) != NULL) {
/* this name is taken, use the next one */
++i;
g_free (name);
if (!tee->silent) {
g_free (tee->last_message);
tee->last_message =
- g_strdup_printf ("chain ******* (%s:%s)t (%d bytes, %"
- G_GUINT64_FORMAT ") %p", GST_DEBUG_PAD_NAME (outpad),
- GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf), buf);
+ g_strdup_printf ("chain ******* (%s:%s)t (%d bytes, %"
+ G_GUINT64_FORMAT ") %p", GST_DEBUG_PAD_NAME (outpad),
+ GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf), buf);
g_object_notify (G_OBJECT (tee), "last_message");
}
};
enum
{
- MODE_NORMAL, /* act as identity */
- MODE_TYPEFIND, /* do typefinding */
+ MODE_NORMAL, /* act as identity */
+ MODE_TYPEFIND, /* do typefinding */
};
g_object_class_install_property (gobject_class, ARG_CAPS,
g_param_spec_boxed ("caps", _("caps"),
- _("detected capabilities in stream"), gst_caps_get_type (),
- G_PARAM_READABLE));
+ _("detected capabilities in stream"), gst_caps_get_type (),
+ G_PARAM_READABLE));
g_object_class_install_property (gobject_class, ARG_MINIMUM,
g_param_spec_uint ("minimum", _("minimum"),
- "minimum probability required to accept caps", GST_TYPE_FIND_MINIMUM,
- GST_TYPE_FIND_MAXIMUM, GST_TYPE_FIND_MINIMUM, G_PARAM_READWRITE));
+ "minimum probability required to accept caps", GST_TYPE_FIND_MINIMUM,
+ GST_TYPE_FIND_MAXIMUM, GST_TYPE_FIND_MINIMUM, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_MINIMUM,
g_param_spec_uint ("maximum", _("maximum"),
- "probability to stop typefinding", GST_TYPE_FIND_MINIMUM,
- GST_TYPE_FIND_MAXIMUM, GST_TYPE_FIND_MAXIMUM, G_PARAM_READWRITE));
+ "probability to stop typefinding", GST_TYPE_FIND_MINIMUM,
+ GST_TYPE_FIND_MAXIMUM, GST_TYPE_FIND_MAXIMUM, G_PARAM_READWRITE));
gst_type_find_element_signals[HAVE_TYPE] = g_signal_new ("have_type",
G_TYPE_FROM_CLASS (typefind_class), G_SIGNAL_RUN_LAST,
{
static const GstEventMask mask[] = {
{GST_EVENT_SEEK,
- GST_SEEK_METHOD_SET | GST_SEEK_METHOD_CUR | GST_SEEK_METHOD_END |
- GST_SEEK_FLAG_FLUSH},
+ GST_SEEK_METHOD_SET | GST_SEEK_METHOD_CUR | GST_SEEK_METHOD_END |
+ GST_SEEK_FLAG_FLUSH},
/* add more if you want, event masks suck and need to die anyway */
{0,}
};
GList *buffers;
GstTypeFindElement *self;
-} TypeFindEntry;
+}
+TypeFindEntry;
static inline TypeFindEntry *
new_entry (void)
if (typefind->possibilities != NULL) {
/* this should only happen on PAUSED => READY or EOS */
GST_LOG_OBJECT (typefind, "freeing remaining %u typefind functions",
- g_list_length (typefind->possibilities));
+ g_list_length (typefind->possibilities));
g_list_foreach (typefind->possibilities, (GFunc) free_entry, NULL);
g_list_free (typefind->possibilities);
typefind->possibilities = NULL;
guint size = gst_buffer_store_get_size (typefind->store, 0);
if (size
- && (buffer = gst_buffer_store_get_buffer (typefind->store, 0, size))) {
+ && (buffer = gst_buffer_store_get_buffer (typefind->store, 0, size))) {
GST_LOG_OBJECT (typefind, "pushing cached data (%u bytes)", size);
gst_pad_push (typefind->src, GST_DATA (buffer));
} else {
}
GST_LOG_OBJECT (typefind, "seeking back to current position %u", size);
if (!gst_pad_send_event (GST_PAD_PEER (typefind->sink),
- gst_event_new_seek (GST_SEEK_METHOD_SET | GST_FORMAT_BYTES,
- size))) {
+ gst_event_new_seek (GST_SEEK_METHOD_SET | GST_FORMAT_BYTES,
+ size))) {
GST_WARNING_OBJECT (typefind,
- "could not seek to required position %u, hope for the best", size);
+ "could not seek to required position %u, hope for the best", size);
}
}
gst_buffer_store_clear (typefind->store);
if (!typefind->stream_length_available) {
GST_LOG_OBJECT (entry->self,
- "'%s' called get_length () but we know it's not available",
- GST_PLUGIN_FEATURE_NAME (entry->factory));
+ "'%s' called get_length () but we know it's not available",
+ GST_PLUGIN_FEATURE_NAME (entry->factory));
return 0;
}
if (entry->self->stream_length == 0) {
typefind->stream_length_available =
- gst_pad_query (GST_PAD_PEER (entry->self->sink), GST_QUERY_TOTAL,
- &format, &entry->self->stream_length);
+ gst_pad_query (GST_PAD_PEER (entry->self->sink), GST_QUERY_TOTAL,
+ &format, &entry->self->stream_length);
if (format != GST_FORMAT_BYTES)
typefind->stream_length_available = FALSE;
if (!typefind->stream_length_available) {
GST_DEBUG_OBJECT (entry->self,
- "'%s' called get_length () but it's not available",
- GST_PLUGIN_FEATURE_NAME (entry->factory));
+ "'%s' called get_length () but it's not available",
+ GST_PLUGIN_FEATURE_NAME (entry->factory));
return 0;
} else {
GST_DEBUG_OBJECT (entry->self,
- "'%s' called get_length () and it's %" G_GUINT64_FORMAT " bytes",
- GST_PLUGIN_FEATURE_NAME (entry->factory), entry->self->stream_length);
+ "'%s' called get_length () and it's %" G_GUINT64_FORMAT " bytes",
+ GST_PLUGIN_FEATURE_NAME (entry->factory), entry->self->stream_length);
}
}
/* need to do more? */
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
- /* this should only happen when we got all available data */
- entry =
- (TypeFindEntry *) typefind->possibilities ? typefind->
- possibilities->data : NULL;
- if (entry && entry->probability >= typefind->min_probability) {
- GST_INFO_OBJECT (typefind,
- "'%s' is the best typefind left after we got all data, using it now (probability %u)",
- GST_PLUGIN_FEATURE_NAME (entry->factory), entry->probability);
- g_signal_emit (typefind, gst_type_find_element_signals[HAVE_TYPE], 0,
- entry->probability, entry->caps);
- }
- stop_typefinding (typefind);
- gst_pad_event_default (pad, event);
- break;
+ /* this should only happen when we got all available data */
+ entry =
+ (TypeFindEntry *) typefind->possibilities ? typefind->
+ possibilities->data : NULL;
+ if (entry && entry->probability >= typefind->min_probability) {
+ GST_INFO_OBJECT (typefind,
+ "'%s' is the best typefind left after we got all data, using it now (probability %u)",
+ GST_PLUGIN_FEATURE_NAME (entry->factory), entry->probability);
+ g_signal_emit (typefind, gst_type_find_element_signals[HAVE_TYPE], 0,
+ entry->probability, entry->caps);
+ }
+ stop_typefinding (typefind);
+ gst_pad_event_default (pad, event);
+ break;
default:
- gst_data_unref (GST_DATA (event));
- break;
+ gst_data_unref (GST_DATA (event));
+ break;
}
} else {
gst_pad_event_default (pad, event);
buf = NULL;
} else {
buf =
- gst_buffer_store_get_buffer (entry->self->store, length + offset,
- size);
+ gst_buffer_store_get_buffer (entry->self->store, length + offset,
+ size);
}
}
} else {
if (entry->requested_size == 0) {
GST_LOG_OBJECT (entry->self,
- "setting requested peek (%" G_GINT64_FORMAT ", %u) on '%s'", offset,
- size, GST_PLUGIN_FEATURE_NAME (entry->factory));
+ "setting requested peek (%" G_GINT64_FORMAT ", %u) on '%s'", offset,
+ size, GST_PLUGIN_FEATURE_NAME (entry->factory));
entry->requested_offset = offset;
entry->requested_size = size;
}
gst_buffer_store_add_buffer (typefind->store, GST_BUFFER (data));
current_offset = GST_BUFFER_OFFSET_IS_VALID (data) ?
- GST_BUFFER_OFFSET (data) + GST_BUFFER_SIZE (data) :
- gst_buffer_store_get_size (typefind->store, 0);
+ GST_BUFFER_OFFSET (data) + GST_BUFFER_SIZE (data) :
+ gst_buffer_store_get_size (typefind->store, 0);
gst_data_unref (data);
if (typefind->possibilities == NULL) {
- /* not yet started, get all typefinding functions into our "queue" */
- GList *all_factories = gst_type_find_factory_get_list ();
-
- GST_INFO_OBJECT (typefind, "starting with %u typefinding functions",
- g_list_length ((GList *) all_factories));
-
- all_factories = g_list_sort (all_factories, compare_type_find_factory);
- walk = all_factories;
- while (all_factories) {
- entry = new_entry ();
-
- entry->factory = GST_TYPE_FIND_FACTORY (all_factories->data);
- entry->self = typefind;
- entry->probability = 0;
- typefind->possibilities =
- g_list_prepend (typefind->possibilities, entry);
- all_factories = g_list_next (all_factories);
- }
- g_list_free (all_factories);
+ /* not yet started, get all typefinding functions into our "queue" */
+ GList *all_factories = gst_type_find_factory_get_list ();
+
+ GST_INFO_OBJECT (typefind, "starting with %u typefinding functions",
+ g_list_length ((GList *) all_factories));
+
+ all_factories = g_list_sort (all_factories, compare_type_find_factory);
+ walk = all_factories;
+ while (all_factories) {
+ entry = new_entry ();
+
+ entry->factory = GST_TYPE_FIND_FACTORY (all_factories->data);
+ entry->self = typefind;
+ entry->probability = 0;
+ typefind->possibilities =
+ g_list_prepend (typefind->possibilities, entry);
+ all_factories = g_list_next (all_factories);
+ }
+ g_list_free (all_factories);
}
/* call every typefind function once */
walk = entries = typefind->possibilities;
GST_INFO_OBJECT (typefind, "iterating %u typefinding functions",
- g_list_length (entries));
+ g_list_length (entries));
typefind->possibilities = NULL;
while (walk) {
- find.data = entry = (TypeFindEntry *) walk->data;
- walk = g_list_next (walk);
- entry->probability = 0;
- entry->requested_offset = 0;
- entry->requested_size = 0;
- gst_type_find_factory_call_function (entry->factory, &find);
- free_entry_buffers (entry);
- if (entry->probability == 0 && entry->requested_size == 0) {
- GST_DEBUG_OBJECT (typefind,
- "'%s' was removed - no chance of being the right plugin",
- GST_PLUGIN_FEATURE_NAME (entry->factory));
- free_entry (entry);
- } else if (entry->probability >= typefind->max_probability) {
- /* wooha, got caps */
- GstCaps *found_caps = entry->caps;
- guint probability = entry->probability;
-
- GST_INFO_OBJECT (typefind,
- "'%s' returned %u/%u probability, using it NOW",
- GST_PLUGIN_FEATURE_NAME (entry->factory), probability,
- typefind->max_probability);
- while (walk) {
- free_entry ((TypeFindEntry *) walk->data);
- walk = g_list_next (walk);
- }
- walk = typefind->possibilities;
- while (walk) {
- free_entry (walk->data);
- walk = g_list_next (walk);
- }
- typefind->possibilities = NULL;
- g_list_free (typefind->possibilities);
- g_signal_emit (typefind, gst_type_find_element_signals[HAVE_TYPE], 0,
- probability, found_caps);
- free_entry (entry);
- } else {
- typefind->possibilities =
- g_list_prepend (typefind->possibilities, entry);
- }
+ find.data = entry = (TypeFindEntry *) walk->data;
+ walk = g_list_next (walk);
+ entry->probability = 0;
+ entry->requested_offset = 0;
+ entry->requested_size = 0;
+ gst_type_find_factory_call_function (entry->factory, &find);
+ free_entry_buffers (entry);
+ if (entry->probability == 0 && entry->requested_size == 0) {
+ GST_DEBUG_OBJECT (typefind,
+ "'%s' was removed - no chance of being the right plugin",
+ GST_PLUGIN_FEATURE_NAME (entry->factory));
+ free_entry (entry);
+ } else if (entry->probability >= typefind->max_probability) {
+ /* wooha, got caps */
+ GstCaps *found_caps = entry->caps;
+ guint probability = entry->probability;
+
+ GST_INFO_OBJECT (typefind,
+ "'%s' returned %u/%u probability, using it NOW",
+ GST_PLUGIN_FEATURE_NAME (entry->factory), probability,
+ typefind->max_probability);
+ while (walk) {
+ free_entry ((TypeFindEntry *) walk->data);
+ walk = g_list_next (walk);
+ }
+ walk = typefind->possibilities;
+ while (walk) {
+ free_entry (walk->data);
+ walk = g_list_next (walk);
+ }
+ typefind->possibilities = NULL;
+ g_list_free (typefind->possibilities);
+ g_signal_emit (typefind, gst_type_find_element_signals[HAVE_TYPE], 0,
+ probability, found_caps);
+ free_entry (entry);
+ } else {
+ typefind->possibilities =
+ g_list_prepend (typefind->possibilities, entry);
+ }
}
g_list_free (entries);
/* we may now already have caps or we might be left without functions to try */
if (typefind->caps) {
- stop_typefinding (typefind);
+ stop_typefinding (typefind);
} else if (typefind->possibilities == NULL) {
- GST_ELEMENT_ERROR (typefind, STREAM, TYPE_NOT_FOUND, (NULL), (NULL));
+ GST_ELEMENT_ERROR (typefind, STREAM, TYPE_NOT_FOUND, (NULL), (NULL));
} else {
- /* set up typefind element for next iteration */
- typefind->possibilities =
- g_list_sort (typefind->possibilities, compare_type_find_entry);
-
- /* look for typefind functions that require data without seeking */
- for (walk = typefind->possibilities; walk; walk = g_list_next (walk)) {
- entry = (TypeFindEntry *) walk->data;
- if (entry->requested_offset <= current_offset &&
- entry->requested_offset + entry->requested_size > current_offset)
- break;
- }
- if (!walk) {
- /* find out if we should seek */
- for (walk = typefind->possibilities; walk; walk = g_list_next (walk)) {
- entry = (TypeFindEntry *) walk->data;
- if (entry->requested_size > 0) {
- /* FIXME: need heuristic to find out if we should seek */
- gint64 seek_offset;
- GstEvent *event;
-
- seek_offset =
- entry->requested_offset >
- 0 ? entry->
- requested_offset : find_element_get_length (entry) +
- entry->requested_offset;
- seek_offset +=
- gst_buffer_store_get_size (typefind->store, seek_offset);
- event =
- gst_event_new_seek (GST_FORMAT_BYTES | GST_SEEK_METHOD_SET,
- seek_offset);
- if (gst_pad_send_event (GST_PAD_PEER (typefind->sink), event)) {
- /* done seeking */
- GST_DEBUG_OBJECT (typefind,
- "'%s' was reset - seeked to %" G_GINT64_FORMAT,
- GST_PLUGIN_FEATURE_NAME (entry->factory), seek_offset);
- break;
- } else if (entry->requested_offset < 0) {
- /* impossible to seek */
- GST_DEBUG_OBJECT (typefind,
- "'%s' was reset - couldn't seek to %" G_GINT64_FORMAT,
- GST_PLUGIN_FEATURE_NAME (entry->factory), seek_offset);
- entry->requested_size = 0;
- entry->requested_offset = 0;
- }
- }
- }
- }
- /* throw out all entries that can't get more data */
- walk = g_list_next (typefind->possibilities);
- while (walk) {
- GList *cur = walk;
-
- entry = (TypeFindEntry *) walk->data;
- walk = g_list_next (walk);
- if (entry->requested_size == 0) {
- GST_DEBUG_OBJECT (typefind,
- "'%s' was removed - higher possibilities available",
- GST_PLUGIN_FEATURE_NAME (entry->factory));
- free_entry (entry);
- typefind->possibilities =
- g_list_delete_link (typefind->possibilities, cur);
- }
- }
- if (g_list_next (typefind->possibilities) == NULL) {
- entry = (TypeFindEntry *) typefind->possibilities->data;
- if (entry->probability > typefind->min_probability) {
- GST_INFO_OBJECT (typefind,
- "'%s' is the only typefind left, using it now (probability %u)",
- GST_PLUGIN_FEATURE_NAME (entry->factory), entry->probability);
- g_signal_emit (typefind, gst_type_find_element_signals[HAVE_TYPE],
- 0, entry->probability, entry->caps);
- free_entry (entry);
- g_list_free (typefind->possibilities);
- typefind->possibilities = NULL;
- stop_typefinding (typefind);
- }
- }
+ /* set up typefind element for next iteration */
+ typefind->possibilities =
+ g_list_sort (typefind->possibilities, compare_type_find_entry);
+
+ /* look for typefind functions that require data without seeking */
+ for (walk = typefind->possibilities; walk; walk = g_list_next (walk)) {
+ entry = (TypeFindEntry *) walk->data;
+ if (entry->requested_offset <= current_offset &&
+ entry->requested_offset + entry->requested_size > current_offset)
+ break;
+ }
+ if (!walk) {
+ /* find out if we should seek */
+ for (walk = typefind->possibilities; walk; walk = g_list_next (walk)) {
+ entry = (TypeFindEntry *) walk->data;
+ if (entry->requested_size > 0) {
+ /* FIXME: need heuristic to find out if we should seek */
+ gint64 seek_offset;
+ GstEvent *event;
+
+ seek_offset =
+ entry->requested_offset >
+ 0 ? entry->
+ requested_offset : find_element_get_length (entry) +
+ entry->requested_offset;
+ seek_offset +=
+ gst_buffer_store_get_size (typefind->store, seek_offset);
+ event =
+ gst_event_new_seek (GST_FORMAT_BYTES | GST_SEEK_METHOD_SET,
+ seek_offset);
+ if (gst_pad_send_event (GST_PAD_PEER (typefind->sink), event)) {
+ /* done seeking */
+ GST_DEBUG_OBJECT (typefind,
+ "'%s' was reset - seeked to %" G_GINT64_FORMAT,
+ GST_PLUGIN_FEATURE_NAME (entry->factory), seek_offset);
+ break;
+ } else if (entry->requested_offset < 0) {
+ /* impossible to seek */
+ GST_DEBUG_OBJECT (typefind,
+ "'%s' was reset - couldn't seek to %" G_GINT64_FORMAT,
+ GST_PLUGIN_FEATURE_NAME (entry->factory), seek_offset);
+ entry->requested_size = 0;
+ entry->requested_offset = 0;
+ }
+ }
+ }
+ }
+ /* throw out all entries that can't get more data */
+ walk = g_list_next (typefind->possibilities);
+ while (walk) {
+ GList *cur = walk;
+
+ entry = (TypeFindEntry *) walk->data;
+ walk = g_list_next (walk);
+ if (entry->requested_size == 0) {
+ GST_DEBUG_OBJECT (typefind,
+ "'%s' was removed - higher possibilities available",
+ GST_PLUGIN_FEATURE_NAME (entry->factory));
+ free_entry (entry);
+ typefind->possibilities =
+ g_list_delete_link (typefind->possibilities, cur);
+ }
+ }
+ if (g_list_next (typefind->possibilities) == NULL) {
+ entry = (TypeFindEntry *) typefind->possibilities->data;
+ if (entry->probability > typefind->min_probability) {
+ GST_INFO_OBJECT (typefind,
+ "'%s' is the only typefind left, using it now (probability %u)",
+ GST_PLUGIN_FEATURE_NAME (entry->factory), entry->probability);
+ g_signal_emit (typefind, gst_type_find_element_signals[HAVE_TYPE],
+ 0, entry->probability, entry->caps);
+ free_entry (entry);
+ g_list_free (typefind->possibilities);
+ typefind->possibilities = NULL;
+ stop_typefinding (typefind);
+ }
+ }
}
break;
}
#include "gst_private.h"
#include "gst-i18n-lib.h"
-#include <locale.h> /* for LC_ALL */
+#include <locale.h> /* for LC_ALL */
#include "gst.h"
#include "gstqueue.h"
*/
static const GstPoptOption gstreamer_options[] = {
{NULL, NUL, POPT_ARG_CALLBACK | POPT_CBFLAG_PRE | POPT_CBFLAG_POST,
- (void *) &init_popt_callback, 0, NULL, NULL},
+ (void *) &init_popt_callback, 0, NULL, NULL},
/* make sure we use our GETTEXT_PACKAGE as the domain for popt translations */
{NULL, NUL, POPT_ARG_INTL_DOMAIN, GETTEXT_PACKAGE, 0, NULL, NULL},
{"gst-version", NUL, POPT_ARG_NONE | POPT_ARGFLAG_STRIP, NULL, ARG_VERSION,
- N_("Print the GStreamer version"), NULL},
+ N_("Print the GStreamer version"), NULL},
{"gst-fatal-warnings", NUL, POPT_ARG_NONE | POPT_ARGFLAG_STRIP, NULL,
- ARG_FATAL_WARNINGS, N_("Make all warnings fatal"), NULL},
+ ARG_FATAL_WARNINGS, N_("Make all warnings fatal"), NULL},
#ifndef GST_DISABLE_GST_DEBUG
{"gst-debug-help", NUL, POPT_ARG_NONE | POPT_ARGFLAG_STRIP, NULL,
- ARG_DEBUG_HELP, N_("Print available debug categories and exit"), NULL},
+ ARG_DEBUG_HELP, N_("Print available debug categories and exit"), NULL},
{"gst-debug-level", NUL, POPT_ARG_INT | POPT_ARGFLAG_STRIP, NULL,
- ARG_DEBUG_LEVEL,
- N_
- ("Default debug level from 1 (only error) to 5 (anything) or 0 for no output"),
- N_("LEVEL")},
+ ARG_DEBUG_LEVEL,
+ N_
+ ("Default debug level from 1 (only error) to 5 (anything) or 0 for no output"),
+ N_("LEVEL")},
{"gst-debug", NUL, POPT_ARG_STRING | POPT_ARGFLAG_STRIP, NULL, ARG_DEBUG,
- N_
- ("Comma-separated list of category_name:level pairs to set specific levels for the individual categories. Example: GST_AUTOPLUG:5,GST_ELEMENT_*:3"),
- N_("LIST")},
+ N_
+ ("Comma-separated list of category_name:level pairs to set specific levels for the individual categories. Example: GST_AUTOPLUG:5,GST_ELEMENT_*:3"),
+ N_("LIST")},
{"gst-debug-no-color", NUL, POPT_ARG_NONE | POPT_ARGFLAG_STRIP, NULL,
- ARG_DEBUG_NO_COLOR, N_("Disable colored debugging output"), NULL},
+ ARG_DEBUG_NO_COLOR, N_("Disable colored debugging output"), NULL},
{"gst-debug-disable", NUL, POPT_ARG_NONE | POPT_ARGFLAG_STRIP, NULL,
- ARG_DEBUG_DISABLE, N_("Disable debugging")},
+ ARG_DEBUG_DISABLE, N_("Disable debugging")},
#endif
{"gst-disable-cpu-opt", NUL, POPT_ARG_NONE | POPT_ARGFLAG_STRIP, NULL,
- ARG_DISABLE_CPU_OPT, N_("Disable accelerated CPU instructions"), NULL},
+ ARG_DISABLE_CPU_OPT, N_("Disable accelerated CPU instructions"), NULL},
{"gst-plugin-spew", NUL, POPT_ARG_NONE | POPT_ARGFLAG_STRIP, NULL,
- ARG_PLUGIN_SPEW, N_("Enable verbose plugin loading diagnostics"), NULL},
+ ARG_PLUGIN_SPEW, N_("Enable verbose plugin loading diagnostics"), NULL},
{"gst-plugin-path", NUL, POPT_ARG_STRING | POPT_ARGFLAG_STRIP, NULL,
- ARG_PLUGIN_PATH,
- N_("path list for loading plugins (separated by '"
- G_SEARCHPATH_SEPARATOR_S "')"), N_("PATHS")},
+ ARG_PLUGIN_PATH,
+ N_("path list for loading plugins (separated by '"
+ G_SEARCHPATH_SEPARATOR_S "')"), N_("PATHS")},
{"gst-plugin-load", NUL, POPT_ARG_STRING | POPT_ARGFLAG_STRIP, NULL,
- ARG_PLUGIN_LOAD,
- N_
- ("Comma-separated list of plugins to preload in addition to the list stored in env variable GST_PLUGIN_PATH"),
- N_("PLUGINS")},
+ ARG_PLUGIN_LOAD,
+ N_
+ ("Comma-separated list of plugins to preload in addition to the list stored in env variable GST_PLUGIN_PATH"),
+ N_("PLUGINS")},
{"gst-disable-segtrap", NUL, POPT_ARG_NONE | POPT_ARGFLAG_STRIP, NULL,
- ARG_SEGTRAP_DISABLE,
- N_("Disable trapping of segmentation faults during plugin loading"),
- NULL},
+ ARG_SEGTRAP_DISABLE,
+ N_("Disable trapping of segmentation faults during plugin loading"),
+ NULL},
{"gst-scheduler", NUL, POPT_ARG_STRING | POPT_ARGFLAG_STRIP, NULL,
- ARG_SCHEDULER,
- N_("Scheduler to use ('" GST_SCHEDULER_DEFAULT_NAME
- "' is the default)"), N_("SCHEDULER")},
+ ARG_SCHEDULER,
+ N_("Scheduler to use ('" GST_SCHEDULER_DEFAULT_NAME
+ "' is the default)"), N_("SCHEDULER")},
{"gst-registry", NUL, POPT_ARG_STRING | POPT_ARGFLAG_STRIP, NULL,
- ARG_REGISTRY, N_("Registry to use"), N_("REGISTRY")},
+ ARG_REGISTRY, N_("Registry to use"), N_("REGISTRY")},
POPT_TABLEEND
};
GstPoptOption *options;
GstPoptOption options_with[] = {
{NULL, NUL, POPT_ARG_INCLUDE_TABLE, poptHelpOptions, 0, "Help options:",
- NULL},
+ NULL},
{NULL, NUL, POPT_ARG_INCLUDE_TABLE, (GstPoptOption *) gstreamer_options, 0,
- "GStreamer options:", NULL},
+ "GStreamer options:", NULL},
{NULL, NUL, POPT_ARG_INCLUDE_TABLE, (GstPoptOption *) popt_options, 0,
- "Application options:", NULL},
+ "Application options:", NULL},
POPT_TABLEEND
};
GstPoptOption options_without[] = {
{NULL, NUL, POPT_ARG_INCLUDE_TABLE, poptHelpOptions, 0, "Help options:",
- NULL},
+ NULL},
{NULL, NUL, POPT_ARG_INCLUDE_TABLE, (GstPoptOption *) gstreamer_options, 0,
- "GStreamer options:", NULL},
+ "GStreamer options:", NULL},
POPT_TABLEEND
};
if (nextopt != -1) {
g_print ("Error on option %s: %s.\nRun '%s --help' "
- "to see a full list of available command line options.\n",
- poptBadOption (context, 0), poptStrerror (nextopt), (*argv)[0]);
+ "to see a full list of available command line options.\n",
+ poptBadOption (context, 0), poptStrerror (nextopt), (*argv)[0]);
poptFreeContext (context);
return FALSE;
g_strstrip (values[1]);
level = strtol (values[1], NULL, 0);
if (level >= 0 && level < GST_LEVEL_COUNT) {
- GST_DEBUG ("setting debugging to level %d for name \"%s\"",
- level, values[0]);
- gst_debug_set_threshold_for_name (values[0], level);
+ GST_DEBUG ("setting debugging to level %d for name \"%s\"",
+ level, values[0]);
+ gst_debug_set_threshold_for_name (values[0], level);
}
}
g_strfreev (values);
while (strings[j]) {
iterator (strings[j], user_data);
if (++j == MAX_PATH_SPLIT) {
- lastlist = g_strdup (strings[j]);
- g_strfreev (strings);
- j = 0;
- break;
+ lastlist = g_strdup (strings[j]);
+ g_strfreev (strings);
+ j = 0;
+ break;
}
}
}
const gchar *homedir;
_global_registry =
- gst_xml_registry_new ("global_registry", GLOBAL_REGISTRY_FILE);
+ gst_xml_registry_new ("global_registry", GLOBAL_REGISTRY_FILE);
#ifdef PLUGINS_USE_BUILDDIR
/* location libgstelements.so */
gst_registry_add_path (_global_registry, PLUGINS_BUILDDIR "/gst/types");
gst_registry_add_path (_global_registry, PLUGINS_BUILDDIR "/gst/autoplug");
gst_registry_add_path (_global_registry,
- PLUGINS_BUILDDIR "/gst/schedulers");
+ PLUGINS_BUILDDIR "/gst/schedulers");
gst_registry_add_path (_global_registry, PLUGINS_BUILDDIR "/gst/indexers");
#else
/* add the main (installed) library path */
{
/* register some standard builtin types */
g_assert (gst_element_register (plugin, "bin", GST_RANK_PRIMARY,
- GST_TYPE_BIN));
+ GST_TYPE_BIN));
g_assert (gst_element_register (plugin, "pipeline", GST_RANK_PRIMARY,
- GST_TYPE_PIPELINE));
+ GST_TYPE_PIPELINE));
g_assert (gst_element_register (plugin, "thread", GST_RANK_PRIMARY,
- GST_TYPE_THREAD));
+ GST_TYPE_THREAD));
g_assert (gst_element_register (plugin, "queue", GST_RANK_PRIMARY,
- GST_TYPE_QUEUE));
+ GST_TYPE_QUEUE));
return TRUE;
}
/* don't override command-line options */
if (g_getenv ("GST_REGISTRY")) {
g_object_set (_global_registry, "location", g_getenv ("GST_REGISTRY"),
- NULL);
+ NULL);
_gst_registry_fixed = TRUE;
}
}
if (!gst_plugin_is_loaded (plugin)) {
#ifndef GST_DISABLE_REGISTRY
if (GST_IS_REGISTRY (plugin->manager)) {
- GST_CAT_LOG (GST_CAT_PLUGIN_LOADING, "loading plugin %s",
- plugin->desc.name);
- if (gst_registry_load_plugin (GST_REGISTRY (plugin->manager),
- plugin) != GST_REGISTRY_OK)
- GST_CAT_WARNING (GST_CAT_PLUGIN_LOADING, "loading plugin %s failed",
- plugin->desc.name);
+ GST_CAT_LOG (GST_CAT_PLUGIN_LOADING, "loading plugin %s",
+ plugin->desc.name);
+ if (gst_registry_load_plugin (GST_REGISTRY (plugin->manager),
+ plugin) != GST_REGISTRY_OK)
+ GST_CAT_WARNING (GST_CAT_PLUGIN_LOADING, "loading plugin %s failed",
+ plugin->desc.name);
}
#endif /* GST_DISABLE_REGISTRY */
}
gchar *color = gst_debug_construct_term_color (cat->color);
g_print ("%s%-20s\033[00m %1d %s %s%s\033[00m\n",
- color,
- gst_debug_category_get_name (cat),
- gst_debug_category_get_threshold (cat),
- gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
- color, gst_debug_category_get_description (cat));
+ color,
+ gst_debug_category_get_name (cat),
+ gst_debug_category_get_threshold (cat),
+ gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
+ color, gst_debug_category_get_description (cat));
g_free (color);
} else {
g_print ("%-20s %1d %s %s\n", gst_debug_category_get_name (cat),
- gst_debug_category_get_threshold (cat),
- gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
- gst_debug_category_get_description (cat));
+ gst_debug_category_get_threshold (cat),
+ gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
+ gst_debug_category_get_description (cat));
}
walk = g_slist_next (walk);
}
switch (reason) {
case POPT_CALLBACK_REASON_PRE:
if (!init_pre ())
- _gst_initialization_failure = TRUE;
+ _gst_initialization_failure = TRUE;
break;
case POPT_CALLBACK_REASON_OPTION:
switch (option->val) {
- case ARG_VERSION:
- g_print ("GStreamer Core Library version %s\n", GST_VERSION);
- exit (0);
- case ARG_FATAL_WARNINGS:
- fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
- fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
- g_log_set_always_fatal (fatal_mask);
- break;
+ case ARG_VERSION:
+ g_print ("GStreamer Core Library version %s\n", GST_VERSION);
+ exit (0);
+ case ARG_FATAL_WARNINGS:
+ fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
+ fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
+ g_log_set_always_fatal (fatal_mask);
+ break;
#ifndef GST_DISABLE_GST_DEBUG
- case ARG_DEBUG_LEVEL:{
- gint tmp = 0;
-
- tmp = strtol (arg, NULL, 0);
- if (tmp >= 0 && tmp < GST_LEVEL_COUNT) {
- gst_debug_set_default_threshold (tmp);
- }
- break;
- }
- case ARG_DEBUG:
- parse_debug_list (arg);
- break;
- case ARG_DEBUG_NO_COLOR:
- gst_debug_set_colored (FALSE);
- break;
- case ARG_DEBUG_DISABLE:
- gst_debug_set_active (FALSE);
- break;
- case ARG_DEBUG_HELP:
- gst_debug_help ();
- exit (0);
+ case ARG_DEBUG_LEVEL:{
+ gint tmp = 0;
+
+ tmp = strtol (arg, NULL, 0);
+ if (tmp >= 0 && tmp < GST_LEVEL_COUNT) {
+ gst_debug_set_default_threshold (tmp);
+ }
+ break;
+ }
+ case ARG_DEBUG:
+ parse_debug_list (arg);
+ break;
+ case ARG_DEBUG_NO_COLOR:
+ gst_debug_set_colored (FALSE);
+ break;
+ case ARG_DEBUG_DISABLE:
+ gst_debug_set_active (FALSE);
+ break;
+ case ARG_DEBUG_HELP:
+ gst_debug_help ();
+ exit (0);
#endif
- case ARG_DISABLE_CPU_OPT:
- _gst_enable_cpu_opt = FALSE;
- break;
- case ARG_PLUGIN_SPEW:
- break;
- case ARG_PLUGIN_PATH:
+ case ARG_DISABLE_CPU_OPT:
+ _gst_enable_cpu_opt = FALSE;
+ break;
+ case ARG_PLUGIN_SPEW:
+ break;
+ case ARG_PLUGIN_PATH:
#ifndef GST_DISABLE_REGISTRY
- split_and_iterate (arg, G_SEARCHPATH_SEPARATOR_S, add_path_func,
- _user_registry);
+ split_and_iterate (arg, G_SEARCHPATH_SEPARATOR_S, add_path_func,
+ _user_registry);
#endif /* GST_DISABLE_REGISTRY */
- break;
- case ARG_PLUGIN_LOAD:
- split_and_iterate (arg, ",", prepare_for_load_plugin_func, NULL);
- break;
- case ARG_SEGTRAP_DISABLE:
- _gst_disable_segtrap = TRUE;
- break;
- case ARG_SCHEDULER:
- gst_scheduler_factory_set_default_name (arg);
- break;
- case ARG_REGISTRY:
+ break;
+ case ARG_PLUGIN_LOAD:
+ split_and_iterate (arg, ",", prepare_for_load_plugin_func, NULL);
+ break;
+ case ARG_SEGTRAP_DISABLE:
+ _gst_disable_segtrap = TRUE;
+ break;
+ case ARG_SCHEDULER:
+ gst_scheduler_factory_set_default_name (arg);
+ break;
+ case ARG_REGISTRY:
#ifndef GST_DISABLE_REGISTRY
- g_object_set (G_OBJECT (_user_registry), "location", arg, NULL);
- _gst_registry_fixed = TRUE;
+ g_object_set (G_OBJECT (_user_registry), "location", arg, NULL);
+ _gst_registry_fixed = TRUE;
#endif /* GST_DISABLE_REGISTRY */
- break;
- default:
- g_warning ("option %d not recognized", option->val);
- break;
+ break;
+ default:
+ g_warning ("option %d not recognized", option->val);
+ break;
}
break;
case POPT_CALLBACK_REASON_POST:
if (!init_post ())
- _gst_initialization_failure = TRUE;
+ _gst_initialization_failure = TRUE;
gst_initialized = TRUE;
break;
}
};
_gst_bin_type =
- g_type_register_static (GST_TYPE_ELEMENT, "GstBin", &bin_info, 0);
+ g_type_register_static (GST_TYPE_ELEMENT, "GstBin", &bin_info, 0);
}
return _gst_bin_type;
}
if (GST_IS_BIN (element)) {
if (GST_FLAG_IS_SET (element, GST_BIN_FLAG_MANAGER)) {
GST_CAT_DEBUG_OBJECT (GST_CAT_PARENTAGE, element,
- "child is already a manager, not resetting sched");
+ "child is already a manager, not resetting sched");
if (GST_ELEMENT_SCHED (element))
- gst_scheduler_add_scheduler (sched, GST_ELEMENT_SCHED (element));
+ gst_scheduler_add_scheduler (sched, GST_ELEMENT_SCHED (element));
return;
}
GST_CAT_DEBUG_OBJECT (GST_CAT_PARENTAGE, element,
- "setting child bin's scheduler to be the same as the parent's");
+ "setting child bin's scheduler to be the same as the parent's");
gst_scheduler_add_element (sched, element);
/* set the children's schedule */
g_list_foreach (GST_BIN (element)->children,
- (GFunc) gst_bin_set_element_sched, sched);
+ (GFunc) gst_bin_set_element_sched, sched);
}
/* otherwise, if it's just a regular old element */
else {
/* we only operate on real pads */
if (!GST_IS_REAL_PAD (pad))
- continue;
+ continue;
/* if the peer element exists and is a candidate */
if (GST_PAD_PEER (pad)) {
- if (gst_pad_get_scheduler (GST_PAD_PEER (pad)) == sched) {
- GST_CAT_LOG (GST_CAT_SCHEDULING,
- "peer is in same scheduler, telling scheduler");
-
- if (GST_PAD_IS_SRC (pad))
- gst_scheduler_pad_link (sched, pad, GST_PAD_PEER (pad));
- else
- gst_scheduler_pad_link (sched, GST_PAD_PEER (pad), pad);
- }
+ if (gst_pad_get_scheduler (GST_PAD_PEER (pad)) == sched) {
+ GST_CAT_LOG (GST_CAT_SCHEDULING,
+ "peer is in same scheduler, telling scheduler");
+
+ if (GST_PAD_IS_SRC (pad))
+ gst_scheduler_pad_link (sched, pad, GST_PAD_PEER (pad));
+ else
+ gst_scheduler_pad_link (sched, GST_PAD_PEER (pad), pad);
+ }
}
}
}
{
if (GST_ELEMENT_SCHED (element) == NULL) {
GST_CAT_DEBUG (GST_CAT_SCHEDULING, "element \"%s\" has no scheduler",
- GST_ELEMENT_NAME (element));
+ GST_ELEMENT_NAME (element));
return;
}
if (GST_FLAG_IS_SET (element, GST_BIN_FLAG_MANAGER)) {
GST_CAT_DEBUG_OBJECT (GST_CAT_PARENTAGE, element,
- "child is already a manager, not unsetting sched");
+ "child is already a manager, not unsetting sched");
if (sched) {
- gst_scheduler_remove_scheduler (sched, GST_ELEMENT_SCHED (element));
+ gst_scheduler_remove_scheduler (sched, GST_ELEMENT_SCHED (element));
}
return;
}
/* for each child, remove them from their schedule */
g_list_foreach (GST_BIN (element)->children,
- (GFunc) gst_bin_unset_element_sched, sched);
+ (GFunc) gst_bin_unset_element_sched, sched);
gst_scheduler_remove_element (GST_ELEMENT_SCHED (element), element);
}
/* we only operate on real pads */
if (!GST_IS_REAL_PAD (pad))
- continue;
+ continue;
/* if the peer element exists and is a candidate */
if (GST_PAD_PEER (pad)) {
- if (gst_pad_get_scheduler (GST_PAD_PEER (pad)) == sched) {
- GST_CAT_LOG (GST_CAT_SCHEDULING,
- "peer is in same scheduler, telling scheduler");
-
- if (GST_PAD_IS_SRC (pad))
- gst_scheduler_pad_unlink (sched, pad, GST_PAD_PEER (pad));
- else
- gst_scheduler_pad_unlink (sched, GST_PAD_PEER (pad), pad);
- }
+ if (gst_pad_get_scheduler (GST_PAD_PEER (pad)) == sched) {
+ GST_CAT_LOG (GST_CAT_SCHEDULING,
+ "peer is in same scheduler, telling scheduler");
+
+ if (GST_PAD_IS_SRC (pad))
+ gst_scheduler_pad_unlink (sched, pad, GST_PAD_PEER (pad));
+ else
+ gst_scheduler_pad_unlink (sched, GST_PAD_PEER (pad), pad);
+ }
}
}
gst_scheduler_remove_element (GST_ELEMENT_SCHED (element), element);
/* then check to see if the element's name is already taken in the bin */
if (gst_object_check_uniqueness (bin->children,
- GST_ELEMENT_NAME (element)) == FALSE) {
+ GST_ELEMENT_NAME (element)) == FALSE) {
g_warning ("Name %s is not unique in bin %s, not adding\n",
- GST_ELEMENT_NAME (element), GST_ELEMENT_NAME (bin));
+ GST_ELEMENT_NAME (element), GST_ELEMENT_NAME (bin));
return;
}
bclass->add_element (bin, element);
} else {
GST_ELEMENT_ERROR (bin, CORE, FAILED, (NULL),
- ("cannot add element %s to bin %s",
- GST_ELEMENT_NAME (element), GST_ELEMENT_NAME (bin)));
+ ("cannot add element %s to bin %s",
+ GST_ELEMENT_NAME (element), GST_ELEMENT_NAME (bin)));
}
}
/* the element must be in the bin's list of children */
if (g_list_find (bin->children, element) == NULL) {
g_warning ("no element \"%s\" in bin \"%s\"\n", GST_ELEMENT_NAME (element),
- GST_ELEMENT_NAME (bin));
+ GST_ELEMENT_NAME (bin));
return;
}
bclass->child_state_change (bin, oldstate, newstate, child);
} else {
g_warning ("cannot signal state change of child %s to bin %s\n",
- GST_ELEMENT_NAME (child), GST_ELEMENT_NAME (bin));
+ GST_ELEMENT_NAME (child), GST_ELEMENT_NAME (bin));
}
}
gint state = (1 << i);
if (GST_STATE (bin) != state) {
- GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, bin,
- "highest child state is %s, changing bin state accordingly",
- gst_element_state_get_name (state));
- GST_STATE_PENDING (bin) = state;
- GST_UNLOCK (bin);
- gst_bin_change_state_norecurse (bin);
- if (state != GST_STATE (bin)) {
- g_warning ("%s: state change in callback %d %d",
- GST_ELEMENT_NAME (bin), state, GST_STATE (bin));
- }
- return;
+ GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, bin,
+ "highest child state is %s, changing bin state accordingly",
+ gst_element_state_get_name (state));
+ GST_STATE_PENDING (bin) = state;
+ GST_UNLOCK (bin);
+ gst_bin_change_state_norecurse (bin);
+ if (state != GST_STATE (bin)) {
+ g_warning ("%s: state change in callback %d %d",
+ GST_ELEMENT_NAME (bin), state, GST_STATE (bin));
+ }
+ return;
}
break;
}
if (old_state == pending) {
GST_CAT_LOG_OBJECT (GST_CAT_STATES, element,
- "old and pending state are both %s, returning",
- gst_element_state_get_name (pending));
+ "old and pending state are both %s, returning",
+ gst_element_state_get_name (pending));
return GST_STATE_SUCCESS;
}
old_child_state = GST_STATE (child);
GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, element,
- "changing state of child %s from current %s to pending %s",
- GST_ELEMENT_NAME (child), gst_element_state_get_name (old_child_state),
- gst_element_state_get_name (pending));
+ "changing state of child %s from current %s to pending %s",
+ GST_ELEMENT_NAME (child), gst_element_state_get_name (old_child_state),
+ gst_element_state_get_name (pending));
switch (gst_element_set_state (child, pending)) {
case GST_STATE_FAILURE:
- GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
- "child '%s' failed to go to state %d(%s)",
- GST_ELEMENT_NAME (child),
- pending, gst_element_state_get_name (pending));
-
- gst_element_set_state (child, old_child_state);
- /* There was a check for elements being in the same scheduling group
- here. Removed by dolphy <julien@moutte.net>. No matter the
- scheduling group we should always return a failure. This change
- seems to work on my machine and fixes tons of issues. If anyone
- want to revert please tell me what it breaks first, Thanks. */
- GST_STATE_PENDING (element) = old_state;
- return GST_STATE_FAILURE;
- break;
+ GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
+ "child '%s' failed to go to state %d(%s)",
+ GST_ELEMENT_NAME (child),
+ pending, gst_element_state_get_name (pending));
+
+ gst_element_set_state (child, old_child_state);
+ /* There was a check for elements being in the same scheduling group
+ here. Removed by dolphy <julien@moutte.net>. No matter the
+ scheduling group we should always return a failure. This change
+ seems to work on my machine and fixes tons of issues. If anyone
+ want to revert please tell me what it breaks first, Thanks. */
+ GST_STATE_PENDING (element) = old_state;
+ return GST_STATE_FAILURE;
+ break;
case GST_STATE_ASYNC:
- GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
- "child '%s' is changing state asynchronously",
- GST_ELEMENT_NAME (child));
- have_async = TRUE;
- break;
+ GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
+ "child '%s' is changing state asynchronously",
+ GST_ELEMENT_NAME (child));
+ have_async = TRUE;
+ break;
case GST_STATE_SUCCESS:
- GST_CAT_DEBUG (GST_CAT_STATES,
- "child '%s' changed state to %d(%s) successfully",
- GST_ELEMENT_NAME (child), pending,
- gst_element_state_get_name (pending));
- break;
+ GST_CAT_DEBUG (GST_CAT_STATES,
+ "child '%s' changed state to %d(%s) successfully",
+ GST_ELEMENT_NAME (child), pending,
+ gst_element_state_get_name (pending));
+ break;
}
}
GstElement *res = gst_bin_get_by_name (GST_BIN (child), name);
if (res)
- return res;
+ return res;
}
children = g_list_next (children);
}
ret = gst_bin_get_by_interface (GST_BIN (walk->data), interface);
if (ret)
- return ret;
+ return ret;
}
walk = g_list_next (walk);
}
ret = g_list_prepend (ret, walk->data);
if (GST_IS_BIN (walk->data)) {
ret = g_list_concat (ret,
- gst_bin_get_all_by_interface (GST_BIN (walk->data), interface));
+ gst_bin_get_all_by_interface (GST_BIN (walk->data), interface));
}
walk = g_list_next (walk);
}
children = children->next;
if (GST_STATE (element) != state) {
switch (gst_element_set_state (element, state)) {
- case GST_STATE_SUCCESS:
- break;
- case GST_STATE_ASYNC:
- if (ret == GST_STATE_SUCCESS)
- ret = GST_STATE_ASYNC;
- break;
- case GST_STATE_FAILURE:
- ret = GST_STATE_FAILURE;
- default:
- /* make sure gst_element_set_state never returns this */
- g_assert_not_reached ();
+ case GST_STATE_SUCCESS:
+ break;
+ case GST_STATE_ASYNC:
+ if (ret == GST_STATE_SUCCESS)
+ ret = GST_STATE_ASYNC;
+ break;
+ case GST_STATE_FAILURE:
+ ret = GST_STATE_FAILURE;
+ default:
+ /* make sure gst_element_set_state never returns this */
+ g_assert_not_reached ();
}
}
}
while (field) {
if (!strcmp (field->name, "children")) {
GST_CAT_INFO (GST_CAT_XML, "[%s]: loading children",
- GST_ELEMENT_NAME (object));
+ GST_ELEMENT_NAME (object));
childlist = field->xmlChildrenNode;
while (childlist) {
- if (!strcmp (childlist->name, "element")) {
- GstElement *element =
- gst_xml_make_element (childlist, GST_OBJECT (bin));
-
- /* it had to be parented to find the pads, now we ref and unparent so
- * we can add it to the bin */
- gst_object_ref (GST_OBJECT (element));
- gst_object_unparent (GST_OBJECT (element));
-
- gst_bin_add (bin, element);
- }
- childlist = childlist->next;
+ if (!strcmp (childlist->name, "element")) {
+ GstElement *element =
+ gst_xml_make_element (childlist, GST_OBJECT (bin));
+
+ /* it had to be parented to find the pads, now we ref and unparent so
+ * we can add it to the bin */
+ gst_object_ref (GST_OBJECT (element));
+ gst_object_unparent (GST_OBJECT (element));
+
+ gst_bin_add (bin, element);
+ }
+ childlist = childlist->next;
}
}
}
} else {
g_warning ("bin \"%s\" is not the managing bin, can't be iterated on!\n",
- GST_ELEMENT_NAME (bin));
+ GST_ELEMENT_NAME (bin));
}
return FALSE;
if (!running) {
if (GST_STATE (bin) == GST_STATE_PLAYING &&
- GST_STATE_PENDING (bin) == GST_STATE_VOID_PENDING) {
+ GST_STATE_PENDING (bin) == GST_STATE_VOID_PENDING) {
GST_CAT_DEBUG (GST_CAT_DATAFLOW,
- "[%s]: polling for child shutdown after useless iteration",
- GST_ELEMENT_NAME (bin));
+ "[%s]: polling for child shutdown after useless iteration",
+ GST_ELEMENT_NAME (bin));
g_usleep (1);
running = TRUE;
}
/* we simply create a subbuffer of the common parent */
newbuf = gst_buffer_create_sub (parent,
- buf1->data - parent->data + offset, len);
+ buf1->data - parent->data + offset, len);
} else {
GST_CAT_DEBUG (GST_CAT_BUFFER,
- "slow path taken while spanning buffers %p and %p", buf1, buf2);
+ "slow path taken while spanning buffers %p and %p", buf1, buf2);
/* otherwise we simply have to brute-force copy the buffers */
newbuf = gst_buffer_new_and_alloc (len);
memcpy (newbuf->data, buf1->data + offset, buf1->size - offset);
/* copy the second buffer's data across */
memcpy (newbuf->data + (buf1->size - offset), buf2->data,
- len - (buf1->size - offset));
+ len - (buf1->size - offset));
/* if the offset is 0, the new buffer has the same timestamp as buf1 */
if (offset == 0) {
GST_BUFFER_OFFSET (newbuf) = GST_BUFFER_OFFSET (buf1);
* invalid DURATIONS */
if (offset == 0 && buf1->size + buf2->size == len) {
if (GST_BUFFER_DURATION_IS_VALID (buf1) &&
- GST_BUFFER_DURATION_IS_VALID (buf2)) {
+ GST_BUFFER_DURATION_IS_VALID (buf2)) {
/* add duration */
GST_BUFFER_DURATION (newbuf) = GST_BUFFER_DURATION (buf1) +
- GST_BUFFER_DURATION (buf2);
+ GST_BUFFER_DURATION (buf2);
}
if (GST_BUFFER_OFFSET_END_IS_VALID (buf2)) {
/* add offset_end */
if (!gst_caps_type) {
gst_caps_type = g_boxed_type_register_static ("GstCaps",
- (GBoxedCopyFunc) gst_caps_copy_conditional,
- (GBoxedFreeFunc) gst_caps_free);
+ (GBoxedCopyFunc) gst_caps_copy_conditional,
+ (GBoxedFreeFunc) gst_caps_free);
g_value_register_transform_func (gst_caps_type,
- G_TYPE_STRING, gst_caps_transform_to_string);
+ G_TYPE_STRING, gst_caps_transform_to_string);
}
return gst_caps_type;
GstStructure *dest;
const GstStructure *intersect;
gboolean first_run;
-} IntersectData;
+}
+IntersectData;
static gboolean
gst_caps_structure_intersect_field (GQuark id, GValue * val1, gpointer data)
data.intersect = struct2;
data.first_run = TRUE;
if (!gst_structure_foreach ((GstStructure *) struct1,
- gst_caps_structure_intersect_field, &data))
+ gst_caps_structure_intersect_field, &data))
goto error;
data.intersect = struct1;
data.first_run = FALSE;
if (!gst_structure_foreach ((GstStructure *) struct2,
- gst_caps_structure_intersect_field, &data))
+ gst_caps_structure_intersect_field, &data))
goto error;
return data.dest;
continue;
} else {
if (gst_value_union (&dest_value, &field1->value, &field2->value)) {
- gst_structure_set_value (dest, g_quark_to_string (field1->name),
- &dest_value);
+ gst_structure_set_value (dest, g_quark_to_string (field1->name),
+ &dest_value);
} else {
- ret = gst_value_compare (&field1->value, &field2->value);
+ ret = gst_value_compare (&field1->value, &field2->value);
}
}
}
{
GstCaps *caps;
GstStructure *structure;
-} NormalizeForeach;
+}
+NormalizeForeach;
static gboolean
gst_caps_normalize_foreach (GQuark field_id, GValue * value, gpointer ptr)
nf.structure = gst_caps_get_structure (newcaps, i);
while (!gst_structure_foreach (nf.structure,
- gst_caps_normalize_foreach, &nf));
+ gst_caps_normalize_foreach, &nf));
}
return newcaps;
for (j = 0; j < gst_caps_get_size (newcaps); j++) {
struct2 = gst_caps_get_structure (caps, i);
if (gst_caps_structure_simplify (struct2, structure)) {
- break;
+ break;
}
}
if (j == gst_caps_get_size (newcaps)) {
void
gst_caps_replace (GstCaps ** caps, GstCaps * newcaps)
{
-#if 0 /* disable this, since too many plugins rely on undefined behavior */
+#if 0 /* disable this, since too many plugins rely on undefined behavior */
#ifdef USE_POISONING
//if (newcaps) CAPS_POISON (newcaps);
#endif
for (i = 0; i < n; i++) {
list_value = gst_value_list_get_value (value, i);
if (G_VALUE_TYPE (list_value) == G_TYPE_INT) {
- int x = g_value_get_int (list_value);
+ int x = g_value_get_int (list_value);
- if (best_index == -1 || (ABS (target - x) < ABS (best - x))) {
- best_index = i;
- best = x;
- }
+ if (best_index == -1 || (ABS (target - x) < ABS (best - x))) {
+ best_index = i;
+ best = x;
+ }
}
}
if (best_index != -1) {
for (i = 0; i < n; i++) {
list_value = gst_value_list_get_value (value, i);
if (G_VALUE_TYPE (list_value) == G_TYPE_DOUBLE) {
- double x = g_value_get_double (list_value);
+ double x = g_value_get_double (list_value);
- if (best_index == -1 || (ABS (target - x) < ABS (best - x))) {
- best_index = i;
- best = x;
- }
+ if (best_index == -1 || (ABS (target - x) < ABS (best - x))) {
+ best_index = i;
+ best = x;
+ }
}
}
if (best_index != -1) {
(GInstanceInitFunc) gst_clock_init,
NULL
};
+
clock_type = g_type_register_static (GST_TYPE_OBJECT, "GstClock",
- &clock_info, G_TYPE_FLAG_ABSTRACT);
+ &clock_info, G_TYPE_FLAG_ABSTRACT);
}
return clock_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_STATS,
g_param_spec_boolean ("stats", "Stats", "Enable clock stats",
- FALSE, G_PARAM_READWRITE));
+ FALSE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MAX_DIFF,
g_param_spec_int64 ("max-diff", "Max diff",
- "The maximum amount of time to wait in nanoseconds", 0, G_MAXINT64,
- DEFAULT_MAX_DIFF, G_PARAM_READWRITE));
+ "The maximum amount of time to wait in nanoseconds", 0, G_MAXINT64,
+ DEFAULT_MAX_DIFF, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_EVENT_DIFF,
g_param_spec_uint64 ("event-diff", "event diff",
- "The amount of time that may elapse until 2 events are treated as happening at different times",
- 0, G_MAXUINT64, DEFAULT_EVENT_DIFF,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+ "The amount of time that may elapse until 2 events are treated as happening at different times",
+ 0, G_MAXUINT64, DEFAULT_EVENT_DIFF,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
}
static void
if (cclass->change_resolution)
clock->resolution =
- cclass->change_resolution (clock, clock->resolution, resolution);
+ cclass->change_resolution (clock, clock->resolution, resolution);
return clock->resolution;
}
if (clock->last_event + clock->max_event_diff >= time) {
GST_LOG_OBJECT (clock, "reporting last event time %" G_GUINT64_FORMAT,
- clock->last_event);
+ clock->last_event);
} else {
GST_LOG_OBJECT (clock, "reporting new event time %" G_GUINT64_FORMAT,
- clock->last_event);
+ clock->last_event);
clock->last_event = time;
}
gst_cpuid_i386 (0x80000001, &eax, &ebx, &ecx, &edx);
if (edx & (1 << 31)) {
- _gst_cpu_flags |= GST_CPU_FLAG_3DNOW;
- g_string_append (featurelist, "3DNOW ");
+ _gst_cpu_flags |= GST_CPU_FLAG_3DNOW;
+ g_string_append (featurelist, "3DNOW ");
}
if (AMD && (edx & (1 << 22))) {
- _gst_cpu_flags |= GST_CPU_FLAG_MMXEXT;
- g_string_append (featurelist, "MMXEXT ");
+ _gst_cpu_flags |= GST_CPU_FLAG_MMXEXT;
+ g_string_append (featurelist, "MMXEXT ");
}
}
}
if (!type)
type = g_boxed_type_register_static ("GstData",
- (GBoxedCopyFunc) gst_data_copy, (GBoxedFreeFunc) gst_data_unref);
+ (GBoxedCopyFunc) gst_data_copy, (GBoxedFreeFunc) gst_data_unref);
return type;
}
(GInstanceInitFunc) gst_element_init,
NULL
};
+
_gst_element_type = g_type_register_static (GST_TYPE_OBJECT, "GstElement",
- &element_info, G_TYPE_FLAG_ABSTRACT);
+ &element_info, G_TYPE_FLAG_ABSTRACT);
}
return _gst_element_type;
}
{
const GParamSpec *pspec;
GValue value;
-} prop_value_t;
+}
+prop_value_t;
static void
element_set_property (GstElement * element, const GParamSpec * pspec,
while ((prop_value = g_async_queue_try_pop (element->prop_value_queue))) {
g_object_set_property ((GObject *) element, prop_value->pspec->name,
- &prop_value->value);
+ &prop_value->value);
g_value_unset (&prop_value->value);
g_free (prop_value);
}
if (!pspec) {
g_warning ("%s: object class `%s' has no property named `%s'",
- G_STRLOC, G_OBJECT_TYPE_NAME (object), name);
+ G_STRLOC, G_OBJECT_TYPE_NAME (object), name);
break;
}
if (!(pspec->flags & G_PARAM_WRITABLE)) {
g_warning ("%s: property `%s' of object class `%s' is not writable",
- G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (object));
+ G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (object));
break;
}
if (!pspec) {
g_warning ("%s: object class `%s' has no property named `%s'",
- G_STRLOC, G_OBJECT_TYPE_NAME (object), name);
+ G_STRLOC, G_OBJECT_TYPE_NAME (object), name);
break;
}
if (!(pspec->flags & G_PARAM_READABLE)) {
g_warning ("%s: property `%s' of object class `%s' is not readable",
- G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (object));
+ G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (object));
break;
}
if (!pspec)
g_warning ("%s: object class `%s' has no property named `%s'",
- G_STRLOC, G_OBJECT_TYPE_NAME (object), property_name);
+ G_STRLOC, G_OBJECT_TYPE_NAME (object), property_name);
else
element_set_property (element, pspec, value);
if (!pspec)
g_warning ("%s: object class `%s' has no property named `%s'",
- G_STRLOC, G_OBJECT_TYPE_NAME (object), property_name);
+ G_STRLOC, G_OBJECT_TYPE_NAME (object), property_name);
else {
GValue *prop_value, tmp_value = { 0, };
g_value_reset (value);
prop_value = value;
} else if (!g_value_type_transformable (G_PARAM_SPEC_VALUE_TYPE (pspec),
- G_VALUE_TYPE (value))) {
+ G_VALUE_TYPE (value))) {
g_warning
- ("can't retrieve property `%s' of type `%s' as value of type `%s'",
- pspec->name, g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
- G_VALUE_TYPE_NAME (value));
+ ("can't retrieve property `%s' of type `%s' as value of type `%s'",
+ pspec->name, g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
+ G_VALUE_TYPE_NAME (value));
g_object_unref (object);
return;
} else {
if (GST_ELEMENT_SCHED (element)) {
GST_CAT_DEBUG (GST_CAT_CLOCK, "waiting on scheduler clock");
res =
- gst_scheduler_clock_wait (GST_ELEMENT_SCHED (element), element, id,
- jitter);
+ gst_scheduler_clock_wait (GST_ELEMENT_SCHED (element), element, id,
+ jitter);
} else {
GST_CAT_DEBUG (GST_CAT_CLOCK, "no scheduler, returning GST_CLOCK_TIMEOUT");
res = GST_CLOCK_TIMEOUT;
case GST_STATE_PLAYING:
event_time = gst_clock_get_event_time (element->clock);
GST_CAT_LOG_OBJECT (GST_CAT_CLOCK, element,
- "clock time %llu: setting element time to %llu", event_time, time);
+ "clock time %llu: setting element time to %llu", event_time, time);
element->base_time = event_time - time;
break;
default:
switch (element->current_state) {
case GST_STATE_PAUSED:
if (diff < 0 && element->base_time < abs (diff)) {
- g_warning ("attempted to set the current time of element %s below 0",
- GST_OBJECT_NAME (element));
- element->base_time = 0;
+ g_warning ("attempted to set the current time of element %s below 0",
+ GST_OBJECT_NAME (element));
+ element->base_time = 0;
} else {
- element->base_time += diff;
+ element->base_time += diff;
}
break;
case GST_STATE_PLAYING:
time = gst_clock_get_time (element->clock);
if (time < element->base_time - diff) {
- g_warning ("attempted to set the current time of element %s below 0",
- GST_OBJECT_NAME (element));
- element->base_time = time;
+ g_warning ("attempted to set the current time of element %s below 0",
+ GST_OBJECT_NAME (element));
+ element->base_time = time;
} else {
- element->base_time -= diff;
+ element->base_time -= diff;
}
break;
default:
/* then check to see if there's already a pad by that name here */
g_return_if_fail (gst_object_check_uniqueness (element->pads,
- GST_PAD_NAME (pad)) == TRUE);
+ GST_PAD_NAME (pad)) == TRUE);
GST_CAT_INFO_OBJECT (GST_CAT_ELEMENT_PADS, element, "adding pad '%s'",
GST_STR_NULL (GST_OBJECT_NAME (pad)));
/* 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);
+ name) == TRUE, NULL);
ghostpad = gst_ghost_pad_new (name, pad);
pad = GST_PAD (walk->data);
if (strcmp (GST_PAD_NAME (pad), name) == 0) {
GST_CAT_INFO (GST_CAT_ELEMENT_PADS, "found pad %s:%s",
- GST_DEBUG_PAD_NAME (pad));
+ GST_DEBUG_PAD_NAME (pad));
return pad;
}
walk = g_list_next (walk);
while (!templ_found && list) {
templ = (GstPadTemplate *) list->data;
if (templ->presence == GST_PAD_REQUEST) {
- /* Because of sanity checks in gst_pad_template_new(), we know that %s
- and %d, occurring at the end of the name_template, are the only
- possibilities. */
- GST_CAT_DEBUG (GST_CAT_PADS, "comparing %s to %s", name,
- templ->name_template);
- if ((str = strchr (templ->name_template, '%'))
- && strncmp (templ->name_template, name,
- str - templ->name_template) == 0
- && strlen (name) > str - templ->name_template) {
- data = name + (str - templ->name_template);
- if (*(str + 1) == 'd') {
- /* it's an int */
- n = (gint) strtol (data, &endptr, 10);
- if (endptr && *endptr == '\0') {
- templ_found = TRUE;
- req_name = name;
- break;
- }
- } else {
- /* it's a string */
- templ_found = TRUE;
- req_name = name;
- break;
- }
- }
+ /* Because of sanity checks in gst_pad_template_new(), we know that %s
+ and %d, occurring at the end of the name_template, are the only
+ possibilities. */
+ GST_CAT_DEBUG (GST_CAT_PADS, "comparing %s to %s", name,
+ templ->name_template);
+ if ((str = strchr (templ->name_template, '%'))
+ && strncmp (templ->name_template, name,
+ str - templ->name_template) == 0
+ && strlen (name) > str - templ->name_template) {
+ data = name + (str - templ->name_template);
+ if (*(str + 1) == 'd') {
+ /* it's an int */
+ n = (gint) strtol (data, &endptr, 10);
+ if (endptr && *endptr == '\0') {
+ templ_found = TRUE;
+ req_name = name;
+ break;
+ }
+ } else {
+ /* it's a string */
+ templ_found = TRUE;
+ req_name = name;
+ break;
+ }
+ }
}
list = list->next;
}
/* avoid registering pad templates with the same name */
g_return_if_fail (gst_element_class_get_pad_template (klass,
- templ->name_template) == NULL);
+ templ->name_template) == NULL);
klass->padtemplates = g_list_append (klass->padtemplates,
gst_object_ref (GST_OBJECT (templ)));
*/
if (padtempl->direction != compattempl->direction) {
GST_CAT_DEBUG (GST_CAT_CAPS,
- "compatible direction: found %s pad template \"%s\"",
- padtempl->direction == GST_PAD_SRC ? "src" : "sink",
- padtempl->name_template);
+ "compatible direction: found %s pad template \"%s\"",
+ padtempl->direction == GST_PAD_SRC ? "src" : "sink",
+ padtempl->name_template);
intersection = gst_caps_intersect (GST_PAD_TEMPLATE_CAPS (compattempl),
- GST_PAD_TEMPLATE_CAPS (padtempl));
+ GST_PAD_TEMPLATE_CAPS (padtempl));
GST_CAT_DEBUG (GST_CAT_CAPS, "caps are %scompatible",
- (intersection ? "" : "not "));
+ (intersection ? "" : "not "));
if (!gst_caps_is_empty (intersection))
- newtempl = padtempl;
+ newtempl = padtempl;
gst_caps_free (intersection);
if (newtempl)
- break;
+ break;
}
padlist = g_list_next (padlist);
case GST_PAD_SOMETIMES:
ret = gst_element_get_static_pad (element, templ->name_template);
if (!ret && presence == GST_PAD_ALWAYS)
- g_warning
- ("Element %s has an ALWAYS template %s, but no pad of the same name",
- GST_OBJECT_NAME (element), templ->name_template);
+ g_warning
+ ("Element %s has an ALWAYS template %s, but no pad of the same name",
+ GST_OBJECT_NAME (element), templ->name_template);
break;
case GST_PAD_REQUEST:
GstPad *current = GST_PAD (pads->data);
if (GST_PAD_PEER (current) == NULL &&
- gst_pad_can_link_filtered (pad, current, filtercaps)) {
+ gst_pad_can_link_filtered (pad, current, filtercaps)) {
return current;
}
pads = g_list_next (pads);
srcpad = gst_element_get_pad (src, srcpadname);
if (!srcpad) {
GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "no pad %s:%s",
- GST_ELEMENT_NAME (src), srcpadname);
+ GST_ELEMENT_NAME (src), srcpadname);
return FALSE;
} else {
if (!(GST_PAD_DIRECTION (srcpad) == GST_PAD_SRC)) {
- GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "pad %s:%s is no src pad",
- GST_DEBUG_PAD_NAME (srcpad));
- return FALSE;
+ GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "pad %s:%s is no src pad",
+ GST_DEBUG_PAD_NAME (srcpad));
+ return FALSE;
}
if (GST_PAD_PEER (srcpad) != NULL) {
- GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "pad %s:%s is already linked",
- GST_DEBUG_PAD_NAME (srcpad));
- return FALSE;
+ GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "pad %s:%s is already linked",
+ GST_DEBUG_PAD_NAME (srcpad));
+ return FALSE;
}
}
srcpads = NULL;
destpad = gst_element_get_pad (dest, destpadname);
if (!destpad) {
GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "no pad %s:%s",
- GST_ELEMENT_NAME (dest), destpadname);
+ GST_ELEMENT_NAME (dest), destpadname);
return FALSE;
} else {
if (!(GST_PAD_DIRECTION (destpad) == GST_PAD_SINK)) {
- GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "pad %s:%s is no sink pad",
- GST_DEBUG_PAD_NAME (destpad));
- return FALSE;
+ GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "pad %s:%s is no sink pad",
+ GST_DEBUG_PAD_NAME (destpad));
+ return FALSE;
}
if (GST_PAD_PEER (destpad) != NULL) {
- GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "pad %s:%s is already linked",
- GST_DEBUG_PAD_NAME (destpad));
- return FALSE;
+ GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "pad %s:%s is already linked",
+ GST_DEBUG_PAD_NAME (destpad));
+ return FALSE;
}
}
destpads = NULL;
/* loop through the allowed pads in the source, trying to find a
* compatible destination pad */
GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS,
- "looping through allowed src and dest pads");
+ "looping through allowed src and dest pads");
do {
GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "trying src pad %s:%s",
- GST_DEBUG_PAD_NAME (srcpad));
+ GST_DEBUG_PAD_NAME (srcpad));
if ((GST_PAD_DIRECTION (srcpad) == GST_PAD_SRC) &&
- (GST_PAD_PEER (srcpad) == NULL)) {
- GstPad *temp = gst_element_get_compatible_pad_filtered (dest, srcpad,
- filtercaps);
-
- if (temp && gst_pad_link_filtered (srcpad, temp, filtercaps)) {
- GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "linked pad %s:%s to pad %s:%s",
- GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (temp));
- return TRUE;
- }
+ (GST_PAD_PEER (srcpad) == NULL)) {
+ GstPad *temp = gst_element_get_compatible_pad_filtered (dest, srcpad,
+ filtercaps);
+
+ if (temp && gst_pad_link_filtered (srcpad, temp, filtercaps)) {
+ GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "linked pad %s:%s to pad %s:%s",
+ GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (temp));
+ return TRUE;
+ }
}
/* find a better way for this mess */
if (srcpads) {
- srcpads = g_list_next (srcpads);
- if (srcpads)
- srcpad = (GstPad *) GST_PAD_REALIZE (srcpads->data);
+ srcpads = g_list_next (srcpads);
+ if (srcpads)
+ srcpad = (GstPad *) GST_PAD_REALIZE (srcpads->data);
}
} while (srcpads);
}
if (srcpadname) {
GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "no link possible from %s:%s to %s",
- GST_DEBUG_PAD_NAME (srcpad), GST_ELEMENT_NAME (dest));
+ GST_DEBUG_PAD_NAME (srcpad), GST_ELEMENT_NAME (dest));
return FALSE;
}
if (destpad) {
/* loop through the existing pads in the destination */
do {
GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "trying dest pad %s:%s",
- GST_DEBUG_PAD_NAME (destpad));
+ GST_DEBUG_PAD_NAME (destpad));
if ((GST_PAD_DIRECTION (destpad) == GST_PAD_SINK) &&
- (GST_PAD_PEER (destpad) == NULL)) {
- GstPad *temp = gst_element_get_compatible_pad_filtered (src, destpad,
- filtercaps);
-
- if (temp && gst_pad_link_filtered (temp, destpad, filtercaps)) {
- GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "linked pad %s:%s to pad %s:%s",
- GST_DEBUG_PAD_NAME (temp), GST_DEBUG_PAD_NAME (destpad));
- return TRUE;
- }
+ (GST_PAD_PEER (destpad) == NULL)) {
+ GstPad *temp = gst_element_get_compatible_pad_filtered (src, destpad,
+ filtercaps);
+
+ if (temp && gst_pad_link_filtered (temp, destpad, filtercaps)) {
+ GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "linked pad %s:%s to pad %s:%s",
+ GST_DEBUG_PAD_NAME (temp), GST_DEBUG_PAD_NAME (destpad));
+ return TRUE;
+ }
}
if (destpads) {
- destpads = g_list_next (destpads);
- if (destpads)
- destpad = (GstPad *) GST_PAD_REALIZE (destpads->data);
+ destpads = g_list_next (destpads);
+ if (destpads)
+ destpad = (GstPad *) GST_PAD_REALIZE (destpads->data);
}
} while (destpads);
}
if (destpadname) {
GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "no link possible from %s to %s:%s",
- GST_ELEMENT_NAME (src), GST_DEBUG_PAD_NAME (destpad));
+ GST_ELEMENT_NAME (src), GST_DEBUG_PAD_NAME (destpad));
return FALSE;
}
while (srctempls) {
srctempl = (GstPadTemplate *) srctempls->data;
if (srctempl->presence == GST_PAD_REQUEST) {
- for (l = desttempls; l; l = l->next) {
- desttempl = (GstPadTemplate *) l->data;
- if (desttempl->presence == GST_PAD_REQUEST &&
- desttempl->direction != srctempl->direction) {
- if (gst_caps_is_always_compatible (gst_pad_template_get_caps
- (srctempl), gst_pad_template_get_caps (desttempl))) {
- srcpad =
- gst_element_get_request_pad (src, srctempl->name_template);
- destpad =
- gst_element_get_request_pad (dest, desttempl->name_template);
- if (gst_pad_link_filtered (srcpad, destpad, filtercaps)) {
- GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS,
- "linked pad %s:%s to pad %s:%s",
- GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (destpad));
- return TRUE;
- }
- /* it failed, so we release the request pads */
- gst_element_release_request_pad (src, srcpad);
- gst_element_release_request_pad (dest, destpad);
- }
- }
- }
+ for (l = desttempls; l; l = l->next) {
+ desttempl = (GstPadTemplate *) l->data;
+ if (desttempl->presence == GST_PAD_REQUEST &&
+ desttempl->direction != srctempl->direction) {
+ if (gst_caps_is_always_compatible (gst_pad_template_get_caps
+ (srctempl), gst_pad_template_get_caps (desttempl))) {
+ srcpad =
+ gst_element_get_request_pad (src, srctempl->name_template);
+ destpad =
+ gst_element_get_request_pad (dest, desttempl->name_template);
+ if (gst_pad_link_filtered (srcpad, destpad, filtercaps)) {
+ GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS,
+ "linked pad %s:%s to pad %s:%s",
+ GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (destpad));
+ return TRUE;
+ }
+ /* it failed, so we release the request pads */
+ gst_element_release_request_pad (src, srcpad);
+ gst_element_release_request_pad (dest, destpad);
+ }
+ }
+ }
}
srctempls = srctempls->next;
}
destpad = gst_element_get_pad (dest, destpadname);
if (srcpad == NULL) {
GST_WARNING_OBJECT (dest, "destination element has no pad \"%s\"",
- destpadname);
+ destpadname);
return;
}
/* see if the pad is connected and is really a pad
* of dest */
if (peerpad && (GST_OBJECT_PARENT (peerpad) == (GstObject *) dest)) {
- gst_pad_unlink (pad, peerpad);
+ gst_pad_unlink (pad, peerpad);
}
}
/* tell the parent */
if (GST_OBJECT_PARENT (element)) {
GST_CAT_DEBUG (GST_CAT_ERROR_SYSTEM,
- "forwarding error \"%s\" from %s to %s", error->message,
- GST_ELEMENT_NAME (element),
- GST_OBJECT_NAME (GST_OBJECT_PARENT (element)));
+ "forwarding error \"%s\" from %s to %s", error->message,
+ GST_ELEMENT_NAME (element),
+ GST_OBJECT_NAME (GST_OBJECT_PARENT (element)));
gst_object_ref (GST_OBJECT (element));
g_signal_emit (G_OBJECT (GST_OBJECT_PARENT (element)),
- gst_element_signals[ERROR], 0, source, error, debug);
+ gst_element_signals[ERROR], 0, source, error, debug);
gst_object_unref (GST_OBJECT (element));
GST_CAT_DEBUG (GST_CAT_ERROR_SYSTEM, "forwarded error \"%s\" from %s to %s",
- error->message, GST_ELEMENT_NAME (element),
- GST_OBJECT_NAME (GST_OBJECT_PARENT (element)));
+ error->message, GST_ELEMENT_NAME (element),
+ GST_OBJECT_NAME (GST_OBJECT_PARENT (element)));
}
}
GstPad *pad = GST_PAD (pads->data);
GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "checking pad %s:%s",
- GST_DEBUG_PAD_NAME (pad));
+ GST_DEBUG_PAD_NAME (pad));
if (GST_PAD_DIRECTION (pad) == dir) {
if (GST_PAD_IS_LINKED (pad)) {
- return pad;
+ return pad;
} else {
- GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "pad %s:%s is not linked",
- GST_DEBUG_PAD_NAME (pad));
+ GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "pad %s:%s is not linked",
+ GST_DEBUG_PAD_NAME (pad));
}
} else {
GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "pad %s:%s is in wrong direction",
- GST_DEBUG_PAD_NAME (pad));
+ GST_DEBUG_PAD_NAME (pad));
}
pads = g_list_next (pads);
if (pad) {
GST_CAT_DEBUG (GST_CAT_ELEMENT_PADS, "sending event to random pad %s:%s",
- GST_DEBUG_PAD_NAME (pad));
+ GST_DEBUG_PAD_NAME (pad));
return gst_pad_send_event (GST_PAD_PEER (pad), event);
}
}
if (oclass->convert)
return oclass->convert (element,
- src_format, src_value, dest_format, dest_value);
+ src_format, src_value, dest_format, dest_value);
else {
GstPad *pad = gst_element_get_random_pad (element, GST_PAD_SINK);
if (pad)
return gst_pad_convert (GST_PAD_PEER (pad),
- src_format, src_value, dest_format, dest_value);
+ src_format, src_value, dest_format, dest_value);
}
return FALSE;
/* if the element was already in error, stop now */
if (GST_FLAG_IS_SET (element, GST_ELEMENT_IN_ERROR)) {
GST_CAT_INFO (GST_CAT_ERROR_SYSTEM, "recursive ERROR detected in %s",
- GST_ELEMENT_NAME (element));
+ GST_ELEMENT_NAME (element));
g_free (sent_message);
if (debug)
g_free (debug);
name = gst_object_get_path_string (GST_OBJECT (element));
if (debug)
sent_debug = g_strdup_printf ("%s(%d): %s: %s:\n%s",
- file, line, function, name, debug ? debug : "");
+ file, line, function, name, debug ? debug : "");
else
sent_debug = NULL;
g_free (debug);
ret = gst_element_set_state (element, GST_STATE_PAUSED);
if (ret != GST_STATE_SUCCESS) {
g_warning ("could not PAUSE element \"%s\" after error, help!",
- GST_ELEMENT_NAME (element));
+ GST_ELEMENT_NAME (element));
}
}
if (locked_state) {
GST_CAT_DEBUG (GST_CAT_STATES, "locking state of element %s",
- GST_ELEMENT_NAME (element));
+ GST_ELEMENT_NAME (element));
GST_FLAG_SET (element, GST_ELEMENT_LOCKED_STATE);
} else {
GST_CAT_DEBUG (GST_CAT_STATES, "unlocking state of element %s",
- GST_ELEMENT_NAME (element));
+ GST_ELEMENT_NAME (element));
GST_FLAG_UNSET (element, GST_ELEMENT_LOCKED_STATE);
}
}
if (state == curpending) {
GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, element,
- "element is already in requested state %s",
- gst_element_state_get_name (state));
+ "element is already in requested state %s",
+ gst_element_state_get_name (state));
return (GST_STATE_SUCCESS);
}
if (curpending != state) {
GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, element,
- "intermediate: setting state from %s to %s",
- gst_element_state_get_name (GST_STATE (element)),
- gst_element_state_get_name (curpending));
+ "intermediate: setting state from %s to %s",
+ gst_element_state_get_name (GST_STATE (element)),
+ gst_element_state_get_name (curpending));
}
/* call the state change function so it can set the state */
switch (return_val) {
case GST_STATE_FAILURE:
- GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
- "have failed change_state return");
- goto exit;
+ GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
+ "have failed change_state return");
+ goto exit;
case GST_STATE_ASYNC:
- GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
- "element will change state async");
- goto exit;
+ GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
+ "element will change state async");
+ goto exit;
case GST_STATE_SUCCESS:
- /* Last thing we do is verify that a successful state change really
- * did change the state... */
- /* if it did not, this is an error - fix the element that does this */
- if (GST_STATE (element) != curpending) {
- g_warning ("element %s claimed state-change success,"
- "but state didn't change to %s. State is %s (%s pending), fix the element",
- GST_ELEMENT_NAME (element),
- gst_element_state_get_name (curpending),
- gst_element_state_get_name (GST_STATE (element)),
- gst_element_state_get_name (GST_STATE_PENDING (element)));
- return_val = GST_STATE_FAILURE;
- goto exit;
- }
- break;
+ /* Last thing we do is verify that a successful state change really
+ * did change the state... */
+ /* if it did not, this is an error - fix the element that does this */
+ if (GST_STATE (element) != curpending) {
+ g_warning ("element %s claimed state-change success,"
+ "but state didn't change to %s. State is %s (%s pending), fix the element",
+ GST_ELEMENT_NAME (element),
+ gst_element_state_get_name (curpending),
+ gst_element_state_get_name (GST_STATE (element)),
+ gst_element_state_get_name (GST_STATE_PENDING (element)));
+ return_val = GST_STATE_FAILURE;
+ goto exit;
+ }
+ break;
default:
- /* somebody added a GST_STATE_ and forgot to do stuff here ! */
- g_assert_not_reached ();
+ /* somebody added a GST_STATE_ and forgot to do stuff here ! */
+ g_assert_not_reached ();
}
}
exit:
/* check the parent of the peer pad, if there is no parent do nothing */
parent = GST_PAD_PARENT (sinkpad);
if (!parent)
- continue;
+ continue;
/* skips pads that were already negotiating */
if (GST_FLAG_IS_SET (sinkpad, GST_PAD_NEGOTIATING) ||
- GST_FLAG_IS_SET (srcpad, GST_PAD_NEGOTIATING))
- continue;
+ GST_FLAG_IS_SET (srcpad, GST_PAD_NEGOTIATING))
+ continue;
otherstate = GST_STATE (parent);
/* swap pads if needed */
if (!GST_PAD_IS_SRC (srcpad)) {
- GstRealPad *temp;
+ GstRealPad *temp;
- temp = srcpad;
- srcpad = sinkpad;
- sinkpad = temp;
+ temp = srcpad;
+ srcpad = sinkpad;
+ sinkpad = temp;
}
/* only try to negotiate if the peer element is in PAUSED or higher too */
if (otherstate >= GST_STATE_READY) {
- GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, element,
- "perform negotiate for %s:%s and %s:%s",
- GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
- if (gst_pad_renegotiate (pad) == GST_PAD_LINK_REFUSED)
- return FALSE;
+ GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, element,
+ "perform negotiate for %s:%s and %s:%s",
+ GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
+ if (gst_pad_renegotiate (pad) == GST_PAD_LINK_REFUSED)
+ return FALSE;
} else {
- GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, element,
- "not negotiating %s:%s and %s:%s, not in READY yet",
- GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
+ GST_CAT_DEBUG_OBJECT (GST_CAT_CAPS, element,
+ "not negotiating %s:%s and %s:%s, not in READY yet",
+ GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
}
}
}
if (old_pending == GST_STATE_VOID_PENDING ||
old_state == GST_STATE_PENDING (element)) {
GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, element,
- "element is already in the %s state",
- gst_element_state_get_name (old_state));
+ "element is already in the %s state",
+ gst_element_state_get_name (old_state));
return GST_STATE_SUCCESS;
}
switch (old_transition) {
case GST_STATE_PLAYING_TO_PAUSED:
if (element->clock) {
- GstClockTime time = gst_clock_get_event_time (element->clock);
+ GstClockTime time = gst_clock_get_event_time (element->clock);
- g_assert (time >= element->base_time);
- element->base_time = time - element->base_time;
- GST_CAT_LOG_OBJECT (GST_CAT_CLOCK, element, "setting base time to %"
- G_GINT64_FORMAT, element->base_time);
+ g_assert (time >= element->base_time);
+ element->base_time = time - element->base_time;
+ GST_CAT_LOG_OBJECT (GST_CAT_CLOCK, element, "setting base time to %"
+ G_GINT64_FORMAT, element->base_time);
}
gst_element_pads_activate (element, FALSE);
break;
case GST_STATE_PAUSED_TO_PLAYING:
gst_element_pads_activate (element, TRUE);
if (element->clock) {
- GstClockTime time = gst_clock_get_event_time (element->clock);
+ GstClockTime time = gst_clock_get_event_time (element->clock);
- element->base_time = time - element->base_time;
- GST_CAT_LOG_OBJECT (GST_CAT_CLOCK, element, "setting base time to %"
- G_GINT64_FORMAT, element->base_time);
+ element->base_time = time - element->base_time;
+ GST_CAT_LOG_OBJECT (GST_CAT_CLOCK, element, "setting base time to %"
+ G_GINT64_FORMAT, element->base_time);
}
break;
/* if we are going to paused, we try to negotiate the pads */
case GST_STATE_READY_TO_PAUSED:
g_assert (element->base_time == 0);
if (!gst_element_negotiate_pads (element))
- goto failure;
+ goto failure;
break;
/* going to the READY state clears all pad caps */
/* FIXME: Why doesn't this happen on READY => NULL? -- Company */
/* tell the scheduler if we have one */
if (element->sched) {
if (gst_scheduler_state_transition (element->sched, element,
- old_transition) != GST_STATE_SUCCESS) {
+ old_transition) != GST_STATE_SUCCESS) {
GST_CAT_INFO_OBJECT (GST_CAT_STATES, element,
- "scheduler could not change state");
+ "scheduler could not change state");
goto failure;
}
}
/* tell our parent about the state change */
if (parent && GST_IS_BIN (parent)) {
gst_bin_child_state_change (GST_BIN (parent), old_state,
- GST_STATE (element), element);
+ GST_STATE (element), element);
}
/* at this point the state of the element could have changed again */
pad = GST_PAD (pads->data);
if (GST_PAD_PEER (pad)) {
- GST_CAT_DEBUG (GST_CAT_REFCOUNTING, "unlinking pad '%s'",
- GST_OBJECT_NAME (GST_OBJECT (GST_PAD (GST_PAD_PEER (pad)))));
- gst_pad_unlink (pad, GST_PAD (GST_PAD_PEER (pad)));
+ GST_CAT_DEBUG (GST_CAT_REFCOUNTING, "unlinking pad '%s'",
+ GST_OBJECT_NAME (GST_OBJECT (GST_PAD (GST_PAD_PEER (pad)))));
+ gst_pad_unlink (pad, GST_PAD (GST_PAD_PEER (pad)));
}
gst_element_remove_pad (element, pad);
xmlNewChild (param, NULL, "name", spec->name);
if (G_IS_PARAM_SPEC_STRING (spec))
- contents = g_value_dup_string (&value);
+ contents = g_value_dup_string (&value);
else if (G_IS_PARAM_SPEC_ENUM (spec))
- contents = g_strdup_printf ("%d", g_value_get_enum (&value));
+ contents = g_strdup_printf ("%d", g_value_get_enum (&value));
else if (G_IS_PARAM_SPEC_INT64 (spec))
- contents = g_strdup_printf ("%" G_GINT64_FORMAT,
- g_value_get_int64 (&value));
+ contents = g_strdup_printf ("%" G_GINT64_FORMAT,
+ g_value_get_int64 (&value));
else
- contents = g_strdup_value_contents (&value);
+ contents = g_strdup_value_contents (&value);
xmlNewChild (param, NULL, "value", contents);
g_free (contents);
xmlNodePtr child = children->xmlChildrenNode;
while (child) {
- if (!strcmp (child->name, "name")) {
- name = xmlNodeGetContent (child);
- } else if (!strcmp (child->name, "value")) {
- value = xmlNodeGetContent (child);
- }
- child = child->next;
+ if (!strcmp (child->name, "name")) {
+ name = xmlNodeGetContent (child);
+ } else if (!strcmp (child->name, "value")) {
+ value = xmlNodeGetContent (child);
+ }
+ child = child->next;
}
/* FIXME: can this just be g_object_set ? */
gst_util_set_object_arg (G_OBJECT (element), name, value);
/* tell the parent */
if (GST_OBJECT_PARENT (element)) {
GST_CAT_LOG_OBJECT (GST_CAT_EVENT, element, "forwarding tag event to %s",
- GST_OBJECT_NAME (GST_OBJECT_PARENT (element)));
+ GST_OBJECT_NAME (GST_OBJECT_PARENT (element)));
gst_element_emit_found_tag (GST_ELEMENT (GST_OBJECT_PARENT (element)),
- source, tag_list);
+ source, tag_list);
}
}
if (prop_id == fd_id) {
pspec = g_param_spec_int ("fd", "File-descriptor",
- "File-descriptor for the file being read", 0, G_MAXINT, 0, flags);
+ "File-descriptor for the file being read", 0, G_MAXINT, 0, flags);
} else if (prop_id == blocksize_id) {
pspec = g_param_spec_ulong ("blocksize", "Block Size",
- "Block size to read per buffer", 0, G_MAXULONG, 4096, flags);
+ "Block size to read per buffer", 0, G_MAXULONG, 4096, flags);
} else if (prop_id == bytesperread_id) {
pspec = g_param_spec_int ("bytesperread", "Bytes per read",
- "Number of bytes to read per buffer", G_MININT, G_MAXINT, 0, flags);
+ "Number of bytes to read per buffer", G_MININT, G_MAXINT, 0, flags);
} else if (prop_id == dump_id) {
pspec = g_param_spec_boolean ("dump", "Dump",
- "Dump bytes to stdout", FALSE, flags);
+ "Dump bytes to stdout", FALSE, flags);
} else if (prop_id == filesize_id) {
pspec = g_param_spec_int64 ("filesize", "File Size",
- "Size of the file being read", 0, G_MAXINT64, 0, flags);
+ "Size of the file being read", 0, G_MAXINT64, 0, flags);
} else if (prop_id == mmapsize_id) {
pspec = g_param_spec_ulong ("mmapsize", "mmap() Block Size",
- "Size in bytes of mmap()d regions", 0, G_MAXULONG, 4 * 1048576, flags);
+ "Size in bytes of mmap()d regions", 0, G_MAXULONG, 4 * 1048576, flags);
} else if (prop_id == location_id) {
pspec = g_param_spec_string ("location", "File Location",
- "Location of the file to read", NULL, flags);
+ "Location of the file to read", NULL, flags);
} else if (prop_id == offset_id) {
pspec = g_param_spec_int64 ("offset", "File Offset",
- "Byte offset of current read pointer", 0, G_MAXINT64, 0, flags);
+ "Byte offset of current read pointer", 0, G_MAXINT64, 0, flags);
} else if (prop_id == silent_id) {
pspec = g_param_spec_boolean ("silent", "Silent", "Don't produce events",
- FALSE, flags);
+ FALSE, flags);
} else if (prop_id == touch_id) {
pspec = g_param_spec_boolean ("touch", "Touch read data",
- "Touch data to force disk read before " "push ()", TRUE, flags);
+ "Touch data to force disk read before " "push ()", TRUE, flags);
} else {
g_warning ("Unknown - 'standard' property '%s' id %d from klass %s",
- prop_name, arg_id, g_type_name (G_OBJECT_CLASS_TYPE (klass)));
+ prop_name, arg_id, g_type_name (G_OBJECT_CLASS_TYPE (klass)));
pspec = NULL;
}
int flags = va_arg (args, int);
gst_element_populate_std_props ((GObjectClass *) klass, name, arg_id,
- flags);
+ flags);
name = va_arg (args, char *);
}
(GInstanceInitFunc) gst_element_factory_init,
NULL
};
+
elementfactory_type = g_type_register_static (GST_TYPE_PLUGIN_FEATURE,
- "GstElementFactory", &elementfactory_info, 0);
+ "GstElementFactory", &elementfactory_info, 0);
GST_DEBUG_CATEGORY_INIT (element_factory_debug, "GST_ELEMENT_FACTORY",
- GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED,
- "element factories keep information about installed elements");
+ GST_DEBUG_BOLD | GST_DEBUG_FG_WHITE | GST_DEBUG_BG_RED,
+ "element factories keep information about installed elements");
}
return elementfactory_type;
}
if (!factory) {
klass = GST_ELEMENT_CLASS (g_type_class_ref (type));
factory =
- GST_ELEMENT_FACTORY (g_object_new (GST_TYPE_ELEMENT_FACTORY, NULL));
+ GST_ELEMENT_FACTORY (g_object_new (GST_TYPE_ELEMENT_FACTORY, NULL));
gst_plugin_feature_set_name (GST_PLUGIN_FEATURE (factory), name);
GST_LOG_OBJECT (factory, "Created new elementfactory for type %s",
- g_type_name (type));
+ g_type_name (type));
} else {
g_return_val_if_fail (factory->type == 0, FALSE);
klass = GST_ELEMENT_CLASS (g_type_class_ref (type));
gst_element_factory_cleanup (factory);
GST_LOG_OBJECT (factory, "Reuse existing elementfactory for type %s",
- g_type_name (type));
+ g_type_name (type));
}
factory->type = type;
/* special stuff for URI handling */
if (g_type_is_a (type, GST_TYPE_URI_HANDLER)) {
GstURIHandlerInterface *iface = (GstURIHandlerInterface *)
- g_type_interface_peek (klass, GST_TYPE_URI_HANDLER);
+ g_type_interface_peek (klass, GST_TYPE_URI_HANDLER);
if (!iface || !iface->get_type || !iface->get_protocols)
goto error;
if (name)
GST_INFO ("creating \"%s\" named \"%s\"", GST_PLUGIN_FEATURE_NAME (factory),
- GST_STR_NULL (name));
+ GST_STR_NULL (name));
else
GST_INFO ("creating \"%s\"", GST_PLUGIN_FEATURE_NAME (factory));
if (factory->type == 0) {
g_critical ("Factory for `%s' has no type",
- GST_PLUGIN_FEATURE_NAME (factory));
+ GST_PLUGIN_FEATURE_NAME (factory));
return NULL;
}
{
g_return_if_fail (GST_IS_ELEMENT_FACTORY (elementfactory));
g_return_if_fail (interfacename != NULL);
- g_return_if_fail (interfacename[0] != '\0'); /* no empty string */
+ g_return_if_fail (interfacename[0] != '\0'); /* no empty string */
elementfactory->interfaces =
g_list_prepend (elementfactory->interfaces, g_strdup (interfacename));
if (template->direction == GST_PAD_SRC) {
if (gst_caps_is_always_compatible (GST_PAD_TEMPLATE_CAPS (template),
- caps))
- return TRUE;
+ caps))
+ return TRUE;
}
templates = g_list_next (templates);
}
if (template->direction == GST_PAD_SINK) {
if (gst_caps_is_always_compatible (caps,
- GST_PAD_TEMPLATE_CAPS (template)))
- return TRUE;
+ GST_PAD_TEMPLATE_CAPS (template)))
+ return TRUE;
}
templates = g_list_next (templates);
}
if (!type)
type = g_boxed_type_register_static ("GstGError",
- (GBoxedCopyFunc) g_error_copy, (GBoxedFreeFunc) g_error_free);
+ (GBoxedCopyFunc) g_error_copy, (GBoxedFreeFunc) g_error_free);
return type;
}
N_("GStreamer encountered a general core library error."));
TABLE (t, CORE, TOO_LAZY,
N_("GStreamer developers were too lazy to assign an error code "
- "to this error. Please file a bug."));
+ "to this error. Please file a bug."));
TABLE (t, CORE, NOT_IMPLEMENTED,
N_("Internal GStreamer error: code not implemented. File a bug."));
TABLE (t, CORE, STATE_CHANGE,
N_("GStreamer encountered a general supporting library error."));
TABLE (t, LIBRARY, TOO_LAZY,
N_("GStreamer developers were too lazy to assign an error code "
- "to this error. Please file a bug."));
+ "to this error. Please file a bug."));
TABLE (t, LIBRARY, INIT, N_("Could not initialize supporting library."));
TABLE (t, LIBRARY, SHUTDOWN, N_("Could not close supporting library."));
TABLE (t, LIBRARY, SETTINGS, N_("Could not close supporting library."));
N_("GStreamer encountered a general supporting library error."));
TABLE (t, RESOURCE, TOO_LAZY,
N_("GStreamer developers were too lazy to assign an error code "
- "to this error. Please file a bug."));
+ "to this error. Please file a bug."));
TABLE (t, RESOURCE, NOT_FOUND, N_("Resource not found."));
TABLE (t, RESOURCE, BUSY, N_("Resource busy or not available."));
TABLE (t, RESOURCE, OPEN_READ, N_("Could not open resource for reading."));
N_("GStreamer encountered a general supporting library error."));
TABLE (t, STREAM, TOO_LAZY,
N_("GStreamer developers were too lazy to assign an error code "
- "to this error. Please file a bug."));
+ "to this error. Please file a bug."));
TABLE (t, STREAM, NOT_IMPLEMENTED,
N_("Element doesn't implement handling of this stream. "
- "Please file a bug."));
+ "Please file a bug."));
TABLE (t, STREAM, TYPE_NOT_FOUND, N_("Could not determine type of stream."));
TABLE (t, STREAM, WRONG_TYPE,
N_("The stream is of a different type than handled by this element."));
else {
g_warning ("No error messages for domain %s", g_quark_to_string (domain));
return g_strdup_printf (_("No error message for domain %s."),
- g_quark_to_string (domain));
+ g_quark_to_string (domain));
}
if (message)
return g_strdup (_(message));
else
return
- g_strdup_printf (_
- ("No standard error message for domain %s and code %d."),
- g_quark_to_string (domain), code);
+ g_strdup_printf (_
+ ("No standard error message for domain %s and code %d."),
+ g_quark_to_string (domain), code);
}
* Boston, MA 02111-1307, USA.
*/
-#include <string.h> /* memcpy */
+#include <string.h> /* memcpy */
#include "gst_private.h"
#include "gstdata_private.h"
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_TAG:
copy->event_data.structure.structure =
- gst_tag_list_copy ((GstTagList *) event->event_data.structure.
- structure);
+ gst_tag_list_copy ((GstTagList *) event->event_data.structure.
+ structure);
break;
case GST_EVENT_NAVIGATION:
copy->event_data.structure.structure =
- gst_structure_copy (event->event_data.structure.structure);
+ gst_structure_copy (event->event_data.structure.structure);
default:
break;
}
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_TAG:
if (GST_IS_TAG_LIST (event->event_data.structure.structure)) {
- gst_tag_list_free (event->event_data.structure.structure);
+ gst_tag_list_free (event->event_data.structure.structure);
} else {
- g_warning ("tag event %p didn't contain a valid tag list!", event);
- GST_ERROR ("tag event %p didn't contain a valid tag list!", event);
+ g_warning ("tag event %p didn't contain a valid tag list!", event);
+ GST_ERROR ("tag event %p didn't contain a valid tag list!", event);
}
break;
case GST_EVENT_NAVIGATION:
while (masks->type) {
if (masks->type == mask->type &&
- (masks->flags & mask->flags) == mask->flags)
+ (masks->flags & mask->flags) == mask->flags)
return TRUE;
masks++;
while (format1 != GST_FORMAT_UNDEFINED && count < 8) {
GST_EVENT_DISCONT_OFFSET (event, count).format =
- format1 & GST_SEEK_FORMAT_MASK;
+ format1 & GST_SEEK_FORMAT_MASK;
GST_EVENT_DISCONT_OFFSET (event, count).value = va_arg (var_args, gint64);
format1 = va_arg (var_args, GstFormat);
result = g_list_prepend (result, data);
if (first)
- break;
+ break;
}
}
static GList *_gst_formats = NULL;
static GHashTable *_nick_to_format = NULL;
static GHashTable *_format_to_nick = NULL;
-static gint _n_values = 1; /* we start from 1 because 0 reserved for UNDEFINED */
+static gint _n_values = 1; /* we start from 1 because 0 reserved for UNDEFINED */
static GstFormatDefinition standard_definitions[] = {
{GST_FORMAT_DEFAULT, "default", "Default format for the media type"},
while (standards->nick) {
g_hash_table_insert (_nick_to_format, standards->nick, standards);
g_hash_table_insert (_format_to_nick, GINT_TO_POINTER (standards->value),
- standards);
+ standards);
_gst_formats = g_list_append (_gst_formats, standards);
standards++;
GstIndexResolverMethod method;
GstIndexResolver resolver;
gpointer user_data;
-} ResolverEntry;
+}
+ResolverEntry;
static const ResolverEntry resolvers[] = {
{GST_INDEX_RESOLVER_CUSTOM, NULL, NULL},
static GType index_resolver_type = 0;
static GEnumValue index_resolver[] = {
{GST_INDEX_RESOLVER_CUSTOM, "GST_INDEX_RESOLVER_CUSTOM",
- "Use a custom resolver"},
+ "Use a custom resolver"},
{GST_INDEX_RESOLVER_GTYPE, "GST_INDEX_RESOLVER_GTYPE",
- "Resolve an object to its GType[.padname]"},
+ "Resolve an object to its GType[.padname]"},
{GST_INDEX_RESOLVER_PATH, "GST_INDEX_RESOLVER_PATH",
- "Resolve an object to its path in the pipeline"},
+ "Resolve an object to its path in the pipeline"},
{0, NULL, NULL},
};
+
if (!index_resolver_type) {
index_resolver_type =
- g_enum_register_static ("GstIndexResolver", index_resolver);
+ g_enum_register_static ("GstIndexResolver", index_resolver);
}
return index_resolver_type;
}
if (!index_entry_type) {
index_entry_type = g_boxed_type_register_static ("GstIndexEntry",
- (GBoxedCopyFunc) gst_index_entry_copy,
- (GBoxedFreeFunc) gst_index_entry_free);
+ (GBoxedCopyFunc) gst_index_entry_copy,
+ (GBoxedFreeFunc) gst_index_entry_free);
}
return index_entry_type;
}
(GInstanceInitFunc) gst_index_init,
NULL
};
+
index_type =
- g_type_register_static (GST_TYPE_OBJECT, "GstIndex", &index_info, 0);
+ g_type_register_static (GST_TYPE_OBJECT, "GstIndex", &index_info, 0);
}
return index_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_RESOLVER,
g_param_spec_enum ("resolver", "Resolver",
- "Select a predefined object to string mapper",
- GST_TYPE_INDEX_RESOLVER, GST_INDEX_RESOLVER_PATH, G_PARAM_READWRITE));
+ "Select a predefined object to string mapper",
+ GST_TYPE_INDEX_RESOLVER, GST_INDEX_RESOLVER_PATH, G_PARAM_READWRITE));
}
static void
GstElement *element = gst_pad_get_parent (GST_PAD (writer));
*writer_string = g_strdup_printf ("%s.%s",
- g_type_name (G_OBJECT_TYPE (element)), gst_object_get_name (writer));
+ g_type_name (G_OBJECT_TYPE (element)), gst_object_get_name (writer));
} else {
*writer_string =
- g_strdup_printf ("%s", g_type_name (G_OBJECT_TYPE (writer)));
+ g_strdup_printf ("%s", g_type_name (G_OBJECT_TYPE (writer)));
}
return TRUE;
gboolean res;
res =
- index->resolver (index, writer, &writer_string,
- index->resolver_user_data);
+ index->resolver (index, writer, &writer_string,
+ index->resolver_user_data);
if (!res)
- return FALSE;
+ return FALSE;
} else {
g_warning ("no resolver found");
return FALSE;
if (iclass->get_assoc_entry)
return iclass->get_assoc_entry (index, id, method, flags, format, value,
- func, user_data);
+ func, user_data);
return NULL;
}
(GInstanceInitFunc) gst_index_factory_init,
NULL
};
+
indexfactory_type = g_type_register_static (GST_TYPE_PLUGIN_FEATURE,
- "GstIndexFactory", &indexfactory_info, 0);
+ "GstIndexFactory", &indexfactory_info, 0);
}
return indexfactory_type;
}
#ifdef HAVE_PRINTF_EXTENSION
#include <printf.h>
#endif
-#include <stdio.h> /* fprintf */
+#include <stdio.h> /* fprintf */
#include <unistd.h>
-#include <string.h> /* G_VA_COPY */
+#include <string.h> /* G_VA_COPY */
#include "gstinfo.h"
#include "gstlog.h"
#include "gst_private.h"
int dli_version;
int dli_reserved1;
long dli_reserved[4];
-} Dl_info;
+}
+Dl_info;
#define _RLD_DLADDR 14
int dladdr (void *address, Dl_info * dl);
{
GPatternSpec *pat;
GstDebugLevel level;
-} LevelNameEntry;
+}
+LevelNameEntry;
/* list of all categories */
static GStaticMutex __cat_mutex = G_STATIC_MUTEX_INIT;
{
GstLogFunction func;
gpointer user_data;
-} LogFuncEntry;
+}
+LogFuncEntry;
static GStaticMutex __log_func_mutex = G_STATIC_MUTEX_INIT;
static GSList *__log_functions = NULL;
entry = handler->data;
handler = g_slist_next (handler);
entry->func (category, level, file, function, line, object, &message,
- entry->user_data);
+ entry->user_data);
}
g_free (message.message);
va_end (message.arguments);
}
if (colorinfo & GST_DEBUG_BG_MASK) {
g_string_append_printf (color, ";4%1d",
- (colorinfo & GST_DEBUG_BG_MASK) >> 4);
+ (colorinfo & GST_DEBUG_BG_MASK) >> 4);
}
g_string_append (color, "m");
/* color info */
if (gst_debug_is_colored ()) {
color =
- gst_debug_construct_term_color (gst_debug_category_get_color
- (category));
+ gst_debug_construct_term_color (gst_debug_category_get_color
+ (category));
clear = "\033[00m";
pidcolor = g_strdup_printf ("\033[3%1dm", pid % 6 + 31);
} else {
walk = g_slist_next (walk);
if (g_pattern_match_string (entry->pat, cat->name)) {
GST_LOG ("category %s matches pattern %p - gets set to level %d",
- cat->name, entry->pat, entry->level);
+ cat->name, entry->pat, entry->level);
gst_debug_category_set_threshold (cat, entry->level);
goto exit;
}
if (g_pattern_match_string (entry->pat, cat->name)) {
GST_LOG ("category %s matches pattern %p - gets set to level %d",
- cat->name, entry->pat, entry->level);
+ cat->name, entry->pat, entry->level);
gst_debug_category_set_threshold (cat, entry->level);
}
}
site);
stack_trace =
g_slist_prepend (stack_trace, g_strdup_printf ("%8p in %s from %p (%s)",
- this_fn, name, call_site, site));
+ this_fn, name, call_site, site));
g_free (name);
g_free (site);
};
gst_interface_type = g_type_register_static (G_TYPE_INTERFACE,
- "GstImplementsInterface", &gst_interface_info, 0);
+ "GstImplementsInterface", &gst_interface_info, 0);
g_type_interface_add_prerequisite (gst_interface_type, GST_TYPE_ELEMENT);
}
GstImplementsInterfaceClass *ifclass;
iface = G_TYPE_CHECK_INSTANCE_CAST (G_OBJECT (element),
- iface_type, GstImplementsInterface);
+ iface_type, GstImplementsInterface);
ifclass = GST_IMPLEMENTS_INTERFACE_GET_CLASS (iface);
if (ifclass->supported != NULL &&
- ifclass->supported (iface, iface_type) == TRUE) {
+ ifclass->supported (iface, iface_type) == TRUE) {
return TRUE;
}
}
/* check cast, give warning+fail if it's invalid */
if (!(iface = G_TYPE_CHECK_INSTANCE_CAST (from, iface_type,
- GstImplementsInterface))) {
+ GstImplementsInterface))) {
return NULL;
}
* is actually implemented */
if (GST_IS_ELEMENT (from)) {
g_return_val_if_fail (gst_element_implements_interface (GST_ELEMENT (from),
- iface_type), NULL);
+ iface_type), NULL);
}
return iface;
* Boston, MA 02111-1307, USA.
*/
-#include <string.h> /* memset */
+#include <string.h> /* memset */
#include "gstlog.h"
#include "gstutils.h"
struct _GstMemChunkElement
{
- GstTrashStackElement elem; /* make sure we can safely push it on the trashstack */
- gpointer area; /* pointer to data areas */
+ GstTrashStackElement elem; /* make sure we can safely push it on the trashstack */
+ gpointer area; /* pointer to data areas */
};
struct _GstMemChunk
(GInstanceInitFunc) gst_object_init,
NULL
};
+
_gst_object_type =
- g_type_register_static (G_TYPE_OBJECT, "GstObject", &object_info,
- G_TYPE_FLAG_ABSTRACT);
+ g_type_register_static (G_TYPE_OBJECT, "GstObject", &object_info,
+ G_TYPE_FLAG_ABSTRACT);
}
return _gst_object_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NAME,
g_param_spec_string ("name", "Name", "The name of the object",
- NULL, G_PARAM_READWRITE));
+ NULL, G_PARAM_READWRITE));
gst_object_signals[PARENT_SET] =
g_signal_new ("parent-set", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
/* need own category? */
for (i = 0; i < n_pspecs; i++) {
GST_CAT_LOG (GST_CAT_EVENT, "deep notification from %s to %s (%s)",
- GST_OBJECT_NAME (object), GST_OBJECT_NAME (gst_object),
- pspecs[i]->name);
+ GST_OBJECT_NAME (object), GST_OBJECT_NAME (gst_object),
+ pspecs[i]->name);
g_signal_emit (gst_object, gst_object_signals[DEEP_NOTIFY],
- g_quark_from_string (pspecs[i]->name), (GstObject *) object,
- pspecs[i]);
+ g_quark_from_string (pspecs[i]->name), (GstObject *) object,
+ pspecs[i]);
}
gst_object = GST_OBJECT_PARENT (gst_object);
gst_object_default_deep_notify (GObject * object, GstObject * orig,
GParamSpec * pspec, gchar ** excluded_props)
{
- GValue value = { 0, }; /* the important thing is that value.type = 0 */
+ GValue value = { 0, }; /* the important thing is that value.type = 0 */
gchar *str = 0;
gchar *name = NULL;
/* let's not print these out for excluded properties... */
while (excluded_props != NULL && *excluded_props != NULL) {
if (strcmp (pspec->name, *excluded_props) == 0)
- return;
+ return;
excluded_props++;
}
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
GEnumValue *enum_value;
enum_value =
- g_enum_get_value (G_ENUM_CLASS (g_type_class_ref (pspec->value_type)),
- g_value_get_enum (&value));
+ g_enum_get_value (G_ENUM_CLASS (g_type_class_ref (pspec->value_type)),
+ g_value_get_enum (&value));
str = g_strdup_printf ("%s (%d)", enum_value->value_nick,
- enum_value->value);
+ enum_value->value);
} else {
str = g_strdup_value_contents (&value);
}
if (!object_name_counts) {
object_name_counts = g_hash_table_new_full (g_str_hash, g_str_equal,
- g_free, NULL);
+ g_free, NULL);
}
count = GPOINTER_TO_INT (g_hash_table_lookup (object_name_counts, type_name));
#ifndef GST_DISABLE_LOADSAVE_REGISTRY
void (*object_loaded) (GstSignalObject * object, GstObject * new,
xmlNodePtr self);
-#endif /* GST_DISABLE_LOADSAVE_REGISTRY */
+#endif /* GST_DISABLE_LOADSAVE_REGISTRY */
};
static GType
(GInstanceInitFunc) gst_signal_object_init,
NULL
};
+
signal_object_type =
- g_type_register_static (G_TYPE_OBJECT, "GstSignalObject",
- &signal_object_info, 0);
+ g_type_register_static (G_TYPE_OBJECT, "GstSignalObject",
+ &signal_object_info, 0);
}
return signal_object_type;
}
32,
(GInstanceInitFunc) gst_pad_init, NULL
};
+
_gst_pad_type = g_type_register_static (GST_TYPE_OBJECT, "GstPad",
- &pad_info, 0);
+ &pad_info, 0);
}
return _gst_pad_type;
}
32,
(GInstanceInitFunc) gst_real_pad_init, NULL
};
+
_gst_real_pad_type = g_type_register_static (GST_TYPE_PAD, "GstRealPad",
- &pad_info, 0);
+ &pad_info, 0);
}
return _gst_real_pad_type;
}
/* GTK_ARG_READWRITE, REAL_ARG_ACTIVE); */
g_object_class_install_property (G_OBJECT_CLASS (klass), REAL_ARG_ACTIVE,
g_param_spec_boolean ("active", "Active", "Whether the pad is active.",
- TRUE, G_PARAM_READWRITE));
+ TRUE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), REAL_ARG_CAPS,
g_param_spec_boxed ("caps", "Caps", "The capabilities of the pad",
- GST_TYPE_CAPS, G_PARAM_READABLE));
+ GST_TYPE_CAPS, G_PARAM_READABLE));
#ifndef GST_DISABLE_LOADSAVE
gstobject_class->save_thyself = GST_DEBUG_FUNCPTR (gst_pad_save_thyself);
if (active) {
GST_CAT_DEBUG (GST_CAT_PADS, "activating pad %s:%s",
- GST_DEBUG_PAD_NAME (realpad));
+ GST_DEBUG_PAD_NAME (realpad));
GST_FLAG_UNSET (realpad, GST_PAD_DISABLED);
} else {
GST_CAT_DEBUG (GST_CAT_PADS, "de-activating pad %s:%s",
- GST_DEBUG_PAD_NAME (realpad));
+ GST_DEBUG_PAD_NAME (realpad));
GST_FLAG_SET (realpad, GST_PAD_DISABLED);
}
parent = GST_PAD_PARENT (link->srcpad);
if (!parent || GST_STATE (parent) < GST_STATE_READY) {
GST_DEBUG ("parent %s of pad %s:%s is not READY",
- GST_ELEMENT_NAME (parent), GST_DEBUG_PAD_NAME (link->srcpad));
+ GST_ELEMENT_NAME (parent), GST_DEBUG_PAD_NAME (link->srcpad));
return FALSE;
}
parent = GST_PAD_PARENT (link->sinkpad);
if (!parent || GST_STATE (parent) < GST_STATE_READY) {
GST_DEBUG ("parent %s of pad %s:%s is not READY",
- GST_ELEMENT_NAME (parent), GST_DEBUG_PAD_NAME (link->sinkpad));
+ GST_ELEMENT_NAME (parent), GST_DEBUG_PAD_NAME (link->sinkpad));
return FALSE;
}
for (i = 0; i < 5; i++) {
newcaps = NULL;
switch (i) {
- case 0:
- g_signal_emit (G_OBJECT (link->srcpad),
- gst_real_pad_signals[REAL_FIXATE], 0, caps, &newcaps);
- GST_DEBUG ("app srcpad signal fixated to %" GST_PTR_FORMAT, newcaps);
- break;
- case 1:
- g_signal_emit (G_OBJECT (link->sinkpad),
- gst_real_pad_signals[REAL_FIXATE], 0, caps, &newcaps);
- GST_DEBUG ("app sinkpad signal fixated to %" GST_PTR_FORMAT, newcaps);
- break;
- case 2:
- if (GST_RPAD_FIXATEFUNC (link->srcpad)) {
- newcaps =
- GST_RPAD_FIXATEFUNC (link->srcpad) (GST_PAD (link->srcpad),
- caps);
- GST_DEBUG ("srcpad %s:%s fixated to %" GST_PTR_FORMAT,
- GST_DEBUG_PAD_NAME (link->srcpad), newcaps);
- } else
- GST_DEBUG ("srcpad %s:%s doesn't have a fixate function",
- GST_DEBUG_PAD_NAME (link->srcpad));
-
- break;
- case 3:
- if (GST_RPAD_FIXATEFUNC (link->sinkpad)) {
- newcaps =
- GST_RPAD_FIXATEFUNC (link->sinkpad) (GST_PAD (link->sinkpad),
- caps);
- GST_DEBUG ("sinkpad %s:%s fixated to %" GST_PTR_FORMAT,
- GST_DEBUG_PAD_NAME (link->sinkpad), newcaps);
- } else
- GST_DEBUG ("sinkpad %s:%s doesn't have a fixate function",
- GST_DEBUG_PAD_NAME (link->sinkpad));
- break;
- case 4:
- newcaps = _gst_pad_default_fixate_func (GST_PAD (link->srcpad), caps);
- GST_DEBUG ("core fixated to %" GST_PTR_FORMAT, newcaps);
- break;
+ case 0:
+ g_signal_emit (G_OBJECT (link->srcpad),
+ gst_real_pad_signals[REAL_FIXATE], 0, caps, &newcaps);
+ GST_DEBUG ("app srcpad signal fixated to %" GST_PTR_FORMAT, newcaps);
+ break;
+ case 1:
+ g_signal_emit (G_OBJECT (link->sinkpad),
+ gst_real_pad_signals[REAL_FIXATE], 0, caps, &newcaps);
+ GST_DEBUG ("app sinkpad signal fixated to %" GST_PTR_FORMAT, newcaps);
+ break;
+ case 2:
+ if (GST_RPAD_FIXATEFUNC (link->srcpad)) {
+ newcaps =
+ GST_RPAD_FIXATEFUNC (link->srcpad) (GST_PAD (link->srcpad),
+ caps);
+ GST_DEBUG ("srcpad %s:%s fixated to %" GST_PTR_FORMAT,
+ GST_DEBUG_PAD_NAME (link->srcpad), newcaps);
+ } else
+ GST_DEBUG ("srcpad %s:%s doesn't have a fixate function",
+ GST_DEBUG_PAD_NAME (link->srcpad));
+
+ break;
+ case 3:
+ if (GST_RPAD_FIXATEFUNC (link->sinkpad)) {
+ newcaps =
+ GST_RPAD_FIXATEFUNC (link->sinkpad) (GST_PAD (link->sinkpad),
+ caps);
+ GST_DEBUG ("sinkpad %s:%s fixated to %" GST_PTR_FORMAT,
+ GST_DEBUG_PAD_NAME (link->sinkpad), newcaps);
+ } else
+ GST_DEBUG ("sinkpad %s:%s doesn't have a fixate function",
+ GST_DEBUG_PAD_NAME (link->sinkpad));
+ break;
+ case 4:
+ newcaps = _gst_pad_default_fixate_func (GST_PAD (link->srcpad), caps);
+ GST_DEBUG ("core fixated to %" GST_PTR_FORMAT, newcaps);
+ break;
}
if (newcaps) {
- gst_caps_free (caps);
- caps = newcaps;
- break;
+ gst_caps_free (caps);
+ caps = newcaps;
+ break;
}
}
}
if (link->srcnotify && GST_RPAD_LINKFUNC (link->srcpad)) {
GST_DEBUG ("calling link function on pad %s:%s",
- GST_DEBUG_PAD_NAME (link->srcpad));
+ GST_DEBUG_PAD_NAME (link->srcpad));
negotiating = GST_FLAG_IS_SET (link->srcpad, GST_PAD_NEGOTIATING);
GST_FLAG_UNSET (link->srcpad, GST_PAD_NEGOTIATING);
GST_DEBUG ("got reply %d from link function on pad %s:%s",
- res, GST_DEBUG_PAD_NAME (link->srcpad));
+ res, GST_DEBUG_PAD_NAME (link->srcpad));
if (GST_PAD_LINK_FAILED (res)) {
GST_CAT_INFO (GST_CAT_CAPS, "pad %s:%s doesn't accept caps",
- GST_DEBUG_PAD_NAME (link->srcpad));
+ GST_DEBUG_PAD_NAME (link->srcpad));
return res;
}
}
if (link->sinknotify && GST_RPAD_LINKFUNC (link->sinkpad)) {
GST_DEBUG ("calling link function on pad %s:%s",
- GST_DEBUG_PAD_NAME (link->sinkpad));
+ GST_DEBUG_PAD_NAME (link->sinkpad));
negotiating = GST_FLAG_IS_SET (link->sinkpad, GST_PAD_NEGOTIATING);
/* call the link function */
res = GST_RPAD_LINKFUNC (link->sinkpad) (GST_PAD (link->sinkpad),
- link->caps);
+ link->caps);
/* unset again after negotiating only if we set it */
if (!negotiating)
GST_FLAG_UNSET (link->sinkpad, GST_PAD_NEGOTIATING);
GST_DEBUG ("got reply %d from link function on pad %s:%s",
- res, GST_DEBUG_PAD_NAME (link->sinkpad));
+ res, GST_DEBUG_PAD_NAME (link->sinkpad));
if (GST_PAD_LINK_FAILED (res)) {
GST_CAT_INFO (GST_CAT_CAPS, "pad %s:%s doesn't accept caps",
- GST_DEBUG_PAD_NAME (link->sinkpad));
+ GST_DEBUG_PAD_NAME (link->sinkpad));
return res;
}
}
/* setting non-fixed caps on a pad is not allowed */
if (!gst_caps_is_fixed (caps)) {
GST_CAT_INFO (GST_CAT_CAPS,
- "trying to set unfixed caps on pad %s:%s, not allowed",
- GST_DEBUG_PAD_NAME (pad));
+ "trying to set unfixed caps on pad %s:%s, not allowed",
+ GST_DEBUG_PAD_NAME (pad));
g_warning ("trying to set non fixed caps on pad %s:%s, not allowed",
- GST_DEBUG_PAD_NAME (pad));
+ GST_DEBUG_PAD_NAME (pad));
GST_DEBUG ("unfixed caps %" GST_PTR_FORMAT, caps);
return GST_PAD_LINK_REFUSED;
if ((GST_PAD (realsrc) != srcpad) || (GST_PAD (realsink) != sinkpad)) {
GST_CAT_INFO (GST_CAT_PADS, "*actually* linking %s:%s and %s:%s",
- GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink));
+ GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink));
}
/* FIXME: shouldn't we convert this to g_return_val_if_fail? */
if (GST_RPAD_PEER (realsrc) != NULL) {
GST_CAT_INFO (GST_CAT_PADS, "Real source pad %s:%s has a peer, failed",
- GST_DEBUG_PAD_NAME (realsrc));
+ GST_DEBUG_PAD_NAME (realsrc));
return FALSE;
}
if (GST_RPAD_PEER (realsink) != NULL) {
GST_CAT_INFO (GST_CAT_PADS, "Real sink pad %s:%s has a peer, failed",
- GST_DEBUG_PAD_NAME (realsink));
+ GST_DEBUG_PAD_NAME (realsink));
return FALSE;
}
if (GST_PAD_PARENT (realsrc) == NULL) {
GST_CAT_INFO (GST_CAT_PADS, "Real src pad %s:%s has no parent, failed",
- GST_DEBUG_PAD_NAME (realsrc));
+ GST_DEBUG_PAD_NAME (realsrc));
return FALSE;
}
if (GST_PAD_PARENT (realsink) == NULL) {
GST_CAT_INFO (GST_CAT_PADS, "Real sink pad %s:%s has no parent, failed",
- GST_DEBUG_PAD_NAME (realsrc));
+ GST_DEBUG_PAD_NAME (realsrc));
return FALSE;
}
if (!gst_pad_check_schedulers (realsrc, realsink)) {
g_warning ("linking pads with different scheds requires "
- "exactly one decoupled element (such as queue)");
+ "exactly one decoupled element (such as queue)");
return FALSE;
}
if (GST_RPAD_DIRECTION (link->srcpad) != GST_PAD_SRC) {
GST_CAT_INFO (GST_CAT_PADS,
- "Real src pad %s:%s is not a source pad, failed",
- GST_DEBUG_PAD_NAME (link->srcpad));
+ "Real src pad %s:%s is not a source pad, failed",
+ GST_DEBUG_PAD_NAME (link->srcpad));
gst_pad_link_free (link);
return FALSE;
}
if (GST_RPAD_DIRECTION (link->sinkpad) != GST_PAD_SINK) {
GST_CAT_INFO (GST_CAT_PADS, "Real sink pad %s:%s is not a sink pad, failed",
- GST_DEBUG_PAD_NAME (link->sinkpad));
+ GST_DEBUG_PAD_NAME (link->sinkpad));
gst_pad_link_free (link);
return FALSE;
}
if ((GST_PAD (realsrc) != srcpad) || (GST_PAD (realsink) != sinkpad)) {
GST_CAT_INFO (GST_CAT_PADS, "*actually* linking %s:%s and %s:%s",
- GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink));
+ GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink));
}
/* FIXME: shouldn't we convert this to g_return_val_if_fail? */
if (GST_RPAD_PEER (realsrc) != NULL) {
GST_CAT_INFO (GST_CAT_PADS, "Real source pad %s:%s has a peer, failed",
- GST_DEBUG_PAD_NAME (realsrc));
+ GST_DEBUG_PAD_NAME (realsrc));
return FALSE;
}
if (GST_RPAD_PEER (realsink) != NULL) {
GST_CAT_INFO (GST_CAT_PADS, "Real sink pad %s:%s has a peer, failed",
- GST_DEBUG_PAD_NAME (realsink));
+ GST_DEBUG_PAD_NAME (realsink));
return FALSE;
}
if (GST_PAD_PARENT (realsrc) == NULL) {
GST_CAT_INFO (GST_CAT_PADS, "Real src pad %s:%s has no parent, failed",
- GST_DEBUG_PAD_NAME (realsrc));
+ GST_DEBUG_PAD_NAME (realsrc));
return FALSE;
}
if (GST_PAD_PARENT (realsink) == NULL) {
GST_CAT_INFO (GST_CAT_PADS, "Real sink pad %s:%s has no parent, failed",
- GST_DEBUG_PAD_NAME (realsrc));
+ GST_DEBUG_PAD_NAME (realsrc));
return FALSE;
}
if (!gst_pad_check_schedulers (realsrc, realsink)) {
g_warning ("linking pads with different scheds requires "
- "exactly one decoupled element (such as queue)");
+ "exactly one decoupled element (such as queue)");
return FALSE;
}
if (GST_RPAD_DIRECTION (link->srcpad) != GST_PAD_SRC) {
GST_CAT_INFO (GST_CAT_PADS,
- "Real src pad %s:%s is not a source pad, failed",
- GST_DEBUG_PAD_NAME (link->srcpad));
+ "Real src pad %s:%s is not a source pad, failed",
+ GST_DEBUG_PAD_NAME (link->srcpad));
gst_pad_link_free (link);
return FALSE;
}
if (GST_RPAD_DIRECTION (link->sinkpad) != GST_PAD_SINK) {
GST_CAT_INFO (GST_CAT_PADS, "Real sink pad %s:%s is not a sink pad, failed",
- GST_DEBUG_PAD_NAME (link->sinkpad));
+ GST_DEBUG_PAD_NAME (link->sinkpad));
gst_pad_link_free (link);
return FALSE;
}
/* now tell the scheduler */
if (src_sched && src_sched == sink_sched) {
gst_scheduler_pad_link (src_sched,
- GST_PAD (link->srcpad), GST_PAD (link->sinkpad));
+ GST_PAD (link->srcpad), GST_PAD (link->sinkpad));
} else {
GST_CAT_INFO (GST_CAT_PADS,
- "not telling link to scheduler %s:%s and %s:%s, %p %p",
- GST_DEBUG_PAD_NAME (link->srcpad), GST_DEBUG_PAD_NAME (link->sinkpad),
- src_sched, sink_sched);
+ "not telling link to scheduler %s:%s and %s:%s, %p %p",
+ GST_DEBUG_PAD_NAME (link->srcpad), GST_DEBUG_PAD_NAME (link->sinkpad),
+ src_sched, sink_sched);
}
GST_CAT_INFO (GST_CAT_PADS, "linked %s:%s and %s:%s, successful",
if (templ)
g_signal_emit (G_OBJECT (templ),
- gst_pad_template_signals[TEMPL_PAD_CREATED], 0, pad);
+ gst_pad_template_signals[TEMPL_PAD_CREATED], 0, pad);
}
/**
GstRealPad *peer = GST_RPAD_PEER (pad);
if (peer) {
- scheduler =
- gst_element_get_scheduler (gst_pad_get_parent (GST_PAD (peer)));
+ scheduler =
+ gst_element_get_scheduler (gst_pad_get_parent (GST_PAD (peer)));
}
} else {
scheduler = gst_element_get_scheduler (parent);
if (type == GST_TYPE_INT_RANGE) {
gst_structure_set (structure, g_quark_to_string (field_id),
- G_TYPE_INT, gst_value_get_int_range_min (value), NULL);
+ G_TYPE_INT, gst_value_get_int_range_min (value), NULL);
return FALSE;
}
if (type == GST_TYPE_DOUBLE_RANGE) {
gst_structure_set (structure, g_quark_to_string (field_id),
- G_TYPE_DOUBLE, gst_value_get_double_range_min (value), NULL);
+ G_TYPE_DOUBLE, gst_value_get_double_range_min (value), NULL);
return FALSE;
}
if (type == GST_TYPE_LIST) {
gst_structure_set_value (structure, g_quark_to_string (field_id),
- gst_value_list_get_value (value, 0));
+ gst_value_list_get_value (value, 0));
return FALSE;
}
if (caps->structs->len > 1) {
return gst_caps_new_full (gst_structure_copy (gst_caps_get_structure (caps,
- 0)), NULL);
+ 0)), NULL);
}
newcaps = gst_caps_copy (caps);
if ((GST_PAD (realsrc) != srcpad) || (GST_PAD (realsink) != sinkpad)) {
GST_CAT_DEBUG (GST_CAT_PADS, "*actually* linking %s:%s and %s:%s",
- GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink));
+ GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink));
}
g_return_val_if_fail (GST_RPAD_PEER (realsrc) == NULL, NULL);
if (!gst_pad_check_schedulers (realsrc, realsink)) {
g_warning ("linking pads with different scheds requires "
- "exactly one decoupled element (such as queue)");
+ "exactly one decoupled element (such as queue)");
return NULL;
}
if (GST_RPAD_DIRECTION (realsrc) == GST_RPAD_DIRECTION (realsink)) {
g_warning ("%s:%s and %s:%s are both %s pads, failed",
- GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink),
- GST_RPAD_DIRECTION (realsrc) == GST_PAD_SRC ? "src" : "sink");
+ GST_DEBUG_PAD_NAME (realsrc), GST_DEBUG_PAD_NAME (realsink),
+ GST_RPAD_DIRECTION (realsrc) == GST_PAD_SRC ? "src" : "sink");
return NULL;
}
if (GST_RPAD_PEER (link->srcpad) != (GstRealPad *) link->sinkpad) {
g_warning ("Pads %s:%s and %s:%s were never linked",
- GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
+ GST_DEBUG_PAD_NAME (srcpad), GST_DEBUG_PAD_NAME (sinkpad));
gst_pad_link_free (link);
return FALSE;
}
if (otherpad != pad) {
ret = gst_pad_try_set_caps (otherpad, caps);
if (GST_PAD_LINK_FAILED (ret)) {
- return ret;
+ return ret;
}
}
pads = g_list_next (pads);
othercaps = gst_pad_get_negotiated_caps (otherpad);
if (othercaps) {
- GstCaps *icaps;
-
- icaps = gst_caps_intersect (othercaps, caps);
- if (!gst_caps_is_empty (icaps)) {
- return icaps;
- } else {
- gst_caps_free (icaps);
- }
+ GstCaps *icaps;
+
+ icaps = gst_caps_intersect (othercaps, caps);
+ if (!gst_caps_is_empty (icaps)) {
+ return icaps;
+ } else {
+ gst_caps_free (icaps);
+ }
}
}
pads = g_list_next (pads);
link_ret = gst_pad_try_set_caps (pad, caps);
if (link_ret == GST_PAD_LINK_REFUSED) {
GST_ELEMENT_ERROR (gst_pad_get_parent (pad), CORE, PAD, (NULL),
- ("failed to negotiate (try_set_caps returned REFUSED)"));
+ ("failed to negotiate (try_set_caps returned REFUSED)"));
return FALSE;
}
if (caps == NULL) {
g_critical ("pad %s:%s returned NULL caps from getcaps function\n",
- GST_ELEMENT_NAME (GST_PAD_PARENT (GST_PAD (realpad))),
- GST_PAD_NAME (realpad));
+ GST_ELEMENT_NAME (GST_PAD_PARENT (GST_PAD (realpad))),
+ GST_PAD_NAME (realpad));
caps = gst_caps_new_any ();
}
caps = GST_PAD_TEMPLATE_CAPS (templ);
GST_CAT_DEBUG (GST_CAT_CAPS,
- "using pad template %p with caps %" GST_PTR_FORMAT, templ, caps);
+ "using pad template %p with caps %" GST_PTR_FORMAT, templ, caps);
#if 0
/* FIXME we should enable something like this someday, but this is
* a bit buggy */
if (!gst_caps_is_fixed (caps)) {
g_warning
- ("pad %s:%s (%p) has no getcaps function and the pad template returns non-fixed caps. Element is probably broken.\n",
- GST_DEBUG_PAD_NAME (realpad), realpad);
+ ("pad %s:%s (%p) has no getcaps function and the pad template returns non-fixed caps. Element is probably broken.\n",
+ GST_DEBUG_PAD_NAME (realpad), realpad);
}
#endif
if (GST_PAD_CAPS (srcpad) && GST_PAD_CAPS (sinkpad)) {
if (!gst_caps_is_always_compatible (GST_PAD_CAPS (srcpad),
- GST_PAD_CAPS (sinkpad))) {
+ GST_PAD_CAPS (sinkpad))) {
return FALSE;
} else {
return TRUE;
}
} else {
GST_CAT_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));
+ "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;
}
}
if (peer->bufferallocfunc) {
GST_CAT_DEBUG (GST_CAT_PADS,
- "calling bufferallocfunc &%s (@%p) of peer pad %s:%s",
- GST_DEBUG_FUNCPTR_NAME (peer->bufferallocfunc),
- &peer->bufferallocfunc, GST_DEBUG_PAD_NAME (((GstPad *) peer)));
+ "calling bufferallocfunc &%s (@%p) of peer pad %s:%s",
+ GST_DEBUG_FUNCPTR_NAME (peer->bufferallocfunc),
+ &peer->bufferallocfunc, GST_DEBUG_PAD_NAME (((GstPad *) peer)));
return (peer->bufferallocfunc) (GST_PAD (peer), offset, size);
} else {
return gst_buffer_new_and_alloc (size);
GstPad *ghostpad = GST_PAD (ghostpads->data);
if (GST_IS_ELEMENT (GST_OBJECT_PARENT (ghostpad))) {
- GstElement *parent = GST_ELEMENT (GST_OBJECT_PARENT (ghostpad));
+ GstElement *parent = GST_ELEMENT (GST_OBJECT_PARENT (ghostpad));
- GST_CAT_DEBUG (GST_CAT_REFCOUNTING,
- "removing ghost pad from element '%s'", GST_OBJECT_NAME (parent));
- gst_element_remove_pad (parent, ghostpad);
+ GST_CAT_DEBUG (GST_CAT_REFCOUNTING,
+ "removing ghost pad from element '%s'", GST_OBJECT_NAME (parent));
+ gst_element_remove_pad (parent, ghostpad);
} else {
- /* handle the case where we have some floating ghost pad that was never
- added to an element */
- g_object_set (ghostpad, "real-pad", NULL, NULL);
+ /* handle the case where we have some floating ghost pad that was never
+ added to an element */
+ g_object_set (ghostpad, "real-pad", NULL, NULL);
}
ghostpads = g_list_next (ghostpads);
}
if (GST_IS_ELEMENT (GST_OBJECT_PARENT (pad))) {
GST_CAT_DEBUG (GST_CAT_REFCOUNTING, "removing pad from element '%s'",
- GST_OBJECT_NAME (GST_OBJECT (GST_ELEMENT (GST_OBJECT_PARENT (pad)))));
+ GST_OBJECT_NAME (GST_OBJECT (GST_ELEMENT (GST_OBJECT_PARENT (pad)))));
gst_element_remove_pad (GST_ELEMENT (GST_OBJECT_PARENT (pad)), pad);
}
if (GST_RPAD_EXPLICIT_CAPS (pad)) {
GST_ERROR_OBJECT (pad, "still explicit caps %" GST_PTR_FORMAT " set",
- GST_RPAD_EXPLICIT_CAPS (pad));
+ GST_RPAD_EXPLICIT_CAPS (pad));
g_warning ("pad %p has still explicit caps set", pad);
gst_caps_replace (&GST_RPAD_EXPLICIT_CAPS (pad), NULL);
}
while (field) {
if (!strcmp (field->name, "name")) {
pad = gst_element_get_pad (GST_ELEMENT (parent),
- xmlNodeGetContent (field));
+ xmlNodeGetContent (field));
} else if (!strcmp (field->name, "peer")) {
peer = xmlNodeGetContent (field);
}
if (split[0] == NULL || split[1] == NULL) {
GST_CAT_DEBUG (GST_CAT_XML,
- "Could not parse peer '%s' for pad %s:%s, leaving unlinked",
- peer, GST_DEBUG_PAD_NAME (pad));
+ "Could not parse peer '%s' for pad %s:%s, leaving unlinked",
+ peer, GST_DEBUG_PAD_NAME (pad));
return;
}
/* first check to see if the peer's parent's parent is the same */
/* we just save it off */
content = g_strdup_printf ("%s.%s",
- GST_OBJECT_NAME (GST_PAD_PARENT (peer)), GST_PAD_NAME (peer));
+ GST_OBJECT_NAME (GST_PAD_PARENT (peer)), GST_PAD_NAME (peer));
xmlNewChild (parent, NULL, "peer", content);
g_free (content);
} else
if (!GST_PAD_IS_LINKED (pad)) {
GST_CAT_LOG_OBJECT (GST_CAT_DATAFLOW, pad,
- "not pushing data %p as pad is unconnected", data);
+ "not pushing data %p as pad is unconnected", data);
gst_data_unref (data);
return;
}
if (!peer) {
g_warning ("push on pad %s:%s but it is unlinked",
- GST_DEBUG_PAD_NAME (pad));
+ GST_DEBUG_PAD_NAME (pad));
} else {
if (!GST_IS_EVENT (data) && !GST_PAD_IS_ACTIVE (peer)) {
g_warning ("push on peer of pad %s:%s but peer is not active",
- GST_DEBUG_PAD_NAME (pad));
+ GST_DEBUG_PAD_NAME (pad));
return;
}
if (peer->chainhandler) {
if (data) {
- GST_CAT_LOG_OBJECT (GST_CAT_DATAFLOW, pad,
- "calling chainhandler &%s of peer pad %s:%s",
- GST_DEBUG_FUNCPTR_NAME (peer->chainhandler),
- GST_DEBUG_PAD_NAME (GST_PAD (peer)));
- if (!gst_probe_dispatcher_dispatch (&peer->probedisp, &data))
- return;
-
- (peer->chainhandler) (GST_PAD (peer), data);
- return;
+ GST_CAT_LOG_OBJECT (GST_CAT_DATAFLOW, pad,
+ "calling chainhandler &%s of peer pad %s:%s",
+ GST_DEBUG_FUNCPTR_NAME (peer->chainhandler),
+ GST_DEBUG_PAD_NAME (GST_PAD (peer)));
+ if (!gst_probe_dispatcher_dispatch (&peer->probedisp, &data))
+ return;
+
+ (peer->chainhandler) (GST_PAD (peer), data);
+ return;
} else {
- g_warning ("trying to push a NULL buffer on pad %s:%s",
- GST_DEBUG_PAD_NAME (peer));
- return;
+ g_warning ("trying to push a NULL buffer on pad %s:%s",
+ GST_DEBUG_PAD_NAME (peer));
+ return;
}
} else {
g_warning ("internal error: push on pad %s:%s but it has no chainhandler",
- GST_DEBUG_PAD_NAME (peer));
+ GST_DEBUG_PAD_NAME (peer));
}
}
/* clean up the mess here */
if (!peer) {
GST_ELEMENT_ERROR (GST_PAD_PARENT (pad), CORE, PAD, (NULL),
- ("pull on pad %s:%s but it was unlinked", GST_DEBUG_PAD_NAME (pad)));
+ ("pull on pad %s:%s but it was unlinked", GST_DEBUG_PAD_NAME (pad)));
} else {
restart:
if (peer->gethandler) {
GstData *data;
GST_CAT_LOG_OBJECT (GST_CAT_DATAFLOW, pad,
- "calling gethandler %s of peer pad %s:%s",
- GST_DEBUG_FUNCPTR_NAME (peer->gethandler), GST_DEBUG_PAD_NAME (peer));
+ "calling gethandler %s of peer pad %s:%s",
+ GST_DEBUG_FUNCPTR_NAME (peer->gethandler), GST_DEBUG_PAD_NAME (peer));
data = (peer->gethandler) (GST_PAD (peer));
if (data) {
- if (!gst_probe_dispatcher_dispatch (&peer->probedisp, &data))
- goto restart;
- return data;
+ if (!gst_probe_dispatcher_dispatch (&peer->probedisp, &data))
+ goto restart;
+ return data;
}
/* no null buffers allowed */
GST_ELEMENT_ERROR (GST_PAD_PARENT (pad), CORE, PAD, (NULL),
- ("NULL buffer during pull on %s:%s", GST_DEBUG_PAD_NAME (pad)));
+ ("NULL buffer during pull on %s:%s", GST_DEBUG_PAD_NAME (pad)));
} else {
GST_ELEMENT_ERROR (GST_PAD_PARENT (pad), CORE, PAD, (NULL),
- ("pull on pad %s:%s but the peer pad %s:%s has no gethandler",
- GST_DEBUG_PAD_NAME (pad), GST_DEBUG_PAD_NAME (peer)));
+ ("pull on pad %s:%s but the peer pad %s:%s has no gethandler",
+ GST_DEBUG_PAD_NAME (pad), GST_DEBUG_PAD_NAME (peer)));
}
}
return GST_DATA (gst_event_new (GST_EVENT_INTERRUPT));
32,
(GInstanceInitFunc) gst_pad_template_init, NULL
};
+
padtemplate_type =
- g_type_register_static (GST_TYPE_OBJECT, "GstPadTemplate",
- &padtemplate_info, 0);
+ g_type_register_static (GST_TYPE_OBJECT, "GstPadTemplate",
+ &padtemplate_info, 0);
}
return padtemplate_type;
}
if (presence == GST_PAD_ALWAYS) {
if (strchr (name, '%')) {
g_warning ("invalid name template %s: conversion specifications are not"
- " allowed for GST_PAD_ALWAYS padtemplates", name);
+ " allowed for GST_PAD_ALWAYS padtemplates", name);
return FALSE;
}
} else if (presence == GST_PAD_REQUEST) {
if ((str = strchr (name, '%')) && strchr (str + 1, '%')) {
g_warning ("invalid name template %s: only one conversion specification"
- " allowed in GST_PAD_REQUEST padtemplate", name);
+ " allowed in GST_PAD_REQUEST padtemplate", name);
return FALSE;
}
if (str && (*(str + 1) != 's' && *(str + 1) != 'd')) {
g_warning ("invalid name template %s: conversion specification must be of"
- " type '%%d' or '%%s' for GST_PAD_REQUEST padtemplate", name);
+ " type '%%d' or '%%s' for GST_PAD_REQUEST padtemplate", name);
return FALSE;
}
if (str && (*(str + 2) != '\0')) {
g_warning ("invalid name template %s: conversion specification must"
- " appear at the end of the GST_PAD_REQUEST padtemplate name", name);
+ " appear at the end of the GST_PAD_REQUEST padtemplate name", name);
return FALSE;
}
}
(GInstanceInitFunc) gst_ghost_pad_init,
NULL
};
+
_gst_ghost_pad_type = g_type_register_static (GST_TYPE_PAD, "GstGhostPad",
- &pad_info, 0);
+ &pad_info, 0);
}
return _gst_ghost_pad_type;
}
g_object_class_install_property (gobject_class, GPAD_ARG_REAL_PAD,
g_param_spec_object ("real-pad", "Real pad",
- "The real pad for the ghost pad", GST_TYPE_PAD, G_PARAM_READWRITE));
+ "The real pad for the ghost pad", GST_TYPE_PAD, G_PARAM_READWRITE));
}
static void
realpad = g_value_get_object (value);
if (oldrealpad) {
- if (realpad == oldrealpad)
- return;
- else
- gst_pad_remove_ghost_pad (oldrealpad, ghostpad);
+ if (realpad == oldrealpad)
+ return;
+ else
+ gst_pad_remove_ghost_pad (oldrealpad, ghostpad);
}
if (realpad)
- gst_pad_add_ghost_pad (realpad, ghostpad);
+ gst_pad_add_ghost_pad (realpad, ghostpad);
break;
default:
/* for all of the internally-linked pads that are actually linked */
if (GST_PAD_IS_LINKED (eventpad)) {
if (GST_PAD_DIRECTION (eventpad) == GST_PAD_SRC) {
- /* increase the refcount */
- gst_event_ref (event);
- gst_pad_push (eventpad, GST_DATA (event));
+ /* increase the refcount */
+ gst_event_ref (event);
+ gst_pad_push (eventpad, GST_DATA (event));
} else {
- GstPad *peerpad = GST_PAD (GST_RPAD_PEER (eventpad));
+ GstPad *peerpad = GST_PAD (GST_RPAD_PEER (eventpad));
- /* we only send the event on one pad, multi-sinkpad elements
- * should implement a handler */
- g_list_free (orig);
- return gst_pad_send_event (peerpad, event);
+ /* we only send the event on one pad, multi-sinkpad elements
+ * should implement a handler */
+ g_list_free (orig);
+ return gst_pad_send_event (peerpad, event);
}
}
}
guint64 time;
if (gst_element_requires_clock (element) && element->clock) {
- if (gst_event_discont_get_value (event, GST_FORMAT_TIME, &time)) {
- gst_element_set_time (element, time);
- } else {
- GstFormat format = GST_FORMAT_TIME;
- guint i;
-
- for (i = 0; i < event->event_data.discont.noffsets; i++) {
- if (gst_pad_convert (pad,
- event->event_data.discont.offsets[i].format,
- event->event_data.discont.offsets[i].value, &format,
- &time)) {
- gst_element_set_time (element, time);
- } else if (i == event->event_data.discont.noffsets) {
- g_warning
- ("can't adjust clock to new time when time not provided");
- }
- }
- }
+ if (gst_event_discont_get_value (event, GST_FORMAT_TIME, &time)) {
+ gst_element_set_time (element, time);
+ } else {
+ GstFormat format = GST_FORMAT_TIME;
+ guint i;
+
+ for (i = 0; i < event->event_data.discont.noffsets; i++) {
+ if (gst_pad_convert (pad,
+ event->event_data.discont.offsets[i].format,
+ event->event_data.discont.offsets[i].value, &format,
+ &time)) {
+ gst_element_set_time (element, time);
+ } else if (i == event->event_data.discont.noffsets) {
+ g_warning
+ ("can't adjust clock to new time when time not provided");
+ }
+ }
+ }
}
}
default:
if (int_peer) {
res = dispatch (GST_PAD (int_peer), data);
if (res)
- break;
+ break;
}
int_pads = g_list_next (int_pads);
}
gint64 src_value;
GstFormat *dest_format;
gint64 *dest_value;
-} GstPadConvertData;
+}
+GstPadConvertData;
static gboolean
gst_pad_convert_dispatcher (GstPad * pad, GstPadConvertData * data)
if (GST_RPAD_CONVERTFUNC (rpad)) {
return GST_RPAD_CONVERTFUNC (rpad) (GST_PAD (rpad), src_format,
- src_value, dest_format, dest_value);
+ src_value, dest_format, dest_value);
}
return FALSE;
GstQueryType type;
GstFormat *format;
gint64 *value;
-} GstPadQueryData;
+}
+GstPadQueryData;
static gboolean
gst_pad_query_dispatcher (GstPad * pad, GstPadQueryData * data)
gst_pipeline_init,
NULL
};
+
pipeline_type =
- g_type_register_static (GST_TYPE_BIN, "GstPipeline", &pipeline_info, 0);
+ g_type_register_static (GST_TYPE_BIN, "GstPipeline", &pipeline_info, 0);
}
return pipeline_type;
}
const gchar *name = gst_scheduler_factory_get_default_name ();
g_error ("Critical error: could not get scheduler \"%s\"\n"
- "Are you sure you have a registry ?\n"
- "Run gst-register as root if you haven't done so yet.", name);
+ "Are you sure you have a registry ?\n"
+ "Run gst-register as root if you haven't done so yet.", name);
}
}
* might not be in cothread 0 */
#if 0
if (GST_ELEMENT_SCHED (element)) {
- gst_scheduler_reset (GST_ELEMENT_SCHED (element));
+ gst_scheduler_reset (GST_ELEMENT_SCHED (element));
}
#endif
break;
/* static variables for segfault handling of plugin loading */
static char *_gst_plugin_fault_handler_filename = NULL;
-extern gboolean *_gst_disable_segtrap; /* see gst.c */
+extern gboolean *_gst_disable_segtrap; /* see gst.c */
static gboolean *_gst_plugin_fault_handler_is_setup = FALSE;
/* list of valid licenses.
* QPL: http://www.trolltech.com/licenses/qpl.html
*/
static gchar *valid_licenses[] = {
- "LGPL", /* GNU Lesser General Public License */
- "GPL", /* GNU General Public License */
- "QPL", /* Trolltech Qt Public License */
- "GPL/QPL", /* Combi-license of GPL + QPL */
- GST_LICENSE_UNKNOWN, /* some other license */
+ "LGPL", /* GNU Lesser General Public License */
+ "GPL", /* GNU General Public License */
+ "QPL", /* Trolltech Qt Public License */
+ "GPL/QPL", /* Combi-license of GPL + QPL */
+ GST_LICENSE_UNKNOWN, /* some other license */
NULL
};
if (plugin_type == 0) {
plugin_type = g_boxed_type_register_static ("GstPlugin",
- (GBoxedCopyFunc) gst_plugin_copy, g_free);
+ (GBoxedCopyFunc) gst_plugin_copy, g_free);
}
return plugin_type;
if (main_module == NULL) {
if (GST_CAT_DEFAULT)
GST_LOG ("queueing static plugin \"%s\" for loading later on",
- desc->name);
+ desc->name);
_gst_plugin_static = g_list_prepend (_gst_plugin_static, desc);
} else {
GstPlugin *plugin;
plugin = g_new0 (GstPlugin, 1);
if (gst_plugin_register_func (plugin, main_module, desc)) {
if (GST_CAT_DEFAULT)
- GST_INFO ("loaded static plugin \"%s\"", desc->name);
+ GST_INFO ("loaded static plugin \"%s\"", desc->name);
gst_registry_pool_add_plugin (plugin);
}
}
if (!gst_plugin_check_version (desc->major_version, desc->minor_version)) {
if (GST_CAT_DEFAULT)
GST_INFO ("plugin \"%s\" has incompatible version, not loading",
- plugin->filename);
+ plugin->filename);
return FALSE;
}
if (!desc->license || !desc->description || !desc->package || !desc->origin) {
if (GST_CAT_DEFAULT)
GST_INFO ("plugin \"%s\" has incorrect GstPluginDesc, not loading",
- plugin->filename);
+ plugin->filename);
return FALSE;
}
if (!gst_plugin_check_license (desc->license)) {
if (GST_CAT_DEFAULT)
GST_INFO ("plugin \"%s\" has invalid license \"%s\", not loading",
- plugin->filename, desc->license);
+ plugin->filename, desc->license);
return FALSE;
}
if (g_module_supported () == FALSE) {
g_set_error (error,
- GST_PLUGIN_ERROR,
- GST_PLUGIN_ERROR_MODULE, "Dynamic loading not supported");
+ GST_PLUGIN_ERROR,
+ GST_PLUGIN_ERROR_MODULE, "Dynamic loading not supported");
return NULL;
}
if (stat (filename, &file_status)) {
g_set_error (error,
- GST_PLUGIN_ERROR,
- GST_PLUGIN_ERROR_MODULE, "Problem opening file %s\n", filename);
+ GST_PLUGIN_ERROR,
+ GST_PLUGIN_ERROR_MODULE, "Problem opening file %s\n", filename);
return NULL;
}
plugin = gst_registry_pool_find_plugin (desc->name);
if (!plugin) {
- free_plugin = TRUE;
- plugin = g_new0 (GstPlugin, 1);
- plugin->filename = g_strdup (filename);
- GST_DEBUG ("created new GstPlugin %p for file \"%s\"", plugin,
- filename);
+ free_plugin = TRUE;
+ plugin = g_new0 (GstPlugin, 1);
+ plugin->filename = g_strdup (filename);
+ GST_DEBUG ("created new GstPlugin %p for file \"%s\"", plugin,
+ filename);
} else {
- free_plugin = FALSE;
- if (gst_plugin_is_loaded (plugin)) {
- if (strcmp (plugin->filename, filename) != 0) {
- GST_WARNING
- ("plugin %p from file \"%s\" with same name %s is already "
- "loaded, aborting loading of \"%s\"", plugin, plugin->filename,
- plugin->desc.name, filename);
- g_set_error (error, GST_PLUGIN_ERROR,
- GST_PLUGIN_ERROR_NAME_MISMATCH,
- "already a plugin with name \"%s\" loaded", desc->name);
- if (free_plugin)
- g_free (plugin);
- return NULL;
- }
- GST_LOG ("Plugin %p for file \"%s\" already loaded, returning it now",
- plugin, filename);
- return plugin;
- }
+ free_plugin = FALSE;
+ if (gst_plugin_is_loaded (plugin)) {
+ if (strcmp (plugin->filename, filename) != 0) {
+ GST_WARNING
+ ("plugin %p from file \"%s\" with same name %s is already "
+ "loaded, aborting loading of \"%s\"", plugin, plugin->filename,
+ plugin->desc.name, filename);
+ g_set_error (error, GST_PLUGIN_ERROR,
+ GST_PLUGIN_ERROR_NAME_MISMATCH,
+ "already a plugin with name \"%s\" loaded", desc->name);
+ if (free_plugin)
+ g_free (plugin);
+ return NULL;
+ }
+ GST_LOG ("Plugin %p for file \"%s\" already loaded, returning it now",
+ plugin, filename);
+ return plugin;
+ }
}
GST_LOG ("Plugin %p for file \"%s\" prepared, calling entry function...",
- plugin, filename);
+ plugin, filename);
if (g_module_symbol (module, "plugin_init", &ptr)) {
- g_print
- ("plugin %p from file \"%s\" exports a symbol named plugin_init\n",
- plugin, plugin->filename);
- g_set_error (error, GST_PLUGIN_ERROR, GST_PLUGIN_ERROR_NAME_MISMATCH,
- "plugin \"%s\" exports a symbol named plugin_init", desc->name);
+ g_print
+ ("plugin %p from file \"%s\" exports a symbol named plugin_init\n",
+ plugin, plugin->filename);
+ g_set_error (error, GST_PLUGIN_ERROR, GST_PLUGIN_ERROR_NAME_MISMATCH,
+ "plugin \"%s\" exports a symbol named plugin_init", desc->name);
}
/* this is where we load the actual .so, so let's trap SIGSEGV */
_gst_plugin_fault_handler_filename = plugin->filename;
if (gst_plugin_register_func (plugin, module, desc)) {
- /* remove signal handler */
- _gst_plugin_fault_handler_restore ();
- _gst_plugin_fault_handler_filename = NULL;
- GST_INFO ("plugin \"%s\" loaded", plugin->filename);
- return plugin;
+ /* remove signal handler */
+ _gst_plugin_fault_handler_restore ();
+ _gst_plugin_fault_handler_filename = NULL;
+ GST_INFO ("plugin \"%s\" loaded", plugin->filename);
+ return plugin;
} else {
- /* remove signal handler */
- _gst_plugin_fault_handler_restore ();
- GST_DEBUG ("gst_plugin_register_func failed for plugin \"%s\"",
- filename);
- /* plugin == NULL */
- g_set_error (error,
- GST_PLUGIN_ERROR,
- GST_PLUGIN_ERROR_MODULE,
- "gst_plugin_register_func failed for plugin \"%s\"", filename);
- if (free_plugin)
- g_free (plugin);
- return NULL;
+ /* remove signal handler */
+ _gst_plugin_fault_handler_restore ();
+ GST_DEBUG ("gst_plugin_register_func failed for plugin \"%s\"",
+ filename);
+ /* plugin == NULL */
+ g_set_error (error,
+ GST_PLUGIN_ERROR,
+ GST_PLUGIN_ERROR_MODULE,
+ "gst_plugin_register_func failed for plugin \"%s\"", filename);
+ if (free_plugin)
+ g_free (plugin);
+ return NULL;
}
} else {
GST_DEBUG ("Could not find plugin entry point in \"%s\"", filename);
g_set_error (error,
- GST_PLUGIN_ERROR,
- GST_PLUGIN_ERROR_MODULE,
- "Could not find plugin entry point in \"%s\"", filename);
+ GST_PLUGIN_ERROR,
+ GST_PLUGIN_ERROR_MODULE,
+ "Could not find plugin entry point in \"%s\"", filename);
}
return NULL;
} else {
GST_DEBUG ("Error loading plugin %s, reason: %s\n", filename,
- g_module_error ());
+ g_module_error ());
g_set_error (error, GST_PLUGIN_ERROR, GST_PLUGIN_ERROR_MODULE,
- "Error loading plugin %s, reason: %s\n", filename, g_module_error ());
+ "Error loading plugin %s, reason: %s\n", filename, g_module_error ());
return NULL;
}
}
if (g_module_close (plugin->module)) {
plugin->module = NULL;
GST_CAT_INFO (GST_CAT_PLUGIN_LOADING, "plugin \"%s\" unloaded",
- plugin->filename);
+ plugin->filename);
return TRUE;
} else {
GST_CAT_INFO (GST_CAT_PLUGIN_LOADING, "failed to unload plugin \"%s\"",
- plugin->filename);
+ plugin->filename);
return FALSE;
}
}
(GInstanceInitFunc) gst_plugin_feature_init,
NULL
};
+
plugin_feature_type =
- g_type_register_static (G_TYPE_OBJECT, "GstPluginFeature",
- &plugin_feature_info, G_TYPE_FLAG_ABSTRACT);
+ g_type_register_static (G_TYPE_OBJECT, "GstPluginFeature",
+ &plugin_feature_info, G_TYPE_FLAG_ABSTRACT);
}
return plugin_feature_type;
}
#ifndef GST_DISABLE_REGISTRY
if (GST_IS_REGISTRY (plugin->manager)) {
GST_CAT_DEBUG (GST_CAT_PLUGIN_LOADING,
- "loading plugin %s for feature", plugin->desc.name);
+ "loading plugin %s for feature", plugin->desc.name);
if (gst_registry_load_plugin (GST_REGISTRY (plugin->manager),
- plugin) != GST_REGISTRY_OK)
- return FALSE;
+ plugin) != GST_REGISTRY_OK)
+ return FALSE;
} else
#endif /* GST_DISABLE_REGISTRY */
return FALSE;
{
return ((data->type == 0 || data->type == G_OBJECT_TYPE (feature)) &&
(data->name == NULL
- || !strcmp (data->name, GST_PLUGIN_FEATURE_NAME (feature))));
+ || !strcmp (data->name, GST_PLUGIN_FEATURE_NAME (feature))));
}
/**
static GList *_gst_queries = NULL;
static GHashTable *_nick_to_query = NULL;
static GHashTable *_query_type_to_nick = NULL;
-static gint _n_values = 1; /* we start from 1 because 0 reserved for NONE */
+static gint _n_values = 1; /* we start from 1 because 0 reserved for NONE */
static GstQueryTypeDefinition standard_definitions[] = {
{GST_QUERY_TOTAL, "total", "Total length"},
while (standards->nick) {
g_hash_table_insert (_nick_to_query, standards->nick, standards);
g_hash_table_insert (_query_type_to_nick,
- GINT_TO_POINTER (standards->value), standards);
+ GINT_TO_POINTER (standards->value), standards);
_gst_queries = g_list_append (_gst_queries, standards);
standards++;
{
GstEvent *event;
gboolean ret, handled;
-} GstQueueEventResponse;
+}
+GstQueueEventResponse;
static void gst_queue_base_init (GstQueueClass * klass);
static void gst_queue_class_init (GstQueueClass * klass);
{GST_QUEUE_LEAK_DOWNSTREAM, "2", "Leaky on Downstream"},
{0, NULL, NULL},
};
+
if (!queue_leaky_type) {
queue_leaky_type = g_enum_register_static ("GstQueueLeaky", queue_leaky);
}
};
queue_type = g_type_register_static (GST_TYPE_ELEMENT,
- "GstQueue", &queue_info, 0);
+ "GstQueue", &queue_info, 0);
}
return queue_type;
/* properties */
g_object_class_install_property (gobject_class, ARG_CUR_LEVEL_BYTES,
g_param_spec_uint ("current-level-bytes", "Current level (kB)",
- "Current amount of data in the queue (bytes)",
- 0, G_MAXUINT, 0, G_PARAM_READABLE));
+ "Current amount of data in the queue (bytes)",
+ 0, G_MAXUINT, 0, G_PARAM_READABLE));
g_object_class_install_property (gobject_class, ARG_CUR_LEVEL_BUFFERS,
g_param_spec_uint ("current-level-buffers", "Current level (buffers)",
- "Current number of buffers in the queue",
- 0, G_MAXUINT, 0, G_PARAM_READABLE));
+ "Current number of buffers in the queue",
+ 0, G_MAXUINT, 0, G_PARAM_READABLE));
g_object_class_install_property (gobject_class, ARG_CUR_LEVEL_TIME,
g_param_spec_uint64 ("current-level-time", "Current level (ns)",
- "Current amount of data in the queue (in ns)",
- 0, G_MAXUINT64, 0, G_PARAM_READABLE));
+ "Current amount of data in the queue (in ns)",
+ 0, G_MAXUINT64, 0, G_PARAM_READABLE));
g_object_class_install_property (gobject_class, ARG_MAX_SIZE_BYTES,
g_param_spec_uint ("max-size-bytes", "Max. size (kB)",
- "Max. amount of data in the queue (bytes, 0=disable)",
- 0, G_MAXUINT, 0, G_PARAM_READWRITE));
+ "Max. amount of data in the queue (bytes, 0=disable)",
+ 0, G_MAXUINT, 0, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_MAX_SIZE_BUFFERS,
g_param_spec_uint ("max-size-buffers", "Max. size (buffers)",
- "Max. number of buffers in the queue (0=disable)",
- 0, G_MAXUINT, 0, G_PARAM_READWRITE));
+ "Max. number of buffers in the queue (0=disable)",
+ 0, G_MAXUINT, 0, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_MAX_SIZE_TIME,
g_param_spec_uint64 ("max-size-time", "Max. size (ns)",
- "Max. amount of data in the queue (in ns, 0=disable)",
- 0, G_MAXUINT64, 0, G_PARAM_READWRITE));
+ "Max. amount of data in the queue (in ns, 0=disable)",
+ 0, G_MAXUINT64, 0, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_MIN_THRESHOLD_BYTES,
g_param_spec_uint ("min-threshold-bytes", "Min. threshold (kB)",
- "Min. amount of data in the queue to allow reading (bytes, 0=disable)",
- 0, G_MAXUINT, 0, G_PARAM_READWRITE));
+ "Min. amount of data in the queue to allow reading (bytes, 0=disable)",
+ 0, G_MAXUINT, 0, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_MIN_THRESHOLD_BUFFERS,
g_param_spec_uint ("min-threshold-buffers", "Min. threshold (buffers)",
- "Min. number of buffers in the queue to allow reading (0=disable)",
- 0, G_MAXUINT, 0, G_PARAM_READWRITE));
+ "Min. number of buffers in the queue to allow reading (0=disable)",
+ 0, G_MAXUINT, 0, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_MIN_THRESHOLD_TIME,
g_param_spec_uint64 ("min-threshold-time", "Min. threshold (ns)",
- "Min. amount of data in the queue to allow reading (in ns, 0=disable)",
- 0, G_MAXUINT64, 0, G_PARAM_READWRITE));
+ "Min. amount of data in the queue to allow reading (in ns, 0=disable)",
+ 0, G_MAXUINT64, 0, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_LEAKY,
g_param_spec_enum ("leaky", "Leaky",
- "Where the queue leaks, if at all",
- GST_TYPE_QUEUE_LEAKY, GST_QUEUE_NO_LEAK, G_PARAM_READWRITE));
+ "Where the queue leaks, if at all",
+ GST_TYPE_QUEUE_LEAKY, GST_QUEUE_NO_LEAK, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_MAY_DEADLOCK,
g_param_spec_boolean ("may_deadlock", "May Deadlock",
- "The queue may deadlock if it's full and not PLAYING",
- TRUE, G_PARAM_READWRITE));
+ "The queue may deadlock if it's full and not PLAYING",
+ TRUE, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_BLOCK_TIMEOUT,
g_param_spec_uint64 ("block_timeout", "Timeout for Block",
- "Nanoseconds until blocked queue times out and returns filler event. "
- "Value of -1 disables timeout",
- 0, G_MAXUINT64, -1, G_PARAM_READWRITE));
+ "Nanoseconds until blocked queue times out and returns filler event. "
+ "Value of -1 disables timeout",
+ 0, G_MAXUINT64, -1, G_PARAM_READWRITE));
/* set several parent class virtual functions */
gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_queue_dispose);
GST_DEBUG_FUNCPTR (gst_queue_handle_src_event));
gst_pad_set_active (queue->srcpad, TRUE);
- queue->cur_level.buffers = 0; /* no content */
- queue->cur_level.bytes = 0; /* no content */
- queue->cur_level.time = 0; /* no content */
- queue->max_size.buffers = 100; /* 100 buffers */
- queue->max_size.bytes = 10 * 1024 * 1024; /* 10 MB */
- queue->max_size.time = GST_SECOND; /* 1 s. */
- queue->min_threshold.buffers = 0; /* no threshold */
- queue->min_threshold.bytes = 0; /* no threshold */
- queue->min_threshold.time = 0; /* no threshold */
+ queue->cur_level.buffers = 0; /* no content */
+ queue->cur_level.bytes = 0; /* no content */
+ queue->cur_level.time = 0; /* no content */
+ queue->max_size.buffers = 100; /* 100 buffers */
+ queue->max_size.bytes = 10 * 1024 * 1024; /* 10 MB */
+ queue->max_size.time = GST_SECOND; /* 1 s. */
+ queue->min_threshold.buffers = 0; /* no threshold */
+ queue->min_threshold.bytes = 0; /* no threshold */
+ queue->min_threshold.time = 0; /* no threshold */
queue->leaky = GST_QUEUE_NO_LEAK;
queue->may_deadlock = TRUE;
if (GST_IS_EVENT (data)) {
switch (GST_EVENT_TYPE (data)) {
case GST_EVENT_FLUSH:
- STATUS (queue, "received flush event");
- gst_queue_locked_flush (queue);
- STATUS (queue, "after flush");
- break;
+ STATUS (queue, "received flush event");
+ gst_queue_locked_flush (queue);
+ STATUS (queue, "after flush");
+ break;
case GST_EVENT_EOS:
- STATUS (queue, "received EOS");
- break;
+ STATUS (queue, "received EOS");
+ break;
default:
- /* we put the event in the queue, we don't have to act ourselves */
- GST_CAT_LOG_OBJECT (GST_CAT_DATAFLOW, queue,
- "adding event %p of type %d", data, GST_EVENT_TYPE (data));
- break;
+ /* we put the event in the queue, we don't have to act ourselves */
+ GST_CAT_LOG_OBJECT (GST_CAT_DATAFLOW, queue,
+ "adding event %p of type %d", data, GST_EVENT_TYPE (data));
+ break;
}
}
if (GST_IS_BUFFER (data))
GST_CAT_LOG_OBJECT (GST_CAT_DATAFLOW, queue,
- "adding buffer %p of size %d", data, GST_BUFFER_SIZE (data));
+ "adding buffer %p of size %d", data, GST_BUFFER_SIZE (data));
/* We make space available if we're "full" according to whatever
* the user defined as "full". Note that this only applies to buffers.
* We always handle events and they don't count in our statistics. */
if (GST_IS_BUFFER (data) &&
((queue->max_size.buffers > 0 &&
- queue->cur_level.buffers >= queue->max_size.buffers) ||
- (queue->max_size.bytes > 0 &&
- queue->cur_level.bytes >= queue->max_size.bytes) ||
- (queue->max_size.time > 0 &&
- queue->cur_level.time >= queue->max_size.time))) {
+ queue->cur_level.buffers >= queue->max_size.buffers) ||
+ (queue->max_size.bytes > 0 &&
+ queue->cur_level.bytes >= queue->max_size.bytes) ||
+ (queue->max_size.time > 0 &&
+ queue->cur_level.time >= queue->max_size.time))) {
g_mutex_unlock (queue->qlock);
g_signal_emit (G_OBJECT (queue), gst_queue_signals[SIGNAL_OVERRUN], 0);
g_mutex_lock (queue->qlock);
/* how are we going to make space for this buffer? */
switch (queue->leaky) {
- /* leak current buffer */
+ /* leak current buffer */
case GST_QUEUE_LEAK_UPSTREAM:
- GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
- "queue is full, leaking buffer on upstream end");
- /* now we can clean up and exit right away */
- g_mutex_unlock (queue->qlock);
- goto out_unref;
+ GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
+ "queue is full, leaking buffer on upstream end");
+ /* now we can clean up and exit right away */
+ g_mutex_unlock (queue->qlock);
+ goto out_unref;
- /* leak first buffer in the queue */
+ /* leak first buffer in the queue */
case GST_QUEUE_LEAK_DOWNSTREAM:{
- /* this is a bit hacky. We'll manually iterate the list
- * and find the first buffer from the head on. We'll
- * unref that and "fix up" the GQueue object... */
- GList *item;
- GstData *leak = NULL;
-
- GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
- "queue is full, leaking buffer on downstream end");
-
- for (item = queue->queue->head; item != NULL; item = item->next) {
- if (GST_IS_BUFFER (item->data)) {
- leak = item->data;
- break;
- }
- }
-
- /* if we didn't find anything, it means we have no buffers
- * in here. That cannot happen, since we had >= 1 bufs */
- g_assert (leak);
-
- /* Now remove it from the list, fixing up the GQueue
- * CHECKME: is a queue->head the first or the last item? */
- item = g_list_delete_link (queue->queue->head, item);
- queue->queue->head = g_list_first (item);
- queue->queue->tail = g_list_last (item);
- queue->queue->length--;
-
- /* and unref the data at the end. Twice, because we keep a ref
- * to make things read-only. Also keep our list uptodate. */
- queue->cur_level.bytes -= GST_BUFFER_SIZE (data);
- queue->cur_level.buffers--;
- if (GST_BUFFER_DURATION (data) != GST_CLOCK_TIME_NONE)
- queue->cur_level.time -= GST_BUFFER_DURATION (data);
-
- gst_data_unref (data);
- gst_data_unref (data);
- break;
+ /* this is a bit hacky. We'll manually iterate the list
+ * and find the first buffer from the head on. We'll
+ * unref that and "fix up" the GQueue object... */
+ GList *item;
+ GstData *leak = NULL;
+
+ GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
+ "queue is full, leaking buffer on downstream end");
+
+ for (item = queue->queue->head; item != NULL; item = item->next) {
+ if (GST_IS_BUFFER (item->data)) {
+ leak = item->data;
+ break;
+ }
+ }
+
+ /* if we didn't find anything, it means we have no buffers
+ * in here. That cannot happen, since we had >= 1 bufs */
+ g_assert (leak);
+
+ /* Now remove it from the list, fixing up the GQueue
+ * CHECKME: is a queue->head the first or the last item? */
+ item = g_list_delete_link (queue->queue->head, item);
+ queue->queue->head = g_list_first (item);
+ queue->queue->tail = g_list_last (item);
+ queue->queue->length--;
+
+ /* and unref the data at the end. Twice, because we keep a ref
+ * to make things read-only. Also keep our list uptodate. */
+ queue->cur_level.bytes -= GST_BUFFER_SIZE (data);
+ queue->cur_level.buffers--;
+ if (GST_BUFFER_DURATION (data) != GST_CLOCK_TIME_NONE)
+ queue->cur_level.time -= GST_BUFFER_DURATION (data);
+
+ gst_data_unref (data);
+ gst_data_unref (data);
+ break;
}
default:
- g_warning ("Unknown leaky type, using default");
- /* fall-through */
+ g_warning ("Unknown leaky type, using default");
+ /* fall-through */
- /* don't leak. Instead, wait for space to be available */
+ /* don't leak. Instead, wait for space to be available */
case GST_QUEUE_NO_LEAK:
- STATUS (queue, "pre-full wait");
-
- while ((queue->max_size.buffers > 0 &&
- queue->cur_level.buffers >= queue->max_size.buffers) ||
- (queue->max_size.bytes > 0 &&
- queue->cur_level.bytes >= queue->max_size.bytes) ||
- (queue->max_size.time > 0 &&
- queue->cur_level.time >= queue->max_size.time)) {
- /* if there's a pending state change for this queue
- * or its manager, switch back to iterator so bottom
- * half of state change executes */
- if (queue->interrupt) {
- GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue, "interrupted");
- g_mutex_unlock (queue->qlock);
- if (gst_scheduler_interrupt (gst_pad_get_scheduler (queue->sinkpad),
- GST_ELEMENT (queue))) {
- goto out_unref;
- }
- /* if we got here because we were unlocked after a
- * flush, we don't need to add the buffer to the
- * queue again */
- if (queue->flush) {
- GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
- "not adding pending buffer after flush");
- goto out_unref;
- }
- GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
- "adding pending buffer after interrupt");
- goto restart;
- }
-
- if (GST_STATE (queue) != GST_STATE_PLAYING) {
- /* this means the other end is shut down. Try to
- * signal to resolve the error */
- if (!queue->may_deadlock) {
- g_mutex_unlock (queue->qlock);
- gst_data_unref (data);
- GST_ELEMENT_ERROR (queue, CORE, THREAD, (NULL),
- ("deadlock found, shutting down source pad elements"));
- /* we don't go to out_unref here, since we want to
- * unref the buffer *before* calling GST_ELEMENT_ERROR */
- return;
- } else {
- GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
- "%s: waiting for the app to restart "
- "source pad elements", GST_ELEMENT_NAME (queue));
- }
- }
-
- /* OK, we've got a serious issue here. Imagine the situation
- * where the puller (next element) is sending an event here,
- * so it cannot pull events from the queue, and we cannot
- * push data further because the queue is 'full' and therefore,
- * we wait here (and do not handle events): deadlock! to solve
- * that, we handle pending upstream events here, too. */
- gst_queue_handle_pending_events (queue);
-
- STATUS (queue, "waiting for item_del signal");
- g_cond_wait (queue->item_del, queue->qlock);
- STATUS (queue, "received item_del signal");
- }
-
- STATUS (queue, "post-full wait");
- g_mutex_unlock (queue->qlock);
- g_signal_emit (G_OBJECT (queue), gst_queue_signals[SIGNAL_RUNNING], 0);
- g_mutex_lock (queue->qlock);
- break;
+ STATUS (queue, "pre-full wait");
+
+ while ((queue->max_size.buffers > 0 &&
+ queue->cur_level.buffers >= queue->max_size.buffers) ||
+ (queue->max_size.bytes > 0 &&
+ queue->cur_level.bytes >= queue->max_size.bytes) ||
+ (queue->max_size.time > 0 &&
+ queue->cur_level.time >= queue->max_size.time)) {
+ /* if there's a pending state change for this queue
+ * or its manager, switch back to iterator so bottom
+ * half of state change executes */
+ if (queue->interrupt) {
+ GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue, "interrupted");
+ g_mutex_unlock (queue->qlock);
+ if (gst_scheduler_interrupt (gst_pad_get_scheduler (queue->sinkpad),
+ GST_ELEMENT (queue))) {
+ goto out_unref;
+ }
+ /* if we got here because we were unlocked after a
+ * flush, we don't need to add the buffer to the
+ * queue again */
+ if (queue->flush) {
+ GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
+ "not adding pending buffer after flush");
+ goto out_unref;
+ }
+ GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
+ "adding pending buffer after interrupt");
+ goto restart;
+ }
+
+ if (GST_STATE (queue) != GST_STATE_PLAYING) {
+ /* this means the other end is shut down. Try to
+ * signal to resolve the error */
+ if (!queue->may_deadlock) {
+ g_mutex_unlock (queue->qlock);
+ gst_data_unref (data);
+ GST_ELEMENT_ERROR (queue, CORE, THREAD, (NULL),
+ ("deadlock found, shutting down source pad elements"));
+ /* we don't go to out_unref here, since we want to
+ * unref the buffer *before* calling GST_ELEMENT_ERROR */
+ return;
+ } else {
+ GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
+ "%s: waiting for the app to restart "
+ "source pad elements", GST_ELEMENT_NAME (queue));
+ }
+ }
+
+ /* OK, we've got a serious issue here. Imagine the situation
+ * where the puller (next element) is sending an event here,
+ * so it cannot pull events from the queue, and we cannot
+ * push data further because the queue is 'full' and therefore,
+ * we wait here (and do not handle events): deadlock! to solve
+ * that, we handle pending upstream events here, too. */
+ gst_queue_handle_pending_events (queue);
+
+ STATUS (queue, "waiting for item_del signal");
+ g_cond_wait (queue->item_del, queue->qlock);
+ STATUS (queue, "received item_del signal");
+ }
+
+ STATUS (queue, "post-full wait");
+ g_mutex_unlock (queue->qlock);
+ g_signal_emit (G_OBJECT (queue), gst_queue_signals[SIGNAL_RUNNING], 0);
+ g_mutex_lock (queue->qlock);
+ break;
}
}
if (queue->queue->length == 0 ||
(queue->min_threshold.buffers > 0 &&
- queue->cur_level.buffers < queue->min_threshold.buffers) ||
+ queue->cur_level.buffers < queue->min_threshold.buffers) ||
(queue->min_threshold.bytes > 0 &&
- queue->cur_level.bytes < queue->min_threshold.bytes) ||
+ queue->cur_level.bytes < queue->min_threshold.bytes) ||
(queue->min_threshold.time > 0 &&
- queue->cur_level.time < queue->min_threshold.time)) {
+ queue->cur_level.time < queue->min_threshold.time)) {
g_mutex_unlock (queue->qlock);
g_signal_emit (G_OBJECT (queue), gst_queue_signals[SIGNAL_UNDERRUN], 0);
g_mutex_lock (queue->qlock);
STATUS (queue, "pre-empty wait");
while (queue->queue->length == 0 ||
- (queue->min_threshold.buffers > 0 &&
- queue->cur_level.buffers < queue->min_threshold.buffers) ||
- (queue->min_threshold.bytes > 0 &&
- queue->cur_level.bytes < queue->min_threshold.bytes) ||
- (queue->min_threshold.time > 0 &&
- queue->cur_level.time < queue->min_threshold.time)) {
+ (queue->min_threshold.buffers > 0 &&
+ queue->cur_level.buffers < queue->min_threshold.buffers) ||
+ (queue->min_threshold.bytes > 0 &&
+ queue->cur_level.bytes < queue->min_threshold.bytes) ||
+ (queue->min_threshold.time > 0 &&
+ queue->cur_level.time < queue->min_threshold.time)) {
/* if there's a pending state change for this queue or its
* manager, switch back to iterator so bottom half of state
* change executes. */
if (queue->interrupt) {
- GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue, "interrupted");
- g_mutex_unlock (queue->qlock);
- if (gst_scheduler_interrupt (gst_pad_get_scheduler (queue->srcpad),
- GST_ELEMENT (queue)))
- return GST_DATA (gst_event_new (GST_EVENT_INTERRUPT));
- goto restart;
+ GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue, "interrupted");
+ g_mutex_unlock (queue->qlock);
+ if (gst_scheduler_interrupt (gst_pad_get_scheduler (queue->srcpad),
+ GST_ELEMENT (queue)))
+ return GST_DATA (gst_event_new (GST_EVENT_INTERRUPT));
+ goto restart;
}
if (GST_STATE (queue) != GST_STATE_PLAYING) {
- /* this means the other end is shut down */
- if (!queue->may_deadlock) {
- g_mutex_unlock (queue->qlock);
- GST_ELEMENT_ERROR (queue, CORE, THREAD, (NULL),
- ("deadlock found, shutting down sink pad elements"));
- goto restart;
- } else {
- GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
- "%s: waiting for the app to restart "
- "source pad elements", GST_ELEMENT_NAME (queue));
- }
+ /* this means the other end is shut down */
+ if (!queue->may_deadlock) {
+ g_mutex_unlock (queue->qlock);
+ GST_ELEMENT_ERROR (queue, CORE, THREAD, (NULL),
+ ("deadlock found, shutting down sink pad elements"));
+ goto restart;
+ } else {
+ GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
+ "%s: waiting for the app to restart "
+ "source pad elements", GST_ELEMENT_NAME (queue));
+ }
}
STATUS (queue, "waiting for item_add");
if (queue->block_timeout != GST_CLOCK_TIME_NONE) {
- GTimeVal timeout;
-
- g_get_current_time (&timeout);
- g_time_val_add (&timeout, queue->block_timeout / 1000);
- if (!g_cond_timed_wait (queue->item_add, queue->qlock, &timeout)) {
- g_mutex_unlock (queue->qlock);
- GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
- "Sending filler event");
- return GST_DATA (gst_event_new_filler ());
- }
+ GTimeVal timeout;
+
+ g_get_current_time (&timeout);
+ g_time_val_add (&timeout, queue->block_timeout / 1000);
+ if (!g_cond_timed_wait (queue->item_add, queue->qlock, &timeout)) {
+ g_mutex_unlock (queue->qlock);
+ GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
+ "Sending filler event");
+ return GST_DATA (gst_event_new_filler ());
+ }
} else {
- g_cond_wait (queue->item_add, queue->qlock);
+ g_cond_wait (queue->item_add, queue->qlock);
}
STATUS (queue, "got item_add signal");
}
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
- GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
- "queue \"%s\" eos", GST_ELEMENT_NAME (queue));
- gst_element_set_eos (GST_ELEMENT (queue));
- break;
+ GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
+ "queue \"%s\" eos", GST_ELEMENT_NAME (queue));
+ gst_element_set_eos (GST_ELEMENT (queue));
+ break;
default:
- break;
+ break;
}
}
er.handled = FALSE;
g_queue_push_tail (queue->events, &er);
GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
- "Preparing for loop for event handler");
+ "Preparing for loop for event handler");
/* see the chain function on why this is here - it prevents a deadlock */
g_cond_signal (queue->item_del);
while (!er.handled) {
GTimeVal timeout;
g_get_current_time (&timeout);
- g_time_val_add (&timeout, 500 * 1000); /* half a second */
+ g_time_val_add (&timeout, 500 * 1000); /* half a second */
if (!g_cond_timed_wait (queue->event_done, queue->qlock, &timeout) &&
- !er.handled) {
- GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
- "timeout in upstream event handling");
- /* remove ourselves from the pending list. Since we're
- * locked, others cannot reference this anymore. */
- queue->queue->head = g_list_remove (queue->queue->head, &er);
- queue->queue->head = g_list_first (queue->queue->head);
- queue->queue->tail = g_list_last (queue->queue->head);
- queue->queue->length--;
- res = FALSE;
- goto handled;
+ !er.handled) {
+ GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
+ "timeout in upstream event handling");
+ /* remove ourselves from the pending list. Since we're
+ * locked, others cannot reference this anymore. */
+ queue->queue->head = g_list_remove (queue->queue->head, &er);
+ queue->queue->head = g_list_first (queue->queue->head);
+ queue->queue->tail = g_list_last (queue->queue->head);
+ queue->queue->length--;
+ res = FALSE;
+ goto handled;
}
}
GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue, "Event handled");
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_FLUSH:
- GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
- "FLUSH event, flushing queue\n");
- gst_queue_locked_flush (queue);
- break;
+ GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
+ "FLUSH event, flushing queue\n");
+ gst_queue_locked_flush (queue);
+ break;
case GST_EVENT_SEEK:
- if (GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_FLUSH) {
- gst_queue_locked_flush (queue);
- }
+ if (GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_FLUSH) {
+ gst_queue_locked_flush (queue);
+ }
default:
- break;
+ break;
}
}
handled:
break;
case GST_STATE_PAUSED_TO_PLAYING:
if (!GST_PAD_IS_LINKED (queue->sinkpad)) {
- GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, queue,
- "queue %s is not linked", GST_ELEMENT_NAME (queue));
- /* FIXME can this be? */
- g_cond_signal (queue->item_add);
+ GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, queue,
+ "queue %s is not linked", GST_ELEMENT_NAME (queue));
+ /* FIXME can this be? */
+ g_cond_signal (queue->item_add);
- ret = GST_STATE_FAILURE;
- goto error;
+ ret = GST_STATE_FAILURE;
+ goto error;
} else {
- GstScheduler *src_sched, *sink_sched;
+ GstScheduler *src_sched, *sink_sched;
- src_sched = gst_pad_get_scheduler (GST_PAD (queue->srcpad));
- sink_sched = gst_pad_get_scheduler (GST_PAD (queue->sinkpad));
+ src_sched = gst_pad_get_scheduler (GST_PAD (queue->srcpad));
+ sink_sched = gst_pad_get_scheduler (GST_PAD (queue->sinkpad));
- if (src_sched == sink_sched) {
- GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, queue,
- "queue %s does not connect different schedulers",
- GST_ELEMENT_NAME (queue));
+ if (src_sched == sink_sched) {
+ GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, queue,
+ "queue %s does not connect different schedulers",
+ GST_ELEMENT_NAME (queue));
- g_warning ("queue %s does not connect different schedulers",
- GST_ELEMENT_NAME (queue));
+ g_warning ("queue %s does not connect different schedulers",
+ GST_ELEMENT_NAME (queue));
- ret = GST_STATE_FAILURE;
- goto error;
- }
+ ret = GST_STATE_FAILURE;
+ goto error;
+ }
}
queue->interrupt = FALSE;
break;
};
registry_type = g_type_register_static (G_TYPE_OBJECT, "GstRegistry",
- ®istry_info, G_TYPE_FLAG_ABSTRACT);
+ ®istry_info, G_TYPE_FLAG_ABSTRACT);
}
return registry_type;
}
data.type = type;
data.name = name;
- walk =
- gst_registry_pool_feature_filter ((GstPluginFeatureFilter)
+ walk = gst_registry_pool_feature_filter ((GstPluginFeatureFilter)
gst_plugin_feature_type_name_filter, TRUE, &data);
if (walk)
};
_gst_scheduler_type =
- g_type_register_static (GST_TYPE_OBJECT, "GstScheduler",
- &scheduler_info, G_TYPE_FLAG_ABSTRACT);
+ g_type_register_static (GST_TYPE_OBJECT, "GstScheduler",
+ &scheduler_info, G_TYPE_FLAG_ABSTRACT);
}
return _gst_scheduler_type;
}
/* if it's already in this scheduler, don't bother doing anything */
if (GST_ELEMENT_SCHED (element) == sched) {
GST_CAT_DEBUG (GST_CAT_SCHEDULING, "element %s already in scheduler %p",
- GST_ELEMENT_NAME (element), sched);
+ GST_ELEMENT_NAME (element), sched);
return;
}
if (gst_element_provides_clock (element)) {
sched->clock_providers = g_list_prepend (sched->clock_providers, element);
GST_CAT_DEBUG (GST_CAT_CLOCK, "added clock provider %s",
- GST_ELEMENT_NAME (element));
+ GST_ELEMENT_NAME (element));
}
if (gst_element_requires_clock (element)) {
sched->clock_receivers = g_list_prepend (sched->clock_receivers, element);
GST_CAT_DEBUG (GST_CAT_CLOCK, "added clock receiver %s",
- GST_ELEMENT_NAME (element));
+ GST_ELEMENT_NAME (element));
}
gst_element_set_scheduler (element, sched);
switch (transition) {
case GST_STATE_READY_TO_PAUSED:
{
- GstClock *clock = gst_scheduler_get_clock (sched);
+ GstClock *clock = gst_scheduler_get_clock (sched);
- GST_CAT_DEBUG (GST_CAT_CLOCK,
- "scheduler READY to PAUSED clock is %p (%s)", clock,
- (clock ? GST_OBJECT_NAME (clock) : "nil"));
+ GST_CAT_DEBUG (GST_CAT_CLOCK,
+ "scheduler READY to PAUSED clock is %p (%s)", clock,
+ (clock ? GST_OBJECT_NAME (clock) : "nil"));
- gst_scheduler_set_clock (sched, clock);
- break;
+ gst_scheduler_set_clock (sched, clock);
+ break;
}
}
}
clock = sched->clock;
GST_CAT_DEBUG (GST_CAT_CLOCK, "scheduler using fixed clock %p (%s)", clock,
- (clock ? GST_OBJECT_NAME (clock) : "nil"));
+ (clock ? GST_OBJECT_NAME (clock) : "nil"));
} else {
GList *schedulers = sched->schedulers;
GList *providers = sched->clock_providers;
clock = gst_scheduler_get_clock (scheduler);
if (clock)
- break;
+ break;
schedulers = g_list_next (schedulers);
}
GstElement *element = GST_ELEMENT (receivers->data);
GST_CAT_DEBUG (GST_CAT_CLOCK,
- "scheduler setting clock %p (%s) on element %s", clock,
- (clock ? GST_OBJECT_NAME (clock) : "nil"), GST_ELEMENT_NAME (element));
+ "scheduler setting clock %p (%s) on element %s", clock,
+ (clock ? GST_OBJECT_NAME (clock) : "nil"), GST_ELEMENT_NAME (element));
gst_element_set_clock (element, clock);
receivers = g_list_next (receivers);
GstScheduler *scheduler = GST_SCHEDULER (schedulers->data);
GST_CAT_DEBUG (GST_CAT_CLOCK,
- "scheduler setting clock %p (%s) on scheduler %p", clock,
- (clock ? GST_OBJECT_NAME (clock) : "nil"), scheduler);
+ "scheduler setting clock %p (%s) on scheduler %p", clock,
+ (clock ? GST_OBJECT_NAME (clock) : "nil"), scheduler);
gst_scheduler_set_clock (scheduler, clock);
schedulers = g_list_next (schedulers);
}
(GInstanceInitFunc) gst_scheduler_factory_init,
NULL
};
+
schedulerfactory_type = g_type_register_static (GST_TYPE_PLUGIN_FEATURE,
- "GstSchedulerFactory", &schedulerfactory_info, 0);
+ "GstSchedulerFactory", &schedulerfactory_info, 0);
}
return schedulerfactory_type;
}
if (!factory) {
factory =
- GST_SCHEDULER_FACTORY (g_object_new (GST_TYPE_SCHEDULER_FACTORY, NULL));
+ GST_SCHEDULER_FACTORY (g_object_new (GST_TYPE_SCHEDULER_FACTORY, NULL));
GST_PLUGIN_FEATURE_NAME (factory) = g_strdup (name);
} else {
g_free (factory->longdesc);
if (!gst_structure_type) {
gst_structure_type = g_boxed_type_register_static ("GstStructure",
- (GBoxedCopyFunc) gst_structure_copy_conditional,
- (GBoxedFreeFunc) gst_structure_free);
+ (GBoxedCopyFunc) gst_structure_copy_conditional,
+ (GBoxedFreeFunc) gst_structure_free);
g_value_register_transform_func (gst_structure_type, G_TYPE_STRING,
- gst_structure_transform_to_string);
+ gst_structure_transform_to_string);
}
return gst_structure_type;
switch (type) {
case G_TYPE_INT:
- i = va_arg (varargs, int);
+ i = va_arg (varargs, int);
- g_value_init (&field.value, G_TYPE_INT);
- g_value_set_int (&field.value, i);
- break;
+ g_value_init (&field.value, G_TYPE_INT);
+ g_value_set_int (&field.value, i);
+ break;
case G_TYPE_DOUBLE:
- d = va_arg (varargs, double);
+ d = va_arg (varargs, double);
- g_value_init (&field.value, G_TYPE_DOUBLE);
- g_value_set_double (&field.value, d);
- break;
+ g_value_init (&field.value, G_TYPE_DOUBLE);
+ g_value_set_double (&field.value, d);
+ break;
case G_TYPE_BOOLEAN:
- i = va_arg (varargs, int);
+ i = va_arg (varargs, int);
- g_value_init (&field.value, G_TYPE_BOOLEAN);
- g_value_set_boolean (&field.value, i);
- break;
+ g_value_init (&field.value, G_TYPE_BOOLEAN);
+ g_value_set_boolean (&field.value, i);
+ break;
case G_TYPE_STRING:
- s = va_arg (varargs, char *);
+ s = va_arg (varargs, char *);
- g_value_init (&field.value, G_TYPE_STRING);
- g_value_set_string (&field.value, s);
- break;
+ g_value_init (&field.value, G_TYPE_STRING);
+ g_value_set_string (&field.value, s);
+ break;
default:
- if (type == GST_TYPE_FOURCC) {
- i = va_arg (varargs, int);
-
- g_value_init (&field.value, GST_TYPE_FOURCC);
- gst_value_set_fourcc (&field.value, i);
- } else if (type == GST_TYPE_INT_RANGE) {
- int min, max;
- min = va_arg (varargs, int);
- max = va_arg (varargs, int);
-
- g_value_init (&field.value, GST_TYPE_INT_RANGE);
- gst_value_set_int_range (&field.value, min, max);
- } else if (type == GST_TYPE_DOUBLE_RANGE) {
- double min, max;
- min = va_arg (varargs, double);
- max = va_arg (varargs, double);
-
- g_value_init (&field.value, GST_TYPE_DOUBLE_RANGE);
- gst_value_set_double_range (&field.value, min, max);
- } else {
- g_critical ("unimplemented vararg field type %d\n", (int) type);
- return;
- }
- break;
+ if (type == GST_TYPE_FOURCC) {
+ i = va_arg (varargs, int);
+
+ g_value_init (&field.value, GST_TYPE_FOURCC);
+ gst_value_set_fourcc (&field.value, i);
+ } else if (type == GST_TYPE_INT_RANGE) {
+ int min, max;
+ min = va_arg (varargs, int);
+ max = va_arg (varargs, int);
+
+ g_value_init (&field.value, GST_TYPE_INT_RANGE);
+ gst_value_set_int_range (&field.value, min, max);
+ } else if (type == GST_TYPE_DOUBLE_RANGE) {
+ double min, max;
+ min = va_arg (varargs, double);
+ max = va_arg (varargs, double);
+
+ g_value_init (&field.value, GST_TYPE_DOUBLE_RANGE);
+ gst_value_set_double_range (&field.value, min, max);
+ } else {
+ g_critical ("unimplemented vararg field type %d\n", (int) type);
+ return;
+ }
+ break;
}
gst_structure_set_field (structure, &field);
if (field->name == id) {
if (G_IS_VALUE (&field->value)) {
- g_value_unset (&field->value);
+ g_value_unset (&field->value);
}
structure->fields = g_array_remove_index (structure->fields, i);
return;
{
char *type_name;
GType type;
-} GstStructureAbbreviation;
+}
+GstStructureAbbreviation;
static GstStructureAbbreviation gst_structure_abbrs[] = {
{"int", G_TYPE_INT},
GArray *array = g_value_peek_pointer (&field->value);
if (array->len > 0) {
- GValue *value = &g_array_index (array, GValue, 0);
+ GValue *value = &g_array_index (array, GValue, 0);
- type = G_VALUE_TYPE (value);
+ type = G_VALUE_TYPE (value);
} else {
- type = G_TYPE_INT;
+ type = G_TYPE_INT;
}
} else if (G_VALUE_TYPE (&field->value) == GST_TYPE_INT_RANGE) {
type = G_TYPE_INT;
type = G_TYPE_DOUBLE;
}
g_string_append_printf (s, ", %s=(%s)%s", g_quark_to_string (field->name),
- gst_structure_to_abbr (type), t);
+ gst_structure_to_abbr (type), t);
g_free (t);
}
return g_string_free (s, FALSE);
g_value_init (value, range_type);
if (range_type == GST_TYPE_DOUBLE_RANGE) {
gst_value_set_double_range (value, g_value_get_double (&value1),
- g_value_get_double (&value2));
+ g_value_get_double (&value2));
} else {
gst_value_set_int_range (value, g_value_get_int (&value1),
- g_value_get_int (&value2));
+ g_value_get_int (&value2));
}
*after = s;
int i;
for (i = 0; i < 3; i++) {
- g_value_init (value, try_types[i]);
- ret = gst_value_deserialize (value, value_s);
- if (ret)
- break;
- g_value_unset (value);
+ g_value_init (value, try_types[i]);
+ ret = gst_value_deserialize (value, value_s);
+ if (ret)
+ break;
+ g_value_unset (value);
}
} else {
g_value_init (value, type);
(GInstanceInitFunc) gst_system_clock_init,
NULL
};
+
clock_type = g_type_register_static (GST_TYPE_CLOCK, "GstSystemClock",
- &clock_info, 0);
+ &clock_info, 0);
}
return clock_type;
}
if (diff + clock->max_diff < 0) {
GST_WARNING_OBJECT (clock, "clock is way behind: %" G_GINT64_FORMAT
- "s (max allowed is %" G_GINT64_FORMAT "s", -diff, clock->max_diff);
+ "s (max allowed is %" G_GINT64_FORMAT "s", -diff, clock->max_diff);
return GST_CLOCK_ENTRY_EARLY;
}
typedef struct
{
- GType type; /* type the data is in */
+ GType type; /* type the data is in */
- gchar *nick; /* translated name */
- gchar *blurb; /* translated description of type */
+ gchar *nick; /* translated name */
+ gchar *blurb; /* translated description of type */
- GstTagMergeFunc merge_func; /* functions to merge the values */
- GstTagFlag flag; /* type of tag */
-} GstTagInfo;
+ GstTagMergeFunc merge_func; /* functions to merge the values */
+ GstTagFlag flag; /* type of tag */
+}
+GstTagInfo;
#define TAGLIST "taglist"
static GQuark gst_tag_list_quark;
if (_gst_tag_list_type == 0) {
_gst_tag_list_type = g_boxed_type_register_static ("GstTagList",
- (GBoxedCopyFunc) gst_tag_list_copy, (GBoxedFreeFunc) gst_tag_list_free);
+ (GBoxedCopyFunc) gst_tag_list_copy, (GBoxedFreeFunc) gst_tag_list_free);
#if 0
g_value_register_transform_func (_gst_tag_list_type, G_TYPE_STRING,
- _gst_structure_transform_to_string);
+ _gst_structure_transform_to_string);
#endif
}
G_TYPE_STRING,
_("album"),
_("album containing this data"), gst_tag_merge_strings_with_comma);
- gst_tag_register (GST_TAG_DATE, GST_TAG_FLAG_META, G_TYPE_UINT, /* FIXME: own data type for dates? */
+ gst_tag_register (GST_TAG_DATE, GST_TAG_FLAG_META, G_TYPE_UINT, /* FIXME: own data type for dates? */
_("date"),
_("date the data was created (in Julian calendar days)"), NULL);
gst_tag_register (GST_TAG_GENRE, GST_TAG_FLAG_META,
_
("International Standard Recording Code - see http://www.ifpi.org/isrc/"),
NULL);
- gst_tag_register (GST_TAG_ORGANIZATION, GST_TAG_FLAG_META, G_TYPE_STRING, _("organization"), _("organization"), /* FIXME */
+ gst_tag_register (GST_TAG_ORGANIZATION, GST_TAG_FLAG_META, G_TYPE_STRING, _("organization"), _("organization"), /* FIXME */
gst_tag_merge_strings_with_comma);
gst_tag_register (GST_TAG_COPYRIGHT, GST_TAG_FLAG_META,
G_TYPE_STRING, _("copyright"), _("copyright notice of the data"), NULL);
/* seperator between two string */
str = g_string_append (str, _(", "));
str =
- g_string_append (str, g_value_get_string (gst_value_list_get_value (src,
- 1)));
+ g_string_append (str, g_value_get_string (gst_value_list_get_value (src,
+ 1)));
}
g_value_init (dest, G_TYPE_STRING);
{
GstStructure *list;
GstTagMergeMode mode;
-} GstTagCopyData;
+}
+GstTagCopyData;
static void
gst_tag_list_add_value_internal (GstStructure * list, GstTagMergeMode mode,
GQuark tag, GValue * value)
if (info->merge_func
&& (value2 = gst_structure_id_get_value (list, tag)) != NULL) {
GValue dest = { 0, };
+
switch (mode) {
case GST_TAG_MERGE_REPLACE_ALL:
case GST_TAG_MERGE_REPLACE:
- gst_structure_id_set_value (list, tag, value);
- break;
+ gst_structure_id_set_value (list, tag, value);
+ break;
case GST_TAG_MERGE_PREPEND:
- gst_value_list_concat (&dest, value, value2);
- gst_structure_id_set_value (list, tag, &dest);
- g_value_unset (&dest);
- break;
+ gst_value_list_concat (&dest, value, value2);
+ gst_structure_id_set_value (list, tag, &dest);
+ g_value_unset (&dest);
+ break;
case GST_TAG_MERGE_APPEND:
- gst_value_list_concat (&dest, value2, value);
- gst_structure_id_set_value (list, tag, &dest);
- g_value_unset (&dest);
- break;
+ gst_value_list_concat (&dest, value2, value);
+ gst_structure_id_set_value (list, tag, &dest);
+ g_value_unset (&dest);
+ break;
case GST_TAG_MERGE_KEEP:
case GST_TAG_MERGE_KEEP_ALL:
- break;
+ break;
default:
- g_assert_not_reached ();
- break;
+ g_assert_not_reached ();
+ break;
}
} else {
switch (mode) {
case GST_TAG_MERGE_APPEND:
case GST_TAG_MERGE_KEEP:
- if (gst_structure_id_get_value (list, tag) != NULL)
- break;
- /* fall through */
+ if (gst_structure_id_get_value (list, tag) != NULL)
+ break;
+ /* fall through */
case GST_TAG_MERGE_REPLACE_ALL:
case GST_TAG_MERGE_REPLACE:
case GST_TAG_MERGE_PREPEND:
- gst_structure_id_set_value (list, tag, value);
- break;
+ gst_structure_id_set_value (list, tag, value);
+ break;
case GST_TAG_MERGE_KEEP_ALL:
- break;
+ break;
default:
- g_assert_not_reached ();
- break;
+ g_assert_not_reached ();
+ break;
}
}
}
while (tag != NULL) {
GValue value = { 0, };
+
quark = g_quark_from_string (tag);
info = gst_tag_lookup (quark);
if (info == NULL)
info = gst_tag_lookup (quark);
g_return_if_fail (info != NULL);
gst_tag_list_add_value_internal (list, mode, quark, va_arg (var_args,
- GValue *));
+ GValue *));
tag = va_arg (var_args, gchar *);
}
}
GstTagForeachFunc func;
GstTagList *tag_list;
gpointer data;
-} TagForeachData;
+}
+TagForeachData;
static int
structure_foreach_wrapper (GQuark field_id, GValue * value, gpointer user_data)
{
{
GstTagMergeMode mode;
GstTagList *list;
-} GstTagData;
+}
+GstTagData;
GType
gst_tag_setter_get_type (void)
if (!tag_setter_type) {
static const GTypeInfo tag_setter_info = {
- sizeof (GstTagSetterIFace), /* class_size */
- NULL, /* base_init */
- NULL, /* base_finalize */
+ sizeof (GstTagSetterIFace), /* class_size */
+ NULL, /* base_init */
+ NULL, /* base_finalize */
NULL,
- NULL, /* class_finalize */
- NULL, /* class_data */
+ NULL, /* class_finalize */
+ NULL, /* class_data */
0,
0,
NULL
};
GST_DEBUG_CATEGORY_INIT (gst_tag_interface_debug, "GstTagInterface", 0,
- "interfaces for tagging");
+ "interfaces for tagging");
tag_setter_type = g_type_register_static (G_TYPE_INTERFACE, "GstTagSetter",
- &tag_setter_info, 0);
+ &tag_setter_info, 0);
g_type_interface_add_prerequisite (tag_setter_type, GST_TYPE_ELEMENT);
data->list = NULL;
data->mode = GST_TAG_MERGE_KEEP;
g_object_set_qdata_full (G_OBJECT (setter), gst_tag_key, data,
- gst_tag_data_free);
+ gst_tag_data_free);
}
return data;
typedef struct
{
- GType type; /* type the data is in */
+ GType type; /* type the data is in */
- gchar *nick; /* translated name */
- gchar *blurb; /* translated description of type */
+ gchar *nick; /* translated name */
+ gchar *blurb; /* translated description of type */
- GstTagMergeFunc merge_func; /* functions to merge the values */
- GstTagFlag flag; /* type of tag */
-} GstTagInfo;
+ GstTagMergeFunc merge_func; /* functions to merge the values */
+ GstTagFlag flag; /* type of tag */
+}
+GstTagInfo;
#define TAGLIST "taglist"
static GQuark gst_tag_list_quark;
if (_gst_tag_list_type == 0) {
_gst_tag_list_type = g_boxed_type_register_static ("GstTagList",
- (GBoxedCopyFunc) gst_tag_list_copy, (GBoxedFreeFunc) gst_tag_list_free);
+ (GBoxedCopyFunc) gst_tag_list_copy, (GBoxedFreeFunc) gst_tag_list_free);
#if 0
g_value_register_transform_func (_gst_tag_list_type, G_TYPE_STRING,
- _gst_structure_transform_to_string);
+ _gst_structure_transform_to_string);
#endif
}
G_TYPE_STRING,
_("album"),
_("album containing this data"), gst_tag_merge_strings_with_comma);
- gst_tag_register (GST_TAG_DATE, GST_TAG_FLAG_META, G_TYPE_UINT, /* FIXME: own data type for dates? */
+ gst_tag_register (GST_TAG_DATE, GST_TAG_FLAG_META, G_TYPE_UINT, /* FIXME: own data type for dates? */
_("date"),
_("date the data was created (in Julian calendar days)"), NULL);
gst_tag_register (GST_TAG_GENRE, GST_TAG_FLAG_META,
_
("International Standard Recording Code - see http://www.ifpi.org/isrc/"),
NULL);
- gst_tag_register (GST_TAG_ORGANIZATION, GST_TAG_FLAG_META, G_TYPE_STRING, _("organization"), _("organization"), /* FIXME */
+ gst_tag_register (GST_TAG_ORGANIZATION, GST_TAG_FLAG_META, G_TYPE_STRING, _("organization"), _("organization"), /* FIXME */
gst_tag_merge_strings_with_comma);
gst_tag_register (GST_TAG_COPYRIGHT, GST_TAG_FLAG_META,
G_TYPE_STRING, _("copyright"), _("copyright notice of the data"), NULL);
/* seperator between two string */
str = g_string_append (str, _(", "));
str =
- g_string_append (str, g_value_get_string (gst_value_list_get_value (src,
- 1)));
+ g_string_append (str, g_value_get_string (gst_value_list_get_value (src,
+ 1)));
}
g_value_init (dest, G_TYPE_STRING);
{
GstStructure *list;
GstTagMergeMode mode;
-} GstTagCopyData;
+}
+GstTagCopyData;
static void
gst_tag_list_add_value_internal (GstStructure * list, GstTagMergeMode mode,
GQuark tag, GValue * value)
if (info->merge_func
&& (value2 = gst_structure_id_get_value (list, tag)) != NULL) {
GValue dest = { 0, };
+
switch (mode) {
case GST_TAG_MERGE_REPLACE_ALL:
case GST_TAG_MERGE_REPLACE:
- gst_structure_id_set_value (list, tag, value);
- break;
+ gst_structure_id_set_value (list, tag, value);
+ break;
case GST_TAG_MERGE_PREPEND:
- gst_value_list_concat (&dest, value, value2);
- gst_structure_id_set_value (list, tag, &dest);
- g_value_unset (&dest);
- break;
+ gst_value_list_concat (&dest, value, value2);
+ gst_structure_id_set_value (list, tag, &dest);
+ g_value_unset (&dest);
+ break;
case GST_TAG_MERGE_APPEND:
- gst_value_list_concat (&dest, value2, value);
- gst_structure_id_set_value (list, tag, &dest);
- g_value_unset (&dest);
- break;
+ gst_value_list_concat (&dest, value2, value);
+ gst_structure_id_set_value (list, tag, &dest);
+ g_value_unset (&dest);
+ break;
case GST_TAG_MERGE_KEEP:
case GST_TAG_MERGE_KEEP_ALL:
- break;
+ break;
default:
- g_assert_not_reached ();
- break;
+ g_assert_not_reached ();
+ break;
}
} else {
switch (mode) {
case GST_TAG_MERGE_APPEND:
case GST_TAG_MERGE_KEEP:
- if (gst_structure_id_get_value (list, tag) != NULL)
- break;
- /* fall through */
+ if (gst_structure_id_get_value (list, tag) != NULL)
+ break;
+ /* fall through */
case GST_TAG_MERGE_REPLACE_ALL:
case GST_TAG_MERGE_REPLACE:
case GST_TAG_MERGE_PREPEND:
- gst_structure_id_set_value (list, tag, value);
- break;
+ gst_structure_id_set_value (list, tag, value);
+ break;
case GST_TAG_MERGE_KEEP_ALL:
- break;
+ break;
default:
- g_assert_not_reached ();
- break;
+ g_assert_not_reached ();
+ break;
}
}
}
while (tag != NULL) {
GValue value = { 0, };
+
quark = g_quark_from_string (tag);
info = gst_tag_lookup (quark);
if (info == NULL)
info = gst_tag_lookup (quark);
g_return_if_fail (info != NULL);
gst_tag_list_add_value_internal (list, mode, quark, va_arg (var_args,
- GValue *));
+ GValue *));
tag = va_arg (var_args, gchar *);
}
}
GstTagForeachFunc func;
GstTagList *tag_list;
gpointer data;
-} TagForeachData;
+}
+TagForeachData;
static int
structure_foreach_wrapper (GQuark field_id, GValue * value, gpointer user_data)
{
{
GstTagMergeMode mode;
GstTagList *list;
-} GstTagData;
+}
+GstTagData;
GType
gst_tag_setter_get_type (void)
if (!tag_setter_type) {
static const GTypeInfo tag_setter_info = {
- sizeof (GstTagSetterIFace), /* class_size */
- NULL, /* base_init */
- NULL, /* base_finalize */
+ sizeof (GstTagSetterIFace), /* class_size */
+ NULL, /* base_init */
+ NULL, /* base_finalize */
NULL,
- NULL, /* class_finalize */
- NULL, /* class_data */
+ NULL, /* class_finalize */
+ NULL, /* class_data */
0,
0,
NULL
};
GST_DEBUG_CATEGORY_INIT (gst_tag_interface_debug, "GstTagInterface", 0,
- "interfaces for tagging");
+ "interfaces for tagging");
tag_setter_type = g_type_register_static (G_TYPE_INTERFACE, "GstTagSetter",
- &tag_setter_info, 0);
+ &tag_setter_info, 0);
g_type_interface_add_prerequisite (tag_setter_type, GST_TYPE_ELEMENT);
data->list = NULL;
data->mode = GST_TAG_MERGE_KEEP;
g_object_set_qdata_full (G_OBJECT (setter), gst_tag_key, data,
- gst_tag_data_free);
+ gst_tag_data_free);
}
return data;
{G_THREAD_PRIORITY_URGENT, "URGENT", "Urgent Scheduling"},
{0, NULL, NULL},
};
+
if (!thread_priority_type) {
thread_priority_type =
- g_enum_register_static ("GstThreadPriority", thread_priority);
+ g_enum_register_static ("GstThreadPriority", thread_priority);
}
return thread_priority_type;
}
gst_thread_init,
NULL
};
+
thread_type = g_type_register_static (GST_TYPE_BIN, "GstThread",
- &thread_info, 0);
+ &thread_info, 0);
}
return thread_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PRIORITY,
g_param_spec_enum ("priority", "Scheduling Policy",
- "The scheduling priority of the thread", GST_TYPE_THREAD_PRIORITY,
- G_THREAD_PRIORITY_NORMAL, G_PARAM_READWRITE));
+ "The scheduling priority of the thread", GST_TYPE_THREAD_PRIORITY,
+ G_THREAD_PRIORITY_NORMAL, G_PARAM_READWRITE));
gst_thread_signals[SHUTDOWN] =
g_signal_new ("shutdown", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
thread->lock = g_mutex_new ();
thread->cond = g_cond_new ();
- thread->thread_id = (GThread *) NULL; /* set in NULL -> READY */
+ thread->thread_id = (GThread *) NULL; /* set in NULL -> READY */
thread->priority = G_THREAD_PRIORITY_NORMAL;
}
g_assert (element);
GST_DEBUG_OBJECT (thread, "waking element \"%s\"",
- GST_ELEMENT_NAME (element));
+ GST_ELEMENT_NAME (element));
elements = g_list_next (elements);
if (!gst_element_release_locks (element))
g_warning ("element %s could not release locks",
- GST_ELEMENT_NAME (element));
+ GST_ELEMENT_NAME (element));
pads = GST_ELEMENT_PADS (element);
while (pads) {
if (GST_PAD_PEER (pads->data)) {
- peer = GST_REAL_PAD (GST_PAD_PEER (pads->data));
- pads = g_list_next (pads);
+ peer = GST_REAL_PAD (GST_PAD_PEER (pads->data));
+ pads = g_list_next (pads);
} else {
- pads = g_list_next (pads);
- continue;
+ pads = g_list_next (pads);
+ continue;
}
if (!peer)
- continue;
+ continue;
peerelement = GST_PAD_PARENT (peer);
if (!peerelement)
- continue; /* FIXME: deal with case where there's no peer */
+ continue; /* FIXME: deal with case where there's no peer */
if (GST_ELEMENT_SCHED (peerelement) != GST_ELEMENT_SCHED (thread)) {
- GST_LOG_OBJECT (thread, "element \"%s\" has pad cross sched boundary",
- GST_ELEMENT_NAME (element));
- GST_LOG_OBJECT (thread, "waking element \"%s\"",
- GST_ELEMENT_NAME (peerelement));
- if (!gst_element_release_locks (peerelement))
- g_warning ("element %s could not release locks",
- GST_ELEMENT_NAME (peerelement));
+ GST_LOG_OBJECT (thread, "element \"%s\" has pad cross sched boundary",
+ GST_ELEMENT_NAME (element));
+ GST_LOG_OBJECT (thread, "waking element \"%s\"",
+ GST_ELEMENT_NAME (peerelement));
+ if (!gst_element_release_locks (peerelement))
+ g_warning ("element %s could not release locks",
+ GST_ELEMENT_NAME (peerelement));
}
}
}
g_cond_signal (thread->cond);
gst_thread_release_children_locks (thread);
g_get_current_time (&tv);
- g_time_val_add (&tv, 1000); /* wait a millisecond to catch the thread */
+ g_time_val_add (&tv, 1000); /* wait a millisecond to catch the thread */
wait = g_cond_timed_wait (thread->cond, thread->lock, &tv);
}
GST_LOG_OBJECT (thread, "caught thread");
/* create the thread */
GST_FLAG_UNSET (thread, GST_THREAD_STATE_REAPING);
thread->thread_id = g_thread_create_full (gst_thread_main_loop,
- thread, STACK_SIZE, FALSE, TRUE, thread->priority, NULL);
+ thread, STACK_SIZE, FALSE, TRUE, thread->priority, NULL);
if (!thread->thread_id) {
- GST_ERROR_OBJECT (element, "g_thread_create_full failed");
- goto error_out;
+ GST_ERROR_OBJECT (element, "g_thread_create_full failed");
+ goto error_out;
}
GST_LOG_OBJECT (element, "GThread created");
GList *elements = (GList *) gst_bin_get_list (GST_BIN (thread));
while (elements) {
- gst_element_enable_threadsafe_properties ((GstElement *) elements->
- data);
- elements = g_list_next (elements);
+ gst_element_enable_threadsafe_properties ((GstElement *) elements->
+ data);
+ elements = g_list_next (elements);
}
/* reset self to spinning */
if (thread == gst_thread_get_current ())
- GST_FLAG_SET (thread, GST_THREAD_STATE_SPINNING);
+ GST_FLAG_SET (thread, GST_THREAD_STATE_SPINNING);
break;
}
case GST_STATE_PLAYING_TO_PAUSED:
GList *elements = (GList *) gst_bin_get_list (GST_BIN (thread));
while (elements) {
- gst_element_disable_threadsafe_properties ((GstElement *) elements->
- data);
- elements = g_list_next (elements);
+ gst_element_disable_threadsafe_properties ((GstElement *) elements->
+ data);
+ elements = g_list_next (elements);
}
break;
}
GST_FLAG_SET (thread, GST_THREAD_STATE_REAPING);
thread->thread_id = NULL;
if (thread == gst_thread_get_current ()) {
- /* or should we continue? */
- g_warning
- ("Thread %s is destroying itself. Function call will not return!",
- GST_ELEMENT_NAME (thread));
- gst_scheduler_reset (GST_ELEMENT_SCHED (thread));
+ /* or should we continue? */
+ g_warning
+ ("Thread %s is destroying itself. Function call will not return!",
+ GST_ELEMENT_NAME (thread));
+ gst_scheduler_reset (GST_ELEMENT_SCHED (thread));
- /* unlock and signal - we are out */
- gst_thread_release (thread);
+ /* unlock and signal - we are out */
+ gst_thread_release (thread);
- GST_INFO_OBJECT (thread, "GThread %p is exiting", g_thread_self ());
+ GST_INFO_OBJECT (thread, "GThread %p is exiting", g_thread_self ());
- g_signal_emit (G_OBJECT (thread), gst_thread_signals[SHUTDOWN], 0);
+ g_signal_emit (G_OBJECT (thread), gst_thread_signals[SHUTDOWN], 0);
- g_thread_exit (NULL);
+ g_thread_exit (NULL);
}
/* now wait for the thread to destroy itself */
g_cond_signal (thread->cond);
break;
default:
GST_ERROR_OBJECT (element, "unhandled state change! %x",
- GST_STATE_TRANSITION (element));
+ GST_STATE_TRANSITION (element));
g_warning ("thread %s: UNHANDLED STATE CHANGE! %x",
- GST_STR_NULL (GST_OBJECT_NAME (element)),
- GST_STATE_TRANSITION (element));
+ GST_STR_NULL (GST_OBJECT_NAME (element)),
+ GST_STATE_TRANSITION (element));
/* FIXME: not doable with current threading mess:
g_assert_not_reached ();
*/
status = TRUE;
GST_LOG_OBJECT (thread, "starting to iterate");
while (status && GST_FLAG_IS_SET (thread, GST_THREAD_STATE_SPINNING)) {
- g_mutex_unlock (thread->lock);
- status = gst_bin_iterate (GST_BIN (thread));
- if (GST_FLAG_IS_SET (thread, GST_THREAD_MUTEX_LOCKED)) {
- GST_FLAG_UNSET (thread, GST_THREAD_MUTEX_LOCKED);
- } else {
- g_mutex_lock (thread->lock);
- }
+ g_mutex_unlock (thread->lock);
+ status = gst_bin_iterate (GST_BIN (thread));
+ if (GST_FLAG_IS_SET (thread, GST_THREAD_MUTEX_LOCKED)) {
+ GST_FLAG_UNSET (thread, GST_THREAD_MUTEX_LOCKED);
+ } else {
+ g_mutex_lock (thread->lock);
+ }
}
GST_FLAG_UNSET (thread, GST_THREAD_STATE_SPINNING);
}
static void
gst_mutex_dummy_impl (GMutex * mutex)
-{ /* NOP */
+{ /* NOP */
}
static gboolean
static void
gst_cond_dummy_impl (GCond * cond)
-{ /* NOP */
+{ /* NOP */
}
static gboolean
static void
gst_thread_dummy_impl (void)
-{ /* NOP */
+{ /* NOP */
}
static void
gst_thread_dummy_impl_1 (gpointer thread)
-{ /* NOP */
+{ /* NOP */
}
static void
gst_thread_set_priority_dummy_impl (gpointer thread, GThreadPriority priority)
-{ /* NOP */
+{ /* NOP */
}
static gboolean
}
GThreadFunctions gst_thread_dummy_functions = {
-gst_mutex_new_dummy_impl,
- (void (*)(GMutex *)) gst_mutex_dummy_impl,
- gst_mutex_trylock_dummy_impl,
- (void (*)(GMutex *)) gst_mutex_dummy_impl,
- gst_mutex_dummy_impl,
- gst_cond_new_dummy_impl,
- (void (*)(GCond *)) gst_cond_dummy_impl,
- (void (*)(GCond *)) gst_cond_dummy_impl,
- (void (*)(GCond *, GMutex *)) gst_cond_dummy_impl,
- gst_cond_timed_wait_dummy_impl,
- gst_cond_dummy_impl,
- gst_private_new_dummy_impl,
- gst_private_get_dummy_impl,
- gst_private_set_dummy_impl,
- gst_thread_create_dummy_impl,
- gst_thread_dummy_impl,
- gst_thread_dummy_impl_1,
- gst_thread_dummy_impl,
- gst_thread_set_priority_dummy_impl,
- gst_thread_dummy_impl_1, gst_thread_equal_dummy_impl};
+ gst_mutex_new_dummy_impl,
+ (void (*)(GMutex *)) gst_mutex_dummy_impl,
+ gst_mutex_trylock_dummy_impl,
+ (void (*)(GMutex *)) gst_mutex_dummy_impl,
+ gst_mutex_dummy_impl,
+ gst_cond_new_dummy_impl,
+ (void (*)(GCond *)) gst_cond_dummy_impl,
+ (void (*)(GCond *)) gst_cond_dummy_impl,
+ (void (*)(GCond *, GMutex *)) gst_cond_dummy_impl,
+ gst_cond_timed_wait_dummy_impl,
+ gst_cond_dummy_impl,
+ gst_private_new_dummy_impl,
+ gst_private_get_dummy_impl,
+ gst_private_set_dummy_impl,
+ gst_thread_create_dummy_impl,
+ gst_thread_dummy_impl,
+ gst_thread_dummy_impl_1,
+ gst_thread_dummy_impl,
+ gst_thread_set_priority_dummy_impl,
+ gst_thread_dummy_impl_1, gst_thread_equal_dummy_impl
+};
for (i = 0; i < trace->bufoffset; i++) {
snprintf (str, STRSIZE, "%20" G_GINT64_FORMAT " %10d %10d %s\n",
- trace->buf[i].timestamp,
- trace->buf[i].sequence, trace->buf[i].data, trace->buf[i].message);
+ trace->buf[i].timestamp,
+ trace->buf[i].sequence, trace->buf[i].data, trace->buf[i].message);
write (trace->fd, str, strlen (str));
}
trace->bufoffset = 0;
g_print (", dumping live memory: ");
while (mem_live) {
- g_print ("%p ", mem_live->data);
- mem_live = g_slist_next (mem_live);
+ g_print ("%p ", mem_live->data);
+ mem_live = g_slist_next (mem_live);
}
g_print ("\ntotal %d", g_slist_length (trace->mem_live));
}
gst_type_find_factory_init,
NULL
};
+
typefind_type = g_type_register_static (GST_TYPE_PLUGIN_FEATURE,
- "GstTypeFindFactory", &typefind_info, 0);
+ "GstTypeFindFactory", &typefind_info, 0);
GST_DEBUG_CATEGORY_INIT (gst_type_find_debug, "GST_TYPEFIND",
- GST_DEBUG_FG_GREEN, "typefinding subsystem");
+ GST_DEBUG_FG_GREEN, "typefinding subsystem");
}
return typefind_type;
if (factory->function == gst_type_find_load_plugin) {
/* looks like we didn't get a real typefind function */
g_warning ("could not load valid typefind function for feature '%s'\n",
- GST_PLUGIN_FEATURE_NAME (factory));
+ GST_PLUGIN_FEATURE_NAME (factory));
} else {
g_assert (factory->function);
gst_type_find_factory_call_function (factory, find);
GST_INFO ("registering typefind function for %s", name);
factory =
GST_TYPE_FIND_FACTORY (gst_registry_pool_find_feature (name,
- GST_TYPE_TYPE_FIND_FACTORY));
+ GST_TYPE_TYPE_FIND_FACTORY));
if (!factory) {
factory = g_object_new (GST_TYPE_TYPE_FIND_FACTORY, NULL);
GST_DEBUG_OBJECT (factory, "using new typefind factory for %s", name);
NULL,
NULL
};
+
urihandler_type = g_type_register_static (G_TYPE_INTERFACE,
- "GstURIHandler", &urihandler_info, 0);
+ "GstURIHandler", &urihandler_info, 0);
GST_DEBUG_CATEGORY_INIT (gst_uri_handler_debug, "GST_URI", GST_DEBUG_BOLD,
- "handling of URIs");
+ "handling of URIs");
}
return urihandler_type;
}
if (!initialized) {
g_signal_new ("new-uri", GST_TYPE_URI_HANDLER, G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GstURIHandlerInterface, new_uri), NULL, NULL,
- gst_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
+ G_STRUCT_OFFSET (GstURIHandlerInterface, new_uri), NULL, NULL,
+ gst_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
initialized = TRUE;
}
}
{
GstURIType type;
gchar *protocol;
-} SearchEntry;
+}
+SearchEntry;
static gboolean
search_by_entry (GstPluginFeature * feature, gpointer search_entry)
{
if (!possibilities) {
GST_DEBUG ("No %s for URI '%s'", type == GST_URI_SINK ? "sink" : "source",
- uri);
+ uri);
return NULL;
}
walk = possibilities;
while (walk) {
if ((ret = gst_element_factory_create (GST_ELEMENT_FACTORY (walk->data),
- elementname)) != NULL) {
+ elementname)) != NULL) {
GstURIHandler *handler = GST_URI_HANDLER (ret);
if (gst_uri_handler_set_uri (handler, uri))
- break;
+ break;
g_object_unref (ret);
ret = NULL;
}
if (j == 16 || i == size) {
g_print ("%08x (%p): %-48.48s %-16.16s\n", i - j, mem + i - j,
- string->str, chars->str);
+ string->str, chars->str);
g_string_set_size (string, 0);
g_string_set_size (chars, 0);
j = 0;
gboolean i = FALSE;
if (!strncmp ("true", value_str, 4))
- i = TRUE;
+ i = TRUE;
g_value_set_boolean (value, i);
break;
}
GParamSpec *paramspec;
paramspec =
- g_object_class_find_property (G_OBJECT_GET_CLASS (object), name);
+ g_object_class_find_property (G_OBJECT_GET_CLASS (object), name);
if (!paramspec) {
return;
}
GST_DEBUG ("paramspec->flags is %d, paramspec->value_type is %d",
- paramspec->flags, (gint) paramspec->value_type);
+ paramspec->flags, (gint) paramspec->value_type);
if (paramspec->flags & G_PARAM_WRITABLE) {
switch (paramspec->value_type) {
- case G_TYPE_STRING:
- g_object_set (G_OBJECT (object), name, value, NULL);
- break;
- case G_TYPE_ENUM:
- case G_TYPE_INT:{
- gint i;
-
- sscanf (value, "%d", &i);
- g_object_set (G_OBJECT (object), name, i, NULL);
- break;
- }
- case G_TYPE_UINT:{
- guint i;
-
- sscanf (value, "%u", &i);
- g_object_set (G_OBJECT (object), name, i, NULL);
- break;
- }
- case G_TYPE_LONG:{
- glong i;
-
- sscanf (value, "%ld", &i);
- g_object_set (G_OBJECT (object), name, i, NULL);
- break;
- }
- case G_TYPE_ULONG:{
- gulong i;
-
- sscanf (value, "%lu", &i);
- g_object_set (G_OBJECT (object), name, i, NULL);
- break;
- }
- case G_TYPE_BOOLEAN:{
- gboolean i = FALSE;
-
- if (!g_ascii_strncasecmp ("true", value, 4))
- i = TRUE;
- g_object_set (G_OBJECT (object), name, i, NULL);
- break;
- }
- case G_TYPE_CHAR:{
- gchar i;
-
- sscanf (value, "%c", &i);
- g_object_set (G_OBJECT (object), name, i, NULL);
- break;
- }
- case G_TYPE_UCHAR:{
- guchar i;
-
- sscanf (value, "%c", &i);
- g_object_set (G_OBJECT (object), name, i, NULL);
- break;
- }
- case G_TYPE_FLOAT:{
- gfloat i;
-
- sscanf (value, "%f", &i);
- g_object_set (G_OBJECT (object), name, i, NULL);
- break;
- }
- case G_TYPE_DOUBLE:{
- gfloat i;
-
- sscanf (value, "%g", &i);
- g_object_set (G_OBJECT (object), name, (gdouble) i, NULL);
- break;
- }
- default:
- if (G_IS_PARAM_SPEC_ENUM (paramspec)) {
- gint i;
-
- sscanf (value, "%d", &i);
- g_object_set (G_OBJECT (object), name, i, NULL);
- } else if (paramspec->value_type == GST_TYPE_URI) {
- g_object_set (G_OBJECT (object), name, value, NULL);
- }
- break;
+ case G_TYPE_STRING:
+ g_object_set (G_OBJECT (object), name, value, NULL);
+ break;
+ case G_TYPE_ENUM:
+ case G_TYPE_INT:{
+ gint i;
+
+ sscanf (value, "%d", &i);
+ g_object_set (G_OBJECT (object), name, i, NULL);
+ break;
+ }
+ case G_TYPE_UINT:{
+ guint i;
+
+ sscanf (value, "%u", &i);
+ g_object_set (G_OBJECT (object), name, i, NULL);
+ break;
+ }
+ case G_TYPE_LONG:{
+ glong i;
+
+ sscanf (value, "%ld", &i);
+ g_object_set (G_OBJECT (object), name, i, NULL);
+ break;
+ }
+ case G_TYPE_ULONG:{
+ gulong i;
+
+ sscanf (value, "%lu", &i);
+ g_object_set (G_OBJECT (object), name, i, NULL);
+ break;
+ }
+ case G_TYPE_BOOLEAN:{
+ gboolean i = FALSE;
+
+ if (!g_ascii_strncasecmp ("true", value, 4))
+ i = TRUE;
+ g_object_set (G_OBJECT (object), name, i, NULL);
+ break;
+ }
+ case G_TYPE_CHAR:{
+ gchar i;
+
+ sscanf (value, "%c", &i);
+ g_object_set (G_OBJECT (object), name, i, NULL);
+ break;
+ }
+ case G_TYPE_UCHAR:{
+ guchar i;
+
+ sscanf (value, "%c", &i);
+ g_object_set (G_OBJECT (object), name, i, NULL);
+ break;
+ }
+ case G_TYPE_FLOAT:{
+ gfloat i;
+
+ sscanf (value, "%f", &i);
+ g_object_set (G_OBJECT (object), name, i, NULL);
+ break;
+ }
+ case G_TYPE_DOUBLE:{
+ gfloat i;
+
+ sscanf (value, "%g", &i);
+ g_object_set (G_OBJECT (object), name, (gdouble) i, NULL);
+ break;
+ }
+ default:
+ if (G_IS_PARAM_SPEC_ENUM (paramspec)) {
+ gint i;
+
+ sscanf (value, "%d", &i);
+ g_object_set (G_OBJECT (object), name, i, NULL);
+ } else if (paramspec->value_type == GST_TYPE_URI) {
+ g_object_set (G_OBJECT (object), name, value, NULL);
+ }
+ break;
}
}
}
if (!caps) {
string_append_indent (buf, indent);
g_string_printf (buf, "%s:%s has no capabilities",
- GST_DEBUG_PAD_NAME (pad));
+ GST_DEBUG_PAD_NAME (pad));
} else {
char *s;
gst_print_element_args (GString * buf, gint indent, GstElement * element)
{
guint width;
- GValue value = { 0, }; /* the important thing is that value.type = 0 */
+ GValue value = { 0, }; /* the important thing is that value.type = 0 */
gchar *str = 0;
GParamSpec *spec, **specs, **walk;
g_array_set_size (dest, src->len);
for (i = 0; i < src->len; i++) {
gst_value_init_and_copy (&g_array_index (dest, GValue, i),
- &g_array_index (src, GValue, i));
+ &g_array_index (src, GValue, i));
}
return dest;
value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
} else {
value->data[0].v_pointer =
- gst_value_list_array_copy ((GArray *) collect_values[0].v_pointer);
+ gst_value_list_array_copy ((GArray *) collect_values[0].v_pointer);
}
return NULL;
}
if (!dest)
return g_strdup_printf ("value location for `%s' passed as NULL",
- G_VALUE_TYPE_NAME (value));
+ G_VALUE_TYPE_NAME (value));
if (!value->data[0].v_pointer)
return g_strdup_printf ("invalid value given for `%s'",
- G_VALUE_TYPE_NAME (value));
+ G_VALUE_TYPE_NAME (value));
if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
*dest = (GArray *) value->data[0].v_pointer;
} else {
if (GST_VALUE_HOLDS_LIST (value1)) {
for (i = 0; i < value1_length; i++) {
gst_value_init_and_copy (&g_array_index (array, GValue, i),
- gst_value_list_get_value (value1, i));
+ gst_value_list_get_value (value1, i));
}
} else {
gst_value_init_and_copy (&g_array_index (array, GValue, 0), value1);
if (GST_VALUE_HOLDS_LIST (value2)) {
for (i = 0; i < value2_length; i++) {
gst_value_init_and_copy (&g_array_index (array, GValue,
- i + value1_length), gst_value_list_get_value (value2, i));
+ i + value1_length), gst_value_list_get_value (value2, i));
}
} else {
gst_value_init_and_copy (&g_array_index (array, GValue, value1_length),
- value2);
+ value2);
}
}
for (j = 0; j < array1->len; j++) {
v2 = &g_array_index (array2, GValue, j);
if (gst_value_compare (v1, v2) == GST_VALUE_EQUAL)
- break;
+ break;
}
if (j == array1->len) {
return GST_VALUE_UNORDERED;
if (!fourcc_p)
return g_strdup_printf ("value location for `%s' passed as NULL",
- G_VALUE_TYPE_NAME (value));
+ G_VALUE_TYPE_NAME (value));
*fourcc_p = value->data[0].v_int;
g_ascii_isprint ((fourcc >> 16) & 0xff) &&
g_ascii_isprint ((fourcc >> 24) & 0xff)) {
dest_value->data[0].v_pointer =
- g_strdup_printf (GST_FOURCC_FORMAT, GST_FOURCC_ARGS (fourcc));
+ g_strdup_printf (GST_FOURCC_FORMAT, GST_FOURCC_ARGS (fourcc));
} else {
dest_value->data[0].v_pointer = g_strdup_printf ("0x%08x", fourcc);
}
if (!int_range_start)
return g_strdup_printf ("start value location for `%s' passed as NULL",
- G_VALUE_TYPE_NAME (value));
+ G_VALUE_TYPE_NAME (value));
if (!int_range_end)
return g_strdup_printf ("end value location for `%s' passed as NULL",
- G_VALUE_TYPE_NAME (value));
+ G_VALUE_TYPE_NAME (value));
*int_range_start = value->data[0].v_int;
*int_range_end = value->data[1].v_int;
if (!double_range_start)
return g_strdup_printf ("start value location for `%s' passed as NULL",
- G_VALUE_TYPE_NAME (value));
+ G_VALUE_TYPE_NAME (value));
if (!double_range_end)
return g_strdup_printf ("end value location for `%s' passed as NULL",
- G_VALUE_TYPE_NAME (value));
+ G_VALUE_TYPE_NAME (value));
*double_range_start = value->data[0].v_double;
*double_range_end = value->data[1].v_double;
dest_value->data[0].v_pointer = g_strdup_printf ("[%s,%s]",
g_ascii_dtostr (s1, G_ASCII_DTOSTR_BUF_SIZE,
- src_value->data[0].v_double),
+ src_value->data[0].v_double),
g_ascii_dtostr (s2, G_ASCII_DTOSTR_BUF_SIZE,
- src_value->data[1].v_double));
+ src_value->data[1].v_double));
}
static int
if (gst_value_intersect (&intersection, cur, value2)) {
/* append value */
if (!ret) {
- gst_value_init_and_copy (dest, &intersection);
- ret = TRUE;
+ gst_value_init_and_copy (dest, &intersection);
+ ret = TRUE;
} else if (GST_VALUE_HOLDS_LIST (dest)) {
- gst_value_list_append_value (dest, &intersection);
+ gst_value_list_append_value (dest, &intersection);
} else {
- GValue temp = { 0, };
+ GValue temp = { 0, };
- gst_value_init_and_copy (&temp, dest);
- g_value_unset (dest);
- gst_value_list_concat (dest, &temp, &intersection);
+ gst_value_init_and_copy (&temp, dest);
+ g_value_unset (dest);
+ gst_value_list_concat (dest, &temp, &intersection);
}
g_value_unset (&intersection);
}
for (i = 0; i < gst_value_union_funcs->len; i++) {
union_info = &g_array_index (gst_value_union_funcs, GstValueUnionInfo, i);
if (union_info->type1 == G_VALUE_TYPE (value1) &&
- union_info->type2 == G_VALUE_TYPE (value2))
+ union_info->type2 == G_VALUE_TYPE (value2))
return TRUE;
}
for (i = 0; i < gst_value_union_funcs->len; i++) {
union_info = &g_array_index (gst_value_union_funcs, GstValueUnionInfo, i);
if (union_info->type1 == G_VALUE_TYPE (value1) &&
- union_info->type2 == G_VALUE_TYPE (value2)) {
+ union_info->type2 == G_VALUE_TYPE (value2)) {
return union_info->func (dest, value1, value2);
}
}
for (i = 0; i < gst_value_intersect_funcs->len; i++) {
intersect_info = &g_array_index (gst_value_intersect_funcs,
- GstValueIntersectInfo, i);
+ GstValueIntersectInfo, i);
if (intersect_info->type1 == G_VALUE_TYPE (value1) &&
- intersect_info->type2 == G_VALUE_TYPE (value2))
+ intersect_info->type2 == G_VALUE_TYPE (value2))
return TRUE;
}
for (i = 0; i < gst_value_intersect_funcs->len; i++) {
intersect_info = &g_array_index (gst_value_intersect_funcs,
- GstValueIntersectInfo, i);
+ GstValueIntersectInfo, i);
if (intersect_info->type1 == G_VALUE_TYPE (value1) &&
- intersect_info->type2 == G_VALUE_TYPE (value2)) {
+ intersect_info->type2 == G_VALUE_TYPE (value2)) {
ret = intersect_info->func (dest, value1, value2);
return ret;
}
if (intersect_info->type1 == G_VALUE_TYPE (value2) &&
- intersect_info->type2 == G_VALUE_TYPE (value1)) {
+ intersect_info->type2 == G_VALUE_TYPE (value1)) {
ret = intersect_info->func (dest, value2, value1);
return ret;
}
NULL,
NULL,
};
+
//const GTypeFundamentalInfo finfo = { G_TYPE_FLAG_DERIVABLE, };
gst_value_table = g_array_new (FALSE, FALSE, sizeof (GstValueTable));
gst_value_serialize_fourcc,
gst_value_deserialize_fourcc,
};
+
info.value_table = &value_table;
gst_type_fourcc =
- g_type_register_static (G_TYPE_BOXED, "GstFourcc", &info, 0);
+ g_type_register_static (G_TYPE_BOXED, "GstFourcc", &info, 0);
gst_value.type = gst_type_fourcc;
gst_value_register (&gst_value);
}
gst_value_serialize_int_range,
gst_value_deserialize_int_range,
};
+
info.value_table = &value_table;
gst_type_int_range =
- g_type_register_static (G_TYPE_BOXED, "GstIntRange", &info, 0);
+ g_type_register_static (G_TYPE_BOXED, "GstIntRange", &info, 0);
gst_value.type = gst_type_int_range;
gst_value_register (&gst_value);
}
gst_value_serialize_double_range,
gst_value_deserialize_double_range,
};
+
info.value_table = &value_table;
gst_type_double_range =
- g_type_register_static (G_TYPE_BOXED, "GstDoubleRange", &info, 0);
+ g_type_register_static (G_TYPE_BOXED, "GstDoubleRange", &info, 0);
gst_value.type = gst_type_double_range;
gst_value_register (&gst_value);
}
gst_value_serialize_list,
gst_value_deserialize_list,
};
+
info.value_table = &value_table;
gst_type_list =
- g_type_register_static (G_TYPE_BOXED, "GstValueList", &info, 0);
+ g_type_register_static (G_TYPE_BOXED, "GstValueList", &info, 0);
gst_value.type = gst_type_list;
gst_value_register (&gst_value);
}
gst_value_serialize_int,
gst_value_deserialize_int,
};
+
gst_value_register (&gst_value);
}
gst_value_serialize_double,
gst_value_deserialize_double,
};
+
gst_value_register (&gst_value);
}
gst_value_serialize_string,
gst_value_deserialize_string,
};
+
gst_value_register (&gst_value);
}
gst_value_serialize_boolean,
gst_value_deserialize_boolean,
};
+
gst_value_register (&gst_value);
}
(GInstanceInitFunc) gst_xml_init,
NULL
};
+
xml_type = g_type_register_static (GST_TYPE_OBJECT, "GstXML", &xml_info, 0);
}
return xml_type;
if (cur->charset != XML_CHAR_ENCODING_UTF8) {
xmlGenericError (xmlGenericErrorContext,
- "xmlDocDump: document not in UTF8\n");
+ "xmlDocDump: document not in UTF8\n");
return -1;
}
if (enc != XML_CHAR_ENCODING_UTF8) {
handler = xmlFindCharEncodingHandler (encoding);
if (handler == NULL) {
- xmlFree ((char *) cur->encoding);
- cur->encoding = NULL;
+ xmlFree ((char *) cur->encoding);
+ cur->encoding = NULL;
}
}
}
return top;
} else {
if (GST_IS_BIN (top)) {
- element = gst_bin_get_by_name (GST_BIN (top), name);
+ element = gst_bin_get_by_name (GST_BIN (top), name);
- if (element)
- return element;
+ if (element)
+ return element;
}
}
topelements = g_list_next (topelements);
gint nformats;
GstFormat *format;
GArray *array;
-} GstFileIndexId;
+}
+GstFileIndexId;
typedef struct _GstFileIndex GstFileIndex;
typedef struct _GstFileIndexClass GstFileIndexClass;
gint next_id;
GHashTable *id_index;
- GstIndexEntry *ret_entry; /* hack to avoid leaking memory */
+ GstIndexEntry *ret_entry; /* hack to avoid leaking memory */
};
struct _GstFileIndexClass
(GInstanceInitFunc) gst_file_index_init,
NULL
};
+
file_index_type =
- g_type_register_static (GST_TYPE_INDEX, "GstFileIndex",
- &file_index_info, 0);
+ g_type_register_static (GST_TYPE_INDEX, "GstFileIndex",
+ &file_index_info, 0);
}
return file_index_type;
}
g_object_class_install_property (gobject_class, ARG_LOCATION,
g_param_spec_string ("location", "File Location",
- "Location of the index file", NULL, G_PARAM_READWRITE));
+ "Location of the index file", NULL, G_PARAM_READWRITE));
}
static void
g_hash_table_destroy (index->id_index);
index->id_index = NULL;
- gst_index_entry_free (index->ret_entry); /* hack */
+ gst_index_entry_free (index->ret_entry); /* hack */
G_OBJECT_CLASS (parent_class)->dispose (object);
}
if (match) {
GST_CAT_WARNING_OBJECT (DC, index, "Duplicate matches for writer '%s'",
- writer_string);
+ writer_string);
continue;
}
if (cx.ii) {
match = TRUE;
GST_CAT_DEBUG_OBJECT (DC, index, "Resolved writer '%s' again",
- writer_string);
+ writer_string);
} else
GST_CAT_WARNING_OBJECT (DC, index, "Can't resolve writer '%s'",
- writer_string);
+ writer_string);
}
return match;
xmlNodePtr writer;
for (writer = part->children; writer; writer = writer->next) {
- xmlChar *datafile = xmlGetProp (writer, "datafile");
- gchar *path = g_strdup_printf ("%s/%s", index->location, datafile);
- int fd;
- GstFileIndexId *id_index;
- xmlNodePtr wpart;
- xmlChar *entries_str;
- gpointer array_data;
-
- free (datafile);
-
- fd = open (path, O_RDONLY);
- g_free (path);
- if (fd < 0) {
- GST_CAT_ERROR_OBJECT (DC, index,
- "Can't open '%s': %s", path, strerror (errno));
- continue;
- }
-
- id_index = g_new0 (GstFileIndexId, 1);
- id_index->id_desc = xmlGetProp (writer, "id");
-
- for (wpart = writer->children; wpart; wpart = wpart->next) {
- if (strcmp (wpart->name, "formats") == 0) {
- xmlChar *count_str = xmlGetProp (wpart, "count");
- gint fx = 0;
- xmlNodePtr format;
-
- id_index->nformats = atoi (count_str);
- free (count_str);
-
- id_index->format = g_new (GstFormat, id_index->nformats);
-
- for (format = wpart->children; format; format = format->next) {
- xmlChar *nick = xmlGetProp (format, "nick");
- GstFormat fmt = gst_format_get_by_nick (nick);
-
- if (fmt == GST_FORMAT_UNDEFINED)
- GST_CAT_ERROR_OBJECT (DC, index, "format '%s' undefined", nick);
- g_assert (fx < id_index->nformats);
- id_index->format[fx++] = fmt;
- free (nick);
- }
- } else
- GST_CAT_INFO_OBJECT (DC, index, "unknown wpart '%s'", wpart->name);
- }
-
- g_assert (id_index->nformats > 0);
- _fc_alloc_array (id_index);
- g_assert (id_index->array->data == NULL); /* little bit risky */
-
- entries_str = xmlGetProp (writer, "entries");
- id_index->array->len = atoi (entries_str);
- free (entries_str);
-
- array_data =
- mmap (NULL, ARRAY_TOTAL_SIZE (id_index), PROT_READ, MAP_SHARED, fd,
- 0);
- close (fd);
- if (array_data == MAP_FAILED) {
- GST_CAT_ERROR_OBJECT (DC, index,
- "mmap %s failed: %s", path, strerror (errno));
- continue;
- }
-
- id_index->array->data = array_data;
-
- index->unresolved = g_slist_prepend (index->unresolved, id_index);
+ xmlChar *datafile = xmlGetProp (writer, "datafile");
+ gchar *path = g_strdup_printf ("%s/%s", index->location, datafile);
+ int fd;
+ GstFileIndexId *id_index;
+ xmlNodePtr wpart;
+ xmlChar *entries_str;
+ gpointer array_data;
+
+ free (datafile);
+
+ fd = open (path, O_RDONLY);
+ g_free (path);
+ if (fd < 0) {
+ GST_CAT_ERROR_OBJECT (DC, index,
+ "Can't open '%s': %s", path, strerror (errno));
+ continue;
+ }
+
+ id_index = g_new0 (GstFileIndexId, 1);
+ id_index->id_desc = xmlGetProp (writer, "id");
+
+ for (wpart = writer->children; wpart; wpart = wpart->next) {
+ if (strcmp (wpart->name, "formats") == 0) {
+ xmlChar *count_str = xmlGetProp (wpart, "count");
+ gint fx = 0;
+ xmlNodePtr format;
+
+ id_index->nformats = atoi (count_str);
+ free (count_str);
+
+ id_index->format = g_new (GstFormat, id_index->nformats);
+
+ for (format = wpart->children; format; format = format->next) {
+ xmlChar *nick = xmlGetProp (format, "nick");
+ GstFormat fmt = gst_format_get_by_nick (nick);
+
+ if (fmt == GST_FORMAT_UNDEFINED)
+ GST_CAT_ERROR_OBJECT (DC, index, "format '%s' undefined", nick);
+ g_assert (fx < id_index->nformats);
+ id_index->format[fx++] = fmt;
+ free (nick);
+ }
+ } else
+ GST_CAT_INFO_OBJECT (DC, index, "unknown wpart '%s'", wpart->name);
+ }
+
+ g_assert (id_index->nformats > 0);
+ _fc_alloc_array (id_index);
+ g_assert (id_index->array->data == NULL); /* little bit risky */
+
+ entries_str = xmlGetProp (writer, "entries");
+ id_index->array->len = atoi (entries_str);
+ free (entries_str);
+
+ array_data =
+ mmap (NULL, ARRAY_TOTAL_SIZE (id_index), PROT_READ, MAP_SHARED, fd,
+ 0);
+ close (fd);
+ if (array_data == MAP_FAILED) {
+ GST_CAT_ERROR_OBJECT (DC, index,
+ "mmap %s failed: %s", path, strerror (errno));
+ continue;
+ }
+
+ id_index->array->data = array_data;
+
+ index->unresolved = g_slist_prepend (index->unresolved, id_index);
}
} else
GST_CAT_INFO_OBJECT (DC, index, "unknown part '%s'", part->name);
switch (prop_id) {
case ARG_LOCATION:
if (index->location)
- g_free (index->location);
+ g_free (index->location);
index->location = g_value_dup_string (value);
if (index->location && !g_hash_table_size (index->id_index))
- gst_file_index_load (index);
+ gst_file_index_load (index);
break;
}
}
xmlSetProp (writer, "id", ii->id_desc);
g_snprintf (buf, bufsize, "%d", ii->array->len);
xmlSetProp (writer, "entries", buf);
- g_snprintf (buf, bufsize, "%d", ii->id); /* any unique number is OK */
+ g_snprintf (buf, bufsize, "%d", ii->id); /* any unique number is OK */
xmlSetProp (writer, "datafile", buf);
formats = xmlNewChild (writer, NULL, "formats", NULL);
if (mkdir (index->location, 0777) && errno != EEXIST) {
GST_CAT_ERROR_OBJECT (DC, index,
- "mkdir %s: %s", index->location, strerror (errno));
+ "mkdir %s: %s", index->location, strerror (errno));
return;
}
if (cmp == 0) {
/* if there are multiple matches then scan for the first match */
while (mid > 0 &&
- (*compare) (sample, ary->data + (mid - 1) * stride, user_data) == 0)
- --mid;
+ (*compare) (sample, ary->data + (mid - 1) * stride, user_data) == 0)
+ --mid;
if (ret)
- *ret = mid;
+ *ret = mid;
return TRUE;
}
if (cmp < 0) {
if (ret)
- *ret = tx;
+ *ret = tx;
return FALSE;
}
if (cmp == 0) {
if (ret)
- *ret = tx;
+ *ret = tx;
return TRUE;
}
}
id_index->nformats = GST_INDEX_NASSOCS (entry);
GST_CAT_LOG_OBJECT (DC, fileindex, "creating %d formats for %d",
- id_index->nformats, entry->id);
+ id_index->nformats, entry->id);
id_index->format = g_new (GstFormat, id_index->nformats);
for (fx = 0; fx < id_index->nformats; fx++)
id_index->format[fx] = GST_INDEX_ASSOC_FORMAT (entry, fx);
/* only sanity checking */
if (id_index->nformats != GST_INDEX_NASSOCS (entry))
GST_CAT_WARNING_OBJECT (DC, fileindex, "arity change %d -> %d",
- id_index->nformats, GST_INDEX_NASSOCS (entry));
+ id_index->nformats, GST_INDEX_NASSOCS (entry));
else {
gint fx;
for (fx = 0; fx < id_index->nformats; fx++)
- if (id_index->format[fx] != GST_INDEX_ASSOC_FORMAT (entry, fx))
- GST_CAT_WARNING_OBJECT (DC, fileindex, "format[%d] changed %d -> %d",
- fx, id_index->format[fx], GST_INDEX_ASSOC_FORMAT (entry, fx));
+ if (id_index->format[fx] != GST_INDEX_ASSOC_FORMAT (entry, fx))
+ GST_CAT_WARNING_OBJECT (DC, fileindex, "format[%d] changed %d -> %d",
+ fx, id_index->format[fx], GST_INDEX_ASSOC_FORMAT (entry, fx));
}
}
if (exact) {
/* maybe overwrite instead? */
GST_CAT_DEBUG_OBJECT (DC, index,
- "Ignoring duplicate index association at %lld",
- GST_INDEX_ASSOC_VALUE (entry, 0));
+ "Ignoring duplicate index association at %lld",
+ GST_INDEX_ASSOC_VALUE (entry, 0));
return;
}
break;
case GST_INDEX_ENTRY_OBJECT:
GST_CAT_ERROR_OBJECT (DC, index,
- "gst_file_index_add_object not implemented");
+ "gst_file_index_add_object not implemented");
break;
case GST_INDEX_ENTRY_FORMAT:
/*
GST_INDEX_ENTRY_* can probably go away.
*/
GST_CAT_DEBUG_OBJECT (DC, index,
- "gst_file_index_add_format not implemented");
+ "gst_file_index_add_format not implemented");
break;
default:
break;
if (formatx == -1) {
GST_CAT_WARNING_OBJECT (DC, fileindex,
- "%s, format %d not available", __FUNCTION__, format);
+ "%s, format %d not available", __FUNCTION__, format);
return NULL;
}
return NULL;
else if (method == GST_INDEX_LOOKUP_BEFORE) {
if (mx == 0)
- return NULL;
+ return NULL;
mx -= 1;
} else if (method == GST_INDEX_LOOKUP_AFTER) {
if (mx == id_index->array->len)
- return NULL;
+ return NULL;
}
}
if (method != GST_INDEX_LOOKUP_EXACT)
while ((GINT32_FROM_BE (ARRAY_ROW_FLAGS (row_data)) & flags) != flags) {
if (method == GST_INDEX_LOOKUP_BEFORE)
- mx -= 1;
+ mx -= 1;
else if (method == GST_INDEX_LOOKUP_AFTER)
- mx += 1;
+ mx += 1;
if (mx < 0 || mx >= id_index->array->len)
- return NULL;
+ return NULL;
row_data = id_index->array->data + mx * ARRAY_ROW_SIZE (id_index);
}
GstFormat format;
gint offset;
GTree *tree;
-} GstMemIndexFormatIndex;
+}
+GstMemIndexFormatIndex;
typedef struct
{
gint id;
GHashTable *format_index;
-} GstMemIndexId;
+}
+GstMemIndexId;
typedef struct _GstMemIndex GstMemIndex;
typedef struct _GstMemIndexClass GstMemIndexClass;
(GInstanceInitFunc) gst_mem_index_init,
NULL
};
+
mem_index_type =
- g_type_register_static (GST_TYPE_INDEX, "GstMemIndex", &mem_index_info,
- 0);
+ g_type_register_static (GST_TYPE_INDEX, "GstMemIndex", &mem_index_info,
+ 0);
}
return mem_index_type;
}
gint64 low_diff;
GstIndexEntry *higher;
gint64 high_diff;
-} GstMemIndexSearchData;
+}
+GstMemIndexSearchData;
static gint
mem_index_search (gconstpointer a, gconstpointer b)
entry = NULL;
while (l_entry) {
- entry = (GstIndexEntry *) l_entry->data;
+ entry = (GstIndexEntry *) l_entry->data;
- if (entry->id == id && (GST_INDEX_ASSOC_FLAGS (entry) & flags) == flags)
- break;
+ if (entry->id == id && (GST_INDEX_ASSOC_FLAGS (entry) & flags) == flags)
+ break;
- if (method == GST_INDEX_LOOKUP_BEFORE)
- l_entry = g_list_next (l_entry);
- else if (method == GST_INDEX_LOOKUP_AFTER) {
- l_entry = g_list_previous (l_entry);
- }
+ if (method == GST_INDEX_LOOKUP_BEFORE)
+ l_entry = g_list_next (l_entry);
+ else if (method == GST_INDEX_LOOKUP_AFTER) {
+ l_entry = g_list_previous (l_entry);
+ }
}
}
}
};
xml_registry_type = g_type_register_static (GST_TYPE_REGISTRY,
- "GstXMLRegistry", &xml_registry_info, 0);
+ "GstXMLRegistry", &xml_registry_info, 0);
}
return xml_registry_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_LOCATION,
g_param_spec_string ("location", "Location",
- "Location of the registry file", NULL, G_PARAM_READWRITE));
+ "Location of the registry file", NULL, G_PARAM_READWRITE));
gstregistry_class->load = GST_DEBUG_FUNCPTR (gst_xml_registry_load);
gstregistry_class->save = GST_DEBUG_FUNCPTR (gst_xml_registry_save);
switch (prop_id) {
case PROP_LOCATION:
if (registry->open) {
- CLASS (object)->close_func (registry);
- g_return_if_fail (registry->open == FALSE);
+ CLASS (object)->close_func (registry);
+ g_return_if_fail (registry->open == FALSE);
}
if (registry->location)
- g_free (registry->location);
+ g_free (registry->location);
registry->location = g_strdup (g_value_get_string (value));
GST_REGISTRY (registry)->flags = 0x0;
if (CLASS (object)->get_perms_func)
- CLASS (object)->get_perms_func (registry);
+ CLASS (object)->get_perms_func (registry);
if (CLASS (object)->add_path_list_func)
- CLASS (object)->add_path_list_func (registry);
+ CLASS (object)->add_path_list_func (registry);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
if (stat (dirname, &dirstat) == -1 && errno == ENOENT) {
if (mkdir (dirname, dirmode) != 0) {
if (make_dir (dirname) != TRUE) {
- g_free (dirname);
- return FALSE;
+ g_free (dirname);
+ return FALSE;
} else {
- if (mkdir (dirname, dirmode) != 0)
- return FALSE;
+ if (mkdir (dirname, dirmode) != 0)
+ return FALSE;
}
}
}
if (error) {
GST_ERROR ("parsing registry %s: %s\n",
- registry->location, error->message);
+ registry->location, error->message);
goto finished;
}
if (pathtime > regtime) {
GST_CAT_INFO (GST_CAT_PLUGIN_LOADING,
- "time for %s was %ld; more recent than registry time of %ld\n",
- path, (long) pathtime, (long) regtime);
+ "time for %s was %ld; more recent than registry time of %ld\n",
+ path, (long) pathtime, (long) regtime);
return FALSE;
}
while ((dirent = readdir (dir))) {
/* don't want to recurse in place or backwards */
if (strcmp (dirent->d_name, ".") && strcmp (dirent->d_name, "..")) {
- pluginname = g_strjoin ("/", path, dirent->d_name, NULL);
- if (!plugin_times_older_than_recurse (pluginname, regtime)) {
- g_free (pluginname);
- closedir (dir);
- return FALSE;
- }
- g_free (pluginname);
+ pluginname = g_strjoin ("/", path, dirent->d_name, NULL);
+ if (!plugin_times_older_than_recurse (pluginname, regtime)) {
+ g_free (pluginname);
+ closedir (dir);
+ return FALSE;
+ }
+ g_free (pluginname);
}
}
closedir (dir);
while (paths) {
GST_CAT_LOG (GST_CAT_PLUGIN_LOADING,
- "comparing plugin times from %s with %ld",
- (gchar *) paths->data, (long) regtime);
+ "comparing plugin times from %s with %ld",
+ (gchar *) paths->data, (long) regtime);
if (!plugin_times_older_than_recurse (paths->data, regtime))
return FALSE;
paths = g_list_next (paths);
if (!(gst_registry->flags & GST_REGISTRY_EXISTS)) {
/* if it's not writable, then don't bother */
if (!(gst_registry->flags & GST_REGISTRY_WRITABLE)) {
- GST_CAT_INFO (GST_CAT_GST_INIT, "Registry isn't writable");
- return FALSE;
+ GST_CAT_INFO (GST_CAT_GST_INIT, "Registry isn't writable");
+ return FALSE;
}
GST_CAT_INFO (GST_CAT_GST_INIT,
- "Registry doesn't exist, trying to build...");
+ "Registry doesn't exist, trying to build...");
gst_registry_rebuild (gst_registry);
gst_registry_save (gst_registry);
/* FIXME: verify that the flags actually get updated ! */
if (!(gst_registry->flags & GST_REGISTRY_EXISTS)) {
- return FALSE;
+ return FALSE;
}
}
/* at this point we know it exists */
if (!plugin_times_older_than (paths, get_time (registry->location))) {
if (gst_registry->flags & GST_REGISTRY_WRITABLE) {
- GST_CAT_INFO (GST_CAT_GST_INIT, "Registry out of date, rebuilding...");
+ GST_CAT_INFO (GST_CAT_GST_INIT, "Registry out of date, rebuilding...");
- gst_registry_rebuild (gst_registry);
+ gst_registry_rebuild (gst_registry);
- gst_registry_save (gst_registry);
+ gst_registry_save (gst_registry);
- if (!plugin_times_older_than (paths, get_time (registry->location))) {
- GST_CAT_INFO (GST_CAT_GST_INIT,
- "Registry still out of date, something is wrong...");
- return FALSE;
- }
+ if (!plugin_times_older_than (paths, get_time (registry->location))) {
+ GST_CAT_INFO (GST_CAT_GST_INIT,
+ "Registry still out of date, something is wrong...");
+ return FALSE;
+ }
} else {
- GST_CAT_INFO (GST_CAT_GST_INIT,
- "Can't write to this registry and it's out of date, ignoring it");
- return FALSE;
+ GST_CAT_INFO (GST_CAT_GST_INIT,
+ "Can't write to this registry and it's out of date, ignoring it");
+ return FALSE;
}
}
GST_CAT_DEBUG (GST_CAT_GST_INIT, "opening registry %s for reading",
- registry->location);
+ registry->location);
registry->regfile = fopen (registry->location, "r");
} else if (mode == GST_XML_REGISTRY_WRITE) {
g_return_val_if_fail (gst_registry->flags & GST_REGISTRY_WRITABLE, FALSE);
GST_CAT_DEBUG (GST_CAT_GST_INIT, "opening registry %s for writing",
- registry->location);
+ registry->location);
registry->regfile = fopen (registry->location, "w");
}
if (!plugin) {
if (error) {
g_warning ("could not load plugin %s: %s", plugin->desc.name,
- error->message);
+ error->message);
g_error_free (error);
}
return GST_REGISTRY_PLUGIN_LOAD_ERROR;
registry->caps = gst_caps_from_string (s);
if (registry->caps == NULL) {
g_critical ("Could not parse caps: length %d, content: %*s\n", text_len,
- text_len, text);
+ text_len, text);
}
g_free (s);
return TRUE;
switch (xmlregistry->state) {
case GST_XML_REGISTRY_NONE:
if (!strcmp (element_name, "GST-PluginRegistry")) {
- xmlregistry->state = GST_XML_REGISTRY_TOP;
+ xmlregistry->state = GST_XML_REGISTRY_TOP;
}
break;
case GST_XML_REGISTRY_TOP:
if (!strncmp (element_name, "plugin", 6)) {
- xmlregistry->state = GST_XML_REGISTRY_PLUGIN;
- xmlregistry->parser = gst_xml_registry_parse_plugin;
- xmlregistry->current_plugin = (GstPlugin *) g_new0 (GstPlugin, 1);
+ xmlregistry->state = GST_XML_REGISTRY_PLUGIN;
+ xmlregistry->parser = gst_xml_registry_parse_plugin;
+ xmlregistry->current_plugin = (GstPlugin *) g_new0 (GstPlugin, 1);
}
break;
case GST_XML_REGISTRY_PLUGIN:
if (!strncmp (element_name, "feature", 7)) {
- gint i = 0;
- GstPluginFeature *feature = NULL;
-
- xmlregistry->state = GST_XML_REGISTRY_FEATURE;
-
- while (attribute_names[i]) {
- if (!strncmp (attribute_names[i], "typename", 8)) {
- feature =
- GST_PLUGIN_FEATURE (g_object_new (g_type_from_name
- (attribute_values[i]), NULL));
- break;
- }
- i++;
- }
- if (feature) {
- xmlregistry->current_feature = feature;
-
- if (GST_IS_ELEMENT_FACTORY (feature)) {
- GstElementFactory *factory = GST_ELEMENT_FACTORY (feature);
-
- factory->padtemplates = NULL;
- xmlregistry->parser = gst_xml_registry_parse_element_factory;
- break;
- } else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
- xmlregistry->parser = gst_xml_registry_parse_type_find_factory;
- } else if (GST_IS_SCHEDULER_FACTORY (feature)) {
- xmlregistry->parser = gst_xml_registry_parse_scheduler_factory;
- GST_SCHEDULER_FACTORY (feature)->type = 0;
- } else if (GST_IS_INDEX_FACTORY (feature)) {
- xmlregistry->parser = gst_xml_registry_parse_index_factory;
- } else {
- g_warning ("unknown feature type");
- }
- }
+ gint i = 0;
+ GstPluginFeature *feature = NULL;
+
+ xmlregistry->state = GST_XML_REGISTRY_FEATURE;
+
+ while (attribute_names[i]) {
+ if (!strncmp (attribute_names[i], "typename", 8)) {
+ feature =
+ GST_PLUGIN_FEATURE (g_object_new (g_type_from_name
+ (attribute_values[i]), NULL));
+ break;
+ }
+ i++;
+ }
+ if (feature) {
+ xmlregistry->current_feature = feature;
+
+ if (GST_IS_ELEMENT_FACTORY (feature)) {
+ GstElementFactory *factory = GST_ELEMENT_FACTORY (feature);
+
+ factory->padtemplates = NULL;
+ xmlregistry->parser = gst_xml_registry_parse_element_factory;
+ break;
+ } else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
+ xmlregistry->parser = gst_xml_registry_parse_type_find_factory;
+ } else if (GST_IS_SCHEDULER_FACTORY (feature)) {
+ xmlregistry->parser = gst_xml_registry_parse_scheduler_factory;
+ GST_SCHEDULER_FACTORY (feature)->type = 0;
+ } else if (GST_IS_INDEX_FACTORY (feature)) {
+ xmlregistry->parser = gst_xml_registry_parse_index_factory;
+ } else {
+ g_warning ("unknown feature type");
+ }
+ }
}
break;
case GST_XML_REGISTRY_FEATURE:
if (!strncmp (element_name, "padtemplate", 11)) {
- xmlregistry->state = GST_XML_REGISTRY_PADTEMPLATE;
- xmlregistry->parser = gst_xml_registry_parse_padtemplate;
- xmlregistry->name_template = NULL;
- xmlregistry->direction = 0;
- xmlregistry->presence = 0;
- xmlregistry->caps = NULL;
+ xmlregistry->state = GST_XML_REGISTRY_PADTEMPLATE;
+ xmlregistry->parser = gst_xml_registry_parse_padtemplate;
+ xmlregistry->name_template = NULL;
+ xmlregistry->direction = 0;
+ xmlregistry->presence = 0;
+ xmlregistry->caps = NULL;
}
break;
default:
switch (xmlregistry->state) {
case GST_XML_REGISTRY_TOP:
if (!strcmp (element_name, "GST-PluginRegistry")) {
- xmlregistry->state = GST_XML_REGISTRY_NONE;
+ xmlregistry->state = GST_XML_REGISTRY_NONE;
}
break;
case GST_XML_REGISTRY_PLUGIN:
if (!strcmp (element_name, "plugin")) {
- xmlregistry->state = GST_XML_REGISTRY_TOP;
- xmlregistry->parser = NULL;
- gst_registry_add_plugin (GST_REGISTRY (xmlregistry),
- xmlregistry->current_plugin);
+ xmlregistry->state = GST_XML_REGISTRY_TOP;
+ xmlregistry->parser = NULL;
+ gst_registry_add_plugin (GST_REGISTRY (xmlregistry),
+ xmlregistry->current_plugin);
}
break;
case GST_XML_REGISTRY_FEATURE:
if (!strcmp (element_name, "feature")) {
- xmlregistry->state = GST_XML_REGISTRY_PLUGIN;
- xmlregistry->parser = gst_xml_registry_parse_plugin;
- gst_plugin_add_feature (xmlregistry->current_plugin,
- xmlregistry->current_feature);
- xmlregistry->current_feature = NULL;
+ xmlregistry->state = GST_XML_REGISTRY_PLUGIN;
+ xmlregistry->parser = gst_xml_registry_parse_plugin;
+ gst_plugin_add_feature (xmlregistry->current_plugin,
+ xmlregistry->current_feature);
+ xmlregistry->current_feature = NULL;
}
break;
case GST_XML_REGISTRY_PADTEMPLATE:
if (!strcmp (element_name, "padtemplate")) {
- GstPadTemplate *template;
+ GstPadTemplate *template;
- template = gst_pad_template_new (xmlregistry->name_template,
- xmlregistry->direction, xmlregistry->presence, xmlregistry->caps);
+ template = gst_pad_template_new (xmlregistry->name_template,
+ xmlregistry->direction, xmlregistry->presence, xmlregistry->caps);
- g_free (xmlregistry->name_template);
- xmlregistry->name_template = NULL;
- xmlregistry->caps = NULL;
+ g_free (xmlregistry->name_template);
+ xmlregistry->name_template = NULL;
+ xmlregistry->caps = NULL;
- __gst_element_factory_add_pad_template (GST_ELEMENT_FACTORY
- (xmlregistry->current_feature), template);
- xmlregistry->state = GST_XML_REGISTRY_FEATURE;
- xmlregistry->parser = gst_xml_registry_parse_element_factory;
+ __gst_element_factory_add_pad_template (GST_ELEMENT_FACTORY
+ (xmlregistry->current_feature), template);
+ xmlregistry->state = GST_XML_REGISTRY_FEATURE;
+ xmlregistry->parser = gst_xml_registry_parse_element_factory;
}
break;
default:
//gst_plugin_add_path (g_strndup (text, text_len));
} else if (xmlregistry->parser) {
xmlregistry->parser (context, open_tag, text, text_len, xmlregistry,
- error);
+ error);
}
}
}
switch (xmlregistry->state) {
case GST_XML_REGISTRY_NONE:
if (!strcmp (element_name, "GST-PluginRegistry")) {
- xmlregistry->state = GST_XML_REGISTRY_TOP;
+ xmlregistry->state = GST_XML_REGISTRY_TOP;
}
break;
case GST_XML_REGISTRY_TOP:
if (!strcmp (element_name, "gst-registry-paths")) {
- xmlregistry->state = GST_XML_REGISTRY_PATHS;
+ xmlregistry->state = GST_XML_REGISTRY_PATHS;
}
break;
case GST_XML_REGISTRY_PATHS:
if (!strcmp (element_name, "path")) {
- xmlregistry->state = GST_XML_REGISTRY_PATH;
+ xmlregistry->state = GST_XML_REGISTRY_PATH;
}
break;
default:
switch (xmlregistry->state) {
case GST_XML_REGISTRY_PATH:
if (!strcmp (element_name, "path")) {
- xmlregistry->state = GST_XML_REGISTRY_PATHS;
+ xmlregistry->state = GST_XML_REGISTRY_PATHS;
}
break;
case GST_XML_REGISTRY_PATHS:
if (!strcmp (element_name, "gst-plugin-paths")) {
- xmlregistry->state = GST_XML_REGISTRY_PATHS_DONE;
+ xmlregistry->state = GST_XML_REGISTRY_PATHS_DONE;
}
break;
default:
if (xmlregistry->state == GST_XML_REGISTRY_PATH)
gst_registry_add_path (GST_REGISTRY (xmlregistry), g_strndup (text,
- text_len));
+ text_len));
}
/*
gchar **protocol;
PUT_ESCAPED ("uri_type",
- factory->uri_type == GST_URI_SINK ? "sink" : "source");
+ factory->uri_type == GST_URI_SINK ? "sink" : "source");
g_assert (factory->uri_protocols);
protocol = factory->uri_protocols;
while (*protocol) {
- PUT_ESCAPED ("uri_protocol", *protocol);
- protocol++;
+ PUT_ESCAPED ("uri_protocol", *protocol);
+ protocol++;
}
}
} else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
}
if (factory->extensions) {
while (factory->extensions[i]) {
- PUT_ESCAPED ("extension", factory->extensions[i]);
- i++;
+ PUT_ESCAPED ("extension", factory->extensions[i]);
+ i++;
}
}
} else if (GST_IS_SCHEDULER_FACTORY (feature)) {
GstPluginFeature *feature = GST_PLUGIN_FEATURE (walk->data);
CLASS (xmlregistry)->save_func (xmlregistry, "<feature typename=\"%s\">\n",
- g_type_name (G_OBJECT_TYPE (feature)));
+ g_type_name (G_OBJECT_TYPE (feature)));
gst_xml_registry_save_feature (xmlregistry, feature);
CLASS (xmlregistry)->save_func (xmlregistry, "</feature>\n");
gchar *dirname;
if (*dirent == '=') {
- /* =build, =inst, etc. -- automake distcheck directories */
- continue;
+ /* =build, =inst, etc. -- automake distcheck directories */
+ continue;
}
dirname = g_strjoin ("/", directory, dirent, NULL);
ret =
- g_list_concat (ret, gst_xml_registry_rebuild_recurse (registry,
- dirname));
+ g_list_concat (ret, gst_xml_registry_rebuild_recurse (registry,
+ dirname));
g_free (dirname);
}
g_dir_close (dir);
} else {
if ((temp = strstr (directory, G_MODULE_SUFFIX)) &&
- (!strcmp (temp, G_MODULE_SUFFIX))) {
+ (!strcmp (temp, G_MODULE_SUFFIX))) {
ret = g_list_prepend (ret, g_strdup (directory));
}
}
gchar *path = (gchar *) walk->data;
GST_CAT_INFO (GST_CAT_PLUGIN_LOADING,
- "Rebuilding registry %p in directory %s...", registry, path);
+ "Rebuilding registry %p in directory %s...", registry, path);
plugins = g_list_concat (plugins,
- gst_xml_registry_rebuild_recurse (xmlregistry, path));
+ gst_xml_registry_rebuild_recurse (xmlregistry, path));
walk = g_list_next (walk);
}
g_assert (walk->data);
plugin = gst_plugin_load_file ((gchar *) walk->data, NULL);
if (plugin) {
- prune = g_list_prepend (prune, walk->data);
- gst_registry_add_plugin (registry, plugin);
+ prune = g_list_prepend (prune, walk->data);
+ gst_registry_add_plugin (registry, plugin);
}
walk = g_list_next (walk);
while (walk) {
if ((plugin = gst_plugin_load_file ((gchar *) walk->data, &error))) {
g_warning ("Bizarre behavior: plugin %s actually loaded",
- (gchar *) walk->data);
+ (gchar *) walk->data);
gst_registry_add_plugin (registry, plugin);
} else {
GST_CAT_INFO (GST_CAT_PLUGIN_LOADING, "Plugin %s failed to load: %s",
- (gchar *) walk->data, error->message);
+ (gchar *) walk->data, error->message);
g_free (walk->data);
g_error_free (error);
GST_BASIC_SCHEDULER_STATE_STOPPED,
GST_BASIC_SCHEDULER_STATE_ERROR,
GST_BASIC_SCHEDULER_STATE_RUNNING,
-} GstBasicSchedulerState;
+}
+GstBasicSchedulerState;
typedef enum
{
/* something important has changed inside the scheduler */
GST_BASIC_SCHEDULER_CHANGE = GST_SCHEDULER_FLAG_LAST,
-} GstBasicSchedulerFlags;
+}
+GstBasicSchedulerFlags;
struct _GstBasicScheduler
{
};
_gst_basic_scheduler_type =
- g_type_register_static (GST_TYPE_SCHEDULER,
- "Gst" COTHREADS_NAME_CAPITAL "Scheduler", &scheduler_info, 0);
+ g_type_register_static (GST_TYPE_SCHEDULER,
+ "Gst" COTHREADS_NAME_CAPITAL "Scheduler", &scheduler_info, 0);
}
return _gst_basic_scheduler_type;
}
gst_object_ref (GST_OBJECT (element));
do {
GST_CAT_DEBUG (debug_dataflow, "calling loopfunc %s for element %s",
- GST_DEBUG_FUNCPTR_NAME (element->loopfunc), name);
+ GST_DEBUG_FUNCPTR_NAME (element->loopfunc), name);
(element->loopfunc) (element);
GST_CAT_DEBUG (debug_dataflow, "element %s ended loop function", name);
pads = element->pads;
while (pads) {
- GstPad *pad = GST_PAD (pads->data);
- GstRealPad *realpad;
-
- if (!GST_IS_REAL_PAD (pad))
- continue;
-
- realpad = GST_REAL_PAD (pad);
-
- if (GST_RPAD_DIRECTION (realpad) == GST_PAD_SINK &&
- GST_PAD_IS_LINKED (realpad) &&
- g_slist_find (already_iterated, pad) == NULL) {
- GstData *data;
-
- GST_CAT_DEBUG (debug_dataflow, "pulling data from %s:%s", name,
- GST_PAD_NAME (pad));
- data = gst_pad_pull (pad);
- if (data) {
- if (GST_IS_EVENT (data) && !GST_ELEMENT_IS_EVENT_AWARE (element)) {
- gst_pad_send_event (pad, GST_EVENT (data));
- } else {
- GST_CAT_DEBUG (debug_dataflow,
- "calling chain function of %s:%s %p", name,
- GST_PAD_NAME (pad), data);
- GST_RPAD_CHAINFUNC (realpad) (pad, data);
- GST_CAT_DEBUG (debug_dataflow,
- "calling chain function of element %s done", name);
- }
- }
- already_iterated = g_slist_prepend (already_iterated, pad);
- break;
- }
- pads = g_list_next (pads);
+ GstPad *pad = GST_PAD (pads->data);
+ GstRealPad *realpad;
+
+ if (!GST_IS_REAL_PAD (pad))
+ continue;
+
+ realpad = GST_REAL_PAD (pad);
+
+ if (GST_RPAD_DIRECTION (realpad) == GST_PAD_SINK &&
+ GST_PAD_IS_LINKED (realpad) &&
+ g_slist_find (already_iterated, pad) == NULL) {
+ GstData *data;
+
+ GST_CAT_DEBUG (debug_dataflow, "pulling data from %s:%s", name,
+ GST_PAD_NAME (pad));
+ data = gst_pad_pull (pad);
+ if (data) {
+ if (GST_IS_EVENT (data) && !GST_ELEMENT_IS_EVENT_AWARE (element)) {
+ gst_pad_send_event (pad, GST_EVENT (data));
+ } else {
+ GST_CAT_DEBUG (debug_dataflow,
+ "calling chain function of %s:%s %p", name,
+ GST_PAD_NAME (pad), data);
+ GST_RPAD_CHAINFUNC (realpad) (pad, data);
+ GST_CAT_DEBUG (debug_dataflow,
+ "calling chain function of element %s done", name);
+ }
+ }
+ already_iterated = g_slist_prepend (already_iterated, pad);
+ break;
+ }
+ pads = g_list_next (pads);
}
} while (pads != NULL);
g_slist_free (already_iterated);
while (pads) {
if (!GST_IS_REAL_PAD (pads->data))
- continue;
+ continue;
realpad = GST_REAL_PAD (pads->data);
pads = g_list_next (pads);
if (GST_RPAD_DIRECTION (realpad) == GST_PAD_SRC
- && GST_PAD_IS_USABLE (realpad)) {
- GST_CAT_DEBUG (debug_dataflow, "calling _getfunc for %s:%s",
- GST_DEBUG_PAD_NAME (realpad));
- g_return_val_if_fail (GST_RPAD_GETFUNC (realpad) != NULL, 0);
- data = GST_RPAD_GETFUNC (realpad) (GST_PAD (realpad));
- if (data) {
- GST_CAT_DEBUG (debug_dataflow, "calling gst_pad_push on pad %s:%s %p",
- GST_DEBUG_PAD_NAME (realpad), data);
- gst_pad_push (GST_PAD (realpad), data);
- }
+ && GST_PAD_IS_USABLE (realpad)) {
+ GST_CAT_DEBUG (debug_dataflow, "calling _getfunc for %s:%s",
+ GST_DEBUG_PAD_NAME (realpad));
+ g_return_val_if_fail (GST_RPAD_GETFUNC (realpad) != NULL, 0);
+ data = GST_RPAD_GETFUNC (realpad) (GST_PAD (realpad));
+ if (data) {
+ GST_CAT_DEBUG (debug_dataflow, "calling gst_pad_push on pad %s:%s %p",
+ GST_DEBUG_PAD_NAME (realpad), data);
+ gst_pad_push (GST_PAD (realpad), data);
+ }
}
}
} while (!GST_ELEMENT_IS_COTHREAD_STOPPING (element));
*/
while (GST_RPAD_BUFPEN (GST_RPAD_PEER (pad)) != NULL && --loop_count) {
GST_CAT_DEBUG (debug_dataflow, "switching to %p to empty bufpen %d",
- GST_ELEMENT_THREADSTATE (parent), loop_count);
+ GST_ELEMENT_THREADSTATE (parent), loop_count);
do_element_switch (parent);
if (loop_count == 0) {
GST_ELEMENT_ERROR (parent, CORE, SCHEDULER, (NULL),
- ("(internal error) basic: maximum number of switches exceeded"));
+ ("(internal error) basic: maximum number of switches exceeded"));
return;
}
while (GST_RPAD_BUFPEN (pad) == NULL) {
GST_CAT_DEBUG (debug_dataflow, "switching to \"%s\": %p to fill bufpen",
- GST_ELEMENT_NAME (parent), GST_ELEMENT_THREADSTATE (parent));
+ GST_ELEMENT_NAME (parent), GST_ELEMENT_THREADSTATE (parent));
do_element_switch (parent);
GST_CAT_DEBUG (debug_dataflow, "new pad in mid-switch!");
pad = (GstPad *) GST_RPAD_PEER (peer);
if (!pad) {
- GST_ELEMENT_ERROR (parent, CORE, PAD, (NULL), ("pad unlinked"));
+ GST_ELEMENT_ERROR (parent, CORE, PAD, (NULL), ("pad unlinked"));
}
parent = GST_PAD_PARENT (pad);
peer = GST_RPAD_PEER (pad);
/* if the element has a loopfunc... */
if (element->loopfunc != NULL) {
wrapper_function =
- GST_DEBUG_FUNCPTR (gst_basic_scheduler_loopfunc_wrapper);
+ GST_DEBUG_FUNCPTR (gst_basic_scheduler_loopfunc_wrapper);
GST_DEBUG ("element '%s' is a loop-based", GST_ELEMENT_NAME (element));
} else {
/* otherwise we need to decide what kind of cothread
* if it's not DECOUPLED, we decide based on
* whether it's a source or not */
if (!decoupled) {
- /* 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 ("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 ("element '%s' is a filter, using _chain_wrapper",
- GST_ELEMENT_NAME (element));
- }
+ /* 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 ("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 ("element '%s' is a filter, using _chain_wrapper",
+ GST_ELEMENT_NAME (element));
+ }
}
}
pads = g_list_next (pads);
if (!GST_IS_REAL_PAD (pad))
- continue;
+ continue;
peerpad = GST_PAD_PEER (pad);
if (peerpad) {
- GstElement *peerelement = GST_ELEMENT (GST_PAD_PARENT (peerpad));
- gboolean different_sched =
- (peerelement->sched != GST_SCHEDULER (chain->sched));
- gboolean peer_decoupled =
- GST_FLAG_IS_SET (peerelement, GST_ELEMENT_DECOUPLED);
-
- GST_DEBUG ("inspecting pad %s:%s", GST_DEBUG_PAD_NAME (peerpad));
-
- /* we don't need to check this for decoupled elements */
- if (!decoupled) {
- /* if the peer element is in another schedule,
- * it's not decoupled and we are not decoupled
- * either, we have an error */
- if (different_sched && !peer_decoupled) {
- GST_ELEMENT_ERROR (element, CORE, SCHEDULER, (NULL),
- ("element \"%s\" is not decoupled but has pads in different schedulers",
- GST_ELEMENT_NAME (element)));
- return FALSE;
- }
- /* ok, the peer is in a different scheduler and is decoupled,
- * we need to set the
- * handlers so we can talk with it */
- else if (different_sched) {
- if (GST_RPAD_DIRECTION (peerpad) == GST_PAD_SINK) {
- GST_DEBUG ("copying chain func into push proxy for peer %s:%s",
- GST_DEBUG_PAD_NAME (peerpad));
- GST_RPAD_CHAINHANDLER (peerpad) = GST_RPAD_CHAINFUNC (peerpad);
- } else {
- GST_DEBUG ("copying get func into pull proxy for peer %s:%s",
- GST_DEBUG_PAD_NAME (peerpad));
- GST_RPAD_GETHANDLER (peerpad) = GST_RPAD_GETFUNC (peerpad);
- }
- }
- }
- /* in any case we need to copy the eventfunc into the handler */
- GST_RPAD_EVENTHANDLER (peerpad) = GST_RPAD_EVENTFUNC (peerpad);
+ GstElement *peerelement = GST_ELEMENT (GST_PAD_PARENT (peerpad));
+ gboolean different_sched =
+ (peerelement->sched != GST_SCHEDULER (chain->sched));
+ gboolean peer_decoupled =
+ GST_FLAG_IS_SET (peerelement, GST_ELEMENT_DECOUPLED);
+
+ GST_DEBUG ("inspecting pad %s:%s", GST_DEBUG_PAD_NAME (peerpad));
+
+ /* we don't need to check this for decoupled elements */
+ if (!decoupled) {
+ /* if the peer element is in another schedule,
+ * it's not decoupled and we are not decoupled
+ * either, we have an error */
+ if (different_sched && !peer_decoupled) {
+ GST_ELEMENT_ERROR (element, CORE, SCHEDULER, (NULL),
+ ("element \"%s\" is not decoupled but has pads in different schedulers",
+ GST_ELEMENT_NAME (element)));
+ return FALSE;
+ }
+ /* ok, the peer is in a different scheduler and is decoupled,
+ * we need to set the
+ * handlers so we can talk with it */
+ else if (different_sched) {
+ if (GST_RPAD_DIRECTION (peerpad) == GST_PAD_SINK) {
+ GST_DEBUG ("copying chain func into push proxy for peer %s:%s",
+ GST_DEBUG_PAD_NAME (peerpad));
+ GST_RPAD_CHAINHANDLER (peerpad) = GST_RPAD_CHAINFUNC (peerpad);
+ } else {
+ GST_DEBUG ("copying get func into pull proxy for peer %s:%s",
+ GST_DEBUG_PAD_NAME (peerpad));
+ GST_RPAD_GETHANDLER (peerpad) = GST_RPAD_GETFUNC (peerpad);
+ }
+ }
+ }
+ /* in any case we need to copy the eventfunc into the handler */
+ GST_RPAD_EVENTHANDLER (peerpad) = GST_RPAD_EVENTFUNC (peerpad);
}
/* if the element is DECOUPLED or outside the manager, we have to chain */
if (decoupled) {
- /* set the chain proxies */
- if (GST_RPAD_DIRECTION (pad) == GST_PAD_SINK) {
- GST_DEBUG ("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 ("copying get function into pull proxy for %s:%s",
- GST_DEBUG_PAD_NAME (pad));
- GST_RPAD_GETHANDLER (pad) = GST_RPAD_GETFUNC (pad);
- }
+ /* set the chain proxies */
+ if (GST_RPAD_DIRECTION (pad) == GST_PAD_SINK) {
+ GST_DEBUG ("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 ("copying get function into pull proxy for %s:%s",
+ GST_DEBUG_PAD_NAME (pad));
+ GST_RPAD_GETHANDLER (pad) = GST_RPAD_GETFUNC (pad);
+ }
}
/* otherwise we really are a cothread */
else {
- if (GST_RPAD_DIRECTION (pad) == GST_PAD_SINK) {
- GST_DEBUG ("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);
- GST_RPAD_EVENTHANDLER (pad) = GST_RPAD_EVENTFUNC (pad);
- } else {
- GST_DEBUG ("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);
- /* the gethandler proxy function can queue a buffer in the bufpen, we need
- * to remove this buffer when a flush event is sent on the pad */
- GST_RPAD_EVENTHANDLER (pad) =
- GST_DEBUG_FUNCPTR (gst_basic_scheduler_eventhandler_proxy);
- }
+ if (GST_RPAD_DIRECTION (pad) == GST_PAD_SINK) {
+ GST_DEBUG ("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);
+ GST_RPAD_EVENTHANDLER (pad) = GST_RPAD_EVENTFUNC (pad);
+ } else {
+ GST_DEBUG ("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);
+ /* the gethandler proxy function can queue a buffer in the bufpen, we need
+ * to remove this buffer when a flush event is sent on the pad */
+ GST_RPAD_EVENTHANDLER (pad) =
+ GST_DEBUG_FUNCPTR (gst_basic_scheduler_eventhandler_proxy);
+ }
}
}
/* need to set up the cothread now */
if (wrapper_function != NULL) {
if (GST_ELEMENT_THREADSTATE (element) == NULL) {
- GST_DEBUG ("about to create a cothread, wrapper for '%s' is &%s",
- GST_ELEMENT_NAME (element),
- GST_DEBUG_FUNCPTR_NAME (wrapper_function));
- do_cothread_create (GST_ELEMENT_THREADSTATE (element),
- chain->sched->context, wrapper_function, 0, (char **) element);
- if (GST_ELEMENT_THREADSTATE (element) == NULL) {
- GST_ELEMENT_ERROR (element, RESOURCE, TOO_LAZY, (NULL),
- ("could not create cothread for \"%s\"",
- GST_ELEMENT_NAME (element)));
- return FALSE;
- }
- GST_DEBUG ("created cothread %p for '%s'",
- GST_ELEMENT_THREADSTATE (element), GST_ELEMENT_NAME (element));
+ GST_DEBUG ("about to create a cothread, wrapper for '%s' is &%s",
+ GST_ELEMENT_NAME (element),
+ GST_DEBUG_FUNCPTR_NAME (wrapper_function));
+ do_cothread_create (GST_ELEMENT_THREADSTATE (element),
+ chain->sched->context, wrapper_function, 0, (char **) element);
+ if (GST_ELEMENT_THREADSTATE (element) == NULL) {
+ GST_ELEMENT_ERROR (element, RESOURCE, TOO_LAZY, (NULL),
+ ("could not create cothread for \"%s\"",
+ GST_ELEMENT_NAME (element)));
+ return FALSE;
+ }
+ GST_DEBUG ("created cothread %p for '%s'",
+ GST_ELEMENT_THREADSTATE (element), GST_ELEMENT_NAME (element));
} else {
- /* set the cothread wrapper function */
- GST_DEBUG ("about to set the wrapper function for '%s' to &%s",
- GST_ELEMENT_NAME (element),
- GST_DEBUG_FUNCPTR_NAME (wrapper_function));
- do_cothread_setfunc (GST_ELEMENT_THREADSTATE (element),
- chain->sched->context, wrapper_function, 0, (char **) element);
- GST_DEBUG ("set wrapper function for '%s' to &%s",
- GST_ELEMENT_NAME (element),
- GST_DEBUG_FUNCPTR_NAME (wrapper_function));
+ /* set the cothread wrapper function */
+ GST_DEBUG ("about to set the wrapper function for '%s' to &%s",
+ GST_ELEMENT_NAME (element),
+ GST_DEBUG_FUNCPTR_NAME (wrapper_function));
+ do_cothread_setfunc (GST_ELEMENT_THREADSTATE (element),
+ chain->sched->context, wrapper_function, 0, (char **) element);
+ GST_DEBUG ("set wrapper function for '%s' to &%s",
+ GST_ELEMENT_NAME (element),
+ GST_DEBUG_FUNCPTR_NAME (wrapper_function));
}
}
}
sched->num_chains--;
/* destroy the chain */
- g_list_free (chain->disabled); /* should be empty... */
- g_list_free (chain->elements); /* ditto */
+ g_list_free (chain->disabled); /* should be empty... */
+ g_list_free (chain->elements); /* ditto */
GST_INFO ("destroyed chain %p, now are %d chains in sched %p", chain,
sched->num_chains, sched);
/* add the element to either the main list or the disabled list */
if (GST_STATE (element) == GST_STATE_PLAYING) {
GST_INFO ("adding element \"%s\" to chain %p enabled",
- GST_ELEMENT_NAME (element), chain);
+ GST_ELEMENT_NAME (element), chain);
chain->elements = g_list_prepend (chain->elements, element);
} else {
GST_INFO ("adding element \"%s\" to chain %p disabled",
- GST_ELEMENT_NAME (element), chain);
+ GST_ELEMENT_NAME (element), chain);
chain->disabled = g_list_prepend (chain->disabled, element);
}
chain->num_elements++;
/* reschedule the chain */
return gst_basic_scheduler_cothreaded_chain (GST_BIN (GST_SCHEDULER (chain->
- sched)->parent), chain);
+ sched)->parent), chain);
}
static void
GST_INFO ("merging chain %p into chain %p", chain2, chain1);
/* take the contents of chain2 and merge them into chain1 */
chain1->disabled =
- g_list_concat (chain1->disabled, g_list_copy (chain2->disabled));
+ g_list_concat (chain1->disabled, g_list_copy (chain2->disabled));
chain1->elements =
- g_list_concat (chain1->elements, g_list_copy (chain2->elements));
+ g_list_concat (chain1->elements, g_list_copy (chain2->elements));
chain1->num_elements += chain2->num_elements;
/* FIXME chain changed here */
/* gst_basic_scheduler_cothreaded_chain(chain->sched->parent,chain); */
pads = g_list_next (pads);
GST_DEBUG ("have pad %s:%s, checking for valid peer",
- GST_DEBUG_PAD_NAME (pad));
+ GST_DEBUG_PAD_NAME (pad));
/* if the peer exists and could be in the same chain */
if (GST_PAD_PEER (pad)) {
GST_DEBUG ("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 ("peer \"%s\" is valid for same chain",
- GST_ELEMENT_NAME (peerelement));
- gst_basic_scheduler_chain_recursive_add (chain, peerelement, remove);
+ GST_ELEMENT_SCHED (peerelement)) {
+ GST_DEBUG ("peer \"%s\" is valid for same chain",
+ GST_ELEMENT_NAME (peerelement));
+ gst_basic_scheduler_chain_recursive_add (chain, peerelement, remove);
}
}
}
if (g_list_find (bsched->elements, element)) {
GST_INFO ("removing element \"%s\" from scheduler",
- GST_ELEMENT_NAME (element));
+ GST_ELEMENT_NAME (element));
/* if we are removing the currently scheduled element */
if (bsched->current == element) {
GST_FLAG_SET (element, GST_ELEMENT_COTHREAD_STOPPING);
if (element->post_run_func)
- element->post_run_func (element);
+ element->post_run_func (element);
bsched->current = NULL;
}
/* find what chain the element is in */
/* remove it from the chain */
if (chain) {
if (transition == GST_STATE_PLAYING_TO_PAUSED) {
- gst_basic_scheduler_chain_disable_element (chain, element);
+ gst_basic_scheduler_chain_disable_element (chain, element);
} else if (transition == GST_STATE_PAUSED_TO_PLAYING) {
- if (!gst_basic_scheduler_chain_enable_element (chain, element)) {
- GST_INFO ("could not enable element \"%s\"",
- GST_ELEMENT_NAME (element));
- return GST_STATE_FAILURE;
- }
+ if (!gst_basic_scheduler_chain_enable_element (chain, element)) {
+ GST_INFO ("could not enable element \"%s\"",
+ GST_ELEMENT_NAME (element));
+ return GST_STATE_FAILURE;
+ }
}
} else {
GST_INFO ("element \"%s\" not found in any chain, no state change",
- GST_ELEMENT_NAME (element));
+ GST_ELEMENT_NAME (element));
}
}
if (GST_ELEMENT_SCHED (srcelement) == GST_ELEMENT_SCHED (sinkelement)) {
GST_INFO ("peer %s:%s is in same scheduler, chaining together",
- GST_DEBUG_PAD_NAME (sinkpad));
+ GST_DEBUG_PAD_NAME (sinkpad));
gst_basic_scheduler_chain_elements (bsched, srcelement, sinkelement);
}
}
pad = GST_PAD (padlist->data);
GST_RPAD_CHAINHANDLER (pad) =
- GST_DEBUG_FUNCPTR (gst_basic_scheduler_select_proxy);
+ GST_DEBUG_FUNCPTR (gst_basic_scheduler_select_proxy);
padlist = g_list_next (padlist);
}
/* all we really have to do is switch to the first child */
/* FIXME this should be lots more intelligent about where to start */
GST_CAT_DEBUG (debug_dataflow,
- "starting iteration via cothreads using %s scheduler", _SCHEDULER_NAME);
+ "starting iteration via cothreads using %s scheduler", _SCHEDULER_NAME);
if (chain->elements) {
- entry = NULL; /*MattH ADDED? */
+ entry = NULL; /*MattH ADDED? */
GST_DEBUG ("there are %d elements in this chain", chain->num_elements);
elements = chain->elements;
while (elements) {
- entry = GST_ELEMENT (elements->data);
- elements = g_list_next (elements);
- if (GST_FLAG_IS_SET (entry, GST_ELEMENT_DECOUPLED)) {
- GST_DEBUG ("entry \"%s\" is DECOUPLED, skipping",
- GST_ELEMENT_NAME (entry));
- entry = NULL;
- } else if (GST_FLAG_IS_SET (entry, GST_ELEMENT_INFINITE_LOOP)) {
- GST_DEBUG ("entry \"%s\" is not valid, skipping",
- GST_ELEMENT_NAME (entry));
- entry = NULL;
- } else
- break;
+ entry = GST_ELEMENT (elements->data);
+ elements = g_list_next (elements);
+ if (GST_FLAG_IS_SET (entry, GST_ELEMENT_DECOUPLED)) {
+ GST_DEBUG ("entry \"%s\" is DECOUPLED, skipping",
+ GST_ELEMENT_NAME (entry));
+ entry = NULL;
+ } else if (GST_FLAG_IS_SET (entry, GST_ELEMENT_INFINITE_LOOP)) {
+ GST_DEBUG ("entry \"%s\" is not valid, skipping",
+ GST_ELEMENT_NAME (entry));
+ entry = NULL;
+ } else
+ break;
}
if (entry) {
- GstSchedulerState state;
-
- GST_FLAG_SET (entry, GST_ELEMENT_COTHREAD_STOPPING);
-
- GST_CAT_DEBUG (debug_dataflow,
- "set COTHREAD_STOPPING flag on \"%s\"(@%p)",
- GST_ELEMENT_NAME (entry), entry);
- if (GST_ELEMENT_THREADSTATE (entry)) {
-
- do_switch_from_main (entry);
-
- state = GST_SCHEDULER_STATE (sched);
- /* if something changed, return - go on else */
- if (GST_FLAG_IS_SET (bsched, GST_BASIC_SCHEDULER_CHANGE) &&
- state != GST_SCHEDULER_STATE_ERROR)
- return GST_SCHEDULER_STATE_RUNNING;
- } else {
- GST_CAT_DEBUG (debug_dataflow,
- "cothread switch not possible, element has no threadstate");
- return GST_SCHEDULER_STATE_ERROR;
- }
-
- /* following is a check to see if the chain was interrupted due to a
- * top-half state_change(). (i.e., if there's a pending state.)
- *
- * if it was, return to gstthread.c::gst_thread_main_loop() to
- * execute the state change.
- */
- GST_CAT_DEBUG (debug_dataflow, "cothread switch ended or interrupted");
-
- if (state != GST_SCHEDULER_STATE_RUNNING) {
- GST_CAT_INFO (debug_dataflow, "scheduler is not running, in state %d",
- state);
- return state;
- }
-
- scheduled++;
+ GstSchedulerState state;
+
+ GST_FLAG_SET (entry, GST_ELEMENT_COTHREAD_STOPPING);
+
+ GST_CAT_DEBUG (debug_dataflow,
+ "set COTHREAD_STOPPING flag on \"%s\"(@%p)",
+ GST_ELEMENT_NAME (entry), entry);
+ if (GST_ELEMENT_THREADSTATE (entry)) {
+
+ do_switch_from_main (entry);
+
+ state = GST_SCHEDULER_STATE (sched);
+ /* if something changed, return - go on else */
+ if (GST_FLAG_IS_SET (bsched, GST_BASIC_SCHEDULER_CHANGE) &&
+ state != GST_SCHEDULER_STATE_ERROR)
+ return GST_SCHEDULER_STATE_RUNNING;
+ } else {
+ GST_CAT_DEBUG (debug_dataflow,
+ "cothread switch not possible, element has no threadstate");
+ return GST_SCHEDULER_STATE_ERROR;
+ }
+
+ /* following is a check to see if the chain was interrupted due to a
+ * top-half state_change(). (i.e., if there's a pending state.)
+ *
+ * if it was, return to gstthread.c::gst_thread_main_loop() to
+ * execute the state change.
+ */
+ GST_CAT_DEBUG (debug_dataflow, "cothread switch ended or interrupted");
+
+ if (state != GST_SCHEDULER_STATE_RUNNING) {
+ GST_CAT_INFO (debug_dataflow, "scheduler is not running, in state %d",
+ state);
+ return state;
+ }
+
+ scheduled++;
} else {
- GST_CAT_INFO (debug_dataflow,
- "no entry in this chain, trying the next one");
+ GST_CAT_INFO (debug_dataflow,
+ "no entry in this chain, trying the next one");
}
} else {
GST_CAT_INFO (debug_dataflow,
- "no enabled elements in this chain, trying the next one");
+ "no enabled elements in this chain, trying the next one");
}
}
/* have to check to see if we merged with the head buffer */
if (end == bs->buflist) {
- bs->headbufavail += GST_BUFFER_SIZE (nextbuf);
+ bs->headbufavail += GST_BUFFER_SIZE (nextbuf);
}
gst_buffer_unref (lastbuf);
/* as long as we don't have enough, we get more buffers */
while (bs->listavail < len) {
GST_DEBUG ("fill_bytes: there are %d bytes in the list, we need %d",
- bs->listavail, len);
+ bs->listavail, len);
if (!gst_bytestream_get_next_buf (bs))
return FALSE;
}
if (!gst_bytestream_fill_bytes (bs, len)) {
/* we must have an event coming up */
if (bs->listavail > 0) {
- /* we have some data left, len will be shrunk to the amount of data available */
- len = bs->listavail;
+ /* we have some data left, len will be shrunk to the amount of data available */
+ len = bs->listavail;
} else {
- /* there is no data */
- *buf = retbuf;
- return 0;
+ /* there is no data */
+ *buf = retbuf;
+ return 0;
}
}
GST_DEBUG ("peek: there are now %d bytes in the list", bs->listavail);
GST_DEBUG ("peek: headbufavail is %d", bs->headbufavail);
if (len <= bs->headbufavail) {
GST_DEBUG ("peek: there are enough bytes in headbuf (need %d, have %d)",
- len, bs->headbufavail);
+ len, bs->headbufavail);
/* create a sub-buffer of the headbuf */
retbuf =
- gst_buffer_create_sub (headbuf,
- GST_BUFFER_SIZE (headbuf) - bs->headbufavail, len);
+ gst_buffer_create_sub (headbuf,
+ GST_BUFFER_SIZE (headbuf) - bs->headbufavail, len);
GST_BUFFER_OFFSET (retbuf) =
- GST_BUFFER_OFFSET (headbuf) + GST_BUFFER_SIZE (headbuf) -
- bs->headbufavail;
+ GST_BUFFER_OFFSET (headbuf) + GST_BUFFER_SIZE (headbuf) -
+ bs->headbufavail;
}
/* otherwise we need to figure out how to assemble one */
if (!gst_bytestream_fill_bytes (bs, len)) {
/* we must have an event coming up */
if (bs->listavail > 0) {
- /* we have some data left, len will be shrunk to the amount of data available */
- len = bs->listavail;
+ /* we have some data left, len will be shrunk to the amount of data available */
+ len = bs->listavail;
} else {
- /* there is no data */
- *data = NULL;
- return 0;
+ /* there is no data */
+ *data = NULL;
+ return 0;
}
}
GST_DEBUG ("peek_bytes: there are now %d bytes in the list", bs->listavail);
GST_DEBUG ("peek_bytes: headbufavail is %d", bs->headbufavail);
if (len <= bs->headbufavail) {
GST_DEBUG
- ("peek_bytes: there are enough bytes in headbuf (need %d, have %d)",
- len, bs->headbufavail);
+ ("peek_bytes: there are enough bytes in headbuf (need %d, have %d)",
+ len, bs->headbufavail);
/* create a sub-buffer of the headbuf */
*data =
- GST_BUFFER_DATA (headbuf) + (GST_BUFFER_SIZE (headbuf) -
- bs->headbufavail);
+ GST_BUFFER_DATA (headbuf) + (GST_BUFFER_SIZE (headbuf) -
+ bs->headbufavail);
}
/* otherwise we need to figure out how to assemble one */
buf = GST_BUFFER (walk->data);
if (GST_BUFFER_SIZE (buf) < (len - copied)) {
GST_DEBUG ("assemble: copying %d bytes from buf to output offset %d",
- GST_BUFFER_SIZE (buf), copied);
+ GST_BUFFER_SIZE (buf), copied);
memcpy (data + copied, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
copied += GST_BUFFER_SIZE (buf);
} else {
GST_DEBUG ("assemble: copying %d bytes from buf to output offset %d",
- len - copied, copied);
+ len - copied, copied);
memcpy (data + copied, GST_BUFFER_DATA (buf), len - copied);
copied = len;
}
headbuf = GST_BUFFER (bs->buflist->data);
GST_DEBUG ("flush: analyzing buffer that's %d bytes long, offset %"
- G_GUINT64_FORMAT, GST_BUFFER_SIZE (headbuf),
- GST_BUFFER_OFFSET (headbuf));
+ G_GUINT64_FORMAT, GST_BUFFER_SIZE (headbuf),
+ GST_BUFFER_OFFSET (headbuf));
/* if there's enough to complete the flush */
if (bs->headbufavail > len) {
/* record the new headbufavail */
if (bs->buflist) {
- bs->headbufavail = GST_BUFFER_SIZE (GST_BUFFER (bs->buflist->data));
- GST_DEBUG ("flush: next headbuf is %d bytes", bs->headbufavail);
+ bs->headbufavail = GST_BUFFER_SIZE (GST_BUFFER (bs->buflist->data));
+ GST_DEBUG ("flush: next headbuf is %d bytes", bs->headbufavail);
} else {
- GST_DEBUG ("flush: no more bytes at all");
+ GST_DEBUG ("flush: no more bytes at all");
}
}
GST_DEBUG ("bs: send event\n");
if (gst_pad_send_event (GST_PAD (peer), gst_event_new_seek (GST_FORMAT_BYTES |
- (method & GST_SEEK_METHOD_MASK) |
- GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE, offset))) {
+ (method & GST_SEEK_METHOD_MASK) |
+ GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE, offset))) {
gst_bytestream_flush_fast (bs, bs->listavail);
/* we set the seek flag here. We cannot pull the pad here
format = GST_FORMAT_BYTES;
if (gst_pad_query (GST_PAD_PEER (bs->pad), GST_QUERY_POSITION, &format,
- &value)) {
+ &value)) {
return value - bs->listavail;
}
walk = g_slist_next (walk);
GST_DEBUG ("STATUS: buffer starts at %" G_GUINT64_FORMAT
- " and is %d bytes long", GST_BUFFER_OFFSET (buf),
- GST_BUFFER_SIZE (buf));
+ " and is %d bytes long", GST_BUFFER_OFFSET (buf),
+ GST_BUFFER_SIZE (buf));
}
}
0,
(GInstanceInitFunc) gst_dparam_init,
};
+
dparam_type =
- g_type_register_static (GST_TYPE_OBJECT, "GstDParam", &dparam_info, 0);
+ g_type_register_static (GST_TYPE_OBJECT, "GstDParam", &dparam_info, 0);
}
return dparam_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VALUE_FLOAT,
g_param_spec_float ("value_float", "Float Value",
- "The value that should be changed if gfloat is the type",
- -G_MAXFLOAT, G_MAXFLOAT, 0.0F, G_PARAM_READWRITE));
+ "The value that should be changed if gfloat is the type",
+ -G_MAXFLOAT, G_MAXFLOAT, 0.0F, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VALUE_DOUBLE,
g_param_spec_double ("value_double", "Double Value",
- "The value that should be changed if gdouble is the type",
- -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_READWRITE));
+ "The value that should be changed if gdouble is the type",
+ -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VALUE_INT,
g_param_spec_int ("value_int", "Integer Value",
- "The value that should be changed if gint is the type",
- G_MININT, G_MAXINT, 0, G_PARAM_READWRITE));
+ "The value that should be changed if gint is the type",
+ G_MININT, G_MAXINT, 0, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_VALUE_INT64,
g_param_spec_int64 ("value_int64", "64 bit Integer Value",
- "The value that should be changed if gint64 is the type",
- G_MININT64, G_MAXINT64, 0, G_PARAM_READWRITE));
+ "The value that should be changed if gint64 is the type",
+ G_MININT64, G_MAXINT64, 0, G_PARAM_READWRITE));
gobject_class->dispose = gst_dparam_dispose;
switch (prop_id) {
case ARG_VALUE_FLOAT:
GST_DEBUG ("setting value from %g to %g", dparam->value_float,
- g_value_get_float (value));
+ g_value_get_float (value));
dparam->value_float = g_value_get_float (value);
GST_DPARAM_NEXT_UPDATE_TIMESTAMP (dparam) =
- GST_DPARAM_LAST_UPDATE_TIMESTAMP (dparam);
+ GST_DPARAM_LAST_UPDATE_TIMESTAMP (dparam);
GST_DPARAM_READY_FOR_UPDATE (dparam) = TRUE;
break;
case ARG_VALUE_DOUBLE:
GST_DEBUG ("setting value from %g to %g",
- dparam->value_double, g_value_get_double (value));
+ dparam->value_double, g_value_get_double (value));
dparam->value_double = g_value_get_double (value);
GST_DPARAM_NEXT_UPDATE_TIMESTAMP (dparam) =
- GST_DPARAM_LAST_UPDATE_TIMESTAMP (dparam);
+ GST_DPARAM_LAST_UPDATE_TIMESTAMP (dparam);
GST_DPARAM_READY_FOR_UPDATE (dparam) = TRUE;
break;
case ARG_VALUE_INT:
GST_DEBUG ("setting value from %d to %d", dparam->value_int,
- g_value_get_int (value));
+ g_value_get_int (value));
dparam->value_int = g_value_get_int (value);
GST_DPARAM_NEXT_UPDATE_TIMESTAMP (dparam) =
- GST_DPARAM_LAST_UPDATE_TIMESTAMP (dparam);
+ GST_DPARAM_LAST_UPDATE_TIMESTAMP (dparam);
GST_DPARAM_READY_FOR_UPDATE (dparam) = TRUE;
break;
case ARG_VALUE_INT64:
GST_DEBUG ("setting value from %"
- G_GINT64_FORMAT " to %"
- G_GINT64_FORMAT, dparam->value_int64, g_value_get_int64 (value));
+ G_GINT64_FORMAT " to %"
+ G_GINT64_FORMAT, dparam->value_int64, g_value_get_int64 (value));
dparam->value_int64 = g_value_get_int64 (value);
GST_DPARAM_NEXT_UPDATE_TIMESTAMP (dparam) =
- GST_DPARAM_LAST_UPDATE_TIMESTAMP (dparam);
+ GST_DPARAM_LAST_UPDATE_TIMESTAMP (dparam);
GST_DPARAM_READY_FOR_UPDATE (dparam) = TRUE;
break;
0,
(GInstanceInitFunc) gst_dpsmooth_init,
};
+
dpsmooth_type =
- g_type_register_static (GST_TYPE_DPARAM, "GstDParamSmooth",
- &dpsmooth_info, 0);
+ g_type_register_static (GST_TYPE_DPARAM, "GstDParamSmooth",
+ &dpsmooth_info, 0);
}
return dpsmooth_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_UPDATE_PERIOD,
g_param_spec_int64 ("update_period",
- "Update Period (nanoseconds)",
- "Number of nanoseconds between updates",
- 0LL, G_MAXINT64, 2000000LL, G_PARAM_READWRITE));
+ "Update Period (nanoseconds)",
+ "Number of nanoseconds between updates",
+ 0LL, G_MAXINT64, 2000000LL, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SLOPE_TIME,
g_param_spec_int64 ("slope_time",
- "Slope Time (nanoseconds)",
- "The time period to define slope_delta by",
- 0LL, G_MAXINT64, 10000000LL, G_PARAM_READWRITE));
+ "Slope Time (nanoseconds)",
+ "The time period to define slope_delta by",
+ 0LL, G_MAXINT64, 10000000LL, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass),
ARG_SLOPE_DELTA_FLOAT,
g_param_spec_float ("slope_delta_float", "Slope Delta float",
- "The amount a float value can change for a given slope_time",
- 0.0F, G_MAXFLOAT, 0.2F, G_PARAM_READWRITE));
+ "The amount a float value can change for a given slope_time",
+ 0.0F, G_MAXFLOAT, 0.2F, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass),
ARG_SLOPE_DELTA_DOUBLE,
g_param_spec_double ("slope_delta_double", "Slope Delta double",
- "The amount a double value can change for a given slope_time",
- 0.0, G_MAXDOUBLE, 0.2, G_PARAM_READWRITE));
+ "The amount a double value can change for a given slope_time",
+ 0.0, G_MAXDOUBLE, 0.2, G_PARAM_READWRITE));
/*gstobject_class->save_thyself = gst_dparam_save_thyself; */
case G_TYPE_FLOAT:{
dparam->do_update_func = gst_dpsmooth_do_update_float;
g_signal_connect (G_OBJECT (dpsmooth), "value_changed",
- G_CALLBACK (gst_dpsmooth_value_changed_float), NULL);
+ G_CALLBACK (gst_dpsmooth_value_changed_float), NULL);
break;
}
case G_TYPE_DOUBLE:{
dparam->do_update_func = gst_dpsmooth_do_update_double;
g_signal_connect (G_OBJECT (dpsmooth), "value_changed",
- G_CALLBACK (gst_dpsmooth_value_changed_double), NULL);
+ G_CALLBACK (gst_dpsmooth_value_changed_double), NULL);
break;
}
default:
case ARG_SLOPE_TIME:
dpsmooth->slope_time = g_value_get_int64 (value);
GST_DEBUG ("dpsmooth->slope_time:%"
- G_GINT64_FORMAT, dpsmooth->slope_time);
+ G_GINT64_FORMAT, dpsmooth->slope_time);
GST_DPARAM_READY_FOR_UPDATE (dparam) = TRUE;
break;
}
GST_DPARAM_LAST_UPDATE_TIMESTAMP (dparam) = timestamp;
GST_DPARAM_NEXT_UPDATE_TIMESTAMP (dparam) =
- dpsmooth->start_interp + dpsmooth->update_period;
+ dpsmooth->start_interp + dpsmooth->update_period;
GST_DEBUG ("interp started at %" G_GINT64_FORMAT, timestamp);
}
GST_DPARAM_LAST_UPDATE_TIMESTAMP (dparam) = timestamp;
GST_DPARAM_NEXT_UPDATE_TIMESTAMP (dparam) =
- dpsmooth->start_interp + dpsmooth->update_period;
+ dpsmooth->start_interp + dpsmooth->update_period;
GST_DEBUG ("interp started at %" G_GINT64_FORMAT, timestamp);
0,
(GInstanceInitFunc) gst_dpman_init,
};
+
dpman_type =
- g_type_register_static (GST_TYPE_OBJECT, "GstDParamManager",
- &dpman_info, 0);
+ g_type_register_static (GST_TYPE_OBJECT, "GstDParamManager",
+ &dpman_info, 0);
}
return dpman_type;
}
gst_dpman_signals[NEW_REQUIRED_DPARAM] =
g_signal_new ("new-required-dparam", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstDParamManagerClass,
- new_required_dparam), NULL, NULL, gst_marshal_VOID__STRING,
+ new_required_dparam), NULL, NULL, gst_marshal_VOID__STRING,
G_TYPE_NONE, 1, G_TYPE_STRING);
}
if (dpwrap->dparam != NULL) {
g_warning ("Bypassing attached dparam '%s'. It will be detached",
- dparam_name);
+ dparam_name);
gst_dpman_detach_dparam (dpman, dparam_name);
}
}
dparam = dpwrap->dparam;
if (dparam) {
- GST_DPARAM_READY_FOR_UPDATE (dparam) = TRUE;
- GST_DPARAM_NEXT_UPDATE_TIMESTAMP (dparam) = 0LL;
+ GST_DPARAM_READY_FOR_UPDATE (dparam) = TRUE;
+ GST_DPARAM_NEXT_UPDATE_TIMESTAMP (dparam) = 0LL;
}
/* some dparams treat the first update after the pipeline starts differently */
dpwrap->update_info = GST_DPARAM_UPDATE_FIRST;
dpwrap = (GstDParamWrapper *) dwraps->data;
if (dpwrap->dparam &&
- GST_DPARAM_READY_FOR_UPDATE (dpwrap->dparam) &&
- GST_DPARAM_NEXT_UPDATE_TIMESTAMP (dpwrap->dparam) <= timestamp) {
+ GST_DPARAM_READY_FOR_UPDATE (dpwrap->dparam) &&
+ GST_DPARAM_NEXT_UPDATE_TIMESTAMP (dpwrap->dparam) <= timestamp) {
switch (dpwrap->update_method) {
- /* direct method - set the value directly in the struct of the element */
- case GST_DPMAN_DIRECT:
- GST_DPARAM_DO_UPDATE (dpwrap->dparam, timestamp, dpwrap->value,
- dpwrap->update_info);
- GST_DEBUG ("doing direct update");
-
- gst_dpman_inline_direct_update (dpwrap->value, dpwrap->update_data);
- break;
-
- /* callback method - call the element's callback so it can do what it likes */
- case GST_DPMAN_CALLBACK:
- GST_DPARAM_DO_UPDATE (dpwrap->dparam, timestamp, dpwrap->value,
- dpwrap->update_info);
- GST_DEBUG ("doing callback update");
-
- GST_DPMAN_CALLBACK_UPDATE (dpwrap, dpwrap->value);
- break;
-
- case GST_DPMAN_ARRAY:
- /* FIXME do array method checking here */
- break;
- default:
- break;
+ /* direct method - set the value directly in the struct of the element */
+ case GST_DPMAN_DIRECT:
+ GST_DPARAM_DO_UPDATE (dpwrap->dparam, timestamp, dpwrap->value,
+ dpwrap->update_info);
+ GST_DEBUG ("doing direct update");
+
+ gst_dpman_inline_direct_update (dpwrap->value, dpwrap->update_data);
+ break;
+
+ /* callback method - call the element's callback so it can do what it likes */
+ case GST_DPMAN_CALLBACK:
+ GST_DPARAM_DO_UPDATE (dpwrap->dparam, timestamp, dpwrap->value,
+ dpwrap->update_info);
+ GST_DEBUG ("doing callback update");
+
+ GST_DPMAN_CALLBACK_UPDATE (dpwrap, dpwrap->value);
+ break;
+
+ case GST_DPMAN_ARRAY:
+ /* FIXME do array method checking here */
+ break;
+ default:
+ break;
}
if (dpwrap->update_info == GST_DPARAM_UPDATE_FIRST) {
- /* it is not the first update anymore */
- dpwrap->update_info = GST_DPARAM_UPDATE_NORMAL;
+ /* it is not the first update anymore */
+ dpwrap->update_info = GST_DPARAM_UPDATE_NORMAL;
}
}
dwraps = g_list_next (dwraps);
current_time = GST_DPARAM_NEXT_UPDATE_TIMESTAMP (dpwrap->dparam);
if (current_time > dpman->time_buffer_ends) {
- /* not due for an update in this buffer */
- dwraps = g_list_next (dwraps);
- continue;
+ /* not due for an update in this buffer */
+ dwraps = g_list_next (dwraps);
+ continue;
}
if (current_time < timestamp) {
- current_time = timestamp;
+ current_time = timestamp;
}
if (current_time == timestamp) {
- /* we are overdue for an update. lets do it now */
-
- GST_DPARAM_DO_UPDATE (dpwrap->dparam, current_time, dpwrap->value,
- dpwrap->update_info);
-
- if (dpwrap->update_info == GST_DPARAM_UPDATE_FIRST) {
- /* it is not the first update anymore */
- dpwrap->update_info = GST_DPARAM_UPDATE_NORMAL;
- }
-
- switch (dpwrap->update_method) {
-
- /* direct method - set the value directly in the struct of the element */
- case GST_DPMAN_DIRECT:
- GST_DEBUG ("doing direct update");
- gst_dpman_inline_direct_update (dpwrap->value, dpwrap->update_data);
- break;
-
- /* callback method - call the element's callback so it can do what it likes */
- case GST_DPMAN_CALLBACK:
- GST_DEBUG ("doing callback update");
- GST_DPMAN_CALLBACK_UPDATE (dpwrap, dpwrap->value);
- break;
- default:
- break;
- }
-
- current_time = GST_DPARAM_NEXT_UPDATE_TIMESTAMP (dpwrap->dparam);
-
- if (!GST_DPARAM_READY_FOR_UPDATE (dpwrap->dparam) ||
- current_time > dpman->time_buffer_ends) {
- /* not due for an update in this buffer */
- dwraps = g_list_next (dwraps);
- continue;
- }
+ /* we are overdue for an update. lets do it now */
+
+ GST_DPARAM_DO_UPDATE (dpwrap->dparam, current_time, dpwrap->value,
+ dpwrap->update_info);
+
+ if (dpwrap->update_info == GST_DPARAM_UPDATE_FIRST) {
+ /* it is not the first update anymore */
+ dpwrap->update_info = GST_DPARAM_UPDATE_NORMAL;
+ }
+
+ switch (dpwrap->update_method) {
+
+ /* direct method - set the value directly in the struct of the element */
+ case GST_DPMAN_DIRECT:
+ GST_DEBUG ("doing direct update");
+ gst_dpman_inline_direct_update (dpwrap->value, dpwrap->update_data);
+ break;
+
+ /* callback method - call the element's callback so it can do what it likes */
+ case GST_DPMAN_CALLBACK:
+ GST_DEBUG ("doing callback update");
+ GST_DPMAN_CALLBACK_UPDATE (dpwrap, dpwrap->value);
+ break;
+ default:
+ break;
+ }
+
+ current_time = GST_DPARAM_NEXT_UPDATE_TIMESTAMP (dpwrap->dparam);
+
+ if (!GST_DPARAM_READY_FOR_UPDATE (dpwrap->dparam) ||
+ current_time > dpman->time_buffer_ends) {
+ /* not due for an update in this buffer */
+ dwraps = g_list_next (dwraps);
+ continue;
+ }
}
dpwrap->next_update_frame =
- (guint) (current_time - timestamp) / dpman->rate_ratio;
+ (guint) (current_time - timestamp) / dpman->rate_ratio;
updates_pending = TRUE;
GST_DEBUG ("timestamp start: %"
- G_GINT64_FORMAT " end: %"
- G_GINT64_FORMAT " current: %"
- G_GINT64_FORMAT, timestamp, dpman->time_buffer_ends, current_time);
+ G_GINT64_FORMAT " end: %"
+ G_GINT64_FORMAT " current: %"
+ G_GINT64_FORMAT, timestamp, dpman->time_buffer_ends, current_time);
}
dwraps = g_list_next (dwraps);
}
if (updates_pending) {
GST_DPMAN_DPARAMS_LIST (dpman) =
- g_list_sort (GST_DPMAN_DPARAMS_LIST (dpman),
- (GCompareFunc) gst_dpman_dpwrap_compare);
+ g_list_sort (GST_DPMAN_DPARAMS_LIST (dpman),
+ (GCompareFunc) gst_dpman_dpwrap_compare);
dwraps = GST_DPMAN_DPARAMS_LIST (dpman);
dpwrap = (GstDParamWrapper *) dwraps->data;
dpman->frames_to_process = dpman->next_update_frame;
GST_DEBUG ("next update frame %u, frames to process %u",
- dpman->next_update_frame, dpman->frames_to_process);
+ dpman->next_update_frame, dpman->frames_to_process);
return TRUE;
}
if (frame_count != dpwrap->next_update_frame) {
g_warning ("frame count %u does not match update frame %u",
- frame_count, dpwrap->next_update_frame);
+ frame_count, dpwrap->next_update_frame);
}
while (dpwrap) {
current_time = GST_DPARAM_NEXT_UPDATE_TIMESTAMP (dpwrap->dparam);
GST_DPARAM_DO_UPDATE (dpwrap->dparam, current_time, dpwrap->value,
- dpwrap->update_info);
+ dpwrap->update_info);
switch (dpwrap->update_method) {
- /* direct method - set the value directly in the struct of the element */
+ /* direct method - set the value directly in the struct of the element */
case GST_DPMAN_DIRECT:
- GST_DEBUG ("doing direct update");
- gst_dpman_inline_direct_update (dpwrap->value, dpwrap->update_data);
- break;
+ GST_DEBUG ("doing direct update");
+ gst_dpman_inline_direct_update (dpwrap->value, dpwrap->update_data);
+ break;
- /* callback method - call the element's callback so it can do what it likes */
+ /* callback method - call the element's callback so it can do what it likes */
case GST_DPMAN_CALLBACK:
- GST_DEBUG ("doing callback update");
- GST_DPMAN_CALLBACK_UPDATE (dpwrap, dpwrap->value);
- break;
+ GST_DEBUG ("doing callback update");
+ GST_DPMAN_CALLBACK_UPDATE (dpwrap, dpwrap->value);
+ break;
default:
- break;
+ break;
}
dpwrap->next_update_frame = dpman->num_frames;
if (GST_DPARAM_READY_FOR_UPDATE (dpwrap->dparam)) {
current_time = GST_DPARAM_NEXT_UPDATE_TIMESTAMP (dpwrap->dparam);
if (current_time <= dpman->time_buffer_ends) {
- dpwrap->next_update_frame =
- (guint) (current_time -
- dpman->time_buffer_starts) / dpman->rate_ratio;
+ dpwrap->next_update_frame =
+ (guint) (current_time -
+ dpman->time_buffer_starts) / dpman->rate_ratio;
}
}
if ((dwraps = g_list_next (dwraps))) {
dpwrap = (GstDParamWrapper *) dwraps->data;
if (frame_count == dpwrap->next_update_frame) {
- continue;
+ continue;
}
}
dpwrap = NULL;
if (needs_resort && g_list_length (GST_DPMAN_DPARAMS_LIST (dpman)) > 1) {
GST_DPMAN_DPARAMS_LIST (dpman) =
- g_list_sort (GST_DPMAN_DPARAMS_LIST (dpman),
- (GCompareFunc) gst_dpman_dpwrap_compare);
+ g_list_sort (GST_DPMAN_DPARAMS_LIST (dpman),
+ (GCompareFunc) gst_dpman_dpwrap_compare);
}
dwraps = GST_DPMAN_DPARAMS_LIST (dpman);
dpman->next_update_frame = dpman->num_frames;
dpman->frames_to_process = dpman->num_frames - frame_count;
GST_DEBUG ("no more updates, frames to process %u",
- dpman->frames_to_process);
+ dpman->frames_to_process);
} else {
dpman->next_update_frame = dpwrap->next_update_frame;
dpman->frames_to_process = dpman->next_update_frame - frame_count;
GST_DEBUG ("next update frame %u, frames to process %u",
- dpman->next_update_frame, dpman->frames_to_process);
+ dpman->next_update_frame, dpman->frames_to_process);
}
return TRUE;
0,
(GInstanceInitFunc) gst_dp_linint_init,
};
+
dp_linint_type =
- g_type_register_static (GST_TYPE_DPARAM, "GstDParamLinInterp",
- &dp_linint_info, 0);
+ g_type_register_static (GST_TYPE_DPARAM, "GstDParamLinInterp",
+ &dp_linint_info, 0);
}
return dp_linint_type;
}
0,
(GInstanceInitFunc) gst_unitconv_init,
};
+
unitconv_type =
- g_type_register_static (GST_TYPE_OBJECT, "GstUnitConvert",
- &unitconv_info, 0);
+ g_type_register_static (GST_TYPE_OBJECT, "GstUnitConvert",
+ &unitconv_info, 0);
}
return unitconv_type;
}
gst_unitconv_register_unit ("frequency", TRUE, TRUE,
g_param_spec_float ("hertz", "Hz", "Frequency in hertz",
- 0, G_MAXFLOAT, 0, 0));
+ 0, G_MAXFLOAT, 0, 0));
gst_unitconv_register_unit ("frequency", FALSE, TRUE,
g_param_spec_float ("hertz-rate-bound", "Hz",
- "Frequency in hertz, bound by the sample rate", 0.0, G_MAXFLOAT, 0.0,
- 0));
+ "Frequency in hertz, bound by the sample rate", 0.0, G_MAXFLOAT, 0.0,
+ 0));
gst_unitconv_register_unit ("frequency", FALSE, FALSE,
g_param_spec_string ("twelve-tone-scale", "note",
- "Name of the note from the western twelve tone scale", "C", 0));
+ "Name of the note from the western twelve tone scale", "C", 0));
gst_unitconv_register_unit ("frequency", FALSE, FALSE,
g_param_spec_int ("midi-note", "midi note",
- "MIDI note value of the frequency", 1, 127, 1, 0));
+ "MIDI note value of the frequency", 1, 127, 1, 0));
/* time based units */
gst_unitconv_register_unit ("time", TRUE, FALSE,
g_param_spec_float ("seconds", "s", "Time in seconds",
- -G_MAXFLOAT, G_MAXFLOAT, 0, 0));
+ -G_MAXFLOAT, G_MAXFLOAT, 0, 0));
gst_unitconv_register_unit ("time", FALSE, FALSE,
g_param_spec_int64 ("nanoseconds", "ns", "Time in nanoseconds",
- G_MININT64, G_MAXINT64, 0, 0));
+ G_MININT64, G_MAXINT64, 0, 0));
gst_unitconv_register_unit ("time", FALSE, FALSE,
g_param_spec_int64 ("samples", "samples", "Time in number of samples",
- G_MININT64, G_MAXINT64, 0, 0));
+ G_MININT64, G_MAXINT64, 0, 0));
gst_unitconv_register_convert_property ("samples",
g_param_spec_int ("samplerate", "samplerate", "samplerate",
- 0, G_MAXINT, 0, G_PARAM_READWRITE));
+ 0, G_MAXINT, 0, G_PARAM_READWRITE));
/* magnitude based units */
gst_unitconv_register_unit ("magnitude", TRUE, FALSE,
g_param_spec_float ("scalar", "scalar", "Magnitude as a scalar",
- -G_MAXFLOAT, G_MAXFLOAT, 0, 0));
+ -G_MAXFLOAT, G_MAXFLOAT, 0, 0));
gst_unitconv_register_unit ("magnitude", FALSE, FALSE,
g_param_spec_int ("scalar-int", "scalar int",
- "Magnitude as an integer scalar", G_MININT, G_MAXINT, 0, 0));
+ "Magnitude as an integer scalar", G_MININT, G_MAXINT, 0, 0));
gst_unitconv_register_unit ("magnitude", FALSE, TRUE,
g_param_spec_float ("decibel", "dB", "Magnitude in decibels",
- -G_MAXFLOAT, G_MAXFLOAT, 0, 0));
+ -G_MAXFLOAT, G_MAXFLOAT, 0, 0));
gst_unitconv_register_unit ("magnitude", FALSE, FALSE,
g_param_spec_float ("percent", "%", "Magnitude in percent",
- -G_MAXFLOAT, G_MAXFLOAT, 0, 0));
+ -G_MAXFLOAT, G_MAXFLOAT, 0, 0));
/* generic units */
gst_unitconv_register_unit ("float_default", TRUE, FALSE,
g_param_spec_float ("float", "float", "Float value",
- -G_MAXFLOAT, G_MAXFLOAT, 0, 0));
+ -G_MAXFLOAT, G_MAXFLOAT, 0, 0));
gst_unitconv_register_unit ("int_default", TRUE, FALSE,
g_param_spec_int ("int", "int", "Integer value",
- G_MININT, G_MAXINT, 0, 0));
+ G_MININT, G_MAXINT, 0, 0));
gst_unitconv_register_unit ("int64_default", TRUE, FALSE,
g_param_spec_int64 ("int64", "int64", "64 bit integer value",
- G_MININT, G_MAXINT, 0, 0));
+ G_MININT, G_MAXINT, 0, 0));
gst_unitconv_add_core_converters ();
if (is_domain_default) {
/* check if an default unit already exists for this domain */
g_return_val_if_fail (g_hash_table_lookup (_gst_unit_domain_defaults,
- domain_name) == NULL, FALSE);
+ domain_name) == NULL, FALSE);
}
GST_DEBUG ("creating unit: %s", unit_name);
if (is_domain_default) {
g_hash_table_insert (_gst_unit_domain_defaults, g_strdup (domain_name),
- unit);
+ unit);
}
return TRUE;
#ifdef unused
unsigned long _getbits_64_minus_index[] = {
64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46,
- 45, 44, 43, 42, 41,
+ 45, 44, 43, 42, 41,
40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22,
- 21, 20, 19, 18, 17,
+ 21, 20, 19, 18, 17,
16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
};
{AGGREGATOR_CHAIN, "4", "Chain Based"},
{0, NULL, NULL},
};
+
if (!aggregator_sched_type) {
aggregator_sched_type =
- g_enum_register_static ("GstAggregatorSched", aggregator_sched);
+ g_enum_register_static ("GstAggregatorSched", aggregator_sched);
}
return aggregator_sched_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NUM_PADS,
g_param_spec_int ("num_pads", "Num pads", "The number of source pads",
- 0, G_MAXINT, 0, G_PARAM_READABLE));
+ 0, G_MAXINT, 0, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SILENT,
g_param_spec_boolean ("silent", "Silent", "Don't produce messages",
- FALSE, G_PARAM_READWRITE));
+ FALSE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SCHED,
g_param_spec_enum ("sched", "Scheduling",
- "The type of scheduling this element should use",
- GST_TYPE_AGGREGATOR_SCHED, AGGREGATOR_CHAIN, G_PARAM_READWRITE));
+ "The type of scheduling this element should use",
+ GST_TYPE_AGGREGATOR_SCHED, AGGREGATOR_CHAIN, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LAST_MESSAGE,
g_param_spec_string ("last_message", "Last message",
- "The current state of the element", NULL, G_PARAM_READABLE));
+ "The current state of the element", NULL, G_PARAM_READABLE));
gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_aggregator_set_property);
gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_aggregator_get_property);
if (AGGREGATOR_IS_LOOP_BASED (aggregator)) {
gst_element_set_loop_function (GST_ELEMENT (aggregator),
- GST_DEBUG_FUNCPTR (gst_aggregator_loop));
+ GST_DEBUG_FUNCPTR (gst_aggregator_loop));
} else {
gst_element_set_loop_function (GST_ELEMENT (aggregator), NULL);
}
g_free (aggregator->last_message);
aggregator->last_message =
- g_strdup_printf ("%10.10s ******* (%s:%s)a (%d bytes, %"
- G_GUINT64_FORMAT ")", debug, GST_DEBUG_PAD_NAME (pad),
- GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf));
+ g_strdup_printf ("%10.10s ******* (%s:%s)a (%d bytes, %"
+ G_GUINT64_FORMAT ")", debug, GST_DEBUG_PAD_NAME (pad),
+ GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf));
g_object_notify (G_OBJECT (aggregator), "last_message");
}
* and that the peer pad is also enabled.
*/
if (GST_PAD_IS_USABLE (pad)) {
- buf = GST_BUFFER (gst_pad_pull (pad));
- debug = "loop";
+ buf = GST_BUFFER (gst_pad_pull (pad));
+ debug = "loop";
- /* then push it forward */
- gst_aggregator_push (aggregator, pad, buf, debug);
+ /* then push it forward */
+ gst_aggregator_push (aggregator, pad, buf, debug);
}
}
} else {
g_printerr ("BUFFERS in store:\n");
while (walk) {
g_print ("%15" G_GUINT64_FORMAT " - %7u\n", GST_BUFFER_OFFSET (walk->data),
- GST_BUFFER_SIZE (walk->data));
+ GST_BUFFER_SIZE (walk->data));
walk = g_list_next (walk);
}
g_printerr ("\n");
store->buffers && GST_BUFFER_OFFSET_IS_VALID (store->buffers->data)) {
/* we assumed valid offsets, but suddenly they are not anymore */
GST_DEBUG_OBJECT (store,
- "attempting to add buffer %p with invalid offset to store with valid offset, abort",
- buffer);
+ "attempting to add buffer %p with invalid offset to store with valid offset, abort",
+ buffer);
return FALSE;
} else if (!store->buffers
|| !GST_BUFFER_OFFSET_IS_VALID (store->buffers->data)) {
/* the starting buffer had an invalid offset, in that case we assume continuous buffers */
GST_LOG_OBJECT (store, "adding buffer %p with invalid offset and size %u",
- buffer, GST_BUFFER_SIZE (buffer));
+ buffer, GST_BUFFER_SIZE (buffer));
gst_data_ref (GST_DATA (buffer));
store->buffers = g_list_append (store->buffers, buffer);
return TRUE;
g_assert (GST_BUFFER_OFFSET_IS_VALID (buffer));
GST_LOG_OBJECT (store,
- "attempting to add buffer %p with offset %" G_GUINT64_FORMAT
- " and size %u", buffer, GST_BUFFER_OFFSET (buffer),
- GST_BUFFER_SIZE (buffer));
+ "attempting to add buffer %p with offset %" G_GUINT64_FORMAT
+ " and size %u", buffer, GST_BUFFER_OFFSET (buffer),
+ GST_BUFFER_SIZE (buffer));
/* we keep a sorted list of non-overlapping buffers */
walk = store->buffers;
while (walk) {
current_list = walk;
walk = g_list_next (walk);
if (GST_BUFFER_OFFSET (current) < GST_BUFFER_OFFSET (buffer)) {
- continue;
+ continue;
} else if (GST_BUFFER_OFFSET (current) == GST_BUFFER_OFFSET (buffer)) {
- guint needed_size;
-
- if (walk) {
- needed_size = MIN (GST_BUFFER_SIZE (buffer),
- GST_BUFFER_OFFSET (walk->data) - GST_BUFFER_OFFSET (current));
- } else {
- needed_size = GST_BUFFER_SIZE (buffer);
- }
- if (needed_size <= GST_BUFFER_SIZE (current)) {
- buffer = NULL;
- break;
- } else {
- if (needed_size < GST_BUFFER_SIZE (buffer)) {
- /* need to create subbuffer to not have overlapping data */
- GstBuffer *sub = gst_buffer_create_sub (buffer, 0, needed_size);
-
- g_assert (sub);
- buffer = sub;
- } else {
- gst_data_ref (GST_DATA (buffer));
- }
- /* replace current buffer with new one */
- GST_INFO_OBJECT (store,
- "replacing buffer %p with buffer %p with offset %" G_GINT64_FORMAT
- " and size %u", current_list->data, buffer,
- GST_BUFFER_OFFSET (buffer), GST_BUFFER_SIZE (buffer));
- gst_data_unref (GST_DATA (current_list->data));
- current_list->data = buffer;
- buffer = NULL;
- break;
- }
+ guint needed_size;
+
+ if (walk) {
+ needed_size = MIN (GST_BUFFER_SIZE (buffer),
+ GST_BUFFER_OFFSET (walk->data) - GST_BUFFER_OFFSET (current));
+ } else {
+ needed_size = GST_BUFFER_SIZE (buffer);
+ }
+ if (needed_size <= GST_BUFFER_SIZE (current)) {
+ buffer = NULL;
+ break;
+ } else {
+ if (needed_size < GST_BUFFER_SIZE (buffer)) {
+ /* need to create subbuffer to not have overlapping data */
+ GstBuffer *sub = gst_buffer_create_sub (buffer, 0, needed_size);
+
+ g_assert (sub);
+ buffer = sub;
+ } else {
+ gst_data_ref (GST_DATA (buffer));
+ }
+ /* replace current buffer with new one */
+ GST_INFO_OBJECT (store,
+ "replacing buffer %p with buffer %p with offset %" G_GINT64_FORMAT
+ " and size %u", current_list->data, buffer,
+ GST_BUFFER_OFFSET (buffer), GST_BUFFER_SIZE (buffer));
+ gst_data_unref (GST_DATA (current_list->data));
+ current_list->data = buffer;
+ buffer = NULL;
+ break;
+ }
} else if (GST_BUFFER_OFFSET (current) > GST_BUFFER_OFFSET (buffer)) {
- GList *previous = g_list_previous (current_list);
- guint64 start_offset = previous ?
- GST_BUFFER_OFFSET (previous->data) +
- GST_BUFFER_SIZE (previous->data) : 0;
-
- if (start_offset == GST_BUFFER_OFFSET (current)) {
- buffer = NULL;
- break;
- } else {
- /* we have data to insert */
- if (start_offset > GST_BUFFER_OFFSET (buffer) ||
- GST_BUFFER_OFFSET (buffer) + GST_BUFFER_SIZE (buffer) >
- GST_BUFFER_OFFSET (current)) {
- GstBuffer *sub;
-
- /* need a subbuffer */
- start_offset = GST_BUFFER_OFFSET (buffer) > start_offset ? 0 :
- start_offset - GST_BUFFER_OFFSET (buffer);
- sub = gst_buffer_create_sub (buffer, start_offset,
- MIN (GST_BUFFER_SIZE (buffer),
- GST_BUFFER_OFFSET (current) - start_offset -
- GST_BUFFER_OFFSET (buffer)));
- g_assert (sub);
- GST_BUFFER_OFFSET (sub) = start_offset + GST_BUFFER_OFFSET (buffer);
- buffer = sub;
- } else {
- gst_data_ref (GST_DATA (buffer));
- }
- GST_INFO_OBJECT (store,
- "adding buffer %p with offset %" G_GINT64_FORMAT " and size %u",
- buffer, GST_BUFFER_OFFSET (buffer), GST_BUFFER_SIZE (buffer));
- store->buffers =
- g_list_insert_before (store->buffers, current_list, buffer);
- buffer = NULL;
- break;
- }
+ GList *previous = g_list_previous (current_list);
+ guint64 start_offset = previous ?
+ GST_BUFFER_OFFSET (previous->data) +
+ GST_BUFFER_SIZE (previous->data) : 0;
+
+ if (start_offset == GST_BUFFER_OFFSET (current)) {
+ buffer = NULL;
+ break;
+ } else {
+ /* we have data to insert */
+ if (start_offset > GST_BUFFER_OFFSET (buffer) ||
+ GST_BUFFER_OFFSET (buffer) + GST_BUFFER_SIZE (buffer) >
+ GST_BUFFER_OFFSET (current)) {
+ GstBuffer *sub;
+
+ /* need a subbuffer */
+ start_offset = GST_BUFFER_OFFSET (buffer) > start_offset ? 0 :
+ start_offset - GST_BUFFER_OFFSET (buffer);
+ sub = gst_buffer_create_sub (buffer, start_offset,
+ MIN (GST_BUFFER_SIZE (buffer),
+ GST_BUFFER_OFFSET (current) - start_offset -
+ GST_BUFFER_OFFSET (buffer)));
+ g_assert (sub);
+ GST_BUFFER_OFFSET (sub) = start_offset + GST_BUFFER_OFFSET (buffer);
+ buffer = sub;
+ } else {
+ gst_data_ref (GST_DATA (buffer));
+ }
+ GST_INFO_OBJECT (store,
+ "adding buffer %p with offset %" G_GINT64_FORMAT " and size %u",
+ buffer, GST_BUFFER_OFFSET (buffer), GST_BUFFER_SIZE (buffer));
+ store->buffers =
+ g_list_insert_before (store->buffers, current_list, buffer);
+ buffer = NULL;
+ break;
+ }
}
}
if (buffer) {
gst_data_ref (GST_DATA (buffer));
GST_INFO_OBJECT (store,
- "adding buffer %p with offset %" G_GINT64_FORMAT " and size %u",
- buffer, GST_BUFFER_OFFSET (buffer), GST_BUFFER_SIZE (buffer));
+ "adding buffer %p with offset %" G_GINT64_FORMAT " and size %u",
+ buffer, GST_BUFFER_OFFSET (buffer), GST_BUFFER_SIZE (buffer));
if (current_list) {
- g_list_append (current_list, buffer);
+ g_list_append (current_list, buffer);
} else {
- g_assert (store->buffers == NULL);
- store->buffers = g_list_prepend (NULL, buffer);
+ g_assert (store->buffers == NULL);
+ store->buffers = g_list_prepend (NULL, buffer);
}
}
return TRUE;
do_nothing_loop (); */
} else if (cur_offset == offset && GST_BUFFER_SIZE (current) == size) {
GST_LOG_OBJECT (store,
- "found matching buffer %p for offset %" G_GUINT64_FORMAT
- " and size %u", current, offset, size);
+ "found matching buffer %p for offset %" G_GUINT64_FORMAT
+ " and size %u", current, offset, size);
ret = current;
gst_data_ref (GST_DATA (ret));
GST_LOG_OBJECT (store, "refcount %d", GST_DATA_REFCOUNT_VALUE (ret));
break;
} else if (cur_offset + GST_BUFFER_SIZE (current) > offset) {
if (cur_offset + GST_BUFFER_SIZE (current) >= offset + size) {
- ret = gst_buffer_create_sub (current, offset - cur_offset, size);
- GST_LOG_OBJECT (store,
- "created subbuffer %p from buffer %p for offset %llu and size %u",
- ret, current, offset, size);
- break;
+ ret = gst_buffer_create_sub (current, offset - cur_offset, size);
+ GST_LOG_OBJECT (store,
+ "created subbuffer %p from buffer %p for offset %llu and size %u",
+ ret, current, offset, size);
+ break;
}
/* uh, the requested data spans some buffers */
ret = gst_buffer_new_and_alloc (size);
GST_LOG_OBJECT (store, "created buffer %p for offset %" G_GUINT64_FORMAT
- " and size %u, will fill with data now", ret, offset, size);
+ " and size %u, will fill with data now", ret, offset, size);
data = GST_BUFFER_DATA (ret);
tmp = GST_BUFFER_SIZE (current) - offset + cur_offset;
memcpy (data, GST_BUFFER_DATA (current) + offset - cur_offset, tmp);
data += tmp;
size -= tmp;
while (size) {
- if (walk == NULL ||
- (have_offset &&
- GST_BUFFER_OFFSET (current) + GST_BUFFER_SIZE (current) !=
- GST_BUFFER_OFFSET (walk->data))) {
- GST_DEBUG_OBJECT (store,
- "not all data for offset %" G_GUINT64_FORMAT
- " and remaining size %u available, aborting", offset, size);
- gst_data_unref (GST_DATA (ret));
- ret = NULL;
- goto out;
- }
- current = GST_BUFFER (walk->data);
- walk = g_list_next (walk);
- tmp = MIN (GST_BUFFER_SIZE (current), size);
- memcpy (data, GST_BUFFER_DATA (current), tmp);
- data += tmp;
- size -= tmp;
+ if (walk == NULL ||
+ (have_offset &&
+ GST_BUFFER_OFFSET (current) + GST_BUFFER_SIZE (current) !=
+ GST_BUFFER_OFFSET (walk->data))) {
+ GST_DEBUG_OBJECT (store,
+ "not all data for offset %" G_GUINT64_FORMAT
+ " and remaining size %u available, aborting", offset, size);
+ gst_data_unref (GST_DATA (ret));
+ ret = NULL;
+ goto out;
+ }
+ current = GST_BUFFER (walk->data);
+ walk = g_list_next (walk);
+ tmp = MIN (GST_BUFFER_SIZE (current), size);
+ memcpy (data, GST_BUFFER_DATA (current), tmp);
+ data += tmp;
+ size -= tmp;
}
}
if (!have_offset) {
}
while (walk) {
if (have_offset && counting &&
- cur_offset + GST_BUFFER_SIZE (current) !=
- GST_BUFFER_OFFSET (walk->data)) {
+ cur_offset + GST_BUFFER_SIZE (current) !=
+ GST_BUFFER_OFFSET (walk->data)) {
break;
}
current = GST_BUFFER (walk->data);
ret += GST_BUFFER_SIZE (current);
} else {
if (cur_offset > offset)
- return 0;
+ return 0;
if (cur_offset + GST_BUFFER_SIZE (current) > offset) {
- /* we have at least some bytes */
- ret = cur_offset + GST_BUFFER_SIZE (current) - offset;
- counting = TRUE;
+ /* we have at least some bytes */
+ ret = cur_offset + GST_BUFFER_SIZE (current) - offset;
+ counting = TRUE;
}
}
if (!have_offset) {
while ((*my_elements).name) {
if (!gst_element_register (plugin, (*my_elements).name, (*my_elements).rank,
- ((*my_elements).type) ()))
+ ((*my_elements).type) ()))
return FALSE;
my_elements++;
}
static GEnumValue fakesink_state_error[] = {
{FAKESINK_STATE_ERROR_NONE, "0", "No state change errors"},
{FAKESINK_STATE_ERROR_NULL_READY, "1",
- "Fail state change from NULL to READY"},
+ "Fail state change from NULL to READY"},
{FAKESINK_STATE_ERROR_READY_PAUSED, "2",
- "Fail state change from READY to PAUSED"},
+ "Fail state change from READY to PAUSED"},
{FAKESINK_STATE_ERROR_PAUSED_PLAYING, "3",
- "Fail state change from PAUSED to PLAYING"},
+ "Fail state change from PAUSED to PLAYING"},
{FAKESINK_STATE_ERROR_PLAYING_PAUSED, "4",
- "Fail state change from PLAYING to PAUSED"},
+ "Fail state change from PLAYING to PAUSED"},
{FAKESINK_STATE_ERROR_PAUSED_READY, "5",
- "Fail state change from PAUSED to READY"},
+ "Fail state change from PAUSED to READY"},
{FAKESINK_STATE_ERROR_READY_NULL, "6",
- "Fail state change from READY to NULL"},
+ "Fail state change from READY to NULL"},
{0, NULL, NULL},
};
+
if (!fakesink_state_error_type) {
fakesink_state_error_type =
- g_enum_register_static ("GstFakeSinkStateError", fakesink_state_error);
+ g_enum_register_static ("GstFakeSinkStateError", fakesink_state_error);
}
return fakesink_state_error_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NUM_SINKS,
g_param_spec_int ("num_sinks", "Number of sinks",
- "The number of sinkpads", 1, G_MAXINT, 1, G_PARAM_READABLE));
+ "The number of sinkpads", 1, G_MAXINT, 1, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_STATE_ERROR,
g_param_spec_enum ("state_error", "State Error",
- "Generate a state change error", GST_TYPE_FAKESINK_STATE_ERROR,
- FAKESINK_STATE_ERROR_NONE, G_PARAM_READWRITE));
+ "Generate a state change error", GST_TYPE_FAKESINK_STATE_ERROR,
+ FAKESINK_STATE_ERROR_NONE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LAST_MESSAGE,
g_param_spec_string ("last_message", "Last Message",
- "The message describing current status", NULL, G_PARAM_READABLE));
+ "The message describing current status", NULL, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SYNC,
g_param_spec_boolean ("sync", "Sync", "Sync on the clock", FALSE,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SIGNAL_HANDOFFS,
g_param_spec_boolean ("signal-handoffs", "Signal handoffs",
- "Send a signal before unreffing the buffer", FALSE,
- G_PARAM_READWRITE));
+ "Send a signal before unreffing the buffer", FALSE,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SILENT,
g_param_spec_boolean ("silent", "Silent",
- "Don't produce last_message events", FALSE, G_PARAM_READWRITE));
+ "Don't produce last_message events", FALSE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DUMP,
g_param_spec_boolean ("dump", "Dump", "Dump received bytes to stdout",
- FALSE, G_PARAM_READWRITE));
+ FALSE, G_PARAM_READWRITE));
gst_fakesink_signals[SIGNAL_HANDOFF] =
g_signal_new ("handoff", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
g_free (fakesink->last_message);
fakesink->last_message =
- g_strdup_printf ("chain ******* (%s:%s)E (type: %d) %p",
- GST_DEBUG_PAD_NAME (pad), GST_EVENT_TYPE (event), event);
+ g_strdup_printf ("chain ******* (%s:%s)E (type: %d) %p",
+ GST_DEBUG_PAD_NAME (pad), GST_EVENT_TYPE (event), event);
g_object_notify (G_OBJECT (fakesink), "last_message");
}
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_DISCONTINUOUS:
- if (fakesink->sync && fakesink->clock) {
- gint64 value = GST_EVENT_DISCONT_OFFSET (event, 0).value;
+ if (fakesink->sync && fakesink->clock) {
+ gint64 value = GST_EVENT_DISCONT_OFFSET (event, 0).value;
- gst_element_set_time (GST_ELEMENT (fakesink), value);
- }
+ gst_element_set_time (GST_ELEMENT (fakesink), value);
+ }
default:
- gst_pad_event_default (pad, event);
- break;
+ gst_pad_event_default (pad, event);
+ break;
}
return;
}
g_free (fakesink->last_message);
fakesink->last_message =
- g_strdup_printf ("chain ******* (%s:%s)< (%d bytes, timestamp: %"
- G_GINT64_FORMAT ", duration: %" G_GINT64_FORMAT ", offset: %"
- G_GINT64_FORMAT ", flags: %d) %p", GST_DEBUG_PAD_NAME (pad),
- GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf),
- GST_BUFFER_DURATION (buf), GST_BUFFER_OFFSET (buf),
- GST_BUFFER_FLAGS (buf), buf);
+ g_strdup_printf ("chain ******* (%s:%s)< (%d bytes, timestamp: %"
+ G_GINT64_FORMAT ", duration: %" G_GINT64_FORMAT ", offset: %"
+ G_GINT64_FORMAT ", flags: %d) %p", GST_DEBUG_PAD_NAME (pad),
+ GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf),
+ GST_BUFFER_DURATION (buf), GST_BUFFER_OFFSET (buf),
+ GST_BUFFER_FLAGS (buf), buf);
g_object_notify (G_OBJECT (fakesink), "last_message");
}
if (fakesink->signal_handoffs)
g_signal_emit (G_OBJECT (fakesink), gst_fakesink_signals[SIGNAL_HANDOFF], 0,
- buf, pad);
+ buf, pad);
if (fakesink->dump) {
gst_util_dump_mem (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
switch (GST_STATE_TRANSITION (element)) {
case GST_STATE_NULL_TO_READY:
if (fakesink->state_error == FAKESINK_STATE_ERROR_NULL_READY)
- goto error;
+ goto error;
break;
case GST_STATE_READY_TO_PAUSED:
if (fakesink->state_error == FAKESINK_STATE_ERROR_READY_PAUSED)
- goto error;
+ goto error;
break;
case GST_STATE_PAUSED_TO_PLAYING:
if (fakesink->state_error == FAKESINK_STATE_ERROR_PAUSED_PLAYING)
- goto error;
+ goto error;
break;
case GST_STATE_PLAYING_TO_PAUSED:
if (fakesink->state_error == FAKESINK_STATE_ERROR_PLAYING_PAUSED)
- goto error;
+ goto error;
break;
case GST_STATE_PAUSED_TO_READY:
if (fakesink->state_error == FAKESINK_STATE_ERROR_PAUSED_READY)
- goto error;
+ goto error;
break;
case GST_STATE_READY_TO_NULL:
if (fakesink->state_error == FAKESINK_STATE_ERROR_READY_NULL)
- goto error;
+ goto error;
g_free (fakesink->last_message);
fakesink->last_message = NULL;
break;
{FAKESRC_GET_ALWAYS_SUCEEDS, "8", "'_get' Always succeeds"},
{0, NULL, NULL},
};
+
if (!fakesrc_output_type) {
fakesrc_output_type =
- g_enum_register_static ("GstFakeSrcOutput", fakesrc_output);
+ g_enum_register_static ("GstFakeSrcOutput", fakesrc_output);
}
return fakesrc_output_type;
}
{FAKESRC_DATA_SUBBUFFER, "2", "Subbuffer data"},
{0, NULL, NULL},
};
+
if (!fakesrc_data_type) {
fakesrc_data_type = g_enum_register_static ("GstFakeSrcData", fakesrc_data);
}
{FAKESRC_SIZETYPE_NULL, "1", "Send empty buffers"},
{FAKESRC_SIZETYPE_FIXED, "2", "Fixed size buffers (sizemax sized)"},
{FAKESRC_SIZETYPE_RANDOM, "3",
- "Random sized buffers (sizemin <= size <= sizemax)"},
+ "Random sized buffers (sizemin <= size <= sizemax)"},
{0, NULL, NULL},
};
+
if (!fakesrc_sizetype_type) {
fakesrc_sizetype_type =
- g_enum_register_static ("GstFakeSrcSizeType", fakesrc_sizetype);
+ g_enum_register_static ("GstFakeSrcSizeType", fakesrc_sizetype);
}
return fakesrc_sizetype_type;
}
{FAKESRC_FILLTYPE_RANDOM, "3", "Fill buffers with random crap"},
{FAKESRC_FILLTYPE_PATTERN, "4", "Fill buffers with pattern 0x00 -> 0xff"},
{FAKESRC_FILLTYPE_PATTERN_CONT, "5",
- "Fill buffers with pattern 0x00 -> 0xff that spans buffers"},
+ "Fill buffers with pattern 0x00 -> 0xff that spans buffers"},
{0, NULL, NULL},
};
+
if (!fakesrc_filltype_type) {
fakesrc_filltype_type =
- g_enum_register_static ("GstFakeSrcFillType", fakesrc_filltype);
+ g_enum_register_static ("GstFakeSrcFillType", fakesrc_filltype);
}
return fakesrc_filltype_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NUM_SOURCES,
g_param_spec_int ("num-sources", "num-sources", "Number of sources",
- 1, G_MAXINT, 1, G_PARAM_READABLE));
+ 1, G_MAXINT, 1, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOOP_BASED,
g_param_spec_boolean ("loop-based", "loop-based",
- "Enable loop-based operation", FALSE, G_PARAM_READWRITE));
+ "Enable loop-based operation", FALSE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_OUTPUT,
g_param_spec_enum ("output", "output", "Output method (currently unused)",
- GST_TYPE_FAKESRC_OUTPUT, FAKESRC_FIRST_LAST_LOOP, G_PARAM_READWRITE));
+ GST_TYPE_FAKESRC_OUTPUT, FAKESRC_FIRST_LAST_LOOP, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DATA,
g_param_spec_enum ("data", "data", "Data allocation method",
- GST_TYPE_FAKESRC_DATA, FAKESRC_DATA_ALLOCATE, G_PARAM_READWRITE));
+ GST_TYPE_FAKESRC_DATA, FAKESRC_DATA_ALLOCATE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SIZETYPE,
g_param_spec_enum ("sizetype", "sizetype",
- "How to determine buffer sizes", GST_TYPE_FAKESRC_SIZETYPE,
- FAKESRC_SIZETYPE_NULL, G_PARAM_READWRITE));
+ "How to determine buffer sizes", GST_TYPE_FAKESRC_SIZETYPE,
+ FAKESRC_SIZETYPE_NULL, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SIZEMIN,
g_param_spec_int ("sizemin", "sizemin", "Minimum buffer size", 0,
- G_MAXINT, DEFAULT_SIZEMIN, G_PARAM_READWRITE));
+ G_MAXINT, DEFAULT_SIZEMIN, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SIZEMAX,
g_param_spec_int ("sizemax", "sizemax", "Maximum buffer size", 0,
- G_MAXINT, DEFAULT_SIZEMAX, G_PARAM_READWRITE));
+ G_MAXINT, DEFAULT_SIZEMAX, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PARENTSIZE,
g_param_spec_int ("parentsize", "parentsize",
- "Size of parent buffer for sub-buffered allocation", 0, G_MAXINT,
- DEFAULT_PARENTSIZE, G_PARAM_READWRITE));
+ "Size of parent buffer for sub-buffered allocation", 0, G_MAXINT,
+ DEFAULT_PARENTSIZE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FILLTYPE,
g_param_spec_enum ("filltype", "filltype",
- "How to fill the buffer, if at all", GST_TYPE_FAKESRC_FILLTYPE,
- FAKESRC_FILLTYPE_NULL, G_PARAM_READWRITE));
+ "How to fill the buffer, if at all", GST_TYPE_FAKESRC_FILLTYPE,
+ FAKESRC_FILLTYPE_NULL, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PATTERN,
g_param_spec_string ("pattern", "pattern", "pattern", NULL,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NUM_BUFFERS,
g_param_spec_int ("num-buffers", "num-buffers",
- "Number of buffers to output before sending EOS", G_MININT, G_MAXINT,
- 0, G_PARAM_READWRITE));
+ "Number of buffers to output before sending EOS", G_MININT, G_MAXINT,
+ 0, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_EOS,
g_param_spec_boolean ("eos", "eos", "Send out the EOS event?", TRUE,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LAST_MESSAGE,
g_param_spec_string ("last-message", "last-message",
- "The last status message", NULL, G_PARAM_READABLE));
+ "The last status message", NULL, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SILENT,
g_param_spec_boolean ("silent", "Silent",
- "Don't produce last_message events", FALSE, G_PARAM_READWRITE));
+ "Don't produce last_message events", FALSE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SIGNAL_HANDOFFS,
g_param_spec_boolean ("signal-handoffs", "Signal handoffs",
- "Send a signal before pushing the buffer", FALSE, G_PARAM_READWRITE));
+ "Send a signal before pushing the buffer", FALSE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DUMP,
g_param_spec_boolean ("dump", "Dump", "Dump produced bytes to stdout",
- FALSE, G_PARAM_READWRITE));
+ FALSE, G_PARAM_READWRITE));
gst_fakesrc_signals[SIGNAL_HANDOFF] =
g_signal_new ("handoff", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
GST_FORMAT_DEFAULT,
0,
};
+
return formats;
}
GST_QUERY_SEGMENT_END,
0,
};
+
return types;
}
{GST_EVENT_FLUSH, 0},
{0, 0},
};
+
return masks;
}
src->buffer_count = GST_EVENT_SEEK_OFFSET (event);
if (!GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_FLUSH) {
- break;
+ break;
}
/* else we do a flush too */
case GST_EVENT_SEEK_SEGMENT:
src->segment_end = GST_EVENT_SEEK_ENDOFFSET (event);
src->buffer_count = src->segment_start;
src->segment_loop =
- GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_SEGMENT_LOOP;
+ GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_SEGMENT_LOOP;
break;
case GST_EVENT_FLUSH:
src->need_flush = TRUE;
if (src->loop_based) {
gst_element_set_loop_function (GST_ELEMENT (src),
- GST_DEBUG_FUNCPTR (gst_fakesrc_loop));
+ GST_DEBUG_FUNCPTR (gst_fakesrc_loop));
} else {
gst_element_set_loop_function (GST_ELEMENT (src), NULL);
}
src->data = g_value_get_enum (value);
if (src->data == FAKESRC_DATA_SUBBUFFER) {
- if (!src->parent)
- gst_fakesrc_alloc_parent (src);
+ if (!src->parent)
+ gst_fakesrc_alloc_parent (src);
} else {
- if (src->parent) {
- gst_buffer_unref (src->parent);
- src->parent = NULL;
- }
+ if (src->parent) {
+ gst_buffer_unref (src->parent);
+ src->parent = NULL;
+ }
}
break;
case ARG_SIZETYPE:
guint8 *ptr = GST_BUFFER_DATA (buf);
for (i = GST_BUFFER_SIZE (buf); i; i--) {
- *ptr++ = (gint8) ((255.0) * rand () / (RAND_MAX));
+ *ptr++ = (gint8) ((255.0) * rand () / (RAND_MAX));
}
break;
}
guint8 *ptr = GST_BUFFER_DATA (buf);
for (i = GST_BUFFER_SIZE (buf); i; i--) {
- *ptr++ = src->pattern_byte++;
+ *ptr++ = src->pattern_byte++;
}
break;
}
if (size != 0) {
switch (src->filltype) {
case FAKESRC_FILLTYPE_NOTHING:
- GST_BUFFER_DATA (buf) = g_malloc (size);
- break;
+ GST_BUFFER_DATA (buf) = g_malloc (size);
+ break;
case FAKESRC_FILLTYPE_NULL:
- GST_BUFFER_DATA (buf) = g_malloc0 (size);
- break;
+ GST_BUFFER_DATA (buf) = g_malloc0 (size);
+ break;
case FAKESRC_FILLTYPE_RANDOM:
case FAKESRC_FILLTYPE_PATTERN:
case FAKESRC_FILLTYPE_PATTERN_CONT:
default:
- GST_BUFFER_DATA (buf) = g_malloc (size);
- gst_fakesrc_prepare_buffer (src, buf);
- break;
+ GST_BUFFER_DATA (buf) = g_malloc (size);
+ gst_fakesrc_prepare_buffer (src, buf);
+ break;
}
}
break;
case FAKESRC_SIZETYPE_RANDOM:
size =
- src->sizemin +
- (guint8) (((gfloat) src->sizemax) * rand () / (RAND_MAX +
- (gfloat) src->sizemin));
+ src->sizemin +
+ (guint8) (((gfloat) src->sizemax) * rand () / (RAND_MAX +
+ (gfloat) src->sizemin));
break;
case FAKESRC_SIZETYPE_NULL:
default:
case FAKESRC_DATA_SUBBUFFER:
/* see if we have a parent to subbuffer */
if (!src->parent) {
- gst_fakesrc_alloc_parent (src);
- g_assert (src->parent);
+ gst_fakesrc_alloc_parent (src);
+ g_assert (src->parent);
}
/* see if it's large enough */
if ((GST_BUFFER_SIZE (src->parent) - src->parentoffset) >= size) {
- buf = gst_buffer_create_sub (src->parent, src->parentoffset, size);
- src->parentoffset += size;
+ buf = gst_buffer_create_sub (src->parent, src->parentoffset, size);
+ src->parentoffset += size;
} else {
- /* the parent is useless now */
- gst_buffer_unref (src->parent);
- src->parent = NULL;
- /* try again (this will allocate a new parent) */
- return gst_fakesrc_create_buffer (src);
+ /* the parent is useless now */
+ gst_buffer_unref (src->parent);
+ src->parent = NULL;
+ /* try again (this will allocate a new parent) */
+ return gst_fakesrc_create_buffer (src);
}
gst_fakesrc_prepare_buffer (src, buf);
break;
g_free (src->last_message);
src->last_message =
- g_strdup_printf ("get ******* (%s:%s)> (%d bytes, %"
- G_GUINT64_FORMAT " ) %p", GST_DEBUG_PAD_NAME (pad),
- GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf), buf);
+ g_strdup_printf ("get ******* (%s:%s)> (%d bytes, %"
+ G_GUINT64_FORMAT " ) %p", GST_DEBUG_PAD_NAME (pad),
+ GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf), buf);
g_object_notify (G_OBJECT (src), "last_message");
}
if (src->signal_handoffs) {
GST_LOG_OBJECT (src, "pre handoff emit");
g_signal_emit (G_OBJECT (src), gst_fakesrc_signals[SIGNAL_HANDOFF], 0,
- buf, pad);
+ buf, pad);
GST_LOG_OBJECT (src, "post handoff emit");
}
break;
case GST_STATE_PAUSED_TO_READY:
if (fakesrc->parent) {
- gst_buffer_unref (fakesrc->parent);
- fakesrc->parent = NULL;
+ gst_buffer_unref (fakesrc->parent);
+ fakesrc->parent = NULL;
}
g_free (fakesrc->last_message);
fakesrc->last_message = NULL;
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FD,
g_param_spec_int ("fd", "fd", "An open file descriptor to write to",
- 0, G_MAXINT, 1, G_PARAM_READWRITE));
+ 0, G_MAXINT, 1, G_PARAM_READWRITE));
gobject_class->set_property = gst_fdsink_set_property;
gobject_class->get_property = gst_fdsink_get_property;
if (GST_BUFFER_DATA (buf)) {
GST_DEBUG ("writing %d bytes to file descriptor %d", GST_BUFFER_SIZE (buf),
- fdsink->fd);
+ fdsink->fd);
write (fdsink->fd, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FD,
g_param_spec_int ("fd", "fd", "An open file descriptor to read from",
- 0, G_MAXINT, 0, G_PARAM_READWRITE));
+ 0, G_MAXINT, 0, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BLOCKSIZE,
g_param_spec_ulong ("blocksize", "Block size",
- "Size in bytes to read per buffer", 1, G_MAXULONG, DEFAULT_BLOCKSIZE,
- G_PARAM_READWRITE));
+ "Size in bytes to read per buffer", 1, G_MAXULONG, DEFAULT_BLOCKSIZE,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TIMEOUT,
g_param_spec_uint64 ("timeout", "Timeout", "Read timeout in nanoseconds",
- 0, G_MAXUINT64, 0, G_PARAM_READWRITE));
+ 0, G_MAXUINT64, 0, G_PARAM_READWRITE));
gst_fdsrc_signals[SIGNAL_TIMEOUT] =
g_signal_new ("timeout", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
do {
retval = select (1, &readfds, NULL, NULL, tp);
- } while (retval == -1 && errno == EINTR); /* retry if interrupted */
+ } while (retval == -1 && errno == EINTR); /* retry if interrupted */
if (retval == -1) {
GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL),
- ("select on file descriptor: %s.", g_strerror (errno)));
+ ("select on file descriptor: %s.", g_strerror (errno)));
gst_element_set_eos (GST_ELEMENT (src));
return GST_DATA (gst_event_new (GST_EVENT_EOS));
} else if (retval == 0) {
do {
readbytes = read (src->fd, GST_BUFFER_DATA (buf), src->blocksize);
- } while (readbytes == -1 && errno == EINTR); /* retry if interrupted */
+ } while (readbytes == -1 && errno == EINTR); /* retry if interrupted */
if (readbytes > 0) {
GST_BUFFER_OFFSET (buf) = src->curoffset;
return GST_DATA (gst_event_new (GST_EVENT_EOS));
} else {
GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL),
- ("read on file descriptor: %s.", g_strerror (errno)));
+ ("read on file descriptor: %s.", g_strerror (errno)));
gst_element_set_eos (GST_ELEMENT (src));
return GST_DATA (gst_event_new (GST_EVENT_EOS));
}
GST_FORMAT_BYTES,
0,
};
+
return formats;
}
GST_QUERY_POSITION,
0
};
+
return types;
}
NULL,
NULL
};
+
g_type_add_interface_static (filesink_type, GST_TYPE_URI_HANDLER,
&urihandler_info);
GST_DEBUG_CATEGORY_INIT (gst_filesink_debug, "filesink", 0,
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOCATION,
g_param_spec_string ("location", "File Location",
- "Location of the file to write", NULL, G_PARAM_READWRITE));
+ "Location of the file to write", NULL, G_PARAM_READWRITE));
gst_filesink_signals[SIGNAL_HANDOFF] =
g_signal_new ("handoff", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
/* open the file */
if (sink->filename == NULL || sink->filename[0] == '\0') {
GST_ELEMENT_ERROR (sink, RESOURCE, NOT_FOUND,
- (_("No file name specified for writing.")), (NULL));
+ (_("No file name specified for writing.")), (NULL));
return FALSE;
}
sink->file = fopen (sink->filename, "w");
if (sink->file == NULL) {
GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_WRITE,
- (_("Could not open file \"%s\" for writing."), sink->filename),
- GST_ERROR_SYSTEM);
+ (_("Could not open file \"%s\" for writing."), sink->filename),
+ GST_ERROR_SYSTEM);
return FALSE;
}
if (fclose (sink->file) != 0) {
GST_ELEMENT_ERROR (sink, RESOURCE, CLOSE,
- (_("Error closing file \"%s\"."), sink->filename), GST_ERROR_SYSTEM);
+ (_("Error closing file \"%s\"."), sink->filename), GST_ERROR_SYSTEM);
} else {
GST_FLAG_UNSET (sink, GST_FILESINK_OPEN);
}
switch (type) {
case GST_QUERY_TOTAL:
switch (*format) {
- case GST_FORMAT_BYTES:
- if (GST_FLAG_IS_SET (GST_ELEMENT (sink), GST_FILESINK_OPEN)) {
- *value = sink->data_written; /* FIXME - doesn't the kernel provide
- such a function? */
- break;
- }
- default:
- return FALSE;
+ case GST_FORMAT_BYTES:
+ if (GST_FLAG_IS_SET (GST_ELEMENT (sink), GST_FILESINK_OPEN)) {
+ *value = sink->data_written; /* FIXME - doesn't the kernel provide
+ such a function? */
+ break;
+ }
+ default:
+ return FALSE;
}
break;
case GST_QUERY_POSITION:
switch (*format) {
- case GST_FORMAT_BYTES:
- if (GST_FLAG_IS_SET (GST_ELEMENT (sink), GST_FILESINK_OPEN)) {
- *value = ftell (sink->file);
- break;
- }
- default:
- return FALSE;
+ case GST_FORMAT_BYTES:
+ if (GST_FLAG_IS_SET (GST_ELEMENT (sink), GST_FILESINK_OPEN)) {
+ *value = ftell (sink->file);
+ break;
+ }
+ default:
+ return FALSE;
}
break;
default:
switch (type) {
case GST_EVENT_SEEK:
g_return_val_if_fail (GST_EVENT_SEEK_FORMAT (event) == GST_FORMAT_BYTES,
- FALSE);
+ FALSE);
if (GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_FLUSH)
- if (fflush (filesink->file))
- GST_ELEMENT_ERROR (filesink, RESOURCE, WRITE,
- (_("Error while writing to file \"%s\"."), filesink->filename),
- GST_ERROR_SYSTEM);
+ if (fflush (filesink->file))
+ GST_ELEMENT_ERROR (filesink, RESOURCE, WRITE,
+ (_("Error while writing to file \"%s\"."), filesink->filename),
+ GST_ERROR_SYSTEM);
switch (GST_EVENT_SEEK_METHOD (event)) {
- case GST_SEEK_METHOD_SET:
- fseek (filesink->file, GST_EVENT_SEEK_OFFSET (event), SEEK_SET);
- break;
- case GST_SEEK_METHOD_CUR:
- fseek (filesink->file, GST_EVENT_SEEK_OFFSET (event), SEEK_CUR);
- break;
- case GST_SEEK_METHOD_END:
- fseek (filesink->file, GST_EVENT_SEEK_OFFSET (event), SEEK_END);
- break;
- default:
- g_warning ("unknown seek method!");
- break;
+ case GST_SEEK_METHOD_SET:
+ fseek (filesink->file, GST_EVENT_SEEK_OFFSET (event), SEEK_SET);
+ break;
+ case GST_SEEK_METHOD_CUR:
+ fseek (filesink->file, GST_EVENT_SEEK_OFFSET (event), SEEK_CUR);
+ break;
+ case GST_SEEK_METHOD_END:
+ fseek (filesink->file, GST_EVENT_SEEK_OFFSET (event), SEEK_END);
+ break;
+ default:
+ g_warning ("unknown seek method!");
+ break;
}
break;
case GST_EVENT_DISCONTINUOUS:
gint64 offset;
if (gst_event_discont_get_value (event, GST_FORMAT_BYTES, &offset))
- fseek (filesink->file, offset, SEEK_SET);
+ fseek (filesink->file, offset, SEEK_SET);
gst_event_unref (event);
break;
}
case GST_EVENT_FLUSH:
if (fflush (filesink->file)) {
- GST_ELEMENT_ERROR (filesink, RESOURCE, WRITE,
- (_("Error while writing to file \"%s\"."), filesink->filename),
- GST_ERROR_SYSTEM);
+ GST_ELEMENT_ERROR (filesink, RESOURCE, WRITE,
+ (_("Error while writing to file \"%s\"."), filesink->filename),
+ GST_ERROR_SYSTEM);
}
break;
case GST_EVENT_EOS:
back_pending = filesink->data_written - ftell (filesink->file);
while (bytes_written < GST_BUFFER_SIZE (buf)) {
size_t wrote = fwrite (GST_BUFFER_DATA (buf) + bytes_written, 1,
- GST_BUFFER_SIZE (buf) - bytes_written,
- filesink->file);
+ GST_BUFFER_SIZE (buf) - bytes_written,
+ filesink->file);
if (wrote <= 0) {
- GST_ELEMENT_ERROR (filesink, RESOURCE, WRITE,
- (_("Error while writing to file \"%s\"."), filesink->filename),
- ("Only %d of %d bytes written: %s",
- bytes_written, GST_BUFFER_SIZE (buf), strerror (errno)));
- break;
+ GST_ELEMENT_ERROR (filesink, RESOURCE, WRITE,
+ (_("Error while writing to file \"%s\"."), filesink->filename),
+ ("Only %d of %d bytes written: %s",
+ bytes_written, GST_BUFFER_SIZE (buf), strerror (errno)));
+ break;
}
bytes_written += wrote;
}
switch (GST_STATE_TRANSITION (element)) {
case GST_STATE_PAUSED_TO_READY:
if (GST_FLAG_IS_SET (element, GST_FILESINK_OPEN))
- gst_filesink_close_file (GST_FILESINK (element));
+ gst_filesink_close_file (GST_FILESINK (element));
break;
case GST_STATE_READY_TO_PAUSED:
if (!GST_FLAG_IS_SET (element, GST_FILESINK_OPEN)) {
- if (!gst_filesink_open_file (GST_FILESINK (element)))
- return GST_STATE_FAILURE;
+ if (!gst_filesink_open_file (GST_FILESINK (element)))
+ return GST_STATE_FAILURE;
}
break;
}
gst_filesink_uri_get_protocols (void)
{
static gchar *protocols[] = { "file", NULL };
+
return protocols;
}
static const gchar *
{
static const GstEventMask masks[] = {
{GST_EVENT_SEEK, GST_SEEK_METHOD_CUR |
- GST_SEEK_METHOD_SET | GST_SEEK_METHOD_END | GST_SEEK_FLAG_FLUSH},
+ GST_SEEK_METHOD_SET | GST_SEEK_METHOD_END | GST_SEEK_FLAG_FLUSH},
{GST_EVENT_FLUSH, 0},
{GST_EVENT_SIZE, 0},
{0, 0}
};
+
return masks;
}
GST_QUERY_POSITION,
0
};
+
return types;
}
GST_FORMAT_BYTES,
0,
};
+
return formats;
}
NULL,
NULL
};
+
g_type_add_interface_static (filesrc_type, GST_TYPE_URI_HANDLER,
&urihandler_info);
GST_DEBUG_CATEGORY_INIT (gst_filesrc_debug, "filesrc", 0, "filesrc element");
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_FD,
g_param_spec_int ("fd", "File-descriptor",
- "File-descriptor for the file being mmap()d", 0, G_MAXINT, 0,
- G_PARAM_READABLE));
+ "File-descriptor for the file being mmap()d", 0, G_MAXINT, 0,
+ G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOCATION,
g_param_spec_string ("location", "File Location",
- "Location of the file to read", NULL, G_PARAM_READWRITE));
+ "Location of the file to read", NULL, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BLOCKSIZE,
g_param_spec_ulong ("blocksize", "Block size",
- "Size in bytes to read per buffer", 1, G_MAXULONG, DEFAULT_BLOCKSIZE,
- G_PARAM_READWRITE));
+ "Size in bytes to read per buffer", 1, G_MAXULONG, DEFAULT_BLOCKSIZE,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MMAPSIZE,
g_param_spec_ulong ("mmapsize", "mmap() Block Size",
- "Size in bytes of mmap()d regions", 0, G_MAXULONG, DEFAULT_MMAPSIZE,
- G_PARAM_READWRITE));
+ "Size in bytes of mmap()d regions", 0, G_MAXULONG, DEFAULT_MMAPSIZE,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TOUCH,
g_param_spec_boolean ("touch", "Touch read data",
- "Touch data to force disk read", FALSE, G_PARAM_READWRITE));
+ "Touch data to force disk read", FALSE, G_PARAM_READWRITE));
gobject_class->dispose = gst_filesrc_dispose;
gobject_class->set_property = gst_filesrc_set_property;
src->touch = FALSE;
src->mapbuf = NULL;
- src->mapsize = DEFAULT_MMAPSIZE; /* default is 4MB */
+ src->mapsize = DEFAULT_MMAPSIZE; /* default is 4MB */
src->seek_happened = FALSE;
}
break;
case ARG_MMAPSIZE:
if ((src->mapsize % src->pagesize) == 0) {
- src->mapsize = g_value_get_ulong (value);
- g_object_notify (G_OBJECT (src), "mmapsize");
+ src->mapsize = g_value_get_ulong (value);
+ g_object_notify (G_OBJECT (src), "mmapsize");
} else {
- GST_INFO_OBJECT (src,
- "invalid mapsize, must be a multiple of pagesize, which is %d",
- src->pagesize);
+ GST_INFO_OBJECT (src,
+ "invalid mapsize, must be a multiple of pagesize, which is %d",
+ src->pagesize);
}
break;
case ARG_TOUCH:
return NULL;
} else if (mmapregion == MAP_FAILED) {
GST_WARNING_OBJECT (src, "mmap (0x%08lx, %d, 0x%llx) failed: %s",
- (unsigned long) size, src->fd, offset, strerror (errno));
+ (unsigned long) size, src->fd, offset, strerror (errno));
return NULL;
}
GST_LOG_OBJECT (src, "mapped region %08lx+%08lx from file into memory at %p",
mapbase = offset - mod;
mapsize =
- ((size + mod + src->pagesize - 1) / src->pagesize) * src->pagesize;
+ ((size + mod + src->pagesize - 1) / src->pagesize) * src->pagesize;
/* printf("not on page boundaries, resizing map to %d+%d\n",mapbase,mapsize);*/
map = gst_filesrc_map_region (src, mapbase, mapsize);
if (map == NULL)
/* calculate end pointers so we don't have to do so repeatedly later */
readsize = src->block_size;
- readend = src->curoffset + src->block_size; /* note this is the byte *after* the read */
+ readend = src->curoffset + src->block_size; /* note this is the byte *after* the read */
mapstart = GST_BUFFER_OFFSET (src->mapbuf);
mapsize = GST_BUFFER_SIZE (src->mapbuf);
- mapend = mapstart + mapsize; /* note this is the byte *after* the map */
+ mapend = mapstart + mapsize; /* note this is the byte *after* the map */
/* check to see if we're going to overflow the end of the file */
if (readend > src->filelen) {
/* ('cause by definition if readend is in the buffer, so's readstart) */
if (readend <= mapend) {
GST_LOG_OBJECT (src,
- "read buf %llu+%d lives in current mapbuf %lld+%d, creating subbuffer of mapbuf",
- src->curoffset, (int) readsize, mapstart, mapsize);
+ "read buf %llu+%d lives in current mapbuf %lld+%d, creating subbuffer of mapbuf",
+ src->curoffset, (int) readsize, mapstart, mapsize);
buf =
- gst_buffer_create_sub (src->mapbuf, src->curoffset - mapstart,
- readsize);
+ gst_buffer_create_sub (src->mapbuf, src->curoffset - mapstart,
+ readsize);
GST_BUFFER_OFFSET (buf) = src->curoffset;
/* if the start actually is within the current mmap region, map an overlap buffer */
} else if (src->curoffset < mapend) {
GST_LOG_OBJECT (src,
- "read buf %llu+%d starts in mapbuf %d+%d but ends outside, creating new mmap",
- (unsigned long long) src->curoffset, (gint) readsize, (gint) mapstart,
- (gint) mapsize);
+ "read buf %llu+%d starts in mapbuf %d+%d but ends outside, creating new mmap",
+ (unsigned long long) src->curoffset, (gint) readsize, (gint) mapstart,
+ (gint) mapsize);
buf = gst_filesrc_map_small_region (src, src->curoffset, readsize);
if (buf == NULL)
- return NULL;
+ return NULL;
}
/* the only other option is that buffer is totally outside, which means we search for it */
/* or the read buffer fully contains the current mmap region */
/* either way, it's really not relevant, we just create a new region anyway */
GST_LOG_OBJECT (src,
- "read buf %llu+%d starts before mapbuf %d+%d, but overlaps it",
- (unsigned long long) src->curoffset, (gint) readsize, (gint) mapstart,
- (gint) mapsize);
+ "read buf %llu+%d starts before mapbuf %d+%d, but overlaps it",
+ (unsigned long long) src->curoffset, (gint) readsize, (gint) mapstart,
+ (gint) mapsize);
buf = gst_filesrc_map_small_region (src, src->curoffset, readsize);
if (buf == NULL)
return NULL;
if (buf == NULL) {
/* first check to see if there's a map that covers the right region already */
GST_LOG_OBJECT (src, "searching for mapbuf to cover %llu+%d",
- src->curoffset, (int) readsize);
+ src->curoffset, (int) readsize);
/* if the read buffer crosses a mmap region boundary, create a one-off region */
if ((src->curoffset / src->mapsize) != (readend / src->mapsize)) {
GST_LOG_OBJECT (src,
- "read buf %llu+%d crosses a %d-byte boundary, creating a one-off",
- src->curoffset, (int) readsize, (int) src->mapsize);
+ "read buf %llu+%d crosses a %d-byte boundary, creating a one-off",
+ src->curoffset, (int) readsize, (int) src->mapsize);
buf = gst_filesrc_map_small_region (src, src->curoffset, readsize);
if (buf == NULL)
- return NULL;
+ return NULL;
/* otherwise we will create a new mmap region and set it to the default */
} else {
off_t nextmap = src->curoffset - (src->curoffset % src->mapsize);
GST_LOG_OBJECT (src,
- "read buf %llu+%d in new mapbuf at %llu+%d, mapping and subbuffering",
- src->curoffset, readsize, nextmap, src->mapsize);
+ "read buf %llu+%d in new mapbuf at %llu+%d, mapping and subbuffering",
+ src->curoffset, readsize, nextmap, src->mapsize);
/* first, we're done with the old mapbuf */
gst_buffer_unref (src->mapbuf);
mapsize = src->mapsize;
/* double the mapsize as long as the readsize is smaller */
while (readsize - (src->curoffset - nextmap) > mapsize) {
- GST_LOG_OBJECT (src, "readsize smaller then mapsize %08x %d",
- readsize, (int) mapsize);
- mapsize <<= 1;
+ GST_LOG_OBJECT (src, "readsize smaller then mapsize %08x %d",
+ readsize, (int) mapsize);
+ mapsize <<= 1;
}
/* create a new one */
src->mapbuf = gst_filesrc_map_region (src, nextmap, mapsize);
if (src->mapbuf == NULL)
- return NULL;
+ return NULL;
/* subbuffer it */
buf =
- gst_buffer_create_sub (src->mapbuf, src->curoffset - nextmap,
- readsize);
+ gst_buffer_create_sub (src->mapbuf, src->curoffset - nextmap,
+ readsize);
GST_BUFFER_OFFSET (buf) =
- GST_BUFFER_OFFSET (src->mapbuf) + src->curoffset - nextmap;
+ GST_BUFFER_OFFSET (src->mapbuf) + src->curoffset - nextmap;
}
}
readsize = src->block_size;
if (src->curoffset + readsize > src->filelen) {
if (!gst_filesrc_check_filesize (src)
- || src->curoffset + readsize > src->filelen) {
+ || src->curoffset + readsize > src->filelen) {
readsize = src->filelen - src->curoffset;
}
}
}
if (ret < readsize) {
GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL),
- ("unexpected end of file."));
+ ("unexpected end of file."));
return NULL;
}
src->seek_happened = FALSE;
GST_DEBUG_OBJECT (src, "sending discont");
event =
- gst_event_new_discontinuous (FALSE, GST_FORMAT_BYTES, src->curoffset,
- NULL);
+ gst_event_new_discontinuous (FALSE, GST_FORMAT_BYTES, src->curoffset,
+ NULL);
return GST_DATA (event);
}
if (src->curoffset == src->filelen) {
if (!gst_filesrc_check_filesize (src) || src->curoffset >= src->filelen) {
GST_DEBUG_OBJECT (src, "eos %" G_GINT64_FORMAT " %" G_GINT64_FORMAT,
- src->curoffset, src->filelen);
+ src->curoffset, src->filelen);
gst_element_set_eos (GST_ELEMENT (src));
return GST_DATA (gst_event_new (GST_EVENT_EOS));
}
if (src->filename == NULL || src->filename[0] == '\0') {
GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND,
- (_("No file name specified for reading.")), (NULL));
+ (_("No file name specified for reading.")), (NULL));
return FALSE;
}
GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND, (NULL), (NULL));
else
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
- (_("Could not open file \"%s\" for reading."), src->filename),
- GST_ERROR_SYSTEM);
+ (_("Could not open file \"%s\" for reading."), src->filename),
+ GST_ERROR_SYSTEM);
return FALSE;
} else {
/* check if it is a regular file, otherwise bail out */
if (!S_ISREG (stat_results.st_mode)) {
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
- (_("File \"%s\" isn't a regular file."), src->filename), (NULL));
+ (_("File \"%s\" isn't a regular file."), src->filename), (NULL));
close (src->fd);
return FALSE;
}
break;
case GST_STATE_READY_TO_PAUSED:
if (!GST_FLAG_IS_SET (element, GST_FILESRC_OPEN)) {
- if (!gst_filesrc_open_file (GST_FILESRC (element)))
- return GST_STATE_FAILURE;
+ if (!gst_filesrc_open_file (GST_FILESRC (element)))
+ return GST_STATE_FAILURE;
}
break;
case GST_STATE_PAUSED_TO_READY:
if (GST_FLAG_IS_SET (element, GST_FILESRC_OPEN))
- gst_filesrc_close_file (GST_FILESRC (element));
+ gst_filesrc_close_file (GST_FILESRC (element));
src->seek_happened = TRUE;
break;
default:
switch (type) {
case GST_QUERY_TOTAL:
if (*format != GST_FORMAT_BYTES) {
- return FALSE;
+ return FALSE;
}
gst_filesrc_check_filesize (src);
*value = src->filelen;
break;
case GST_QUERY_POSITION:
switch (*format) {
- case GST_FORMAT_BYTES:
- *value = src->curoffset;
- break;
- case GST_FORMAT_PERCENT:
- if (src->filelen == 0)
- return FALSE;
- *value = src->curoffset * GST_FORMAT_PERCENT_MAX / src->filelen;
- break;
- default:
- return FALSE;
+ case GST_FORMAT_BYTES:
+ *value = src->curoffset;
+ break;
+ case GST_FORMAT_PERCENT:
+ if (src->filelen == 0)
+ return FALSE;
+ *value = src->curoffset * GST_FORMAT_PERCENT_MAX / src->filelen;
+ break;
+ default:
+ return FALSE;
}
break;
default:
gint64 offset;
if (GST_EVENT_SEEK_FORMAT (event) != GST_FORMAT_BYTES) {
- goto error;
+ goto error;
}
offset = GST_EVENT_SEEK_OFFSET (event);
switch (GST_EVENT_SEEK_METHOD (event)) {
- case GST_SEEK_METHOD_SET:
- if (offset > src->filelen && (!gst_filesrc_check_filesize (src)
- || offset > src->filelen)) {
- goto error;
- }
- src->curoffset = offset;
- GST_DEBUG_OBJECT (src, "seek set pending to %" G_GINT64_FORMAT,
- src->curoffset);
- break;
- case GST_SEEK_METHOD_CUR:
- if (offset + src->curoffset > src->filelen)
- if (!gst_filesrc_check_filesize (src)
- || offset + src->curoffset > src->filelen)
- goto error;
- src->curoffset += offset;
- GST_DEBUG_OBJECT (src, "seek cur pending to %" G_GINT64_FORMAT,
- src->curoffset);
- break;
- case GST_SEEK_METHOD_END:
- if (ABS (offset) > src->filelen) {
- if (!gst_filesrc_check_filesize (src)
- || ABS (offset) > src->filelen)
- goto error;
- goto error;
- }
- src->curoffset = src->filelen - ABS (offset);
- GST_DEBUG_OBJECT (src, "seek end pending to %" G_GINT64_FORMAT,
- src->curoffset);
- break;
- default:
- goto error;
- break;
+ case GST_SEEK_METHOD_SET:
+ if (offset > src->filelen && (!gst_filesrc_check_filesize (src)
+ || offset > src->filelen)) {
+ goto error;
+ }
+ src->curoffset = offset;
+ GST_DEBUG_OBJECT (src, "seek set pending to %" G_GINT64_FORMAT,
+ src->curoffset);
+ break;
+ case GST_SEEK_METHOD_CUR:
+ if (offset + src->curoffset > src->filelen)
+ if (!gst_filesrc_check_filesize (src)
+ || offset + src->curoffset > src->filelen)
+ goto error;
+ src->curoffset += offset;
+ GST_DEBUG_OBJECT (src, "seek cur pending to %" G_GINT64_FORMAT,
+ src->curoffset);
+ break;
+ case GST_SEEK_METHOD_END:
+ if (ABS (offset) > src->filelen) {
+ if (!gst_filesrc_check_filesize (src)
+ || ABS (offset) > src->filelen)
+ goto error;
+ goto error;
+ }
+ src->curoffset = src->filelen - ABS (offset);
+ GST_DEBUG_OBJECT (src, "seek end pending to %" G_GINT64_FORMAT,
+ src->curoffset);
+ break;
+ default:
+ goto error;
+ break;
}
src->seek_happened = TRUE;
src->need_flush = GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_FLUSH;
}
case GST_EVENT_SIZE:
if (GST_EVENT_SIZE_FORMAT (event) != GST_FORMAT_BYTES) {
- goto error;
+ goto error;
}
src->block_size = GST_EVENT_SIZE_VALUE (event);
g_object_notify (G_OBJECT (src), "blocksize");
gst_filesrc_uri_get_protocols (void)
{
static gchar *protocols[] = { "file", NULL };
+
return protocols;
}
static const gchar *
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOOP_BASED,
g_param_spec_boolean ("loop-based", "Loop-based",
- "Set to TRUE to use loop-based rather than chain-based scheduling",
- TRUE, G_PARAM_READWRITE));
+ "Set to TRUE to use loop-based rather than chain-based scheduling",
+ TRUE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SLEEP_TIME,
g_param_spec_uint ("sleep-time", "Sleep time",
- "Microseconds to sleep between processing", 0, G_MAXUINT, 0,
- G_PARAM_READWRITE));
+ "Microseconds to sleep between processing", 0, G_MAXUINT, 0,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DUPLICATE,
g_param_spec_uint ("duplicate", "Duplicate Buffers",
- "Push the buffers N times", 0, G_MAXUINT, 1, G_PARAM_READWRITE));
+ "Push the buffers N times", 0, G_MAXUINT, 1, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ERROR_AFTER,
g_param_spec_int ("error_after", "Error After", "Error after N buffers",
- G_MININT, G_MAXINT, -1, G_PARAM_READWRITE));
+ G_MININT, G_MAXINT, -1, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DROP_PROBABILITY,
g_param_spec_float ("drop_probability", "Drop Probability",
- "The Probability a buffer is dropped", 0.0, 1.0, 0.0,
- G_PARAM_READWRITE));
+ "The Probability a buffer is dropped", 0.0, 1.0, 0.0,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SILENT,
g_param_spec_boolean ("silent", "silent", "silent", FALSE,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LAST_MESSAGE,
g_param_spec_string ("last-message", "last-message", "last-message", NULL,
- G_PARAM_READABLE));
+ G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DUMP,
g_param_spec_boolean ("dump", "Dump", "Dump buffer contents", FALSE,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE));
gst_identity_signals[SIGNAL_HANDOFF] =
g_signal_new ("handoff", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
if (identity->error_after == 0) {
gst_buffer_unref (buf);
GST_ELEMENT_ERROR (identity, CORE, FAILED,
- (_("Failed after iterations as requested.")), (NULL));
+ (_("Failed after iterations as requested.")), (NULL));
return;
}
}
if (identity->drop_probability > 0.0) {
if ((gfloat) (1.0 * rand () / (RAND_MAX)) < identity->drop_probability) {
if (identity->last_message != NULL) {
- g_free (identity->last_message);
+ g_free (identity->last_message);
}
identity->last_message =
- g_strdup_printf ("dropping ******* (%s:%s)i (%d bytes, %"
- G_GINT64_FORMAT ")", GST_DEBUG_PAD_NAME (identity->sinkpad),
- GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf));
+ g_strdup_printf ("dropping ******* (%s:%s)i (%d bytes, %"
+ G_GINT64_FORMAT ")", GST_DEBUG_PAD_NAME (identity->sinkpad),
+ GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf));
g_object_notify (G_OBJECT (identity), "last-message");
gst_buffer_unref (buf);
return;
if (!identity->silent) {
g_free (identity->last_message);
identity->last_message =
- g_strdup_printf ("chain ******* (%s:%s)i (%d bytes, %"
- G_GINT64_FORMAT ")", GST_DEBUG_PAD_NAME (identity->sinkpad),
- GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf));
+ g_strdup_printf ("chain ******* (%s:%s)i (%d bytes, %"
+ G_GINT64_FORMAT ")", GST_DEBUG_PAD_NAME (identity->sinkpad),
+ GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf));
g_object_notify (G_OBJECT (identity), "last-message");
}
g_signal_emit (G_OBJECT (identity), gst_identity_signals[SIGNAL_HANDOFF], 0,
- buf);
+ buf);
if (i > 1)
gst_buffer_ref (buf);
case ARG_LOOP_BASED:
identity->loop_based = g_value_get_boolean (value);
if (identity->loop_based) {
- gst_element_set_loop_function (GST_ELEMENT (identity),
- gst_identity_loop);
- gst_pad_set_chain_function (identity->sinkpad, NULL);
+ gst_element_set_loop_function (GST_ELEMENT (identity),
+ gst_identity_loop);
+ gst_pad_set_chain_function (identity->sinkpad, NULL);
} else {
- gst_pad_set_chain_function (identity->sinkpad, gst_identity_chain);
- gst_element_set_loop_function (GST_ELEMENT (identity), NULL);
+ gst_pad_set_chain_function (identity->sinkpad, gst_identity_chain);
+ gst_element_set_loop_function (GST_ELEMENT (identity), NULL);
}
break;
case ARG_SLEEP_TIME:
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MD5,
g_param_spec_string ("md5", "md5", "current value of the md5 sum",
- "", G_PARAM_READABLE));
+ "", G_PARAM_READABLE));
gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_md5sink_change_state);
}
guchar *md5string = g_malloc0 (33);
for (i = 0; i < 16; ++i)
- sprintf (md5string + i * 2, "%02x", sink->md5[i]);
+ sprintf (md5string + i * 2, "%02x", sink->md5[i]);
g_value_set_string (value, md5string);
g_free (md5string);
}
G_STRUCT_OFFSET (GstMultiFileSrcClass, new_file), NULL, NULL,
g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
- g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOCATIONS, g_param_spec_pointer ("locations", "locations", "locations", G_PARAM_READWRITE)); /* CHECKME */
+ g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LOCATIONS, g_param_spec_pointer ("locations", "locations", "locations", G_PARAM_READWRITE)); /* CHECKME */
gobject_class->set_property = gst_multifilesrc_set_property;
gobject_class->get_property = gst_multifilesrc_get_property;
/* clear the filename if we get a NULL */
if (g_value_get_pointer (value) == NULL) {
- gst_element_set_state (GST_ELEMENT (object), GST_STATE_NULL);
- src->listptr = NULL;
- /* otherwise set the new filenames */
+ gst_element_set_state (GST_ELEMENT (object), GST_STATE_NULL);
+ src->listptr = NULL;
+ /* otherwise set the new filenames */
} else {
- src->listptr = g_value_get_pointer (value);
+ src->listptr = g_value_get_pointer (value);
}
break;
default:
if (src->currentfilename == NULL || src->currentfilename[0] == '\0') {
GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND,
- (_("No file name specified for reading.")), (NULL));
+ (_("No file name specified for reading.")), (NULL));
return FALSE;
}
src->fd = open ((const char *) src->currentfilename, O_RDONLY);
if (src->fd < 0) {
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
- (_("Could not open file \"%s\" for reading."), src->currentfilename),
- GST_ERROR_SYSTEM);
+ (_("Could not open file \"%s\" for reading."), src->currentfilename),
+ GST_ERROR_SYSTEM);
return FALSE;
} else {
if (src->map == NULL) {
close (src->fd);
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY, (NULL),
- ("mmap call failed."));
+ ("mmap call failed."));
return FALSE;
}
GST_FLAG_SET (src, GST_MULTIFILESRC_OPEN);
gobject_class->set_property = gst_pipefilter_set_property;
gobject_class->get_property = gst_pipefilter_get_property;
- g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_COMMAND, g_param_spec_string ("command", "command", "command", NULL, G_PARAM_READWRITE)); /* CHECKME */
+ g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_COMMAND, g_param_spec_string ("command", "command", "command", NULL, G_PARAM_READWRITE)); /* CHECKME */
gstelement_class->change_state = gst_pipefilter_change_state;
}
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
if (close (pipefilter->fdin[1]) < 0)
- perror ("close");
+ perror ("close");
if (close (pipefilter->fdout[0]) < 0)
- perror ("close");
+ perror ("close");
break;
default:
break;
close (src->fdin[1]);
close (src->fdout[0]);
/* child */
- dup2 (src->fdin[0], STDIN_FILENO); /* set the childs input stream */
- dup2 (src->fdout[1], STDOUT_FILENO); /* set the childs output stream */
+ dup2 (src->fdin[0], STDIN_FILENO); /* set the childs input stream */
+ dup2 (src->fdout[1], STDOUT_FILENO); /* set the childs output stream */
execvp (src->command[0], &src->command[0]);
/* will only be reached if execvp has an error */
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY, (NULL), GST_ERROR_SYSTEM);
} else {
if (!GST_FLAG_IS_SET (element, GST_PIPEFILTER_OPEN)) {
if (!gst_pipefilter_open_file (GST_PIPEFILTER (element)))
- return GST_STATE_FAILURE;
+ return GST_STATE_FAILURE;
}
}
{
GstEvent *event;
gboolean ret, handled;
-} GstQueueEventResponse;
+}
+GstQueueEventResponse;
static void gst_queue_base_init (GstQueueClass * klass);
static void gst_queue_class_init (GstQueueClass * klass);
{GST_QUEUE_LEAK_DOWNSTREAM, "2", "Leaky on Downstream"},
{0, NULL, NULL},
};
+
if (!queue_leaky_type) {
queue_leaky_type = g_enum_register_static ("GstQueueLeaky", queue_leaky);
}
};
queue_type = g_type_register_static (GST_TYPE_ELEMENT,
- "GstQueue", &queue_info, 0);
+ "GstQueue", &queue_info, 0);
}
return queue_type;
/* properties */
g_object_class_install_property (gobject_class, ARG_CUR_LEVEL_BYTES,
g_param_spec_uint ("current-level-bytes", "Current level (kB)",
- "Current amount of data in the queue (bytes)",
- 0, G_MAXUINT, 0, G_PARAM_READABLE));
+ "Current amount of data in the queue (bytes)",
+ 0, G_MAXUINT, 0, G_PARAM_READABLE));
g_object_class_install_property (gobject_class, ARG_CUR_LEVEL_BUFFERS,
g_param_spec_uint ("current-level-buffers", "Current level (buffers)",
- "Current number of buffers in the queue",
- 0, G_MAXUINT, 0, G_PARAM_READABLE));
+ "Current number of buffers in the queue",
+ 0, G_MAXUINT, 0, G_PARAM_READABLE));
g_object_class_install_property (gobject_class, ARG_CUR_LEVEL_TIME,
g_param_spec_uint64 ("current-level-time", "Current level (ns)",
- "Current amount of data in the queue (in ns)",
- 0, G_MAXUINT64, 0, G_PARAM_READABLE));
+ "Current amount of data in the queue (in ns)",
+ 0, G_MAXUINT64, 0, G_PARAM_READABLE));
g_object_class_install_property (gobject_class, ARG_MAX_SIZE_BYTES,
g_param_spec_uint ("max-size-bytes", "Max. size (kB)",
- "Max. amount of data in the queue (bytes, 0=disable)",
- 0, G_MAXUINT, 0, G_PARAM_READWRITE));
+ "Max. amount of data in the queue (bytes, 0=disable)",
+ 0, G_MAXUINT, 0, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_MAX_SIZE_BUFFERS,
g_param_spec_uint ("max-size-buffers", "Max. size (buffers)",
- "Max. number of buffers in the queue (0=disable)",
- 0, G_MAXUINT, 0, G_PARAM_READWRITE));
+ "Max. number of buffers in the queue (0=disable)",
+ 0, G_MAXUINT, 0, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_MAX_SIZE_TIME,
g_param_spec_uint64 ("max-size-time", "Max. size (ns)",
- "Max. amount of data in the queue (in ns, 0=disable)",
- 0, G_MAXUINT64, 0, G_PARAM_READWRITE));
+ "Max. amount of data in the queue (in ns, 0=disable)",
+ 0, G_MAXUINT64, 0, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_MIN_THRESHOLD_BYTES,
g_param_spec_uint ("min-threshold-bytes", "Min. threshold (kB)",
- "Min. amount of data in the queue to allow reading (bytes, 0=disable)",
- 0, G_MAXUINT, 0, G_PARAM_READWRITE));
+ "Min. amount of data in the queue to allow reading (bytes, 0=disable)",
+ 0, G_MAXUINT, 0, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_MIN_THRESHOLD_BUFFERS,
g_param_spec_uint ("min-threshold-buffers", "Min. threshold (buffers)",
- "Min. number of buffers in the queue to allow reading (0=disable)",
- 0, G_MAXUINT, 0, G_PARAM_READWRITE));
+ "Min. number of buffers in the queue to allow reading (0=disable)",
+ 0, G_MAXUINT, 0, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_MIN_THRESHOLD_TIME,
g_param_spec_uint64 ("min-threshold-time", "Min. threshold (ns)",
- "Min. amount of data in the queue to allow reading (in ns, 0=disable)",
- 0, G_MAXUINT64, 0, G_PARAM_READWRITE));
+ "Min. amount of data in the queue to allow reading (in ns, 0=disable)",
+ 0, G_MAXUINT64, 0, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_LEAKY,
g_param_spec_enum ("leaky", "Leaky",
- "Where the queue leaks, if at all",
- GST_TYPE_QUEUE_LEAKY, GST_QUEUE_NO_LEAK, G_PARAM_READWRITE));
+ "Where the queue leaks, if at all",
+ GST_TYPE_QUEUE_LEAKY, GST_QUEUE_NO_LEAK, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_MAY_DEADLOCK,
g_param_spec_boolean ("may_deadlock", "May Deadlock",
- "The queue may deadlock if it's full and not PLAYING",
- TRUE, G_PARAM_READWRITE));
+ "The queue may deadlock if it's full and not PLAYING",
+ TRUE, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_BLOCK_TIMEOUT,
g_param_spec_uint64 ("block_timeout", "Timeout for Block",
- "Nanoseconds until blocked queue times out and returns filler event. "
- "Value of -1 disables timeout",
- 0, G_MAXUINT64, -1, G_PARAM_READWRITE));
+ "Nanoseconds until blocked queue times out and returns filler event. "
+ "Value of -1 disables timeout",
+ 0, G_MAXUINT64, -1, G_PARAM_READWRITE));
/* set several parent class virtual functions */
gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_queue_dispose);
GST_DEBUG_FUNCPTR (gst_queue_handle_src_event));
gst_pad_set_active (queue->srcpad, TRUE);
- queue->cur_level.buffers = 0; /* no content */
- queue->cur_level.bytes = 0; /* no content */
- queue->cur_level.time = 0; /* no content */
- queue->max_size.buffers = 100; /* 100 buffers */
- queue->max_size.bytes = 10 * 1024 * 1024; /* 10 MB */
- queue->max_size.time = GST_SECOND; /* 1 s. */
- queue->min_threshold.buffers = 0; /* no threshold */
- queue->min_threshold.bytes = 0; /* no threshold */
- queue->min_threshold.time = 0; /* no threshold */
+ queue->cur_level.buffers = 0; /* no content */
+ queue->cur_level.bytes = 0; /* no content */
+ queue->cur_level.time = 0; /* no content */
+ queue->max_size.buffers = 100; /* 100 buffers */
+ queue->max_size.bytes = 10 * 1024 * 1024; /* 10 MB */
+ queue->max_size.time = GST_SECOND; /* 1 s. */
+ queue->min_threshold.buffers = 0; /* no threshold */
+ queue->min_threshold.bytes = 0; /* no threshold */
+ queue->min_threshold.time = 0; /* no threshold */
queue->leaky = GST_QUEUE_NO_LEAK;
queue->may_deadlock = TRUE;
if (GST_IS_EVENT (data)) {
switch (GST_EVENT_TYPE (data)) {
case GST_EVENT_FLUSH:
- STATUS (queue, "received flush event");
- gst_queue_locked_flush (queue);
- STATUS (queue, "after flush");
- break;
+ STATUS (queue, "received flush event");
+ gst_queue_locked_flush (queue);
+ STATUS (queue, "after flush");
+ break;
case GST_EVENT_EOS:
- STATUS (queue, "received EOS");
- break;
+ STATUS (queue, "received EOS");
+ break;
default:
- /* we put the event in the queue, we don't have to act ourselves */
- GST_CAT_LOG_OBJECT (GST_CAT_DATAFLOW, queue,
- "adding event %p of type %d", data, GST_EVENT_TYPE (data));
- break;
+ /* we put the event in the queue, we don't have to act ourselves */
+ GST_CAT_LOG_OBJECT (GST_CAT_DATAFLOW, queue,
+ "adding event %p of type %d", data, GST_EVENT_TYPE (data));
+ break;
}
}
if (GST_IS_BUFFER (data))
GST_CAT_LOG_OBJECT (GST_CAT_DATAFLOW, queue,
- "adding buffer %p of size %d", data, GST_BUFFER_SIZE (data));
+ "adding buffer %p of size %d", data, GST_BUFFER_SIZE (data));
/* We make space available if we're "full" according to whatever
* the user defined as "full". Note that this only applies to buffers.
* We always handle events and they don't count in our statistics. */
if (GST_IS_BUFFER (data) &&
((queue->max_size.buffers > 0 &&
- queue->cur_level.buffers >= queue->max_size.buffers) ||
- (queue->max_size.bytes > 0 &&
- queue->cur_level.bytes >= queue->max_size.bytes) ||
- (queue->max_size.time > 0 &&
- queue->cur_level.time >= queue->max_size.time))) {
+ queue->cur_level.buffers >= queue->max_size.buffers) ||
+ (queue->max_size.bytes > 0 &&
+ queue->cur_level.bytes >= queue->max_size.bytes) ||
+ (queue->max_size.time > 0 &&
+ queue->cur_level.time >= queue->max_size.time))) {
g_mutex_unlock (queue->qlock);
g_signal_emit (G_OBJECT (queue), gst_queue_signals[SIGNAL_OVERRUN], 0);
g_mutex_lock (queue->qlock);
/* how are we going to make space for this buffer? */
switch (queue->leaky) {
- /* leak current buffer */
+ /* leak current buffer */
case GST_QUEUE_LEAK_UPSTREAM:
- GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
- "queue is full, leaking buffer on upstream end");
- /* now we can clean up and exit right away */
- g_mutex_unlock (queue->qlock);
- goto out_unref;
+ GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
+ "queue is full, leaking buffer on upstream end");
+ /* now we can clean up and exit right away */
+ g_mutex_unlock (queue->qlock);
+ goto out_unref;
- /* leak first buffer in the queue */
+ /* leak first buffer in the queue */
case GST_QUEUE_LEAK_DOWNSTREAM:{
- /* this is a bit hacky. We'll manually iterate the list
- * and find the first buffer from the head on. We'll
- * unref that and "fix up" the GQueue object... */
- GList *item;
- GstData *leak = NULL;
-
- GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
- "queue is full, leaking buffer on downstream end");
-
- for (item = queue->queue->head; item != NULL; item = item->next) {
- if (GST_IS_BUFFER (item->data)) {
- leak = item->data;
- break;
- }
- }
-
- /* if we didn't find anything, it means we have no buffers
- * in here. That cannot happen, since we had >= 1 bufs */
- g_assert (leak);
-
- /* Now remove it from the list, fixing up the GQueue
- * CHECKME: is a queue->head the first or the last item? */
- item = g_list_delete_link (queue->queue->head, item);
- queue->queue->head = g_list_first (item);
- queue->queue->tail = g_list_last (item);
- queue->queue->length--;
-
- /* and unref the data at the end. Twice, because we keep a ref
- * to make things read-only. Also keep our list uptodate. */
- queue->cur_level.bytes -= GST_BUFFER_SIZE (data);
- queue->cur_level.buffers--;
- if (GST_BUFFER_DURATION (data) != GST_CLOCK_TIME_NONE)
- queue->cur_level.time -= GST_BUFFER_DURATION (data);
-
- gst_data_unref (data);
- gst_data_unref (data);
- break;
+ /* this is a bit hacky. We'll manually iterate the list
+ * and find the first buffer from the head on. We'll
+ * unref that and "fix up" the GQueue object... */
+ GList *item;
+ GstData *leak = NULL;
+
+ GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
+ "queue is full, leaking buffer on downstream end");
+
+ for (item = queue->queue->head; item != NULL; item = item->next) {
+ if (GST_IS_BUFFER (item->data)) {
+ leak = item->data;
+ break;
+ }
+ }
+
+ /* if we didn't find anything, it means we have no buffers
+ * in here. That cannot happen, since we had >= 1 bufs */
+ g_assert (leak);
+
+ /* Now remove it from the list, fixing up the GQueue
+ * CHECKME: is a queue->head the first or the last item? */
+ item = g_list_delete_link (queue->queue->head, item);
+ queue->queue->head = g_list_first (item);
+ queue->queue->tail = g_list_last (item);
+ queue->queue->length--;
+
+ /* and unref the data at the end. Twice, because we keep a ref
+ * to make things read-only. Also keep our list uptodate. */
+ queue->cur_level.bytes -= GST_BUFFER_SIZE (data);
+ queue->cur_level.buffers--;
+ if (GST_BUFFER_DURATION (data) != GST_CLOCK_TIME_NONE)
+ queue->cur_level.time -= GST_BUFFER_DURATION (data);
+
+ gst_data_unref (data);
+ gst_data_unref (data);
+ break;
}
default:
- g_warning ("Unknown leaky type, using default");
- /* fall-through */
+ g_warning ("Unknown leaky type, using default");
+ /* fall-through */
- /* don't leak. Instead, wait for space to be available */
+ /* don't leak. Instead, wait for space to be available */
case GST_QUEUE_NO_LEAK:
- STATUS (queue, "pre-full wait");
-
- while ((queue->max_size.buffers > 0 &&
- queue->cur_level.buffers >= queue->max_size.buffers) ||
- (queue->max_size.bytes > 0 &&
- queue->cur_level.bytes >= queue->max_size.bytes) ||
- (queue->max_size.time > 0 &&
- queue->cur_level.time >= queue->max_size.time)) {
- /* if there's a pending state change for this queue
- * or its manager, switch back to iterator so bottom
- * half of state change executes */
- if (queue->interrupt) {
- GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue, "interrupted");
- g_mutex_unlock (queue->qlock);
- if (gst_scheduler_interrupt (gst_pad_get_scheduler (queue->sinkpad),
- GST_ELEMENT (queue))) {
- goto out_unref;
- }
- /* if we got here because we were unlocked after a
- * flush, we don't need to add the buffer to the
- * queue again */
- if (queue->flush) {
- GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
- "not adding pending buffer after flush");
- goto out_unref;
- }
- GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
- "adding pending buffer after interrupt");
- goto restart;
- }
-
- if (GST_STATE (queue) != GST_STATE_PLAYING) {
- /* this means the other end is shut down. Try to
- * signal to resolve the error */
- if (!queue->may_deadlock) {
- g_mutex_unlock (queue->qlock);
- gst_data_unref (data);
- GST_ELEMENT_ERROR (queue, CORE, THREAD, (NULL),
- ("deadlock found, shutting down source pad elements"));
- /* we don't go to out_unref here, since we want to
- * unref the buffer *before* calling GST_ELEMENT_ERROR */
- return;
- } else {
- GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
- "%s: waiting for the app to restart "
- "source pad elements", GST_ELEMENT_NAME (queue));
- }
- }
-
- /* OK, we've got a serious issue here. Imagine the situation
- * where the puller (next element) is sending an event here,
- * so it cannot pull events from the queue, and we cannot
- * push data further because the queue is 'full' and therefore,
- * we wait here (and do not handle events): deadlock! to solve
- * that, we handle pending upstream events here, too. */
- gst_queue_handle_pending_events (queue);
-
- STATUS (queue, "waiting for item_del signal");
- g_cond_wait (queue->item_del, queue->qlock);
- STATUS (queue, "received item_del signal");
- }
-
- STATUS (queue, "post-full wait");
- g_mutex_unlock (queue->qlock);
- g_signal_emit (G_OBJECT (queue), gst_queue_signals[SIGNAL_RUNNING], 0);
- g_mutex_lock (queue->qlock);
- break;
+ STATUS (queue, "pre-full wait");
+
+ while ((queue->max_size.buffers > 0 &&
+ queue->cur_level.buffers >= queue->max_size.buffers) ||
+ (queue->max_size.bytes > 0 &&
+ queue->cur_level.bytes >= queue->max_size.bytes) ||
+ (queue->max_size.time > 0 &&
+ queue->cur_level.time >= queue->max_size.time)) {
+ /* if there's a pending state change for this queue
+ * or its manager, switch back to iterator so bottom
+ * half of state change executes */
+ if (queue->interrupt) {
+ GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue, "interrupted");
+ g_mutex_unlock (queue->qlock);
+ if (gst_scheduler_interrupt (gst_pad_get_scheduler (queue->sinkpad),
+ GST_ELEMENT (queue))) {
+ goto out_unref;
+ }
+ /* if we got here because we were unlocked after a
+ * flush, we don't need to add the buffer to the
+ * queue again */
+ if (queue->flush) {
+ GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
+ "not adding pending buffer after flush");
+ goto out_unref;
+ }
+ GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
+ "adding pending buffer after interrupt");
+ goto restart;
+ }
+
+ if (GST_STATE (queue) != GST_STATE_PLAYING) {
+ /* this means the other end is shut down. Try to
+ * signal to resolve the error */
+ if (!queue->may_deadlock) {
+ g_mutex_unlock (queue->qlock);
+ gst_data_unref (data);
+ GST_ELEMENT_ERROR (queue, CORE, THREAD, (NULL),
+ ("deadlock found, shutting down source pad elements"));
+ /* we don't go to out_unref here, since we want to
+ * unref the buffer *before* calling GST_ELEMENT_ERROR */
+ return;
+ } else {
+ GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
+ "%s: waiting for the app to restart "
+ "source pad elements", GST_ELEMENT_NAME (queue));
+ }
+ }
+
+ /* OK, we've got a serious issue here. Imagine the situation
+ * where the puller (next element) is sending an event here,
+ * so it cannot pull events from the queue, and we cannot
+ * push data further because the queue is 'full' and therefore,
+ * we wait here (and do not handle events): deadlock! to solve
+ * that, we handle pending upstream events here, too. */
+ gst_queue_handle_pending_events (queue);
+
+ STATUS (queue, "waiting for item_del signal");
+ g_cond_wait (queue->item_del, queue->qlock);
+ STATUS (queue, "received item_del signal");
+ }
+
+ STATUS (queue, "post-full wait");
+ g_mutex_unlock (queue->qlock);
+ g_signal_emit (G_OBJECT (queue), gst_queue_signals[SIGNAL_RUNNING], 0);
+ g_mutex_lock (queue->qlock);
+ break;
}
}
if (queue->queue->length == 0 ||
(queue->min_threshold.buffers > 0 &&
- queue->cur_level.buffers < queue->min_threshold.buffers) ||
+ queue->cur_level.buffers < queue->min_threshold.buffers) ||
(queue->min_threshold.bytes > 0 &&
- queue->cur_level.bytes < queue->min_threshold.bytes) ||
+ queue->cur_level.bytes < queue->min_threshold.bytes) ||
(queue->min_threshold.time > 0 &&
- queue->cur_level.time < queue->min_threshold.time)) {
+ queue->cur_level.time < queue->min_threshold.time)) {
g_mutex_unlock (queue->qlock);
g_signal_emit (G_OBJECT (queue), gst_queue_signals[SIGNAL_UNDERRUN], 0);
g_mutex_lock (queue->qlock);
STATUS (queue, "pre-empty wait");
while (queue->queue->length == 0 ||
- (queue->min_threshold.buffers > 0 &&
- queue->cur_level.buffers < queue->min_threshold.buffers) ||
- (queue->min_threshold.bytes > 0 &&
- queue->cur_level.bytes < queue->min_threshold.bytes) ||
- (queue->min_threshold.time > 0 &&
- queue->cur_level.time < queue->min_threshold.time)) {
+ (queue->min_threshold.buffers > 0 &&
+ queue->cur_level.buffers < queue->min_threshold.buffers) ||
+ (queue->min_threshold.bytes > 0 &&
+ queue->cur_level.bytes < queue->min_threshold.bytes) ||
+ (queue->min_threshold.time > 0 &&
+ queue->cur_level.time < queue->min_threshold.time)) {
/* if there's a pending state change for this queue or its
* manager, switch back to iterator so bottom half of state
* change executes. */
if (queue->interrupt) {
- GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue, "interrupted");
- g_mutex_unlock (queue->qlock);
- if (gst_scheduler_interrupt (gst_pad_get_scheduler (queue->srcpad),
- GST_ELEMENT (queue)))
- return GST_DATA (gst_event_new (GST_EVENT_INTERRUPT));
- goto restart;
+ GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue, "interrupted");
+ g_mutex_unlock (queue->qlock);
+ if (gst_scheduler_interrupt (gst_pad_get_scheduler (queue->srcpad),
+ GST_ELEMENT (queue)))
+ return GST_DATA (gst_event_new (GST_EVENT_INTERRUPT));
+ goto restart;
}
if (GST_STATE (queue) != GST_STATE_PLAYING) {
- /* this means the other end is shut down */
- if (!queue->may_deadlock) {
- g_mutex_unlock (queue->qlock);
- GST_ELEMENT_ERROR (queue, CORE, THREAD, (NULL),
- ("deadlock found, shutting down sink pad elements"));
- goto restart;
- } else {
- GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
- "%s: waiting for the app to restart "
- "source pad elements", GST_ELEMENT_NAME (queue));
- }
+ /* this means the other end is shut down */
+ if (!queue->may_deadlock) {
+ g_mutex_unlock (queue->qlock);
+ GST_ELEMENT_ERROR (queue, CORE, THREAD, (NULL),
+ ("deadlock found, shutting down sink pad elements"));
+ goto restart;
+ } else {
+ GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
+ "%s: waiting for the app to restart "
+ "source pad elements", GST_ELEMENT_NAME (queue));
+ }
}
STATUS (queue, "waiting for item_add");
if (queue->block_timeout != GST_CLOCK_TIME_NONE) {
- GTimeVal timeout;
-
- g_get_current_time (&timeout);
- g_time_val_add (&timeout, queue->block_timeout / 1000);
- if (!g_cond_timed_wait (queue->item_add, queue->qlock, &timeout)) {
- g_mutex_unlock (queue->qlock);
- GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
- "Sending filler event");
- return GST_DATA (gst_event_new_filler ());
- }
+ GTimeVal timeout;
+
+ g_get_current_time (&timeout);
+ g_time_val_add (&timeout, queue->block_timeout / 1000);
+ if (!g_cond_timed_wait (queue->item_add, queue->qlock, &timeout)) {
+ g_mutex_unlock (queue->qlock);
+ GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
+ "Sending filler event");
+ return GST_DATA (gst_event_new_filler ());
+ }
} else {
- g_cond_wait (queue->item_add, queue->qlock);
+ g_cond_wait (queue->item_add, queue->qlock);
}
STATUS (queue, "got item_add signal");
}
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
- GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
- "queue \"%s\" eos", GST_ELEMENT_NAME (queue));
- gst_element_set_eos (GST_ELEMENT (queue));
- break;
+ GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
+ "queue \"%s\" eos", GST_ELEMENT_NAME (queue));
+ gst_element_set_eos (GST_ELEMENT (queue));
+ break;
default:
- break;
+ break;
}
}
er.handled = FALSE;
g_queue_push_tail (queue->events, &er);
GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
- "Preparing for loop for event handler");
+ "Preparing for loop for event handler");
/* see the chain function on why this is here - it prevents a deadlock */
g_cond_signal (queue->item_del);
while (!er.handled) {
GTimeVal timeout;
g_get_current_time (&timeout);
- g_time_val_add (&timeout, 500 * 1000); /* half a second */
+ g_time_val_add (&timeout, 500 * 1000); /* half a second */
if (!g_cond_timed_wait (queue->event_done, queue->qlock, &timeout) &&
- !er.handled) {
- GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
- "timeout in upstream event handling");
- /* remove ourselves from the pending list. Since we're
- * locked, others cannot reference this anymore. */
- queue->queue->head = g_list_remove (queue->queue->head, &er);
- queue->queue->head = g_list_first (queue->queue->head);
- queue->queue->tail = g_list_last (queue->queue->head);
- queue->queue->length--;
- res = FALSE;
- goto handled;
+ !er.handled) {
+ GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue,
+ "timeout in upstream event handling");
+ /* remove ourselves from the pending list. Since we're
+ * locked, others cannot reference this anymore. */
+ queue->queue->head = g_list_remove (queue->queue->head, &er);
+ queue->queue->head = g_list_first (queue->queue->head);
+ queue->queue->tail = g_list_last (queue->queue->head);
+ queue->queue->length--;
+ res = FALSE;
+ goto handled;
}
}
GST_CAT_WARNING_OBJECT (GST_CAT_DATAFLOW, queue, "Event handled");
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_FLUSH:
- GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
- "FLUSH event, flushing queue\n");
- gst_queue_locked_flush (queue);
- break;
+ GST_CAT_DEBUG_OBJECT (GST_CAT_DATAFLOW, queue,
+ "FLUSH event, flushing queue\n");
+ gst_queue_locked_flush (queue);
+ break;
case GST_EVENT_SEEK:
- if (GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_FLUSH) {
- gst_queue_locked_flush (queue);
- }
+ if (GST_EVENT_SEEK_FLAGS (event) & GST_SEEK_FLAG_FLUSH) {
+ gst_queue_locked_flush (queue);
+ }
default:
- break;
+ break;
}
}
handled:
break;
case GST_STATE_PAUSED_TO_PLAYING:
if (!GST_PAD_IS_LINKED (queue->sinkpad)) {
- GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, queue,
- "queue %s is not linked", GST_ELEMENT_NAME (queue));
- /* FIXME can this be? */
- g_cond_signal (queue->item_add);
+ GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, queue,
+ "queue %s is not linked", GST_ELEMENT_NAME (queue));
+ /* FIXME can this be? */
+ g_cond_signal (queue->item_add);
- ret = GST_STATE_FAILURE;
- goto error;
+ ret = GST_STATE_FAILURE;
+ goto error;
} else {
- GstScheduler *src_sched, *sink_sched;
+ GstScheduler *src_sched, *sink_sched;
- src_sched = gst_pad_get_scheduler (GST_PAD (queue->srcpad));
- sink_sched = gst_pad_get_scheduler (GST_PAD (queue->sinkpad));
+ src_sched = gst_pad_get_scheduler (GST_PAD (queue->srcpad));
+ sink_sched = gst_pad_get_scheduler (GST_PAD (queue->sinkpad));
- if (src_sched == sink_sched) {
- GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, queue,
- "queue %s does not connect different schedulers",
- GST_ELEMENT_NAME (queue));
+ if (src_sched == sink_sched) {
+ GST_CAT_DEBUG_OBJECT (GST_CAT_STATES, queue,
+ "queue %s does not connect different schedulers",
+ GST_ELEMENT_NAME (queue));
- g_warning ("queue %s does not connect different schedulers",
- GST_ELEMENT_NAME (queue));
+ g_warning ("queue %s does not connect different schedulers",
+ GST_ELEMENT_NAME (queue));
- ret = GST_STATE_FAILURE;
- goto error;
- }
+ ret = GST_STATE_FAILURE;
+ goto error;
+ }
}
queue->interrupt = FALSE;
break;
GstPad *sinkpad;
GstPad *srcpad;
GstBuffer *buffer;
-} GstShaperConnection;
+}
+GstShaperConnection;
GstStaticPadTemplate shaper_src_template = GST_STATIC_PAD_TEMPLATE ("src%d",
GST_PAD_SRC,
{SHAPER_POLICY_BUFFERSIZE, "2", "sync on buffer size"},
{0, NULL, NULL},
};
+
if (!shaper_policy_type) {
shaper_policy_type =
- g_enum_register_static ("GstShaperPolicy", shaper_policy);
+ g_enum_register_static ("GstShaperPolicy", shaper_policy);
}
return shaper_policy_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_POLICY,
g_param_spec_enum ("policy", "Policy", "Shaper policy",
- GST_TYPE_SHAPER_POLICY, SHAPER_POLICY_TIMESTAMPS, G_PARAM_READWRITE));
+ GST_TYPE_SHAPER_POLICY, SHAPER_POLICY_TIMESTAMPS, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SILENT,
g_param_spec_boolean ("silent", "silent", "silent",
- FALSE, G_PARAM_READWRITE));
+ FALSE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LAST_MESSAGE,
g_param_spec_string ("last-message", "last-message", "last-message",
- NULL, G_PARAM_READABLE));
+ NULL, G_PARAM_READABLE));
gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_shaper_set_property);
gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_shaper_get_property);
/* events are simply pushed ASAP */
if (GST_IS_EVENT (buffer)) {
- /* save event type as it will be unreffed after the next push */
- GstEventType type = GST_EVENT_TYPE (buffer);
-
- gst_pad_push (connection->srcpad, GST_DATA (buffer));
-
- switch (type) {
- /* on EOS we disable the pad so that we don't pull on
- * it again and never get more data */
- case GST_EVENT_EOS:
- gst_pad_set_active (connection->sinkpad, FALSE);
- break;
- default:
- break;
- }
+ /* save event type as it will be unreffed after the next push */
+ GstEventType type = GST_EVENT_TYPE (buffer);
+
+ gst_pad_push (connection->srcpad, GST_DATA (buffer));
+
+ switch (type) {
+ /* on EOS we disable the pad so that we don't pull on
+ * it again and never get more data */
+ case GST_EVENT_EOS:
+ gst_pad_set_active (connection->sinkpad, FALSE);
+ break;
+ default:
+ break;
+ }
} else {
- /* we store the buffer */
- connection->buffer = buffer;
+ /* we store the buffer */
+ connection->buffer = buffer;
}
}
/* FIXME policy stuff goes here */
/* find connection with lowest timestamp */
if (min == NULL || (connection->buffer != NULL &&
- (GST_BUFFER_TIMESTAMP (connection->buffer) <
- GST_BUFFER_TIMESTAMP (min->buffer)))) {
+ (GST_BUFFER_TIMESTAMP (connection->buffer) <
+ GST_BUFFER_TIMESTAMP (min->buffer)))) {
min = connection;
}
connections = g_slist_next (connections);
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BUFFERS,
g_param_spec_int64 ("buffers", "buffers", "total buffers count",
- 0, G_MAXINT64, 0, G_PARAM_READABLE));
+ 0, G_MAXINT64, 0, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BYTES,
g_param_spec_int64 ("bytes", "bytes", "total bytes count",
- 0, G_MAXINT64, 0, G_PARAM_READABLE));
+ 0, G_MAXINT64, 0, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_EVENTS,
g_param_spec_int64 ("events", "events", "total event count",
- 0, G_MAXINT64, 0, G_PARAM_READABLE));
+ 0, G_MAXINT64, 0, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass),
ARG_BUFFER_UPDATE_FREQ, g_param_spec_int64 ("buffer_update_freq",
- "buffer update freq", "buffer update frequency", 0, G_MAXINT64, 0,
- G_PARAM_READWRITE));
+ "buffer update freq", "buffer update frequency", 0, G_MAXINT64, 0,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass),
ARG_BYTES_UPDATE_FREQ, g_param_spec_int64 ("bytes_update_freq",
- "bytes update freq", "bytes update frequency", 0, G_MAXINT64, 0,
- G_PARAM_READWRITE));
+ "bytes update freq", "bytes update frequency", 0, G_MAXINT64, 0,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass),
ARG_EVENT_UPDATE_FREQ, g_param_spec_int64 ("event_update_freq",
- "event update freq", "event update frequency", 0, G_MAXINT64, 0,
- G_PARAM_READWRITE));
+ "event update freq", "event update frequency", 0, G_MAXINT64, 0,
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_UPDATE_ON_EOS,
g_param_spec_boolean ("update_on_eos", "update on EOS",
- "update on EOS event", TRUE, G_PARAM_READWRITE));
+ "update on EOS event", TRUE, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_UPDATE,
g_param_spec_boolean ("update", "update", "update", TRUE,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SILENT,
g_param_spec_boolean ("silent", "silent", "silent", TRUE,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE));
gst_statistics_signals[SIGNAL_UPDATE] =
g_signal_new ("update", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
if (GST_EVENT_TYPE (event) == GST_EVENT_EOS) {
gst_element_set_eos (GST_ELEMENT (statistics));
if (statistics->update_on_eos) {
- update = TRUE;
+ update = TRUE;
}
}
if (statistics->update_freq.events) {
statistics->update_count.events += 1;
if (statistics->update_count.events == statistics->update_freq.events) {
- statistics->update_count.events = 0;
- update = TRUE;
+ statistics->update_count.events = 0;
+ update = TRUE;
}
}
} else {
if (statistics->update_freq.buffers) {
statistics->update_count.buffers += 1;
if (statistics->update_count.buffers == statistics->update_freq.buffers) {
- statistics->update_count.buffers = 0;
- update = TRUE;
+ statistics->update_count.buffers = 0;
+ update = TRUE;
}
}
if (statistics->update_freq.bytes) {
statistics->update_count.bytes += GST_BUFFER_SIZE (buf);
if (statistics->update_count.bytes >= statistics->update_freq.bytes) {
- statistics->update_count.bytes = 0;
- update = TRUE;
+ statistics->update_count.bytes = 0;
+ update = TRUE;
}
}
}
if (statistics->update) {
GST_DEBUG ("[%s]: pre update emit", GST_ELEMENT_NAME (statistics));
g_signal_emit (G_OBJECT (statistics),
- gst_statistics_signals[SIGNAL_UPDATE], 0);
+ gst_statistics_signals[SIGNAL_UPDATE], 0);
GST_DEBUG ("[%s]: post update emit", GST_ELEMENT_NAME (statistics));
}
if (!statistics->silent) {
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NUM_PADS,
g_param_spec_int ("num_pads", "num_pads", "num_pads",
- 0, G_MAXINT, 0, G_PARAM_READABLE));
+ 0, G_MAXINT, 0, G_PARAM_READABLE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SILENT,
g_param_spec_boolean ("silent", "silent", "silent",
- TRUE, G_PARAM_CONSTRUCT | G_PARAM_READWRITE));
+ TRUE, G_PARAM_CONSTRUCT | G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LAST_MESSAGE,
g_param_spec_string ("last_message", "last_message", "last_message",
- NULL, G_PARAM_READABLE));
+ NULL, G_PARAM_READABLE));
gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_tee_set_property);
g_assert (GST_IS_PAD (pad));
- return strcmp (name, gst_pad_get_name (pad)); /* returns 0 if match */
+ return strcmp (name, gst_pad_get_name (pad)); /* returns 0 if match */
}
static GstPad *
while (!name) {
name = g_strdup_printf ("src%d", i);
if (g_list_find_custom ((GList *) pads, (gconstpointer) name,
- name_pad_compare) != NULL) {
+ name_pad_compare) != NULL) {
/* this name is taken, use the next one */
++i;
g_free (name);
if (!tee->silent) {
g_free (tee->last_message);
tee->last_message =
- g_strdup_printf ("chain ******* (%s:%s)t (%d bytes, %"
- G_GUINT64_FORMAT ") %p", GST_DEBUG_PAD_NAME (outpad),
- GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf), buf);
+ g_strdup_printf ("chain ******* (%s:%s)t (%d bytes, %"
+ G_GUINT64_FORMAT ") %p", GST_DEBUG_PAD_NAME (outpad),
+ GST_BUFFER_SIZE (buf), GST_BUFFER_TIMESTAMP (buf), buf);
g_object_notify (G_OBJECT (tee), "last_message");
}
};
enum
{
- MODE_NORMAL, /* act as identity */
- MODE_TYPEFIND, /* do typefinding */
+ MODE_NORMAL, /* act as identity */
+ MODE_TYPEFIND, /* do typefinding */
};
g_object_class_install_property (gobject_class, ARG_CAPS,
g_param_spec_boxed ("caps", _("caps"),
- _("detected capabilities in stream"), gst_caps_get_type (),
- G_PARAM_READABLE));
+ _("detected capabilities in stream"), gst_caps_get_type (),
+ G_PARAM_READABLE));
g_object_class_install_property (gobject_class, ARG_MINIMUM,
g_param_spec_uint ("minimum", _("minimum"),
- "minimum probability required to accept caps", GST_TYPE_FIND_MINIMUM,
- GST_TYPE_FIND_MAXIMUM, GST_TYPE_FIND_MINIMUM, G_PARAM_READWRITE));
+ "minimum probability required to accept caps", GST_TYPE_FIND_MINIMUM,
+ GST_TYPE_FIND_MAXIMUM, GST_TYPE_FIND_MINIMUM, G_PARAM_READWRITE));
g_object_class_install_property (gobject_class, ARG_MINIMUM,
g_param_spec_uint ("maximum", _("maximum"),
- "probability to stop typefinding", GST_TYPE_FIND_MINIMUM,
- GST_TYPE_FIND_MAXIMUM, GST_TYPE_FIND_MAXIMUM, G_PARAM_READWRITE));
+ "probability to stop typefinding", GST_TYPE_FIND_MINIMUM,
+ GST_TYPE_FIND_MAXIMUM, GST_TYPE_FIND_MAXIMUM, G_PARAM_READWRITE));
gst_type_find_element_signals[HAVE_TYPE] = g_signal_new ("have_type",
G_TYPE_FROM_CLASS (typefind_class), G_SIGNAL_RUN_LAST,
{
static const GstEventMask mask[] = {
{GST_EVENT_SEEK,
- GST_SEEK_METHOD_SET | GST_SEEK_METHOD_CUR | GST_SEEK_METHOD_END |
- GST_SEEK_FLAG_FLUSH},
+ GST_SEEK_METHOD_SET | GST_SEEK_METHOD_CUR | GST_SEEK_METHOD_END |
+ GST_SEEK_FLAG_FLUSH},
/* add more if you want, event masks suck and need to die anyway */
{0,}
};
GList *buffers;
GstTypeFindElement *self;
-} TypeFindEntry;
+}
+TypeFindEntry;
static inline TypeFindEntry *
new_entry (void)
if (typefind->possibilities != NULL) {
/* this should only happen on PAUSED => READY or EOS */
GST_LOG_OBJECT (typefind, "freeing remaining %u typefind functions",
- g_list_length (typefind->possibilities));
+ g_list_length (typefind->possibilities));
g_list_foreach (typefind->possibilities, (GFunc) free_entry, NULL);
g_list_free (typefind->possibilities);
typefind->possibilities = NULL;
guint size = gst_buffer_store_get_size (typefind->store, 0);
if (size
- && (buffer = gst_buffer_store_get_buffer (typefind->store, 0, size))) {
+ && (buffer = gst_buffer_store_get_buffer (typefind->store, 0, size))) {
GST_LOG_OBJECT (typefind, "pushing cached data (%u bytes)", size);
gst_pad_push (typefind->src, GST_DATA (buffer));
} else {
}
GST_LOG_OBJECT (typefind, "seeking back to current position %u", size);
if (!gst_pad_send_event (GST_PAD_PEER (typefind->sink),
- gst_event_new_seek (GST_SEEK_METHOD_SET | GST_FORMAT_BYTES,
- size))) {
+ gst_event_new_seek (GST_SEEK_METHOD_SET | GST_FORMAT_BYTES,
+ size))) {
GST_WARNING_OBJECT (typefind,
- "could not seek to required position %u, hope for the best", size);
+ "could not seek to required position %u, hope for the best", size);
}
}
gst_buffer_store_clear (typefind->store);
if (!typefind->stream_length_available) {
GST_LOG_OBJECT (entry->self,
- "'%s' called get_length () but we know it's not available",
- GST_PLUGIN_FEATURE_NAME (entry->factory));
+ "'%s' called get_length () but we know it's not available",
+ GST_PLUGIN_FEATURE_NAME (entry->factory));
return 0;
}
if (entry->self->stream_length == 0) {
typefind->stream_length_available =
- gst_pad_query (GST_PAD_PEER (entry->self->sink), GST_QUERY_TOTAL,
- &format, &entry->self->stream_length);
+ gst_pad_query (GST_PAD_PEER (entry->self->sink), GST_QUERY_TOTAL,
+ &format, &entry->self->stream_length);
if (format != GST_FORMAT_BYTES)
typefind->stream_length_available = FALSE;
if (!typefind->stream_length_available) {
GST_DEBUG_OBJECT (entry->self,
- "'%s' called get_length () but it's not available",
- GST_PLUGIN_FEATURE_NAME (entry->factory));
+ "'%s' called get_length () but it's not available",
+ GST_PLUGIN_FEATURE_NAME (entry->factory));
return 0;
} else {
GST_DEBUG_OBJECT (entry->self,
- "'%s' called get_length () and it's %" G_GUINT64_FORMAT " bytes",
- GST_PLUGIN_FEATURE_NAME (entry->factory), entry->self->stream_length);
+ "'%s' called get_length () and it's %" G_GUINT64_FORMAT " bytes",
+ GST_PLUGIN_FEATURE_NAME (entry->factory), entry->self->stream_length);
}
}
/* need to do more? */
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
- /* this should only happen when we got all available data */
- entry =
- (TypeFindEntry *) typefind->possibilities ? typefind->
- possibilities->data : NULL;
- if (entry && entry->probability >= typefind->min_probability) {
- GST_INFO_OBJECT (typefind,
- "'%s' is the best typefind left after we got all data, using it now (probability %u)",
- GST_PLUGIN_FEATURE_NAME (entry->factory), entry->probability);
- g_signal_emit (typefind, gst_type_find_element_signals[HAVE_TYPE], 0,
- entry->probability, entry->caps);
- }
- stop_typefinding (typefind);
- gst_pad_event_default (pad, event);
- break;
+ /* this should only happen when we got all available data */
+ entry =
+ (TypeFindEntry *) typefind->possibilities ? typefind->
+ possibilities->data : NULL;
+ if (entry && entry->probability >= typefind->min_probability) {
+ GST_INFO_OBJECT (typefind,
+ "'%s' is the best typefind left after we got all data, using it now (probability %u)",
+ GST_PLUGIN_FEATURE_NAME (entry->factory), entry->probability);
+ g_signal_emit (typefind, gst_type_find_element_signals[HAVE_TYPE], 0,
+ entry->probability, entry->caps);
+ }
+ stop_typefinding (typefind);
+ gst_pad_event_default (pad, event);
+ break;
default:
- gst_data_unref (GST_DATA (event));
- break;
+ gst_data_unref (GST_DATA (event));
+ break;
}
} else {
gst_pad_event_default (pad, event);
buf = NULL;
} else {
buf =
- gst_buffer_store_get_buffer (entry->self->store, length + offset,
- size);
+ gst_buffer_store_get_buffer (entry->self->store, length + offset,
+ size);
}
}
} else {
if (entry->requested_size == 0) {
GST_LOG_OBJECT (entry->self,
- "setting requested peek (%" G_GINT64_FORMAT ", %u) on '%s'", offset,
- size, GST_PLUGIN_FEATURE_NAME (entry->factory));
+ "setting requested peek (%" G_GINT64_FORMAT ", %u) on '%s'", offset,
+ size, GST_PLUGIN_FEATURE_NAME (entry->factory));
entry->requested_offset = offset;
entry->requested_size = size;
}
gst_buffer_store_add_buffer (typefind->store, GST_BUFFER (data));
current_offset = GST_BUFFER_OFFSET_IS_VALID (data) ?
- GST_BUFFER_OFFSET (data) + GST_BUFFER_SIZE (data) :
- gst_buffer_store_get_size (typefind->store, 0);
+ GST_BUFFER_OFFSET (data) + GST_BUFFER_SIZE (data) :
+ gst_buffer_store_get_size (typefind->store, 0);
gst_data_unref (data);
if (typefind->possibilities == NULL) {
- /* not yet started, get all typefinding functions into our "queue" */
- GList *all_factories = gst_type_find_factory_get_list ();
-
- GST_INFO_OBJECT (typefind, "starting with %u typefinding functions",
- g_list_length ((GList *) all_factories));
-
- all_factories = g_list_sort (all_factories, compare_type_find_factory);
- walk = all_factories;
- while (all_factories) {
- entry = new_entry ();
-
- entry->factory = GST_TYPE_FIND_FACTORY (all_factories->data);
- entry->self = typefind;
- entry->probability = 0;
- typefind->possibilities =
- g_list_prepend (typefind->possibilities, entry);
- all_factories = g_list_next (all_factories);
- }
- g_list_free (all_factories);
+ /* not yet started, get all typefinding functions into our "queue" */
+ GList *all_factories = gst_type_find_factory_get_list ();
+
+ GST_INFO_OBJECT (typefind, "starting with %u typefinding functions",
+ g_list_length ((GList *) all_factories));
+
+ all_factories = g_list_sort (all_factories, compare_type_find_factory);
+ walk = all_factories;
+ while (all_factories) {
+ entry = new_entry ();
+
+ entry->factory = GST_TYPE_FIND_FACTORY (all_factories->data);
+ entry->self = typefind;
+ entry->probability = 0;
+ typefind->possibilities =
+ g_list_prepend (typefind->possibilities, entry);
+ all_factories = g_list_next (all_factories);
+ }
+ g_list_free (all_factories);
}
/* call every typefind function once */
walk = entries = typefind->possibilities;
GST_INFO_OBJECT (typefind, "iterating %u typefinding functions",
- g_list_length (entries));
+ g_list_length (entries));
typefind->possibilities = NULL;
while (walk) {
- find.data = entry = (TypeFindEntry *) walk->data;
- walk = g_list_next (walk);
- entry->probability = 0;
- entry->requested_offset = 0;
- entry->requested_size = 0;
- gst_type_find_factory_call_function (entry->factory, &find);
- free_entry_buffers (entry);
- if (entry->probability == 0 && entry->requested_size == 0) {
- GST_DEBUG_OBJECT (typefind,
- "'%s' was removed - no chance of being the right plugin",
- GST_PLUGIN_FEATURE_NAME (entry->factory));
- free_entry (entry);
- } else if (entry->probability >= typefind->max_probability) {
- /* wooha, got caps */
- GstCaps *found_caps = entry->caps;
- guint probability = entry->probability;
-
- GST_INFO_OBJECT (typefind,
- "'%s' returned %u/%u probability, using it NOW",
- GST_PLUGIN_FEATURE_NAME (entry->factory), probability,
- typefind->max_probability);
- while (walk) {
- free_entry ((TypeFindEntry *) walk->data);
- walk = g_list_next (walk);
- }
- walk = typefind->possibilities;
- while (walk) {
- free_entry (walk->data);
- walk = g_list_next (walk);
- }
- typefind->possibilities = NULL;
- g_list_free (typefind->possibilities);
- g_signal_emit (typefind, gst_type_find_element_signals[HAVE_TYPE], 0,
- probability, found_caps);
- free_entry (entry);
- } else {
- typefind->possibilities =
- g_list_prepend (typefind->possibilities, entry);
- }
+ find.data = entry = (TypeFindEntry *) walk->data;
+ walk = g_list_next (walk);
+ entry->probability = 0;
+ entry->requested_offset = 0;
+ entry->requested_size = 0;
+ gst_type_find_factory_call_function (entry->factory, &find);
+ free_entry_buffers (entry);
+ if (entry->probability == 0 && entry->requested_size == 0) {
+ GST_DEBUG_OBJECT (typefind,
+ "'%s' was removed - no chance of being the right plugin",
+ GST_PLUGIN_FEATURE_NAME (entry->factory));
+ free_entry (entry);
+ } else if (entry->probability >= typefind->max_probability) {
+ /* wooha, got caps */
+ GstCaps *found_caps = entry->caps;
+ guint probability = entry->probability;
+
+ GST_INFO_OBJECT (typefind,
+ "'%s' returned %u/%u probability, using it NOW",
+ GST_PLUGIN_FEATURE_NAME (entry->factory), probability,
+ typefind->max_probability);
+ while (walk) {
+ free_entry ((TypeFindEntry *) walk->data);
+ walk = g_list_next (walk);
+ }
+ walk = typefind->possibilities;
+ while (walk) {
+ free_entry (walk->data);
+ walk = g_list_next (walk);
+ }
+ typefind->possibilities = NULL;
+ g_list_free (typefind->possibilities);
+ g_signal_emit (typefind, gst_type_find_element_signals[HAVE_TYPE], 0,
+ probability, found_caps);
+ free_entry (entry);
+ } else {
+ typefind->possibilities =
+ g_list_prepend (typefind->possibilities, entry);
+ }
}
g_list_free (entries);
/* we may now already have caps or we might be left without functions to try */
if (typefind->caps) {
- stop_typefinding (typefind);
+ stop_typefinding (typefind);
} else if (typefind->possibilities == NULL) {
- GST_ELEMENT_ERROR (typefind, STREAM, TYPE_NOT_FOUND, (NULL), (NULL));
+ GST_ELEMENT_ERROR (typefind, STREAM, TYPE_NOT_FOUND, (NULL), (NULL));
} else {
- /* set up typefind element for next iteration */
- typefind->possibilities =
- g_list_sort (typefind->possibilities, compare_type_find_entry);
-
- /* look for typefind functions that require data without seeking */
- for (walk = typefind->possibilities; walk; walk = g_list_next (walk)) {
- entry = (TypeFindEntry *) walk->data;
- if (entry->requested_offset <= current_offset &&
- entry->requested_offset + entry->requested_size > current_offset)
- break;
- }
- if (!walk) {
- /* find out if we should seek */
- for (walk = typefind->possibilities; walk; walk = g_list_next (walk)) {
- entry = (TypeFindEntry *) walk->data;
- if (entry->requested_size > 0) {
- /* FIXME: need heuristic to find out if we should seek */
- gint64 seek_offset;
- GstEvent *event;
-
- seek_offset =
- entry->requested_offset >
- 0 ? entry->
- requested_offset : find_element_get_length (entry) +
- entry->requested_offset;
- seek_offset +=
- gst_buffer_store_get_size (typefind->store, seek_offset);
- event =
- gst_event_new_seek (GST_FORMAT_BYTES | GST_SEEK_METHOD_SET,
- seek_offset);
- if (gst_pad_send_event (GST_PAD_PEER (typefind->sink), event)) {
- /* done seeking */
- GST_DEBUG_OBJECT (typefind,
- "'%s' was reset - seeked to %" G_GINT64_FORMAT,
- GST_PLUGIN_FEATURE_NAME (entry->factory), seek_offset);
- break;
- } else if (entry->requested_offset < 0) {
- /* impossible to seek */
- GST_DEBUG_OBJECT (typefind,
- "'%s' was reset - couldn't seek to %" G_GINT64_FORMAT,
- GST_PLUGIN_FEATURE_NAME (entry->factory), seek_offset);
- entry->requested_size = 0;
- entry->requested_offset = 0;
- }
- }
- }
- }
- /* throw out all entries that can't get more data */
- walk = g_list_next (typefind->possibilities);
- while (walk) {
- GList *cur = walk;
-
- entry = (TypeFindEntry *) walk->data;
- walk = g_list_next (walk);
- if (entry->requested_size == 0) {
- GST_DEBUG_OBJECT (typefind,
- "'%s' was removed - higher possibilities available",
- GST_PLUGIN_FEATURE_NAME (entry->factory));
- free_entry (entry);
- typefind->possibilities =
- g_list_delete_link (typefind->possibilities, cur);
- }
- }
- if (g_list_next (typefind->possibilities) == NULL) {
- entry = (TypeFindEntry *) typefind->possibilities->data;
- if (entry->probability > typefind->min_probability) {
- GST_INFO_OBJECT (typefind,
- "'%s' is the only typefind left, using it now (probability %u)",
- GST_PLUGIN_FEATURE_NAME (entry->factory), entry->probability);
- g_signal_emit (typefind, gst_type_find_element_signals[HAVE_TYPE],
- 0, entry->probability, entry->caps);
- free_entry (entry);
- g_list_free (typefind->possibilities);
- typefind->possibilities = NULL;
- stop_typefinding (typefind);
- }
- }
+ /* set up typefind element for next iteration */
+ typefind->possibilities =
+ g_list_sort (typefind->possibilities, compare_type_find_entry);
+
+ /* look for typefind functions that require data without seeking */
+ for (walk = typefind->possibilities; walk; walk = g_list_next (walk)) {
+ entry = (TypeFindEntry *) walk->data;
+ if (entry->requested_offset <= current_offset &&
+ entry->requested_offset + entry->requested_size > current_offset)
+ break;
+ }
+ if (!walk) {
+ /* find out if we should seek */
+ for (walk = typefind->possibilities; walk; walk = g_list_next (walk)) {
+ entry = (TypeFindEntry *) walk->data;
+ if (entry->requested_size > 0) {
+ /* FIXME: need heuristic to find out if we should seek */
+ gint64 seek_offset;
+ GstEvent *event;
+
+ seek_offset =
+ entry->requested_offset >
+ 0 ? entry->
+ requested_offset : find_element_get_length (entry) +
+ entry->requested_offset;
+ seek_offset +=
+ gst_buffer_store_get_size (typefind->store, seek_offset);
+ event =
+ gst_event_new_seek (GST_FORMAT_BYTES | GST_SEEK_METHOD_SET,
+ seek_offset);
+ if (gst_pad_send_event (GST_PAD_PEER (typefind->sink), event)) {
+ /* done seeking */
+ GST_DEBUG_OBJECT (typefind,
+ "'%s' was reset - seeked to %" G_GINT64_FORMAT,
+ GST_PLUGIN_FEATURE_NAME (entry->factory), seek_offset);
+ break;
+ } else if (entry->requested_offset < 0) {
+ /* impossible to seek */
+ GST_DEBUG_OBJECT (typefind,
+ "'%s' was reset - couldn't seek to %" G_GINT64_FORMAT,
+ GST_PLUGIN_FEATURE_NAME (entry->factory), seek_offset);
+ entry->requested_size = 0;
+ entry->requested_offset = 0;
+ }
+ }
+ }
+ }
+ /* throw out all entries that can't get more data */
+ walk = g_list_next (typefind->possibilities);
+ while (walk) {
+ GList *cur = walk;
+
+ entry = (TypeFindEntry *) walk->data;
+ walk = g_list_next (walk);
+ if (entry->requested_size == 0) {
+ GST_DEBUG_OBJECT (typefind,
+ "'%s' was removed - higher possibilities available",
+ GST_PLUGIN_FEATURE_NAME (entry->factory));
+ free_entry (entry);
+ typefind->possibilities =
+ g_list_delete_link (typefind->possibilities, cur);
+ }
+ }
+ if (g_list_next (typefind->possibilities) == NULL) {
+ entry = (TypeFindEntry *) typefind->possibilities->data;
+ if (entry->probability > typefind->min_probability) {
+ GST_INFO_OBJECT (typefind,
+ "'%s' is the only typefind left, using it now (probability %u)",
+ GST_PLUGIN_FEATURE_NAME (entry->factory), entry->probability);
+ g_signal_emit (typefind, gst_type_find_element_signals[HAVE_TYPE],
+ 0, entry->probability, entry->caps);
+ free_entry (entry);
+ g_list_free (typefind->possibilities);
+ typefind->possibilities = NULL;
+ stop_typefinding (typefind);
+ }
+ }
}
break;
}
gint nformats;
GstFormat *format;
GArray *array;
-} GstFileIndexId;
+}
+GstFileIndexId;
typedef struct _GstFileIndex GstFileIndex;
typedef struct _GstFileIndexClass GstFileIndexClass;
gint next_id;
GHashTable *id_index;
- GstIndexEntry *ret_entry; /* hack to avoid leaking memory */
+ GstIndexEntry *ret_entry; /* hack to avoid leaking memory */
};
struct _GstFileIndexClass
(GInstanceInitFunc) gst_file_index_init,
NULL
};
+
file_index_type =
- g_type_register_static (GST_TYPE_INDEX, "GstFileIndex",
- &file_index_info, 0);
+ g_type_register_static (GST_TYPE_INDEX, "GstFileIndex",
+ &file_index_info, 0);
}
return file_index_type;
}
g_object_class_install_property (gobject_class, ARG_LOCATION,
g_param_spec_string ("location", "File Location",
- "Location of the index file", NULL, G_PARAM_READWRITE));
+ "Location of the index file", NULL, G_PARAM_READWRITE));
}
static void
g_hash_table_destroy (index->id_index);
index->id_index = NULL;
- gst_index_entry_free (index->ret_entry); /* hack */
+ gst_index_entry_free (index->ret_entry); /* hack */
G_OBJECT_CLASS (parent_class)->dispose (object);
}
if (match) {
GST_CAT_WARNING_OBJECT (DC, index, "Duplicate matches for writer '%s'",
- writer_string);
+ writer_string);
continue;
}
if (cx.ii) {
match = TRUE;
GST_CAT_DEBUG_OBJECT (DC, index, "Resolved writer '%s' again",
- writer_string);
+ writer_string);
} else
GST_CAT_WARNING_OBJECT (DC, index, "Can't resolve writer '%s'",
- writer_string);
+ writer_string);
}
return match;
xmlNodePtr writer;
for (writer = part->children; writer; writer = writer->next) {
- xmlChar *datafile = xmlGetProp (writer, "datafile");
- gchar *path = g_strdup_printf ("%s/%s", index->location, datafile);
- int fd;
- GstFileIndexId *id_index;
- xmlNodePtr wpart;
- xmlChar *entries_str;
- gpointer array_data;
-
- free (datafile);
-
- fd = open (path, O_RDONLY);
- g_free (path);
- if (fd < 0) {
- GST_CAT_ERROR_OBJECT (DC, index,
- "Can't open '%s': %s", path, strerror (errno));
- continue;
- }
-
- id_index = g_new0 (GstFileIndexId, 1);
- id_index->id_desc = xmlGetProp (writer, "id");
-
- for (wpart = writer->children; wpart; wpart = wpart->next) {
- if (strcmp (wpart->name, "formats") == 0) {
- xmlChar *count_str = xmlGetProp (wpart, "count");
- gint fx = 0;
- xmlNodePtr format;
-
- id_index->nformats = atoi (count_str);
- free (count_str);
-
- id_index->format = g_new (GstFormat, id_index->nformats);
-
- for (format = wpart->children; format; format = format->next) {
- xmlChar *nick = xmlGetProp (format, "nick");
- GstFormat fmt = gst_format_get_by_nick (nick);
-
- if (fmt == GST_FORMAT_UNDEFINED)
- GST_CAT_ERROR_OBJECT (DC, index, "format '%s' undefined", nick);
- g_assert (fx < id_index->nformats);
- id_index->format[fx++] = fmt;
- free (nick);
- }
- } else
- GST_CAT_INFO_OBJECT (DC, index, "unknown wpart '%s'", wpart->name);
- }
-
- g_assert (id_index->nformats > 0);
- _fc_alloc_array (id_index);
- g_assert (id_index->array->data == NULL); /* little bit risky */
-
- entries_str = xmlGetProp (writer, "entries");
- id_index->array->len = atoi (entries_str);
- free (entries_str);
-
- array_data =
- mmap (NULL, ARRAY_TOTAL_SIZE (id_index), PROT_READ, MAP_SHARED, fd,
- 0);
- close (fd);
- if (array_data == MAP_FAILED) {
- GST_CAT_ERROR_OBJECT (DC, index,
- "mmap %s failed: %s", path, strerror (errno));
- continue;
- }
-
- id_index->array->data = array_data;
-
- index->unresolved = g_slist_prepend (index->unresolved, id_index);
+ xmlChar *datafile = xmlGetProp (writer, "datafile");
+ gchar *path = g_strdup_printf ("%s/%s", index->location, datafile);
+ int fd;
+ GstFileIndexId *id_index;
+ xmlNodePtr wpart;
+ xmlChar *entries_str;
+ gpointer array_data;
+
+ free (datafile);
+
+ fd = open (path, O_RDONLY);
+ g_free (path);
+ if (fd < 0) {
+ GST_CAT_ERROR_OBJECT (DC, index,
+ "Can't open '%s': %s", path, strerror (errno));
+ continue;
+ }
+
+ id_index = g_new0 (GstFileIndexId, 1);
+ id_index->id_desc = xmlGetProp (writer, "id");
+
+ for (wpart = writer->children; wpart; wpart = wpart->next) {
+ if (strcmp (wpart->name, "formats") == 0) {
+ xmlChar *count_str = xmlGetProp (wpart, "count");
+ gint fx = 0;
+ xmlNodePtr format;
+
+ id_index->nformats = atoi (count_str);
+ free (count_str);
+
+ id_index->format = g_new (GstFormat, id_index->nformats);
+
+ for (format = wpart->children; format; format = format->next) {
+ xmlChar *nick = xmlGetProp (format, "nick");
+ GstFormat fmt = gst_format_get_by_nick (nick);
+
+ if (fmt == GST_FORMAT_UNDEFINED)
+ GST_CAT_ERROR_OBJECT (DC, index, "format '%s' undefined", nick);
+ g_assert (fx < id_index->nformats);
+ id_index->format[fx++] = fmt;
+ free (nick);
+ }
+ } else
+ GST_CAT_INFO_OBJECT (DC, index, "unknown wpart '%s'", wpart->name);
+ }
+
+ g_assert (id_index->nformats > 0);
+ _fc_alloc_array (id_index);
+ g_assert (id_index->array->data == NULL); /* little bit risky */
+
+ entries_str = xmlGetProp (writer, "entries");
+ id_index->array->len = atoi (entries_str);
+ free (entries_str);
+
+ array_data =
+ mmap (NULL, ARRAY_TOTAL_SIZE (id_index), PROT_READ, MAP_SHARED, fd,
+ 0);
+ close (fd);
+ if (array_data == MAP_FAILED) {
+ GST_CAT_ERROR_OBJECT (DC, index,
+ "mmap %s failed: %s", path, strerror (errno));
+ continue;
+ }
+
+ id_index->array->data = array_data;
+
+ index->unresolved = g_slist_prepend (index->unresolved, id_index);
}
} else
GST_CAT_INFO_OBJECT (DC, index, "unknown part '%s'", part->name);
switch (prop_id) {
case ARG_LOCATION:
if (index->location)
- g_free (index->location);
+ g_free (index->location);
index->location = g_value_dup_string (value);
if (index->location && !g_hash_table_size (index->id_index))
- gst_file_index_load (index);
+ gst_file_index_load (index);
break;
}
}
xmlSetProp (writer, "id", ii->id_desc);
g_snprintf (buf, bufsize, "%d", ii->array->len);
xmlSetProp (writer, "entries", buf);
- g_snprintf (buf, bufsize, "%d", ii->id); /* any unique number is OK */
+ g_snprintf (buf, bufsize, "%d", ii->id); /* any unique number is OK */
xmlSetProp (writer, "datafile", buf);
formats = xmlNewChild (writer, NULL, "formats", NULL);
if (mkdir (index->location, 0777) && errno != EEXIST) {
GST_CAT_ERROR_OBJECT (DC, index,
- "mkdir %s: %s", index->location, strerror (errno));
+ "mkdir %s: %s", index->location, strerror (errno));
return;
}
if (cmp == 0) {
/* if there are multiple matches then scan for the first match */
while (mid > 0 &&
- (*compare) (sample, ary->data + (mid - 1) * stride, user_data) == 0)
- --mid;
+ (*compare) (sample, ary->data + (mid - 1) * stride, user_data) == 0)
+ --mid;
if (ret)
- *ret = mid;
+ *ret = mid;
return TRUE;
}
if (cmp < 0) {
if (ret)
- *ret = tx;
+ *ret = tx;
return FALSE;
}
if (cmp == 0) {
if (ret)
- *ret = tx;
+ *ret = tx;
return TRUE;
}
}
id_index->nformats = GST_INDEX_NASSOCS (entry);
GST_CAT_LOG_OBJECT (DC, fileindex, "creating %d formats for %d",
- id_index->nformats, entry->id);
+ id_index->nformats, entry->id);
id_index->format = g_new (GstFormat, id_index->nformats);
for (fx = 0; fx < id_index->nformats; fx++)
id_index->format[fx] = GST_INDEX_ASSOC_FORMAT (entry, fx);
/* only sanity checking */
if (id_index->nformats != GST_INDEX_NASSOCS (entry))
GST_CAT_WARNING_OBJECT (DC, fileindex, "arity change %d -> %d",
- id_index->nformats, GST_INDEX_NASSOCS (entry));
+ id_index->nformats, GST_INDEX_NASSOCS (entry));
else {
gint fx;
for (fx = 0; fx < id_index->nformats; fx++)
- if (id_index->format[fx] != GST_INDEX_ASSOC_FORMAT (entry, fx))
- GST_CAT_WARNING_OBJECT (DC, fileindex, "format[%d] changed %d -> %d",
- fx, id_index->format[fx], GST_INDEX_ASSOC_FORMAT (entry, fx));
+ if (id_index->format[fx] != GST_INDEX_ASSOC_FORMAT (entry, fx))
+ GST_CAT_WARNING_OBJECT (DC, fileindex, "format[%d] changed %d -> %d",
+ fx, id_index->format[fx], GST_INDEX_ASSOC_FORMAT (entry, fx));
}
}
if (exact) {
/* maybe overwrite instead? */
GST_CAT_DEBUG_OBJECT (DC, index,
- "Ignoring duplicate index association at %lld",
- GST_INDEX_ASSOC_VALUE (entry, 0));
+ "Ignoring duplicate index association at %lld",
+ GST_INDEX_ASSOC_VALUE (entry, 0));
return;
}
break;
case GST_INDEX_ENTRY_OBJECT:
GST_CAT_ERROR_OBJECT (DC, index,
- "gst_file_index_add_object not implemented");
+ "gst_file_index_add_object not implemented");
break;
case GST_INDEX_ENTRY_FORMAT:
/*
GST_INDEX_ENTRY_* can probably go away.
*/
GST_CAT_DEBUG_OBJECT (DC, index,
- "gst_file_index_add_format not implemented");
+ "gst_file_index_add_format not implemented");
break;
default:
break;
if (formatx == -1) {
GST_CAT_WARNING_OBJECT (DC, fileindex,
- "%s, format %d not available", __FUNCTION__, format);
+ "%s, format %d not available", __FUNCTION__, format);
return NULL;
}
return NULL;
else if (method == GST_INDEX_LOOKUP_BEFORE) {
if (mx == 0)
- return NULL;
+ return NULL;
mx -= 1;
} else if (method == GST_INDEX_LOOKUP_AFTER) {
if (mx == id_index->array->len)
- return NULL;
+ return NULL;
}
}
if (method != GST_INDEX_LOOKUP_EXACT)
while ((GINT32_FROM_BE (ARRAY_ROW_FLAGS (row_data)) & flags) != flags) {
if (method == GST_INDEX_LOOKUP_BEFORE)
- mx -= 1;
+ mx -= 1;
else if (method == GST_INDEX_LOOKUP_AFTER)
- mx += 1;
+ mx += 1;
if (mx < 0 || mx >= id_index->array->len)
- return NULL;
+ return NULL;
row_data = id_index->array->data + mx * ARRAY_ROW_SIZE (id_index);
}
GstFormat format;
gint offset;
GTree *tree;
-} GstMemIndexFormatIndex;
+}
+GstMemIndexFormatIndex;
typedef struct
{
gint id;
GHashTable *format_index;
-} GstMemIndexId;
+}
+GstMemIndexId;
typedef struct _GstMemIndex GstMemIndex;
typedef struct _GstMemIndexClass GstMemIndexClass;
(GInstanceInitFunc) gst_mem_index_init,
NULL
};
+
mem_index_type =
- g_type_register_static (GST_TYPE_INDEX, "GstMemIndex", &mem_index_info,
- 0);
+ g_type_register_static (GST_TYPE_INDEX, "GstMemIndex", &mem_index_info,
+ 0);
}
return mem_index_type;
}
gint64 low_diff;
GstIndexEntry *higher;
gint64 high_diff;
-} GstMemIndexSearchData;
+}
+GstMemIndexSearchData;
static gint
mem_index_search (gconstpointer a, gconstpointer b)
entry = NULL;
while (l_entry) {
- entry = (GstIndexEntry *) l_entry->data;
+ entry = (GstIndexEntry *) l_entry->data;
- if (entry->id == id && (GST_INDEX_ASSOC_FLAGS (entry) & flags) == flags)
- break;
+ if (entry->id == id && (GST_INDEX_ASSOC_FLAGS (entry) & flags) == flags)
+ break;
- if (method == GST_INDEX_LOOKUP_BEFORE)
- l_entry = g_list_next (l_entry);
- else if (method == GST_INDEX_LOOKUP_AFTER) {
- l_entry = g_list_previous (l_entry);
- }
+ if (method == GST_INDEX_LOOKUP_BEFORE)
+ l_entry = g_list_next (l_entry);
+ else if (method == GST_INDEX_LOOKUP_AFTER) {
+ l_entry = g_list_previous (l_entry);
+ }
}
}
}
#include "gstmempool.h"
-#include <string.h> /* memset */
+#include <string.h> /* memset */
#ifdef __SMP__
#define POOL_LOCK "lock ; "
__asm__ __volatile__ ("1: \t"
" movl %2, (%1) \n"
POOL_LOCK "cmpxchg %1, %0 \n\t"
- " jnz 1b \n\t"::"m"
- (*mem_pool), "r" (pool), "a" (mem_pool->free));
+ " jnz 1b \n\t"::
+ "m" (*mem_pool), "r" (pool), "a" (mem_pool->free));
#else
g_mutex_lock (mem_pool->chunk_lock);
pool->link = (GstMemPoolElement *) mem_pool->free;
if ((count % print_del) == 0) {
g_print ("%07d:%08" G_GUINT64_FORMAT " min:%08" G_GUINT64_FORMAT " max:%08"
- G_GUINT64_FORMAT " avg:%08" G_GUINT64_FORMAT " avg-s:0.%09d\r", count,
- d, min, max, avg, avg_ns);
+ G_GUINT64_FORMAT " avg:%08" G_GUINT64_FORMAT " avg-s:0.%09d\r", count,
+ d, min, max, avg, avg_ns);
}
}
g_object_set (G_OBJECT (ident), "silent", TRUE, NULL);
gst_bin_add (GST_BIN (pipeline), GST_ELEMENT (ident));
gst_pad_link (gst_element_get_pad (last, "src"),
- gst_element_get_pad (ident, "sink"));
+ gst_element_get_pad (ident, "sink"));
last = ident;
}
if (argc < 3) {
fprintf (stderr,
- "usage: %s iterations print_del mhz test_name [test_params...]\n",
- argv[0]);
+ "usage: %s iterations print_del mhz test_name [test_params...]\n",
+ argv[0]);
for (i = 0; tests[i].name; i++) {
fprintf (stderr, " %s %s\n", tests[i].name, tests[i].params);
}
-#include <string.h> /* strerror */
-#include <stdlib.h> /* strerror */
+#include <string.h> /* strerror */
+#include <stdlib.h> /* strerror */
#include <gst/gst.h>
#define MAX_THREADS 100
-#include <string.h> /* memset */
-#include <stdlib.h> /* memset */
+#include <string.h> /* memset */
+#include <stdlib.h> /* memset */
#include "gstmemchunk.h"
#ifdef __SMP__
__asm__ __volatile__ ("1: \t"
" movl %2, (%1) \n"
CHUNK_LOCK "cmpxchg %1, %0 \n\t"
- " jnz 1b \n\t"::"m"
- (*mem_chunk), "r" (chunk), "a" (mem_chunk->free));
+ " jnz 1b \n\t"::
+ "m" (*mem_chunk), "r" (chunk), "a" (mem_chunk->free));
#else
fprintf (stderr, "This only compiles correctly on i386. Sorry\n");
abort ();
-#include <string.h> /* strerror */
-#include <stdlib.h> /* strerror */
+#include <string.h> /* strerror */
+#include <stdlib.h> /* strerror */
#include <gst/gst.h>
#include "gstmemchunk.h"
else
/* else we use our hardcoded caps as an exazmple */
toset = GST_CAPS_NEW ("testcaps", "test/test", "prop", GST_PROPS_INT (2)
- );
+ );
res = gst_pad_relink_filtered (pad, peer, toset);
if (!res) {
gboolean cut_start_signalled = FALSE;
gboolean cut_stop_signalled = FALSE;
-int id = 0; /* increment this for each new cut */
+int id = 0; /* increment this for each new cut */
GstElement *main_bin;
GstElement *audiosrc;
GstElement *queue;
ct = localtime (&seconds);
/* sprintf (buffer, "/news/incoming/audio/cutter.%06d.wav", id); */
sprintf (buffer,
- "/news/incoming/audio/cutter.%04d%02d%02d.%02d%02d%02d.wav",
- ct->tm_year + 1900, ct->tm_mon, ct->tm_mday, ct->tm_hour, ct->tm_min,
- ct->tm_sec);
+ "/news/incoming/audio/cutter.%04d%02d%02d.%02d%02d%02d.wav",
+ ct->tm_year + 1900, ct->tm_mon, ct->tm_mday, ct->tm_hour, ct->tm_min,
+ ct->tm_sec);
}
g_print ("DEBUG: cut_start: setting new location to %s\n", buffer);
g_object_set (G_OBJECT (disksink), "location", buffer, NULL);
return -1;
}
- pipeline =
- (GstElement *)
+ pipeline = (GstElement *)
gst_parse_launch ("filesrc name=my_filesrc ! mad ! osssink", &error);
if (!pipeline) {
fprintf (stderr, "Parse error: %s", error->message);
char buffer[20];
- GList *input_channels; /* structure holding all the input channels */
+ GList *input_channels; /* structure holding all the input channels */
input_channel_t *channel_in;
GstElement *adder;
GstElement *audiosink;
- GstPad *pad; /* to request pads for the adder */
+ GstPad *pad; /* to request pads for the adder */
gst_init (&argc, &argv);
/* first song gets special treatment for end style */
env_register_cp (channel_in->volenv, 0.0, 1.0);
} else {
- env_register_cp (channel_in->volenv, 0.0, 0.0000001); /* start muted */
- env_register_cp (channel_in->volenv, i * 10.0 - 15.0, 0.0000001); /* start fade in */
+ env_register_cp (channel_in->volenv, 0.0, 0.0000001); /* start muted */
+ env_register_cp (channel_in->volenv, i * 10.0 - 15.0, 0.0000001); /* start fade in */
env_register_cp (channel_in->volenv, i * 10.0 - 10.0, 1.0);
}
- env_register_cp (channel_in->volenv, i * 10.0 - 5.0, 1.0); /* end of full level */
+ env_register_cp (channel_in->volenv, i * 10.0 - 5.0, 1.0); /* end of full level */
if (i != num_channels) {
- env_register_cp (channel_in->volenv, i * 10.0, 0.0000001); /* fade to black */
- env_register_cp (channel_in->volenv, num_channels * 10.0 - 5.0, 0.0000001); /* start fade in */
+ env_register_cp (channel_in->volenv, i * 10.0, 0.0000001); /* fade to black */
+ env_register_cp (channel_in->volenv, num_channels * 10.0 - 5.0, 0.0000001); /* start fade in */
}
- env_register_cp (channel_in->volenv, num_channels * 10.0, 1.0 / num_channels); /* to end level */
+ env_register_cp (channel_in->volenv, num_channels * 10.0, 1.0 / num_channels); /* to end level */
#ifndef GST_DISABLE_LOADSAVE
gst_xml_write_file (GST_ELEMENT (main_bin), fopen ("mixer.xml", "w"));
input_channel_t *channel;
- char buffer[20]; /* hold the names */
+ char buffer[20]; /* hold the names */
/* GstAutoplug *autoplug;
GstCaps *srccaps; */
* can have. They can be quite complex, but for this example plugin
* they are rather simple.
*/
-GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink", /* The name of the pad */
- GST_PAD_SINK, /* Direction of the pad */
- GST_PAD_ALWAYS, /* The pad exists for every instance */
- GST_STATIC_CAPS ("unknown/unknown, " /* The MIME media type */
- "foo:int=1, " /* an integer property */
- "bar:boolean=true, " /* a boolean property */
- "baz:int={ 1, 3 }" /* a list of values */
+GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink", /* The name of the pad */
+ GST_PAD_SINK, /* Direction of the pad */
+ GST_PAD_ALWAYS, /* The pad exists for every instance */
+ GST_STATIC_CAPS ("unknown/unknown, " /* The MIME media type */
+ "foo:int=1, " /* an integer property */
+ "bar:boolean=true, " /* a boolean property */
+ "baz:int={ 1, 3 }" /* a list of values */
)
);
0,
(GInstanceInitFunc) gst_example_init,
};
+
example_type =
- g_type_register_static (GST_TYPE_ELEMENT, "GstExample", &example_info,
- 0);
+ g_type_register_static (GST_TYPE_ELEMENT, "GstExample", &example_info,
+ 0);
}
return example_type;
}
/* Here we add an argument to the object. This argument is an integer,
* and can be both read and written.
*/
- g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ACTIVE, g_param_spec_int ("active", "active", "active", G_MININT, G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
+ g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ACTIVE, g_param_spec_int ("active", "active", "active", G_MININT, G_MAXINT, 0, G_PARAM_READWRITE)); /* CHECKME */
/* Here we add a signal to the object. This is avery useless signal
* called asdf. The signal will also pass a pointer to the listeners
/* Then copy the data in the incoming buffer into the new buffer. */
memcpy (GST_BUFFER_DATA (outbuf), GST_BUFFER_DATA (buf),
- GST_BUFFER_SIZE (outbuf));
+ GST_BUFFER_SIZE (outbuf));
/* we don't need the incomming buffer anymore so we unref it. When we are
* the last plugin with a handle to the buffer, its memory will be freed */
* when compared to similar plugins and the GType identifier.
*/
if (!gst_element_register (plugin, "example", GST_RANK_MARGINAL,
- GST_TYPE_EXAMPLE))
+ GST_TYPE_EXAMPLE))
return FALSE;
/* Now we can return successfully. */
* The symbol pointing to this structure is the only symbol looked up when
* loading the plugin.
*/
-GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, /* The major version of the core that this was built with */
- GST_VERSION_MINOR, /* The minor version of the core that this was built with */
- "example", /* The name of the plugin. This must be unique: plugins with
- * the same name will be assumed to be identical, and only
- * one will be loaded. */
- "an example plugin", /* a short description of the plugin in English */
- plugin_init, /* Pointer to the initialisation function for the plugin. */
- "0.1", /* The version number of the plugin */
- "LGPL", /* ieffective license the plugin can be shipped with. Must be
- * valid for all libraries it links to, too. */
+GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, /* The major version of the core that this was built with */
+ GST_VERSION_MINOR, /* The minor version of the core that this was built with */
+ "example", /* The name of the plugin. This must be unique: plugins with
+ * the same name will be assumed to be identical, and only
+ * one will be loaded. */
+ "an example plugin", /* a short description of the plugin in English */
+ plugin_init, /* Pointer to the initialisation function for the plugin. */
+ "0.1", /* The version number of the plugin */
+ "LGPL", /* ieffective license the plugin can be shipped with. Must be
+ * valid for all libraries it links to, too. */
"my nifty plugin package",
/* package this plugin belongs to. */
"http://www.mydomain.com"
g_assert (filesink);
/* set the filenames */
- filename = g_strdup_printf ("%s.temp", argv[1]); /* easy solution */
+ filename = g_strdup_printf ("%s.temp", argv[1]); /* easy solution */
g_object_set (G_OBJECT (filesrc), "location", argv[1], NULL);
g_object_set (G_OBJECT (filesink), "location", filename, NULL);
g_assert (filesink);
/* set the filenames */
- filename = g_strdup_printf ("%s.ogg", argv[1]); /* easy solution */
+ filename = g_strdup_printf ("%s.ogg", argv[1]); /* easy solution */
g_object_set (G_OBJECT (filesrc), "location", argv[1], NULL);
g_object_set (G_OBJECT (filesink), "location", filename, NULL);
g_free (filename);
xmlNodePtr nodes = children->xmlChildrenNode;
while (nodes) {
- if (!strcmp (nodes->name, "text")) {
- gchar *name = g_strdup (xmlNodeGetContent (nodes));
+ if (!strcmp (nodes->name, "text")) {
+ gchar *name = g_strdup (xmlNodeGetContent (nodes));
- g_print ("object %s loaded with comment '%s'\n",
- gst_object_get_name (object), name);
- }
- nodes = nodes->next;
+ g_print ("object %s loaded with comment '%s'\n",
+ gst_object_get_name (object), name);
+ }
+ nodes = nodes->next;
}
}
children = children->next;
};
bstest_type =
- g_type_register_static (GST_TYPE_ELEMENT, "BSTest", &bstest_info, 0);
+ g_type_register_static (GST_TYPE_ELEMENT, "BSTest", &bstest_info, 0);
}
return bstest_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SIZEMIN,
g_param_spec_int ("sizemin", "sizemin", "sizemin", 0, G_MAXINT,
- 0, G_PARAM_READWRITE));
+ 0, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SIZEMAX,
g_param_spec_int ("sizemax", "sizemax", "sizemax", 0, G_MAXINT,
- 384, G_PARAM_READWRITE));
+ 384, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ACCESSPATTERN,
g_param_spec_string ("accesspattern", "accesspattern", "accesspattern",
- "r", G_PARAM_READWRITE));
+ "r", G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_COUNT,
g_param_spec_uint ("count", "count", "count",
- 0, G_MAXUINT, 0, G_PARAM_READWRITE));
+ 0, G_MAXUINT, 0, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SILENT,
g_param_spec_boolean ("silent", "silent", "silent",
- FALSE, G_PARAM_READWRITE));
+ FALSE, G_PARAM_READWRITE));
gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_bstest_set_property);
gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_bstest_get_property);
size = bstest->sizemax;
} else if (sizestring[0] == 'r') {
size =
- bstest->sizemin +
- (guint8) (((gfloat) bstest->sizemax) * rand () / (RAND_MAX +
- (gfloat) bstest->sizemin));
+ bstest->sizemin +
+ (guint8) (((gfloat) bstest->sizemax) * rand () / (RAND_MAX +
+ (gfloat) bstest->sizemin));
} else if (sizestring[0] == '<') {
size = prevsize;
} else {
buf = NULL;
if (bstest->patterns[i][0] == 'r') {
- size = gst_bstest_get_size (bstest, &bstest->patterns[i][1], size);
- if (!bstest->silent)
- g_print ("bstest: ***** read %d bytes\n", size);
- gst_bytestream_read (bstest->bs, &buf, size);
+ size = gst_bstest_get_size (bstest, &bstest->patterns[i][1], size);
+ if (!bstest->silent)
+ g_print ("bstest: ***** read %d bytes\n", size);
+ gst_bytestream_read (bstest->bs, &buf, size);
} else if (bstest->patterns[i][0] == 'f') {
- size = gst_bstest_get_size (bstest, &bstest->patterns[i][1], size);
- if (!bstest->silent)
- g_print ("bstest: ***** flush %d bytes\n", size);
- gst_bytestream_flush (bstest->bs, size);
+ size = gst_bstest_get_size (bstest, &bstest->patterns[i][1], size);
+ if (!bstest->silent)
+ g_print ("bstest: ***** flush %d bytes\n", size);
+ gst_bytestream_flush (bstest->bs, size);
} else if (!strncmp (bstest->patterns[i], "pb", 2)) {
- size = gst_bstest_get_size (bstest, &bstest->patterns[i][2], size);
- if (!bstest->silent)
- g_print ("bstest: ***** peek bytes %d bytes\n", size);
- gst_bytestream_peek_bytes (bstest->bs, &ptr, size);
+ size = gst_bstest_get_size (bstest, &bstest->patterns[i][2], size);
+ if (!bstest->silent)
+ g_print ("bstest: ***** peek bytes %d bytes\n", size);
+ gst_bytestream_peek_bytes (bstest->bs, &ptr, size);
} else if (bstest->patterns[i][0] == 'p') {
- size = gst_bstest_get_size (bstest, &bstest->patterns[i][1], size);
- if (!bstest->silent)
- g_print ("bstest: ***** peek %d bytes\n", size);
- gst_bytestream_peek (bstest->bs, &buf, size);
- gst_buffer_unref (buf);
- buf = NULL;
+ size = gst_bstest_get_size (bstest, &bstest->patterns[i][1], size);
+ if (!bstest->silent)
+ g_print ("bstest: ***** peek %d bytes\n", size);
+ gst_bytestream_peek (bstest->bs, &buf, size);
+ gst_buffer_unref (buf);
+ buf = NULL;
}
if (buf)
- gst_pad_push (bstest->srcpad, GST_DATA (buf));
+ gst_pad_push (bstest->srcpad, GST_DATA (buf));
i++;
}
break;
case ARG_ACCESSPATTERN:
if (bstest->accesspattern) {
- g_free (bstest->accesspattern);
- g_strfreev (bstest->patterns);
+ g_free (bstest->accesspattern);
+ g_strfreev (bstest->patterns);
}
if (g_value_get_string (value) == NULL) {
- gst_element_set_state (GST_ELEMENT (object), GST_STATE_NULL);
- bstest->accesspattern = NULL;
- bstest->num_patterns = 0;
+ gst_element_set_state (GST_ELEMENT (object), GST_STATE_NULL);
+ bstest->accesspattern = NULL;
+ bstest->num_patterns = 0;
} else {
- guint i = 0;
+ guint i = 0;
- bstest->accesspattern = g_strdup (g_value_get_string (value));
- bstest->patterns = g_strsplit (bstest->accesspattern, ":", 0);
- while (bstest->patterns[i++]);
- bstest->num_patterns = i - 1;
+ bstest->accesspattern = g_strdup (g_value_get_string (value));
+ bstest->patterns = g_strsplit (bstest->accesspattern, ":", 0);
+ while (bstest->patterns[i++]);
+ bstest->num_patterns = i - 1;
}
break;
case ARG_COUNT:
gchar *bs_accesspattern;
gboolean integrity_check;
-} TestParam;
+}
+TestParam;
static GSList *params = NULL;
guint8 *ptr = GST_BUFFER_DATA (buf);
for (i = 0; i < GST_BUFFER_SIZE (buf); i++) {
- if (*ptr++ != count++) {
- g_print ("data error!\n");
- return;
- }
+ if (*ptr++ != count++) {
+ g_print ("data error!\n");
+ return;
+ }
}
}
} else {
continue;
if (sscanf (line, scan_str, &data, &sizetype, pattern,
- &integrity_check) != 4) {
+ &integrity_check) != 4) {
g_print ("error on line: %d\n", linenr);
res = FALSE;
break;
if (percent != prev_percent || newvm - vm > VM_THRES) {
g_print ("\r%d (delta %d) %.3d%% ", newvm, newvm - vm,
- percent);
+ percent);
prev_percent = percent;
vm = newvm;
}
g_free (desc);
g_object_set (G_OBJECT (src), "data", param->src_data,
- "sizetype", param->src_sizetype,
- "filltype", (integrity_check ? 5 : 0), "silent", !verbose, NULL);
+ "sizetype", param->src_sizetype,
+ "filltype", (integrity_check ? 5 : 0), "silent", !verbose, NULL);
g_object_set (G_OBJECT (bs), "accesspattern", param->bs_accesspattern,
- "silent", !verbose, NULL);
+ "silent", !verbose, NULL);
g_object_set (G_OBJECT (sink), "dump", dump, "silent", !verbose, NULL);
if (gst_caps_is_any (caps)) {
return gst_caps_new_simple ("application/x-foo",
- "field", GST_TYPE_INT_RANGE, 1, 10, NULL);
+ "field", GST_TYPE_INT_RANGE, 1, 10, NULL);
}
return NULL;
caps =
gst_caps_new_full (gst_structure_new ("audio/raw", "_int", G_TYPE_INT,
- 100, NULL), gst_structure_new ("audio/raw2", "_int", G_TYPE_INT, 100,
- NULL), NULL);
+ 100, NULL), gst_structure_new ("audio/raw2", "_int", G_TYPE_INT, 100,
+ NULL), NULL);
g_assert (caps != NULL);
g_assert (gst_caps_is_empty (caps) == FALSE);
g_assert (gst_caps_is_any (caps) == FALSE);
caps1 =
gst_caps_new_full (gst_structure_new ("audio/raw", "_int", G_TYPE_INT,
- 100, NULL), gst_structure_new ("audio/raw", "_int", G_TYPE_INT, 200,
- NULL), NULL);
+ 100, NULL), gst_structure_new ("audio/raw", "_int", G_TYPE_INT, 200,
+ NULL), NULL);
caps2 =
gst_caps_new_full (gst_structure_new ("audio/raw", "_int", G_TYPE_INT,
- 100, NULL), gst_structure_new ("audio/raw", "_int", G_TYPE_INT, 300,
- NULL), NULL);
+ 100, NULL), gst_structure_new ("audio/raw", "_int", G_TYPE_INT, 300,
+ NULL), NULL);
caps = gst_caps_intersect (caps1, caps2);
g_print ("%s\n", gst_caps_to_string (caps));
gst_caps_free (caps);
("video/x-raw-yuv, format=(fourcc)YUY2, framerate=(double)[0,1.79769e+308], width=(int)[0,2147483647], height=(int)[0,2147483647]; video/x-raw-yuv, format=(fourcc)UYVY, framerate=(double)[0,1.79769e+308], width=(int)[0,2147483647], height=(int)[0,2147483647]");
GstStaticCaps rawcaps6 =
-GST_STATIC_CAPS
+ GST_STATIC_CAPS
("video/x-raw-yuv, format=(fourcc)YUY2, width=(int)320, height=(int)240");
GstStaticCaps rawcaps7 =
-GST_STATIC_CAPS
+ GST_STATIC_CAPS
("video/x-raw-yuv, format=(fourcc)YUY2, width=(int)[0,2147483647], height=(int)[0,2147483647], framerate=(double)[0,1.79769e+308]");
GstStaticCaps rawcaps8 =
-GST_STATIC_CAPS
+ GST_STATIC_CAPS
("video/x-raw-yuv, format=(fourcc)YUY2, width=(int)320, height=(int)240");
caps1 = gst_caps_copy (gst_static_caps_get (&rawcaps1));
caps2 =
gst_caps_new_full (gst_structure_copy (gst_caps_get_structure
- (gst_static_caps_get (&rawcaps1), 0)), NULL);
+ (gst_static_caps_get (&rawcaps1), 0)), NULL);
#if 0
gst_caps_set (caps1, "height", GST_PROPS_INT (640));
"height=(int)640, " "width=(int)480, " "framerate=(double)30.0");
GstStaticCaps rawcaps7 =
-GST_STATIC_CAPS
+ GST_STATIC_CAPS
("video/x-raw-yuv, format=(fourcc)YUY2, width=(int)[1,2147483647], height=(int)[1,2147483647], framerate=(double)[0,1.79769e+308]");
GstStaticCaps rawcaps8 =
-GST_STATIC_CAPS
+ GST_STATIC_CAPS
("video/x-raw-yuv, format=(fourcc){ I420, YV12, YUY2 }, width=(int)[16,4096], height=(int)[16,4096], framerate=(double)[0,1.79769e+308]");
int
caps = gst_caps_intersect (gst_static_caps_get (&rawcaps6),
gst_caps_new_full (gst_structure_copy (gst_caps_get_structure
- (gst_static_caps_get (&rawcaps6), 0)), NULL));
+ (gst_static_caps_get (&rawcaps6), 0)), NULL));
parent = xmlNewChild (doc->xmlRootNode, NULL, "Capabilities5", NULL);
gst_caps_save_thyself (caps, parent);
gint i = 1000;
gint step = 100;
- free (malloc (8)); /* -lefence */
+ free (malloc (8)); /* -lefence */
gst_init (&argc, &argv);
gint i = 1000;
gint step = 100;
- free (malloc (8)); /* -lefence */
+ free (malloc (8)); /* -lefence */
gst_init (&argc, &argv);
gint i = 10000;
gint step = 100;
- free (malloc (8)); /* -lefence */
+ free (malloc (8)); /* -lefence */
gst_init (&argc, &argv);
GstElement *fakesrc;
gint i;
- free (malloc (8)); /* -lefence */
+ free (malloc (8)); /* -lefence */
gst_init (&argc, &argv);
gint step = 100;
- free (malloc (8)); /* -lefence */
+ free (malloc (8)); /* -lefence */
gst_init (&argc, &argv);
g_assert (strcmp (gst_debug_category_get_name (cat), "cat") == 0);
g_assert (gst_debug_category_get_color (cat) == GST_DEBUG_FG_GREEN);
g_assert (strcmp (gst_debug_category_get_description (cat),
- "default category for this test") == 0);
+ "default category for this test") == 0);
g_assert (gst_debug_category_get_threshold (cat) ==
gst_debug_get_default_threshold ());
g_assert (strcmp (gst_debug_category_get_name (cat_static),
- "cat_static") == 0);
+ "cat_static") == 0);
g_assert (gst_debug_category_get_color (cat_static) | GST_DEBUG_FG_GREEN);
g_assert (gst_debug_category_get_color (cat_static) | GST_DEBUG_BG_RED);
g_assert (gst_debug_category_get_color (cat_static) | GST_DEBUG_BOLD);
g_assert (strcmp (gst_debug_category_get_description (cat_static),
- "static category for this test") == 0);
+ "static category for this test") == 0);
g_assert (gst_debug_category_get_threshold (cat_static) ==
gst_debug_get_default_threshold ());
/* check if setting levels for names work */
command = g_strdup_printf ("%s %s %d", argv[0], lines[i], i);
g_print ("running \"%s\"\n", command);
g_assert (g_spawn_command_line_sync (command, NULL, NULL, &exit,
- NULL) == TRUE);
+ NULL) == TRUE);
g_assert (exit == 0);
g_print ("\"%s\" worked as expected.\n", command);
g_free (command);
gst_init (&argc, &argv);
if (argc != 2) {
g_print
- ("something funny happened to the command line arguments, aborting.\n");
+ ("something funny happened to the command line arguments, aborting.\n");
return 1;
}
gst_debug_remove_log_function (gst_debug_log_default);
GST_DEBUG_CATEGORY_INIT (cat_static, "cat_static", 0, "static category");
switch (argv[1][0]) {
case '0':
- g_assert (gst_debug_is_active () == FALSE);
- gst_debug_add_log_function (debug_not_reached, NULL);
- GST_ERROR ("This will not be seen");
- return 0;
+ g_assert (gst_debug_is_active () == FALSE);
+ gst_debug_add_log_function (debug_not_reached, NULL);
+ GST_ERROR ("This will not be seen");
+ return 0;
case '1':
- return gst_debug_is_colored ()? 1 : 0;
+ return gst_debug_is_colored ()? 1 : 0;
case '2':
- g_assert (gst_debug_get_default_threshold () == 4);
- g_assert (gst_debug_category_get_threshold (cat) == 4);
- return 0;
+ g_assert (gst_debug_get_default_threshold () == 4);
+ g_assert (gst_debug_category_get_threshold (cat) == 4);
+ return 0;
case '3':
- g_assert (gst_debug_get_default_threshold () == GST_LEVEL_DEFAULT);
- g_assert (gst_debug_category_get_threshold (cat) == 4);
- g_assert (gst_debug_category_get_threshold (cat_static) == 3);
- return 0;
+ g_assert (gst_debug_get_default_threshold () == GST_LEVEL_DEFAULT);
+ g_assert (gst_debug_category_get_threshold (cat) == 4);
+ g_assert (gst_debug_category_get_threshold (cat_static) == 3);
+ return 0;
case '4':
- g_assert (gst_debug_get_default_threshold () == 4);
- g_assert (gst_debug_category_get_threshold (cat) == 4);
- g_assert (gst_debug_category_get_threshold (cat_static) == 5);
- return 0;
+ g_assert (gst_debug_get_default_threshold () == 4);
+ g_assert (gst_debug_category_get_threshold (cat) == 4);
+ g_assert (gst_debug_category_get_threshold (cat_static) == 5);
+ return 0;
default:
- g_print ("usupported command, aborting...\n");
- return -1;
+ g_print ("usupported command, aborting...\n");
+ return -1;
}
}
g_assert_not_reached ();
GObject * object, gchar * message, gpointer thread) G_GNUC_NO_INSTRUMENT;
static void
- gst_debug_log_one (GstDebugCategory * category, GstDebugLevel level,
+ gst_debug_log_one (GstDebugCategory * category, GstDebugLevel level,
const gchar * file, const gchar * function, gint line, GObject * object,
gchar * message, gpointer thread)
{
g_print ("creating %d threads\n", THREAD_COUNT);
for (i = 0; i < THREAD_COUNT; i++) {
g_assert ((threads[i] =
- g_thread_create (thread_main, GINT_TO_POINTER (i), TRUE, NULL)));
+ g_thread_create (thread_main, GINT_TO_POINTER (i), TRUE, NULL)));
}
g_print ("joining %d threads\n", THREAD_COUNT);
for (i = 0; i < THREAD_COUNT; i++) {
};
dptest_type =
- g_type_register_static (GST_TYPE_ELEMENT, "GstDpTest", &dptest_info, 0);
+ g_type_register_static (GST_TYPE_ELEMENT, "GstDpTest", &dptest_info, 0);
}
return dptest_type;
}
gst_dpman_add_required_dparam_direct (dptest->dpman,
g_param_spec_float ("float1", "float1", "float1",
- 0.0, 1.0, 0.5, G_PARAM_READWRITE), "float", &(dptest->float1)
+ 0.0, 1.0, 0.5, G_PARAM_READWRITE), "float", &(dptest->float1)
);
dptest->float1 = 0.0;
/* we expect this to give an error */
if (gst_bin_iterate (GST_BIN (pipeline)) != FALSE) {
g_warning
- ("Iterating a bin with unlinked elements should return FALSE !\n");
+ ("Iterating a bin with unlinked elements should return FALSE !\n");
retval = 1;
}
g_assert (GST_IS_ELEMENT (element));
g_assert (gst_element_get_name (element) != NULL);
g_print ("Created identity element with name %s\n",
- gst_element_get_name (element));
+ gst_element_get_name (element));
}
g_print ("Done !\n");
return 0;
/* compare */
if (sizemin_set != sizemin_get) {
g_print ("sizemin: set value %d differs from returned value %d\n",
- sizemin_set, sizemin_get);
+ sizemin_set, sizemin_get);
retval = 1;
} else
g_print ("name: set right\n");
if (silent_set != silent_get) {
g_print ("silent: set value %s differs from returned value %s\n",
- silent_set ? "TRUE" : "FALSE", silent_get ? "TRUE" : "FALSE");
+ silent_set ? "TRUE" : "FALSE", silent_get ? "TRUE" : "FALSE");
retval = 1;
} else
g_print ("silent: set right\n");
if (strcmp (name_set, name_get) != 0) {
g_print ("name: set value %s differs from returned value %s\n",
- name_set, name_get);
+ name_set, name_get);
retval = 1;
} else
g_print ("name: set right\n");
g_print ("OK (not found)\n");
else
g_print ("FAIL - no index entry found for %lld %s, expecting %lld\n",
- src_value, def->nick, expecting);
+ src_value, def->nick, expecting);
}
}
gint64 src_value;
GstFormat dest_format;
gint64 expecting;
-} GstIndexTestCase;
+}
+GstIndexTestCase;
const static GstIndexTestCase cases[] = {
{GST_INDEX_LOOKUP_EXACT, GST_FORMAT_BYTES, 3, GST_FORMAT_TIME, 3000},
{GST_INDEX_LOOKUP_AFTER, GST_FORMAT_TIME, 0, GST_FORMAT_BYTES, 0},
{GST_INDEX_LOOKUP_BEFORE, GST_FORMAT_TIME, -1, GST_FORMAT_BYTES, -1},
{GST_INDEX_LOOKUP_BEFORE, GST_FORMAT_TIME, G_MAXINT64, GST_FORMAT_BYTES,
- 99999},
+ 99999},
{GST_INDEX_LOOKUP_AFTER, GST_FORMAT_TIME, G_MAXINT64, GST_FORMAT_BYTES, -1},
};
for (i = 0; i < 100000; i++) {
gst_index_add_association (index, 0, 0, GST_FORMAT_BYTES, (gint64) i,
- GST_FORMAT_TIME, (gint64) (i * 1000), 0);
+ GST_FORMAT_TIME, (gint64) (i * 1000), 0);
}
g_print ("Testing index...\n");
for (i = 0; i < (sizeof (cases) / sizeof (GstIndexTestCase)); i++) {
lookup (index, cases[i].method, cases[i].src_format, cases[i].src_value,
- cases[i].dest_format, cases[i].expecting);
+ cases[i].dest_format, cases[i].expecting);
}
return 0;
while (1) {
gint fx;
GstIndexEntry *entry =
- gst_index_get_assoc_entry (index, id, GST_INDEX_LOOKUP_AFTER, 0,
- GST_FORMAT_TIME, cur);
+ gst_index_get_assoc_entry (index, id, GST_INDEX_LOOKUP_AFTER, 0,
+ GST_FORMAT_TIME, cur);
if (!entry)
break;
const GstFormatDefinition *def = gst_format_get_details (fmt);
if (fmt == GST_FORMAT_TIME) {
- cur = GST_INDEX_ASSOC_VALUE (entry, fx) + 1;
- g_print (" time %.4f",
- GST_INDEX_ASSOC_VALUE (entry, fx) / (double) GST_SECOND);
+ cur = GST_INDEX_ASSOC_VALUE (entry, fx) + 1;
+ g_print (" time %.4f",
+ GST_INDEX_ASSOC_VALUE (entry, fx) / (double) GST_SECOND);
} else
- g_print (" %s %lld", def->nick, GST_INDEX_ASSOC_VALUE (entry, fx));
+ g_print (" %s %lld", def->nick, GST_INDEX_ASSOC_VALUE (entry, fx));
}
g_print ("\n");
}
* - if multiple toplevel elements exist, a pipeline is returned
*/
TEST_START (PIPELINE3);
- TEST_CHECK_FAIL (GST_BIN (cur)->numchildren == 3); /* a bit hacky here */
+ TEST_CHECK_FAIL (GST_BIN (cur)->numchildren == 3); /* a bit hacky here */
TEST_CHECK_FAIL (GST_IS_PIPELINE (cur));
TEST_OK;
for (i = 0; i < iters; i++) {
padtempl =
- gst_pad_template_new ("sink%d", GST_PAD_SINK, GST_PAD_SOMETIMES, NULL);
+ gst_pad_template_new ("sink%d", GST_PAD_SINK, GST_PAD_SOMETIMES, NULL);
gst_object_unref (GST_OBJECT (padtempl));
}
g_print ("%d padtemplates create/unref %ld\n", iters, vmsize () - usage1);
for (i = 0; i < iters; i++) {
padtempl =
- gst_pad_template_new ("sink%d", GST_PAD_SINK, GST_PAD_SOMETIMES, NULL);
+ gst_pad_template_new ("sink%d", GST_PAD_SINK, GST_PAD_SOMETIMES, NULL);
pad = gst_pad_new_from_template (padtempl, "sink1");
gst_object_unref (GST_OBJECT (pad));
}
if (element == NULL) {
g_warning
- ("Could not run test, because element type \"%s\" is not installed. Please retry when it is. Assuming it works for now...",
- type);
+ ("Could not run test, because element type \"%s\" is not installed. Please retry when it is. Assuming it works for now...",
+ type);
exit (1);
}
g_assert (sink);
g_signal_connect (G_OBJECT (sink), "handoff",
- G_CALLBACK (change_state), pipeline);
+ G_CALLBACK (change_state), pipeline);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
g_print ("running ...\n");
while (gst_bin_iterate (GST_BIN (pipeline)));
/* connect state change signal */
id = g_signal_connect (G_OBJECT (thread), "state_change",
- G_CALLBACK (state_changed), NULL);
+ G_CALLBACK (state_changed), NULL);
construct_pipeline (thread);
g_print ("Setting thread to play\n");
/* connect state change signal */
id = g_signal_connect (G_OBJECT (thread), "state_change",
- G_CALLBACK (state_changed), NULL);
+ G_CALLBACK (state_changed), NULL);
construct_pipeline (thread, i / 10 + 1);
g_print ("Setting thread to play with %d identities\n", i / 10 + 1);
g_error ("Failed setting thread to play\n");
} else {
g_print ("Going into the main GStreamer loop\n");
- can_quit = TRUE; /* we don't want gst_main_quit called before gst_main */
+ can_quit = TRUE; /* we don't want gst_main_quit called before gst_main */
gst_main ();
}
running = FALSE;
/* connect state change signal */
id = g_signal_connect (G_OBJECT (thread), "state_change",
- G_CALLBACK (state_changed), NULL);
+ G_CALLBACK (state_changed), NULL);
construct_pipeline (thread, i / RUNS_PER_IDENTITY + 1);
g_print ("Setting thread to play with %d identities\n",
- i / RUNS_PER_IDENTITY + 1);
+ i / RUNS_PER_IDENTITY + 1);
done = FALSE;
if (gst_element_set_state (thread, GST_STATE_PLAYING) == GST_STATE_FAILURE) {
g_warning ("failed to go to PLAYING");
} else {
g_print ("Waiting for thread PLAYING->PAUSED\n");
- while (!done) /* do nothing */
- ;
+ while (!done) /* do nothing */
+ ;
}
running = FALSE;
g_print ("Coming out of the main GStreamer loop\n");
g_print ("Created GThread\n");
g_print ("Waiting for thread PLAYING->PAUSED\n");
- while (!done) /* do nothing */
+ while (!done) /* do nothing */
;
running = FALSE;
g_print ("Unreffing pipeline\n");
switch (state) {
case 0:
if (GST_BUFFER_TIMESTAMP (*data) == 10) {
- gst_element_set_state (GST_ELEMENT (bin), GST_STATE_PAUSED);
-
- gst_element_unlink_pads (GST_ELEMENT (src1), "src", sink, "sink");
- gst_bin_add (GST_BIN (bin), src2);
- gst_bin_remove (GST_BIN (bin), src1);
- gst_element_link_pads (GST_ELEMENT (src2), "src", sink, "sink");
- gst_element_set_state (GST_ELEMENT (bin), GST_STATE_PLAYING);
- state++;
- gst_data_unref (*data);
- return FALSE;
+ gst_element_set_state (GST_ELEMENT (bin), GST_STATE_PAUSED);
+
+ gst_element_unlink_pads (GST_ELEMENT (src1), "src", sink, "sink");
+ gst_bin_add (GST_BIN (bin), src2);
+ gst_bin_remove (GST_BIN (bin), src1);
+ gst_element_link_pads (GST_ELEMENT (src2), "src", sink, "sink");
+ gst_element_set_state (GST_ELEMENT (bin), GST_STATE_PLAYING);
+ state++;
+ gst_data_unref (*data);
+ return FALSE;
}
break;
case 1:
GST_BUFFER_TIMESTAMP (*data) = GST_BUFFER_TIMESTAMP (*data) + 10;
if (GST_BUFFER_TIMESTAMP (*data) == 20) {
- gst_data_unref (*data);
- *data = GST_DATA (gst_event_new (GST_EVENT_EOS));
- gst_element_set_state (src2, GST_STATE_PAUSED);
- return TRUE;
+ gst_data_unref (*data);
+ *data = GST_DATA (gst_event_new (GST_EVENT_EOS));
+ gst_element_set_state (src2, GST_STATE_PAUSED);
+ return TRUE;
}
break;
default:
gst_init (&argc, &argv);
- free (malloc (8)); /* -lefence */
+ free (malloc (8)); /* -lefence */
pipeline = gst_pipeline_new ("pipeline");
gst_init (&argc, &argv);
- free (malloc (8)); /* -lefence */
+ free (malloc (8)); /* -lefence */
pipeline = gst_pipeline_new ("pipeline");
gst_init (&argc, &argv);
- free (malloc (8)); /* -lefence */
+ free (malloc (8)); /* -lefence */
pipeline = gst_pipeline_new ("pipeline");
src = gst_bin_get_by_name (GST_BIN (bin), "fakesrc");
if (src) {
g_signal_connect (G_OBJECT (src), "handoff",
- G_CALLBACK (buffer_handoff_src), bin);
+ G_CALLBACK (buffer_handoff_src), bin);
} else {
g_print ("could not find src element\n");
exit (-1);
sink = gst_bin_get_by_name (GST_BIN (bin), "fakesink");
if (sink) {
g_signal_connect (G_OBJECT (sink), "handoff",
- G_CALLBACK (buffer_handoff_sink), bin);
+ G_CALLBACK (buffer_handoff_sink), bin);
} else {
g_print ("could not find sink element\n");
exit (-1);
gst_init (&argc, &argv);
- free (malloc (8)); /* -lefence */
+ free (malloc (8)); /* -lefence */
for (i = 0; i < TAILLE; i++) {
bin = gst_pipeline_new ("pipeline");
g_print ("segment done\n");
if (--looping == 1) {
event = gst_event_new_segment_seek (GST_FORMAT_DEFAULT |
- GST_SEEK_METHOD_SET | GST_SEEK_FLAG_FLUSH, 20, 25);
+ GST_SEEK_METHOD_SET | GST_SEEK_FLAG_FLUSH, 20, 25);
} else {
event = gst_event_new_segment_seek (GST_FORMAT_DEFAULT |
- GST_SEEK_METHOD_SET |
- GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SEGMENT_LOOP, 50, 55);
+ GST_SEEK_METHOD_SET |
+ GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SEGMENT_LOOP, 50, 55);
}
gst_pad_send_event (pad, event);
}
gst_pad_send_event (pad,
gst_event_new_segment_seek (GST_FORMAT_DEFAULT |
- GST_SEEK_METHOD_SET | GST_SEEK_FLAG_FLUSH, 5, 10));
+ GST_SEEK_METHOD_SET | GST_SEEK_FLAG_FLUSH, 5, 10));
format = GST_FORMAT_DEFAULT;
};
bstest_type =
- g_type_register_static (GST_TYPE_ELEMENT, "BSTest", &bstest_info, 0);
+ g_type_register_static (GST_TYPE_ELEMENT, "BSTest", &bstest_info, 0);
}
return bstest_type;
}
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SIZEMIN,
g_param_spec_int ("sizemin", "sizemin", "sizemin", 0, G_MAXINT,
- 0, G_PARAM_READWRITE));
+ 0, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SIZEMAX,
g_param_spec_int ("sizemax", "sizemax", "sizemax", 0, G_MAXINT,
- 384, G_PARAM_READWRITE));
+ 384, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ACCESSPATTERN,
g_param_spec_string ("accesspattern", "accesspattern", "accesspattern",
- "r", G_PARAM_READWRITE));
+ "r", G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_COUNT,
g_param_spec_uint ("count", "count", "count",
- 0, G_MAXUINT, 0, G_PARAM_READWRITE));
+ 0, G_MAXUINT, 0, G_PARAM_READWRITE));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SILENT,
g_param_spec_boolean ("silent", "silent", "silent",
- FALSE, G_PARAM_READWRITE));
+ FALSE, G_PARAM_READWRITE));
gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_bstest_set_property);
gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_bstest_get_property);
size = bstest->sizemax;
} else if (sizestring[0] == 'r') {
size =
- bstest->sizemin +
- (guint8) (((gfloat) bstest->sizemax) * rand () / (RAND_MAX +
- (gfloat) bstest->sizemin));
+ bstest->sizemin +
+ (guint8) (((gfloat) bstest->sizemax) * rand () / (RAND_MAX +
+ (gfloat) bstest->sizemin));
} else if (sizestring[0] == '<') {
size = prevsize;
} else {
buf = NULL;
if (bstest->patterns[i][0] == 'r') {
- size = gst_bstest_get_size (bstest, &bstest->patterns[i][1], size);
- if (!bstest->silent)
- g_print ("bstest: ***** read %d bytes\n", size);
- gst_bytestream_read (bstest->bs, &buf, size);
+ size = gst_bstest_get_size (bstest, &bstest->patterns[i][1], size);
+ if (!bstest->silent)
+ g_print ("bstest: ***** read %d bytes\n", size);
+ gst_bytestream_read (bstest->bs, &buf, size);
} else if (bstest->patterns[i][0] == 'f') {
- size = gst_bstest_get_size (bstest, &bstest->patterns[i][1], size);
- if (!bstest->silent)
- g_print ("bstest: ***** flush %d bytes\n", size);
- gst_bytestream_flush (bstest->bs, size);
+ size = gst_bstest_get_size (bstest, &bstest->patterns[i][1], size);
+ if (!bstest->silent)
+ g_print ("bstest: ***** flush %d bytes\n", size);
+ gst_bytestream_flush (bstest->bs, size);
} else if (!strncmp (bstest->patterns[i], "pb", 2)) {
- size = gst_bstest_get_size (bstest, &bstest->patterns[i][2], size);
- if (!bstest->silent)
- g_print ("bstest: ***** peek bytes %d bytes\n", size);
- gst_bytestream_peek_bytes (bstest->bs, &ptr, size);
+ size = gst_bstest_get_size (bstest, &bstest->patterns[i][2], size);
+ if (!bstest->silent)
+ g_print ("bstest: ***** peek bytes %d bytes\n", size);
+ gst_bytestream_peek_bytes (bstest->bs, &ptr, size);
} else if (bstest->patterns[i][0] == 'p') {
- size = gst_bstest_get_size (bstest, &bstest->patterns[i][1], size);
- if (!bstest->silent)
- g_print ("bstest: ***** peek %d bytes\n", size);
- gst_bytestream_peek (bstest->bs, &buf, size);
- gst_buffer_unref (buf);
- buf = NULL;
+ size = gst_bstest_get_size (bstest, &bstest->patterns[i][1], size);
+ if (!bstest->silent)
+ g_print ("bstest: ***** peek %d bytes\n", size);
+ gst_bytestream_peek (bstest->bs, &buf, size);
+ gst_buffer_unref (buf);
+ buf = NULL;
}
if (buf)
- gst_pad_push (bstest->srcpad, GST_DATA (buf));
+ gst_pad_push (bstest->srcpad, GST_DATA (buf));
i++;
}
break;
case ARG_ACCESSPATTERN:
if (bstest->accesspattern) {
- g_free (bstest->accesspattern);
- g_strfreev (bstest->patterns);
+ g_free (bstest->accesspattern);
+ g_strfreev (bstest->patterns);
}
if (g_value_get_string (value) == NULL) {
- gst_element_set_state (GST_ELEMENT (object), GST_STATE_NULL);
- bstest->accesspattern = NULL;
- bstest->num_patterns = 0;
+ gst_element_set_state (GST_ELEMENT (object), GST_STATE_NULL);
+ bstest->accesspattern = NULL;
+ bstest->num_patterns = 0;
} else {
- guint i = 0;
+ guint i = 0;
- bstest->accesspattern = g_strdup (g_value_get_string (value));
- bstest->patterns = g_strsplit (bstest->accesspattern, ":", 0);
- while (bstest->patterns[i++]);
- bstest->num_patterns = i - 1;
+ bstest->accesspattern = g_strdup (g_value_get_string (value));
+ bstest->patterns = g_strsplit (bstest->accesspattern, ":", 0);
+ while (bstest->patterns[i++]);
+ bstest->num_patterns = i - 1;
}
break;
case ARG_COUNT:
gchar *bs_accesspattern;
gboolean integrity_check;
-} TestParam;
+}
+TestParam;
static GSList *params = NULL;
guint8 *ptr = GST_BUFFER_DATA (buf);
for (i = 0; i < GST_BUFFER_SIZE (buf); i++) {
- if (*ptr++ != count++) {
- g_print ("data error!\n");
- return;
- }
+ if (*ptr++ != count++) {
+ g_print ("data error!\n");
+ return;
+ }
}
}
} else {
continue;
if (sscanf (line, scan_str, &data, &sizetype, pattern,
- &integrity_check) != 4) {
+ &integrity_check) != 4) {
g_print ("error on line: %d\n", linenr);
res = FALSE;
break;
if (percent != prev_percent || newvm - vm > VM_THRES) {
g_print ("\r%d (delta %d) %.3d%% ", newvm, newvm - vm,
- percent);
+ percent);
prev_percent = percent;
vm = newvm;
}
g_free (desc);
g_object_set (G_OBJECT (src), "data", param->src_data,
- "sizetype", param->src_sizetype,
- "filltype", (integrity_check ? 5 : 0), "silent", !verbose, NULL);
+ "sizetype", param->src_sizetype,
+ "filltype", (integrity_check ? 5 : 0), "silent", !verbose, NULL);
g_object_set (G_OBJECT (bs), "accesspattern", param->bs_accesspattern,
- "silent", !verbose, NULL);
+ "silent", !verbose, NULL);
g_object_set (G_OBJECT (sink), "dump", dump, "silent", !verbose, NULL);
if (gst_caps_is_any (caps)) {
return gst_caps_new_simple ("application/x-foo",
- "field", GST_TYPE_INT_RANGE, 1, 10, NULL);
+ "field", GST_TYPE_INT_RANGE, 1, 10, NULL);
}
return NULL;
caps =
gst_caps_new_full (gst_structure_new ("audio/raw", "_int", G_TYPE_INT,
- 100, NULL), gst_structure_new ("audio/raw2", "_int", G_TYPE_INT, 100,
- NULL), NULL);
+ 100, NULL), gst_structure_new ("audio/raw2", "_int", G_TYPE_INT, 100,
+ NULL), NULL);
g_assert (caps != NULL);
g_assert (gst_caps_is_empty (caps) == FALSE);
g_assert (gst_caps_is_any (caps) == FALSE);
caps1 =
gst_caps_new_full (gst_structure_new ("audio/raw", "_int", G_TYPE_INT,
- 100, NULL), gst_structure_new ("audio/raw", "_int", G_TYPE_INT, 200,
- NULL), NULL);
+ 100, NULL), gst_structure_new ("audio/raw", "_int", G_TYPE_INT, 200,
+ NULL), NULL);
caps2 =
gst_caps_new_full (gst_structure_new ("audio/raw", "_int", G_TYPE_INT,
- 100, NULL), gst_structure_new ("audio/raw", "_int", G_TYPE_INT, 300,
- NULL), NULL);
+ 100, NULL), gst_structure_new ("audio/raw", "_int", G_TYPE_INT, 300,
+ NULL), NULL);
caps = gst_caps_intersect (caps1, caps2);
g_print ("%s\n", gst_caps_to_string (caps));
gst_caps_free (caps);
("video/x-raw-yuv, format=(fourcc)YUY2, framerate=(double)[0,1.79769e+308], width=(int)[0,2147483647], height=(int)[0,2147483647]; video/x-raw-yuv, format=(fourcc)UYVY, framerate=(double)[0,1.79769e+308], width=(int)[0,2147483647], height=(int)[0,2147483647]");
GstStaticCaps rawcaps6 =
-GST_STATIC_CAPS
+ GST_STATIC_CAPS
("video/x-raw-yuv, format=(fourcc)YUY2, width=(int)320, height=(int)240");
GstStaticCaps rawcaps7 =
-GST_STATIC_CAPS
+ GST_STATIC_CAPS
("video/x-raw-yuv, format=(fourcc)YUY2, width=(int)[0,2147483647], height=(int)[0,2147483647], framerate=(double)[0,1.79769e+308]");
GstStaticCaps rawcaps8 =
-GST_STATIC_CAPS
+ GST_STATIC_CAPS
("video/x-raw-yuv, format=(fourcc)YUY2, width=(int)320, height=(int)240");
caps1 = gst_caps_copy (gst_static_caps_get (&rawcaps1));
caps2 =
gst_caps_new_full (gst_structure_copy (gst_caps_get_structure
- (gst_static_caps_get (&rawcaps1), 0)), NULL);
+ (gst_static_caps_get (&rawcaps1), 0)), NULL);
#if 0
gst_caps_set (caps1, "height", GST_PROPS_INT (640));
"height=(int)640, " "width=(int)480, " "framerate=(double)30.0");
GstStaticCaps rawcaps7 =
-GST_STATIC_CAPS
+ GST_STATIC_CAPS
("video/x-raw-yuv, format=(fourcc)YUY2, width=(int)[1,2147483647], height=(int)[1,2147483647], framerate=(double)[0,1.79769e+308]");
GstStaticCaps rawcaps8 =
-GST_STATIC_CAPS
+ GST_STATIC_CAPS
("video/x-raw-yuv, format=(fourcc){ I420, YV12, YUY2 }, width=(int)[16,4096], height=(int)[16,4096], framerate=(double)[0,1.79769e+308]");
int
caps = gst_caps_intersect (gst_static_caps_get (&rawcaps6),
gst_caps_new_full (gst_structure_copy (gst_caps_get_structure
- (gst_static_caps_get (&rawcaps6), 0)), NULL));
+ (gst_static_caps_get (&rawcaps6), 0)), NULL));
parent = xmlNewChild (doc->xmlRootNode, NULL, "Capabilities5", NULL);
gst_caps_save_thyself (caps, parent);
gint i = 1000;
gint step = 100;
- free (malloc (8)); /* -lefence */
+ free (malloc (8)); /* -lefence */
gst_init (&argc, &argv);
gint i = 1000;
gint step = 100;
- free (malloc (8)); /* -lefence */
+ free (malloc (8)); /* -lefence */
gst_init (&argc, &argv);
gint i = 10000;
gint step = 100;
- free (malloc (8)); /* -lefence */
+ free (malloc (8)); /* -lefence */
gst_init (&argc, &argv);
GstElement *fakesrc;
gint i;
- free (malloc (8)); /* -lefence */
+ free (malloc (8)); /* -lefence */
gst_init (&argc, &argv);
gint step = 100;
- free (malloc (8)); /* -lefence */
+ free (malloc (8)); /* -lefence */
gst_init (&argc, &argv);
g_assert (strcmp (gst_debug_category_get_name (cat), "cat") == 0);
g_assert (gst_debug_category_get_color (cat) == GST_DEBUG_FG_GREEN);
g_assert (strcmp (gst_debug_category_get_description (cat),
- "default category for this test") == 0);
+ "default category for this test") == 0);
g_assert (gst_debug_category_get_threshold (cat) ==
gst_debug_get_default_threshold ());
g_assert (strcmp (gst_debug_category_get_name (cat_static),
- "cat_static") == 0);
+ "cat_static") == 0);
g_assert (gst_debug_category_get_color (cat_static) | GST_DEBUG_FG_GREEN);
g_assert (gst_debug_category_get_color (cat_static) | GST_DEBUG_BG_RED);
g_assert (gst_debug_category_get_color (cat_static) | GST_DEBUG_BOLD);
g_assert (strcmp (gst_debug_category_get_description (cat_static),
- "static category for this test") == 0);
+ "static category for this test") == 0);
g_assert (gst_debug_category_get_threshold (cat_static) ==
gst_debug_get_default_threshold ());
/* check if setting levels for names work */
command = g_strdup_printf ("%s %s %d", argv[0], lines[i], i);
g_print ("running \"%s\"\n", command);
g_assert (g_spawn_command_line_sync (command, NULL, NULL, &exit,
- NULL) == TRUE);
+ NULL) == TRUE);
g_assert (exit == 0);
g_print ("\"%s\" worked as expected.\n", command);
g_free (command);
gst_init (&argc, &argv);
if (argc != 2) {
g_print
- ("something funny happened to the command line arguments, aborting.\n");
+ ("something funny happened to the command line arguments, aborting.\n");
return 1;
}
gst_debug_remove_log_function (gst_debug_log_default);
GST_DEBUG_CATEGORY_INIT (cat_static, "cat_static", 0, "static category");
switch (argv[1][0]) {
case '0':
- g_assert (gst_debug_is_active () == FALSE);
- gst_debug_add_log_function (debug_not_reached, NULL);
- GST_ERROR ("This will not be seen");
- return 0;
+ g_assert (gst_debug_is_active () == FALSE);
+ gst_debug_add_log_function (debug_not_reached, NULL);
+ GST_ERROR ("This will not be seen");
+ return 0;
case '1':
- return gst_debug_is_colored ()? 1 : 0;
+ return gst_debug_is_colored ()? 1 : 0;
case '2':
- g_assert (gst_debug_get_default_threshold () == 4);
- g_assert (gst_debug_category_get_threshold (cat) == 4);
- return 0;
+ g_assert (gst_debug_get_default_threshold () == 4);
+ g_assert (gst_debug_category_get_threshold (cat) == 4);
+ return 0;
case '3':
- g_assert (gst_debug_get_default_threshold () == GST_LEVEL_DEFAULT);
- g_assert (gst_debug_category_get_threshold (cat) == 4);
- g_assert (gst_debug_category_get_threshold (cat_static) == 3);
- return 0;
+ g_assert (gst_debug_get_default_threshold () == GST_LEVEL_DEFAULT);
+ g_assert (gst_debug_category_get_threshold (cat) == 4);
+ g_assert (gst_debug_category_get_threshold (cat_static) == 3);
+ return 0;
case '4':
- g_assert (gst_debug_get_default_threshold () == 4);
- g_assert (gst_debug_category_get_threshold (cat) == 4);
- g_assert (gst_debug_category_get_threshold (cat_static) == 5);
- return 0;
+ g_assert (gst_debug_get_default_threshold () == 4);
+ g_assert (gst_debug_category_get_threshold (cat) == 4);
+ g_assert (gst_debug_category_get_threshold (cat_static) == 5);
+ return 0;
default:
- g_print ("usupported command, aborting...\n");
- return -1;
+ g_print ("usupported command, aborting...\n");
+ return -1;
}
}
g_assert_not_reached ();
GObject * object, gchar * message, gpointer thread) G_GNUC_NO_INSTRUMENT;
static void
- gst_debug_log_one (GstDebugCategory * category, GstDebugLevel level,
+ gst_debug_log_one (GstDebugCategory * category, GstDebugLevel level,
const gchar * file, const gchar * function, gint line, GObject * object,
gchar * message, gpointer thread)
{
g_print ("creating %d threads\n", THREAD_COUNT);
for (i = 0; i < THREAD_COUNT; i++) {
g_assert ((threads[i] =
- g_thread_create (thread_main, GINT_TO_POINTER (i), TRUE, NULL)));
+ g_thread_create (thread_main, GINT_TO_POINTER (i), TRUE, NULL)));
}
g_print ("joining %d threads\n", THREAD_COUNT);
for (i = 0; i < THREAD_COUNT; i++) {
};
dptest_type =
- g_type_register_static (GST_TYPE_ELEMENT, "GstDpTest", &dptest_info, 0);
+ g_type_register_static (GST_TYPE_ELEMENT, "GstDpTest", &dptest_info, 0);
}
return dptest_type;
}
gst_dpman_add_required_dparam_direct (dptest->dpman,
g_param_spec_float ("float1", "float1", "float1",
- 0.0, 1.0, 0.5, G_PARAM_READWRITE), "float", &(dptest->float1)
+ 0.0, 1.0, 0.5, G_PARAM_READWRITE), "float", &(dptest->float1)
);
dptest->float1 = 0.0;
/* we expect this to give an error */
if (gst_bin_iterate (GST_BIN (pipeline)) != FALSE) {
g_warning
- ("Iterating a bin with unlinked elements should return FALSE !\n");
+ ("Iterating a bin with unlinked elements should return FALSE !\n");
retval = 1;
}
g_assert (GST_IS_ELEMENT (element));
g_assert (gst_element_get_name (element) != NULL);
g_print ("Created identity element with name %s\n",
- gst_element_get_name (element));
+ gst_element_get_name (element));
}
g_print ("Done !\n");
return 0;
/* compare */
if (sizemin_set != sizemin_get) {
g_print ("sizemin: set value %d differs from returned value %d\n",
- sizemin_set, sizemin_get);
+ sizemin_set, sizemin_get);
retval = 1;
} else
g_print ("name: set right\n");
if (silent_set != silent_get) {
g_print ("silent: set value %s differs from returned value %s\n",
- silent_set ? "TRUE" : "FALSE", silent_get ? "TRUE" : "FALSE");
+ silent_set ? "TRUE" : "FALSE", silent_get ? "TRUE" : "FALSE");
retval = 1;
} else
g_print ("silent: set right\n");
if (strcmp (name_set, name_get) != 0) {
g_print ("name: set value %s differs from returned value %s\n",
- name_set, name_get);
+ name_set, name_get);
retval = 1;
} else
g_print ("name: set right\n");
g_print ("OK (not found)\n");
else
g_print ("FAIL - no index entry found for %lld %s, expecting %lld\n",
- src_value, def->nick, expecting);
+ src_value, def->nick, expecting);
}
}
gint64 src_value;
GstFormat dest_format;
gint64 expecting;
-} GstIndexTestCase;
+}
+GstIndexTestCase;
const static GstIndexTestCase cases[] = {
{GST_INDEX_LOOKUP_EXACT, GST_FORMAT_BYTES, 3, GST_FORMAT_TIME, 3000},
{GST_INDEX_LOOKUP_AFTER, GST_FORMAT_TIME, 0, GST_FORMAT_BYTES, 0},
{GST_INDEX_LOOKUP_BEFORE, GST_FORMAT_TIME, -1, GST_FORMAT_BYTES, -1},
{GST_INDEX_LOOKUP_BEFORE, GST_FORMAT_TIME, G_MAXINT64, GST_FORMAT_BYTES,
- 99999},
+ 99999},
{GST_INDEX_LOOKUP_AFTER, GST_FORMAT_TIME, G_MAXINT64, GST_FORMAT_BYTES, -1},
};
for (i = 0; i < 100000; i++) {
gst_index_add_association (index, 0, 0, GST_FORMAT_BYTES, (gint64) i,
- GST_FORMAT_TIME, (gint64) (i * 1000), 0);
+ GST_FORMAT_TIME, (gint64) (i * 1000), 0);
}
g_print ("Testing index...\n");
for (i = 0; i < (sizeof (cases) / sizeof (GstIndexTestCase)); i++) {
lookup (index, cases[i].method, cases[i].src_format, cases[i].src_value,
- cases[i].dest_format, cases[i].expecting);
+ cases[i].dest_format, cases[i].expecting);
}
return 0;
while (1) {
gint fx;
GstIndexEntry *entry =
- gst_index_get_assoc_entry (index, id, GST_INDEX_LOOKUP_AFTER, 0,
- GST_FORMAT_TIME, cur);
+ gst_index_get_assoc_entry (index, id, GST_INDEX_LOOKUP_AFTER, 0,
+ GST_FORMAT_TIME, cur);
if (!entry)
break;
const GstFormatDefinition *def = gst_format_get_details (fmt);
if (fmt == GST_FORMAT_TIME) {
- cur = GST_INDEX_ASSOC_VALUE (entry, fx) + 1;
- g_print (" time %.4f",
- GST_INDEX_ASSOC_VALUE (entry, fx) / (double) GST_SECOND);
+ cur = GST_INDEX_ASSOC_VALUE (entry, fx) + 1;
+ g_print (" time %.4f",
+ GST_INDEX_ASSOC_VALUE (entry, fx) / (double) GST_SECOND);
} else
- g_print (" %s %lld", def->nick, GST_INDEX_ASSOC_VALUE (entry, fx));
+ g_print (" %s %lld", def->nick, GST_INDEX_ASSOC_VALUE (entry, fx));
}
g_print ("\n");
}
* - if multiple toplevel elements exist, a pipeline is returned
*/
TEST_START (PIPELINE3);
- TEST_CHECK_FAIL (GST_BIN (cur)->numchildren == 3); /* a bit hacky here */
+ TEST_CHECK_FAIL (GST_BIN (cur)->numchildren == 3); /* a bit hacky here */
TEST_CHECK_FAIL (GST_IS_PIPELINE (cur));
TEST_OK;
for (i = 0; i < iters; i++) {
padtempl =
- gst_pad_template_new ("sink%d", GST_PAD_SINK, GST_PAD_SOMETIMES, NULL);
+ gst_pad_template_new ("sink%d", GST_PAD_SINK, GST_PAD_SOMETIMES, NULL);
gst_object_unref (GST_OBJECT (padtempl));
}
g_print ("%d padtemplates create/unref %ld\n", iters, vmsize () - usage1);
for (i = 0; i < iters; i++) {
padtempl =
- gst_pad_template_new ("sink%d", GST_PAD_SINK, GST_PAD_SOMETIMES, NULL);
+ gst_pad_template_new ("sink%d", GST_PAD_SINK, GST_PAD_SOMETIMES, NULL);
pad = gst_pad_new_from_template (padtempl, "sink1");
gst_object_unref (GST_OBJECT (pad));
}
if (element == NULL) {
g_warning
- ("Could not run test, because element type \"%s\" is not installed. Please retry when it is. Assuming it works for now...",
- type);
+ ("Could not run test, because element type \"%s\" is not installed. Please retry when it is. Assuming it works for now...",
+ type);
exit (1);
}
g_assert (sink);
g_signal_connect (G_OBJECT (sink), "handoff",
- G_CALLBACK (change_state), pipeline);
+ G_CALLBACK (change_state), pipeline);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
g_print ("running ...\n");
while (gst_bin_iterate (GST_BIN (pipeline)));
/* connect state change signal */
id = g_signal_connect (G_OBJECT (thread), "state_change",
- G_CALLBACK (state_changed), NULL);
+ G_CALLBACK (state_changed), NULL);
construct_pipeline (thread);
g_print ("Setting thread to play\n");
/* connect state change signal */
id = g_signal_connect (G_OBJECT (thread), "state_change",
- G_CALLBACK (state_changed), NULL);
+ G_CALLBACK (state_changed), NULL);
construct_pipeline (thread, i / 10 + 1);
g_print ("Setting thread to play with %d identities\n", i / 10 + 1);
g_error ("Failed setting thread to play\n");
} else {
g_print ("Going into the main GStreamer loop\n");
- can_quit = TRUE; /* we don't want gst_main_quit called before gst_main */
+ can_quit = TRUE; /* we don't want gst_main_quit called before gst_main */
gst_main ();
}
running = FALSE;
/* connect state change signal */
id = g_signal_connect (G_OBJECT (thread), "state_change",
- G_CALLBACK (state_changed), NULL);
+ G_CALLBACK (state_changed), NULL);
construct_pipeline (thread, i / RUNS_PER_IDENTITY + 1);
g_print ("Setting thread to play with %d identities\n",
- i / RUNS_PER_IDENTITY + 1);
+ i / RUNS_PER_IDENTITY + 1);
done = FALSE;
if (gst_element_set_state (thread, GST_STATE_PLAYING) == GST_STATE_FAILURE) {
g_warning ("failed to go to PLAYING");
} else {
g_print ("Waiting for thread PLAYING->PAUSED\n");
- while (!done) /* do nothing */
- ;
+ while (!done) /* do nothing */
+ ;
}
running = FALSE;
g_print ("Coming out of the main GStreamer loop\n");
g_print ("Created GThread\n");
g_print ("Waiting for thread PLAYING->PAUSED\n");
- while (!done) /* do nothing */
+ while (!done) /* do nothing */
;
running = FALSE;
g_print ("Unreffing pipeline\n");
GSList *srcpadtemplates;
GSList *sinkpadtemplates;
GSList *arguments;
-} comp_element;
+}
+comp_element;
enum
{
gchar *name;
int type;
GSList *enums;
-} comp_argument;
+}
+comp_argument;
typedef struct
{
gint value;
gchar *nick;
-} enum_value;
+}
+enum_value;
void
propnode = elementnode->xmlChildrenNode;
while (propnode) {
- if (!strcmp (propnode->name, "name")) {
- element->name = xmlNodeGetContent (propnode);
+ if (!strcmp (propnode->name, "name")) {
+ element->name = xmlNodeGetContent (propnode);
/* fprintf(stderr,element->name); */
- } else if (!strcmp (propnode->name, "srcpad")) {
- element->srcpads =
- g_slist_prepend (element->srcpads, xmlNodeGetContent (propnode));
+ } else if (!strcmp (propnode->name, "srcpad")) {
+ element->srcpads =
+ g_slist_prepend (element->srcpads, xmlNodeGetContent (propnode));
/* fprintf(stderr,"."); */
- } else if (!strcmp (propnode->name, "sinkpad")) {
- element->sinkpads =
- g_slist_prepend (element->sinkpads, xmlNodeGetContent (propnode));
- } else if (!strcmp (propnode->name, "srcpadtemplate")) {
- element->srcpadtemplates =
- g_slist_prepend (element->srcpadtemplates,
- xmlNodeGetContent (propnode));
+ } else if (!strcmp (propnode->name, "sinkpad")) {
+ element->sinkpads =
+ g_slist_prepend (element->sinkpads, xmlNodeGetContent (propnode));
+ } else if (!strcmp (propnode->name, "srcpadtemplate")) {
+ element->srcpadtemplates =
+ g_slist_prepend (element->srcpadtemplates,
+ xmlNodeGetContent (propnode));
/* fprintf(stderr,"."); */
- } else if (!strcmp (propnode->name, "sinkpad")) {
- element->sinkpadtemplates =
- g_slist_prepend (element->sinkpadtemplates,
- xmlNodeGetContent (propnode));
- } else if (!strcmp (propnode->name, "argument")) {
- argument = g_new0 (comp_argument, 1);
- argument->name = xmlNodeGetContent (propnode);
- argument->type = ARG_INT;
-
- /* walk through the values data */
- argnode = propnode->xmlChildrenNode;
- while (argnode) {
- if (!strcmp (argnode->name, "filename")) {
- argument->type = ARG_FILENAME;
- } else if (!strcmp (argnode->name, "option")) {
- argument->type = ARG_ENUM;
- option = g_new0 (enum_value, 1);
- sscanf (xmlNodeGetContent (argnode), "%d", &option->value);
- argument->enums = g_slist_prepend (argument->enums, option);
- }
- argnode = argnode->next;
- }
-
- element->arguments = g_slist_prepend (element->arguments, argument);
- }
-
- propnode = propnode->next;
+ } else if (!strcmp (propnode->name, "sinkpad")) {
+ element->sinkpadtemplates =
+ g_slist_prepend (element->sinkpadtemplates,
+ xmlNodeGetContent (propnode));
+ } else if (!strcmp (propnode->name, "argument")) {
+ argument = g_new0 (comp_argument, 1);
+ argument->name = xmlNodeGetContent (propnode);
+ argument->type = ARG_INT;
+
+ /* walk through the values data */
+ argnode = propnode->xmlChildrenNode;
+ while (argnode) {
+ if (!strcmp (argnode->name, "filename")) {
+ argument->type = ARG_FILENAME;
+ } else if (!strcmp (argnode->name, "option")) {
+ argument->type = ARG_ENUM;
+ option = g_new0 (enum_value, 1);
+ sscanf (xmlNodeGetContent (argnode), "%d", &option->value);
+ argument->enums = g_slist_prepend (argument->enums, option);
+ }
+ argnode = argnode->next;
+ }
+
+ element->arguments = g_slist_prepend (element->arguments, argument);
+ }
+
+ propnode = propnode->next;
}
element_list = g_list_prepend (element_list, element);
element_names = g_slist_prepend (element_names, element->name);
while (elements) {
element = (comp_element *) (elements->data);
if (!element->sinkpads && !element->sinkpadtemplates)
- words = g_slist_prepend (words, element->name);
+ words = g_slist_prepend (words, element->name);
elements = g_list_next (elements);
}
}
while (elements) {
element = (comp_element *) (elements->data);
if (element->sinkpads || element->sinkpadtemplates)
- words = g_slist_prepend (words, element->name);
+ words = g_slist_prepend (words, element->name);
elements = g_list_next (elements);
}
}
/* if the previous word is an element, we need to list both pads and arguments */
if ((elements =
- g_list_find_custom (element_list, prev_word,
- (GCompareFunc) match_element))) {
+ g_list_find_custom (element_list, prev_word,
+ (GCompareFunc) match_element))) {
element = elements->data;
/* zero the numpads list so we can count them */
num_pads = 0;
while (pads) {
num_pads++;
words =
- g_slist_prepend (words, g_strdup_printf ("%s!",
- (gchar *) (pads->data)));
+ g_slist_prepend (words, g_strdup_printf ("%s!",
+ (gchar *) (pads->data)));
pads = g_slist_next (pads);
}
num_pads++;
word = g_strdup_printf ("%s!", (gchar *) (pads->data));
if (!g_slist_find_custom (words, word, (GCompareFunc) strcmp))
- words = g_slist_prepend (words, word);
+ words = g_slist_prepend (words, word);
pads = g_slist_next (pads);
}
features = g_list_next (features);
if (!GST_IS_ELEMENT_FACTORY (feature))
- continue;
+ continue;
factory = GST_ELEMENT_FACTORY (feature);
factorynode = xmlNewChild (doc->xmlRootNode, NULL, "element", NULL);
xmlNewChild (factorynode, NULL, "name",
- GST_PLUGIN_FEATURE_NAME (factory));
+ GST_PLUGIN_FEATURE_NAME (factory));
element = gst_element_factory_create (factory, NULL);
GST_DEBUG ("adding factory %s", GST_PLUGIN_FEATURE_NAME (factory));
if (element == NULL) {
- GST_ERROR ("couldn't construct element from factory %s\n",
- gst_object_get_name (GST_OBJECT (factory)));
- return 1;
+ GST_ERROR ("couldn't construct element from factory %s\n",
+ gst_object_get_name (GST_OBJECT (factory)));
+ return 1;
}
/* write out the padtemplates */
padtemplates = factory->padtemplates;
while (padtemplates) {
- padtemplate = (GstPadTemplate *) (padtemplates->data);
- padtemplates = g_list_next (padtemplates);
-
- if (padtemplate->direction == GST_PAD_SRC)
- padnode =
- xmlNewChild (factorynode, NULL, "srcpadtemplate",
- padtemplate->name_template);
- else if (padtemplate->direction == GST_PAD_SINK)
- padnode =
- xmlNewChild (factorynode, NULL, "sinkpadtemplate",
- padtemplate->name_template);
+ padtemplate = (GstPadTemplate *) (padtemplates->data);
+ padtemplates = g_list_next (padtemplates);
+
+ if (padtemplate->direction == GST_PAD_SRC)
+ padnode =
+ xmlNewChild (factorynode, NULL, "srcpadtemplate",
+ padtemplate->name_template);
+ else if (padtemplate->direction == GST_PAD_SINK)
+ padnode =
+ xmlNewChild (factorynode, NULL, "sinkpadtemplate",
+ padtemplate->name_template);
}
pads = gst_element_get_pad_list (element);
while (pads) {
- pad = (GstPad *) (pads->data);
- pads = g_list_next (pads);
-
- if (GST_PAD_DIRECTION (pad) == GST_PAD_SRC)
- padnode =
- xmlNewChild (factorynode, NULL, "srcpad", GST_PAD_NAME (pad));
- else if (GST_PAD_DIRECTION (pad) == GST_PAD_SINK)
- padnode =
- xmlNewChild (factorynode, NULL, "sinkpad", GST_PAD_NAME (pad));
+ pad = (GstPad *) (pads->data);
+ pads = g_list_next (pads);
+
+ if (GST_PAD_DIRECTION (pad) == GST_PAD_SRC)
+ padnode =
+ xmlNewChild (factorynode, NULL, "srcpad", GST_PAD_NAME (pad));
+ else if (GST_PAD_DIRECTION (pad) == GST_PAD_SINK)
+ padnode =
+ xmlNewChild (factorynode, NULL, "sinkpad", GST_PAD_NAME (pad));
}
/* write out the args */
property_specs =
- g_object_class_list_properties (G_OBJECT_GET_CLASS (element),
- &num_properties);
+ g_object_class_list_properties (G_OBJECT_GET_CLASS (element),
+ &num_properties);
for (i = 0; i < num_properties; i++) {
- GParamSpec *param = property_specs[i];
-
- argnode = xmlNewChild (factorynode, NULL, "argument", param->name);
- if (param->value_type == GST_TYPE_URI) {
- xmlNewChild (argnode, NULL, "filename", NULL);
- } else if (G_IS_PARAM_SPEC_ENUM (param) == G_TYPE_ENUM) {
- GEnumValue *values;
- gint j;
-
- values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values;
- for (j = 0; values[j].value_name; j++) {
- gchar *value = g_strdup_printf ("%d", values[j].value);
-
- optionnode = xmlNewChild (argnode, NULL, "option", value);
- xmlNewChild (optionnode, NULL, "value_nick", values[j].value_nick);
- g_free (value);
- }
- }
+ GParamSpec *param = property_specs[i];
+
+ argnode = xmlNewChild (factorynode, NULL, "argument", param->name);
+ if (param->value_type == GST_TYPE_URI) {
+ xmlNewChild (argnode, NULL, "filename", NULL);
+ } else if (G_IS_PARAM_SPEC_ENUM (param) == G_TYPE_ENUM) {
+ GEnumValue *values;
+ gint j;
+
+ values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values;
+ for (j = 0; values[j].value_name; j++) {
+ gchar *value = g_strdup_printf ("%d", values[j].value);
+
+ optionnode = xmlNewChild (argnode, NULL, "option", value);
+ xmlNewChild (optionnode, NULL, "value_nick", values[j].value_nick);
+ g_free (value);
+ }
+ }
}
}
}
--case-indentation2 \
--braces-after-struct-decl-line \
--line-length80 \
- --use-tabs \
+ --no-tabs \
--cuddle-else \
--dont-line-up-parentheses \
--continuation-indentation4 \
definition = gst_format_get_details (*formats);
if (definition)
g_print ("\t\t(%d):\t%s (%s)\n", *formats,
- definition->nick, definition->description);
+ definition->nick, definition->description);
else
g_print ("\t\t(%d):\tUnknown format\n", *formats);
definition = gst_query_type_get_details (*types);
if (definition)
g_print ("\t\t(%d):\t%s (%s)\n", *types,
- definition->nick, definition->description);
+ definition->nick, definition->description);
else
g_print ("\t\t(%d):\tUnknown query format\n", *types);
switch (masks->type) {
case GST_EVENT_SEEK:
- flags = masks->flags;
- event_flags = gst_seek_type_get_type ();
- flags_class = (GFlagsClass *) g_type_class_ref (event_flags);
- break;
+ flags = masks->flags;
+ event_flags = gst_seek_type_get_type ();
+ flags_class = (GFlagsClass *) g_type_class_ref (event_flags);
+ break;
default:
- break;
+ break;
}
value = g_enum_get_value (klass, masks->type);
GFlagsValue *value;
if (flags & 1) {
- value = g_flags_get_first_value (flags_class, 1 << index);
+ value = g_flags_get_first_value (flags_class, 1 << index);
- if (value)
- g_print ("| %s ", value->value_nick);
- else
- g_print ("| ? ");
+ if (value)
+ g_print ("| %s ", value->value_nick);
+ else
+ g_print ("| ? ");
}
flags >>= 1;
index++;
}
g_print (" %-20s: %s\n", g_param_spec_get_name (param),
- g_param_spec_get_blurb (param));
+ g_param_spec_get_blurb (param));
switch (G_VALUE_TYPE (&value)) {
case G_TYPE_STRING:
- string_val = g_value_get_string (&value);
- g_print ("%-23.23s String. ", "");
- if (readable) {
- if (string_val == NULL)
- g_print ("(Default \"\")");
- else
- g_print ("(Default \"%s\")", g_value_get_string (&value));
- }
- break;
+ string_val = g_value_get_string (&value);
+ g_print ("%-23.23s String. ", "");
+ if (readable) {
+ if (string_val == NULL)
+ g_print ("(Default \"\")");
+ else
+ g_print ("(Default \"%s\")", g_value_get_string (&value));
+ }
+ break;
case G_TYPE_BOOLEAN:
- g_print ("%-23.23s Boolean. ", "");
- if (readable)
- g_print ("(Default %s)",
- (g_value_get_boolean (&value) ? "true" : "false"));
- break;
+ g_print ("%-23.23s Boolean. ", "");
+ if (readable)
+ g_print ("(Default %s)",
+ (g_value_get_boolean (&value) ? "true" : "false"));
+ break;
case G_TYPE_ULONG:
{
- GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (param);
+ GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (param);
- g_print ("%-23.23s Unsigned Long. ", "");
- if (readable)
- g_print ("Range: %lu - %lu (Default %lu)",
- pulong->minimum, pulong->maximum, g_value_get_ulong (&value));
- break;
+ g_print ("%-23.23s Unsigned Long. ", "");
+ if (readable)
+ g_print ("Range: %lu - %lu (Default %lu)",
+ pulong->minimum, pulong->maximum, g_value_get_ulong (&value));
+ break;
}
case G_TYPE_LONG:
{
- GParamSpecLong *plong = G_PARAM_SPEC_LONG (param);
+ GParamSpecLong *plong = G_PARAM_SPEC_LONG (param);
- g_print ("%-23.23s Long. ", "");
- if (readable)
- g_print ("Range: %ld - %ld (Default %ld)",
- plong->minimum, plong->maximum, g_value_get_long (&value));
- break;
+ g_print ("%-23.23s Long. ", "");
+ if (readable)
+ g_print ("Range: %ld - %ld (Default %ld)",
+ plong->minimum, plong->maximum, g_value_get_long (&value));
+ break;
}
case G_TYPE_UINT:
{
- GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param);
+ GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param);
- g_print ("%-23.23s Unsigned Integer. ", "");
- if (readable)
- g_print ("Range: %u - %u (Default %u)",
- puint->minimum, puint->maximum, g_value_get_uint (&value));
- break;
+ g_print ("%-23.23s Unsigned Integer. ", "");
+ if (readable)
+ g_print ("Range: %u - %u (Default %u)",
+ puint->minimum, puint->maximum, g_value_get_uint (&value));
+ break;
}
case G_TYPE_INT:
{
- GParamSpecInt *pint = G_PARAM_SPEC_INT (param);
+ GParamSpecInt *pint = G_PARAM_SPEC_INT (param);
- g_print ("%-23.23s Integer. ", "");
- if (readable)
- g_print ("Range: %d - %d (Default %d)",
- pint->minimum, pint->maximum, g_value_get_int (&value));
- break;
+ g_print ("%-23.23s Integer. ", "");
+ if (readable)
+ g_print ("Range: %d - %d (Default %d)",
+ pint->minimum, pint->maximum, g_value_get_int (&value));
+ break;
}
case G_TYPE_UINT64:
{
- GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64 (param);
-
- g_print ("%-23.23s Unsigned Integer64. ", "");
- if (readable)
- g_print ("Range: %" G_GUINT64_FORMAT " - %"
- G_GUINT64_FORMAT " (Default %" G_GUINT64_FORMAT ")",
- puint64->minimum, puint64->maximum, g_value_get_uint64 (&value));
- break;
+ GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64 (param);
+
+ g_print ("%-23.23s Unsigned Integer64. ", "");
+ if (readable)
+ g_print ("Range: %" G_GUINT64_FORMAT " - %"
+ G_GUINT64_FORMAT " (Default %" G_GUINT64_FORMAT ")",
+ puint64->minimum, puint64->maximum, g_value_get_uint64 (&value));
+ break;
}
case G_TYPE_INT64:
{
- GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64 (param);
-
- g_print ("%-23.23s Integer64. ", "");
- if (readable)
- g_print ("Range: %" G_GINT64_FORMAT " - %" G_GINT64_FORMAT
- " (Default %" G_GINT64_FORMAT ")", pint64->minimum,
- pint64->maximum, g_value_get_int64 (&value));
- break;
+ GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64 (param);
+
+ g_print ("%-23.23s Integer64. ", "");
+ if (readable)
+ g_print ("Range: %" G_GINT64_FORMAT " - %" G_GINT64_FORMAT
+ " (Default %" G_GINT64_FORMAT ")", pint64->minimum,
+ pint64->maximum, g_value_get_int64 (&value));
+ break;
}
case G_TYPE_FLOAT:
{
- GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (param);
+ GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (param);
- g_print ("%-23.23s Float. Default: %-8.8s %15.7g\n", "", "",
- g_value_get_float (&value));
- g_print ("%-23.23s Range: %15.7g - %15.7g", "",
- pfloat->minimum, pfloat->maximum);
- break;
+ g_print ("%-23.23s Float. Default: %-8.8s %15.7g\n", "", "",
+ g_value_get_float (&value));
+ g_print ("%-23.23s Range: %15.7g - %15.7g", "",
+ pfloat->minimum, pfloat->maximum);
+ break;
}
case G_TYPE_DOUBLE:
{
- GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE (param);
+ GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE (param);
- g_print ("%-23.23s Double. Default: %-8.8s %15.7g\n", "", "",
- g_value_get_double (&value));
- g_print ("%-23.23s Range: %15.7g - %15.7g", "",
- pdouble->minimum, pdouble->maximum);
- break;
+ g_print ("%-23.23s Double. Default: %-8.8s %15.7g\n", "", "",
+ g_value_get_double (&value));
+ g_print ("%-23.23s Range: %15.7g - %15.7g", "",
+ pdouble->minimum, pdouble->maximum);
+ break;
}
default:
- if (param->value_type == GST_TYPE_URI) {
- g_print ("%-23.23s URI", "");
- }
- if (param->value_type == GST_TYPE_CAPS) {
- const GstCaps *caps = gst_value_get_caps (&value);
-
- if (!caps)
- g_print ("%-23.23s Caps (NULL)", "");
- else {
- print_caps (caps, " ");
- }
- } else if (G_IS_PARAM_SPEC_ENUM (param)) {
- GEnumValue *values;
- guint j = 0;
- gint enum_value;
-
- values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values;
- enum_value = g_value_get_enum (&value);
-
- while (values[j].value_name) {
- if (values[j].value == enum_value)
- break;
- j++;
- }
-
- g_print ("%-23.23s Enum \"%s\" (default %d, \"%s\")", "",
- g_type_name (G_VALUE_TYPE (&value)),
- enum_value, values[j].value_nick);
-
- j = 0;
- while (values[j].value_name) {
- g_print ("\n%-23.23s (%d): \t%s", "",
- values[j].value, values[j].value_nick);
- j++;
- }
- /* g_type_class_unref (ec); */
- } else if (G_IS_PARAM_SPEC_FLAGS (param)) {
- GFlagsValue *values;
- guint j = 0;
- gint flags_value;
- GString *flags = NULL;
-
- values = G_FLAGS_CLASS (g_type_class_ref (param->value_type))->values;
- flags_value = g_value_get_flags (&value);
-
- while (values[j].value_name) {
- if (values[j].value & flags_value) {
- if (flags) {
- g_string_append_printf (flags, " | %s", values[j].value_nick);
- } else {
- flags = g_string_new (values[j].value_nick);
- }
- }
- j++;
- }
-
- g_print ("%-23.23s Flags \"%s\" (default %d, \"%s\")", "",
- g_type_name (G_VALUE_TYPE (&value)),
- flags_value, (flags ? flags->str : "(none)"));
-
- j = 0;
- while (values[j].value_name) {
- g_print ("\n%-23.23s (%d): \t%s", "",
- values[j].value, values[j].value_nick);
- j++;
- }
-
- if (flags)
- g_string_free (flags, TRUE);
- } else if (G_IS_PARAM_SPEC_OBJECT (param)) {
- g_print ("%-23.23s Object of type \"%s\"", "",
- g_type_name (param->value_type));
- } else {
- g_print ("%-23.23s Unknown type %ld \"%s\"", "", param->value_type,
- g_type_name (param->value_type));
- }
- break;
+ if (param->value_type == GST_TYPE_URI) {
+ g_print ("%-23.23s URI", "");
+ }
+ if (param->value_type == GST_TYPE_CAPS) {
+ const GstCaps *caps = gst_value_get_caps (&value);
+
+ if (!caps)
+ g_print ("%-23.23s Caps (NULL)", "");
+ else {
+ print_caps (caps, " ");
+ }
+ } else if (G_IS_PARAM_SPEC_ENUM (param)) {
+ GEnumValue *values;
+ guint j = 0;
+ gint enum_value;
+
+ values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values;
+ enum_value = g_value_get_enum (&value);
+
+ while (values[j].value_name) {
+ if (values[j].value == enum_value)
+ break;
+ j++;
+ }
+
+ g_print ("%-23.23s Enum \"%s\" (default %d, \"%s\")", "",
+ g_type_name (G_VALUE_TYPE (&value)),
+ enum_value, values[j].value_nick);
+
+ j = 0;
+ while (values[j].value_name) {
+ g_print ("\n%-23.23s (%d): \t%s", "",
+ values[j].value, values[j].value_nick);
+ j++;
+ }
+ /* g_type_class_unref (ec); */
+ } else if (G_IS_PARAM_SPEC_FLAGS (param)) {
+ GFlagsValue *values;
+ guint j = 0;
+ gint flags_value;
+ GString *flags = NULL;
+
+ values = G_FLAGS_CLASS (g_type_class_ref (param->value_type))->values;
+ flags_value = g_value_get_flags (&value);
+
+ while (values[j].value_name) {
+ if (values[j].value & flags_value) {
+ if (flags) {
+ g_string_append_printf (flags, " | %s", values[j].value_nick);
+ } else {
+ flags = g_string_new (values[j].value_nick);
+ }
+ }
+ j++;
+ }
+
+ g_print ("%-23.23s Flags \"%s\" (default %d, \"%s\")", "",
+ g_type_name (G_VALUE_TYPE (&value)),
+ flags_value, (flags ? flags->str : "(none)"));
+
+ j = 0;
+ while (values[j].value_name) {
+ g_print ("\n%-23.23s (%d): \t%s", "",
+ values[j].value, values[j].value_nick);
+ j++;
+ }
+
+ if (flags)
+ g_string_free (flags, TRUE);
+ } else if (G_IS_PARAM_SPEC_OBJECT (param)) {
+ g_print ("%-23.23s Object of type \"%s\"", "",
+ g_type_name (param->value_type));
+ } else {
+ g_print ("%-23.23s Unknown type %ld \"%s\"", "", param->value_type,
+ g_type_name (param->value_type));
+ }
+ break;
}
if (!readable)
g_print (" Write only\n");
pads = g_list_next (pads);
if (padtemplate->direction == GST_PAD_SRC)
- g_print (" SRC template: '%s'\n", padtemplate->name_template);
+ g_print (" SRC template: '%s'\n", padtemplate->name_template);
else if (padtemplate->direction == GST_PAD_SINK)
- g_print (" SINK template: '%s'\n", padtemplate->name_template);
+ g_print (" SINK template: '%s'\n", padtemplate->name_template);
else
- g_print (" UNKNOWN!!! template: '%s'\n", padtemplate->name_template);
+ g_print (" UNKNOWN!!! template: '%s'\n", padtemplate->name_template);
if (padtemplate->presence == GST_PAD_ALWAYS)
- g_print (" Availability: Always\n");
+ g_print (" Availability: Always\n");
else if (padtemplate->presence == GST_PAD_SOMETIMES)
- g_print (" Availability: Sometimes\n");
+ g_print (" Availability: Sometimes\n");
else if (padtemplate->presence == GST_PAD_REQUEST) {
- g_print (" Availability: On request\n");
- g_print (" Has request_new_pad() function: %s\n",
- GST_DEBUG_FUNCPTR_NAME (gstelement_class->request_new_pad));
+ g_print (" Availability: On request\n");
+ g_print (" Has request_new_pad() function: %s\n",
+ GST_DEBUG_FUNCPTR_NAME (gstelement_class->request_new_pad));
} else
- g_print (" Availability: UNKNOWN!!!\n");
+ g_print (" Availability: UNKNOWN!!!\n");
if (padtemplate->caps) {
- g_print (" Capabilities:\n");
- print_caps (padtemplate->caps, " ");
+ g_print (" Capabilities:\n");
+ print_caps (padtemplate->caps, " ");
}
g_print ("\n");
if (element->loopfunc)
g_print (" loopfunc()-based element: %s\n",
- GST_DEBUG_FUNCPTR_NAME (element->loopfunc));
+ GST_DEBUG_FUNCPTR_NAME (element->loopfunc));
else
g_print (" No loopfunc(), must be chain-based or not configured yet\n");
realpad = GST_PAD_REALIZE (pad);
if (gst_pad_get_direction (pad) == GST_PAD_SRC)
- g_print (" SRC: '%s'", gst_pad_get_name (pad));
+ g_print (" SRC: '%s'", gst_pad_get_name (pad));
else if (gst_pad_get_direction (pad) == GST_PAD_SINK)
- g_print (" SINK: '%s'", gst_pad_get_name (pad));
+ g_print (" SINK: '%s'", gst_pad_get_name (pad));
else
- g_print (" UNKNOWN!!!: '%s'\n", gst_pad_get_name (pad));
+ g_print (" UNKNOWN!!!: '%s'\n", gst_pad_get_name (pad));
if (GST_IS_GHOST_PAD (pad))
- g_print (", ghost of real pad %s:%s\n", GST_DEBUG_PAD_NAME (realpad));
+ g_print (", ghost of real pad %s:%s\n", GST_DEBUG_PAD_NAME (realpad));
else
- g_print ("\n");
+ g_print ("\n");
g_print (" Implementation:\n");
if (realpad->chainfunc)
- g_print (" Has chainfunc(): %s\n",
- GST_DEBUG_FUNCPTR_NAME (realpad->chainfunc));
+ g_print (" Has chainfunc(): %s\n",
+ GST_DEBUG_FUNCPTR_NAME (realpad->chainfunc));
if (realpad->getfunc)
- g_print (" Has getfunc(): %s\n",
- GST_DEBUG_FUNCPTR_NAME (realpad->getfunc));
+ g_print (" Has getfunc(): %s\n",
+ GST_DEBUG_FUNCPTR_NAME (realpad->getfunc));
if (realpad->formatsfunc != gst_pad_get_formats_default) {
- g_print (" Supports seeking/conversion/query formats:\n");
- print_formats (gst_pad_get_formats (GST_PAD (realpad)));
+ g_print (" Supports seeking/conversion/query formats:\n");
+ print_formats (gst_pad_get_formats (GST_PAD (realpad)));
}
if (realpad->convertfunc != gst_pad_convert_default)
- g_print (" Has custom convertfunc(): %s\n",
- GST_DEBUG_FUNCPTR_NAME (realpad->convertfunc));
+ g_print (" Has custom convertfunc(): %s\n",
+ GST_DEBUG_FUNCPTR_NAME (realpad->convertfunc));
if (realpad->eventfunc != gst_pad_event_default)
- g_print (" Has custom eventfunc(): %s\n",
- GST_DEBUG_FUNCPTR_NAME (realpad->eventfunc));
+ g_print (" Has custom eventfunc(): %s\n",
+ GST_DEBUG_FUNCPTR_NAME (realpad->eventfunc));
if (realpad->eventmaskfunc != gst_pad_get_event_masks_default) {
- g_print (" Provides event masks:\n");
- print_event_masks (gst_pad_get_event_masks (GST_PAD (realpad)));
+ g_print (" Provides event masks:\n");
+ print_event_masks (gst_pad_get_event_masks (GST_PAD (realpad)));
}
if (realpad->queryfunc != gst_pad_query_default)
- g_print (" Has custom queryfunc(): %s\n",
- GST_DEBUG_FUNCPTR_NAME (realpad->queryfunc));
+ g_print (" Has custom queryfunc(): %s\n",
+ GST_DEBUG_FUNCPTR_NAME (realpad->queryfunc));
if (realpad->querytypefunc != gst_pad_get_query_types_default) {
- g_print (" Provides query types:\n");
- print_query_types (gst_pad_get_query_types (GST_PAD (realpad)));
+ g_print (" Provides query types:\n");
+ print_query_types (gst_pad_get_query_types (GST_PAD (realpad)));
}
if (realpad->intlinkfunc != gst_pad_get_internal_links_default)
- g_print (" Has custom intconnfunc(): %s\n",
- GST_DEBUG_FUNCPTR_NAME (realpad->intlinkfunc));
+ g_print (" Has custom intconnfunc(): %s\n",
+ GST_DEBUG_FUNCPTR_NAME (realpad->intlinkfunc));
if (realpad->bufferallocfunc)
- g_print (" Has bufferallocfunc(): %s\n",
- GST_DEBUG_FUNCPTR_NAME (realpad->bufferallocfunc));
+ g_print (" Has bufferallocfunc(): %s\n",
+ GST_DEBUG_FUNCPTR_NAME (realpad->bufferallocfunc));
if (pad->padtemplate)
- g_print (" Pad Template: '%s'\n", pad->padtemplate->name_template);
+ g_print (" Pad Template: '%s'\n", pad->padtemplate->name_template);
if (realpad->caps) {
- g_print (" Capabilities:\n");
- print_caps (realpad->caps, " ");
+ g_print (" Capabilities:\n");
+ print_caps (realpad->caps, " ");
}
}
} else
if ((dpman = gst_dpman_get_manager (element))) {
specs = gst_dpman_list_dparam_specs (dpman);
for (x = 0; specs[x] != NULL; x++) {
- g_print (" %-20.20s: ", g_param_spec_get_name (specs[x]));
-
- switch (G_PARAM_SPEC_VALUE_TYPE (specs[x])) {
- case G_TYPE_INT64:
- g_print ("64 Bit Integer (Default %" G_GINT64_FORMAT ", Range %"
- G_GINT64_FORMAT " -> %" G_GINT64_FORMAT ")",
- ((GParamSpecInt64 *) specs[x])->default_value,
- ((GParamSpecInt64 *) specs[x])->minimum,
- ((GParamSpecInt64 *) specs[x])->maximum);
- break;
- case G_TYPE_INT:
- g_print ("Integer (Default %d, Range %d -> %d)",
- ((GParamSpecInt *) specs[x])->default_value,
- ((GParamSpecInt *) specs[x])->minimum,
- ((GParamSpecInt *) specs[x])->maximum);
- break;
- case G_TYPE_FLOAT:
- g_print ("Float. Default: %-8.8s %15.7g\n", "",
- ((GParamSpecFloat *) specs[x])->default_value);
- g_print ("%-23.23s Range: %15.7g - %15.7g", "",
- ((GParamSpecFloat *) specs[x])->minimum,
- ((GParamSpecFloat *) specs[x])->maximum);
- break;
- case G_TYPE_DOUBLE:
- g_print ("Double. Default: %-8.8s %15.7g\n", "",
- ((GParamSpecDouble *) specs[x])->default_value);
- g_print ("%-23.23s Range: %15.7g - %15.7g", "",
- ((GParamSpecDouble *) specs[x])->minimum,
- ((GParamSpecDouble *) specs[x])->maximum);
- break;
- default:
- g_print ("unknown %ld", G_PARAM_SPEC_VALUE_TYPE (specs[x]));
- }
- g_print ("\n");
+ g_print (" %-20.20s: ", g_param_spec_get_name (specs[x]));
+
+ switch (G_PARAM_SPEC_VALUE_TYPE (specs[x])) {
+ case G_TYPE_INT64:
+ g_print ("64 Bit Integer (Default %" G_GINT64_FORMAT ", Range %"
+ G_GINT64_FORMAT " -> %" G_GINT64_FORMAT ")",
+ ((GParamSpecInt64 *) specs[x])->default_value,
+ ((GParamSpecInt64 *) specs[x])->minimum,
+ ((GParamSpecInt64 *) specs[x])->maximum);
+ break;
+ case G_TYPE_INT:
+ g_print ("Integer (Default %d, Range %d -> %d)",
+ ((GParamSpecInt *) specs[x])->default_value,
+ ((GParamSpecInt *) specs[x])->minimum,
+ ((GParamSpecInt *) specs[x])->maximum);
+ break;
+ case G_TYPE_FLOAT:
+ g_print ("Float. Default: %-8.8s %15.7g\n", "",
+ ((GParamSpecFloat *) specs[x])->default_value);
+ g_print ("%-23.23s Range: %15.7g - %15.7g", "",
+ ((GParamSpecFloat *) specs[x])->minimum,
+ ((GParamSpecFloat *) specs[x])->maximum);
+ break;
+ case G_TYPE_DOUBLE:
+ g_print ("Double. Default: %-8.8s %15.7g\n", "",
+ ((GParamSpecDouble *) specs[x])->default_value);
+ g_print ("%-23.23s Range: %15.7g - %15.7g", "",
+ ((GParamSpecDouble *) specs[x])->minimum,
+ ((GParamSpecDouble *) specs[x])->maximum);
+ break;
+ default:
+ g_print ("unknown %ld", G_PARAM_SPEC_VALUE_TYPE (specs[x]));
+ }
+ g_print ("\n");
}
g_free (specs);
} else {
gint counted = 0;
if (k == 0)
- g_print ("\nElement Signals:\n");
+ g_print ("\nElement Signals:\n");
else
- g_print ("\nElement Actions:\n");
+ g_print ("\nElement Actions:\n");
for (type = G_OBJECT_TYPE (element); type; type = g_type_parent (type)) {
- signals = g_signal_list_ids (type, &nsignals);
-
- for (i = 0; i < nsignals; i++) {
- gint n_params;
- GType return_type;
- const GType *param_types;
- gint j;
-
- query = g_new0 (GSignalQuery, 1);
- g_signal_query (signals[i], query);
-
- if ((k == 0 && !(query->signal_flags & G_SIGNAL_ACTION)) ||
- (k == 1 && (query->signal_flags & G_SIGNAL_ACTION))) {
- n_params = query->n_params;
- return_type = query->return_type;
- param_types = query->param_types;
-
- g_print (" \"%s\" :\t %s user_function (%s* object",
- query->signal_name, g_type_name (return_type),
- g_type_name (type));
-
- for (j = 0; j < n_params; j++) {
- g_print (",\n \t\t\t\t%s arg%d", g_type_name (param_types[j]),
- j);
- }
- if (k == 0)
- g_print (",\n \t\t\t\tgpointer user_data);\n");
- else
- g_print (");\n");
-
- counted++;
- }
-
- g_free (query);
- }
+ signals = g_signal_list_ids (type, &nsignals);
+
+ for (i = 0; i < nsignals; i++) {
+ gint n_params;
+ GType return_type;
+ const GType *param_types;
+ gint j;
+
+ query = g_new0 (GSignalQuery, 1);
+ g_signal_query (signals[i], query);
+
+ if ((k == 0 && !(query->signal_flags & G_SIGNAL_ACTION)) ||
+ (k == 1 && (query->signal_flags & G_SIGNAL_ACTION))) {
+ n_params = query->n_params;
+ return_type = query->return_type;
+ param_types = query->param_types;
+
+ g_print (" \"%s\" :\t %s user_function (%s* object",
+ query->signal_name, g_type_name (return_type),
+ g_type_name (type));
+
+ for (j = 0; j < n_params; j++) {
+ g_print (",\n \t\t\t\t%s arg%d", g_type_name (param_types[j]),
+ j);
+ }
+ if (k == 0)
+ g_print (",\n \t\t\t\tgpointer user_data);\n");
+ else
+ g_print (");\n");
+
+ counted++;
+ }
+
+ g_free (query);
+ }
}
if (counted == 0)
- g_print (" none\n");
+ g_print (" none\n");
}
}
g_print (" none\n");
else {
while (children) {
- child = GST_ELEMENT (children->data);
- children = g_list_next (children);
+ child = GST_ELEMENT (children->data);
+ children = g_list_next (children);
- g_print (" %s\n", GST_ELEMENT_NAME (child));
+ g_print (" %s\n", GST_ELEMENT_NAME (child));
}
}
}
feature = GST_PLUGIN_FEATURE (features->data);
if (GST_IS_ELEMENT_FACTORY (feature)) {
- GstElementFactory *factory;
+ GstElementFactory *factory;
- factory = GST_ELEMENT_FACTORY (feature);
- g_print ("%s: %s: %s\n", plugin->desc.name,
- GST_PLUGIN_FEATURE_NAME (factory), factory->details.longname);
+ factory = GST_ELEMENT_FACTORY (feature);
+ g_print ("%s: %s: %s\n", plugin->desc.name,
+ GST_PLUGIN_FEATURE_NAME (factory), factory->details.longname);
}
#ifndef GST_DISABLE_INDEX
else if (GST_IS_INDEX_FACTORY (feature)) {
- GstIndexFactory *factory;
+ GstIndexFactory *factory;
- factory = GST_INDEX_FACTORY (feature);
- g_print ("%s: %s: %s\n", plugin->desc.name,
- GST_PLUGIN_FEATURE_NAME (factory), factory->longdesc);
+ factory = GST_INDEX_FACTORY (feature);
+ g_print ("%s: %s: %s\n", plugin->desc.name,
+ GST_PLUGIN_FEATURE_NAME (factory), factory->longdesc);
}
#endif
else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
- GstTypeFindFactory *factory;
-
- factory = GST_TYPE_FIND_FACTORY (feature);
- g_print ("%s: %s: ", plugin->desc.name,
- gst_plugin_feature_get_name (feature));
- if (factory->extensions) {
- guint i = 0;
-
- while (factory->extensions[i]) {
- g_print ("%s%s", i > 0 ? ", " : "", factory->extensions[i]);
- i++;
- }
- g_print ("\n");
- } else {
- g_print ("no extensions\n");
- }
+ GstTypeFindFactory *factory;
+
+ factory = GST_TYPE_FIND_FACTORY (feature);
+ g_print ("%s: %s: ", plugin->desc.name,
+ gst_plugin_feature_get_name (feature));
+ if (factory->extensions) {
+ guint i = 0;
+
+ while (factory->extensions[i]) {
+ g_print ("%s%s", i > 0 ? ", " : "", factory->extensions[i]);
+ i++;
+ }
+ g_print ("\n");
+ } else {
+ g_print ("no extensions\n");
+ }
} else if (GST_IS_SCHEDULER_FACTORY (feature)) {
- GstSchedulerFactory *factory;
+ GstSchedulerFactory *factory;
- factory = GST_SCHEDULER_FACTORY (feature);
- g_print ("%s: %s: %s\n", plugin->desc.name,
- GST_PLUGIN_FEATURE_NAME (factory), factory->longdesc);
+ factory = GST_SCHEDULER_FACTORY (feature);
+ g_print ("%s: %s: %s\n", plugin->desc.name,
+ GST_PLUGIN_FEATURE_NAME (factory), factory->longdesc);
} else {
- g_print ("%s: %s (%s)\n", plugin->desc.name,
- GST_PLUGIN_FEATURE_NAME (feature),
- g_type_name (G_OBJECT_TYPE (feature)));
+ g_print ("%s: %s (%s)\n", plugin->desc.name,
+ GST_PLUGIN_FEATURE_NAME (feature),
+ g_type_name (G_OBJECT_TYPE (feature)));
}
features = g_list_next (features);
factory = GST_ELEMENT_FACTORY (feature);
g_print (" %s: %s\n", GST_OBJECT_NAME (factory),
- factory->details.longname);
+ factory->details.longname);
num_elements++;
}
#ifndef GST_DISABLE_INDEX
factory = GST_TYPE_FIND_FACTORY (feature);
if (factory->extensions) {
- guint i = 0;
+ guint i = 0;
- g_print ("%s type: ", plugin->desc.name);
- while (factory->extensions[i]) {
- g_print ("%s%s", i > 0 ? ", " : "", factory->extensions[i]);
- i++;
- }
+ g_print ("%s type: ", plugin->desc.name);
+ while (factory->extensions[i]) {
+ g_print ("%s%s", i > 0 ? ", " : "", factory->extensions[i]);
+ i++;
+ }
} else
- g_print ("%s type: N/A\n", plugin->desc.name);
+ g_print ("%s type: N/A\n", plugin->desc.name);
num_types++;
} else if (GST_IS_SCHEDULER_FACTORY (feature)) {
num_schedulers++;
} else {
g_print (" %s (%s)\n", gst_object_get_name (GST_OBJECT (feature)),
- g_type_name (G_OBJECT_TYPE (feature)));
+ g_type_name (G_OBJECT_TYPE (feature)));
num_other++;
}
num_features++;
gchar *so;
struct poptOption options[] = {
{"gst-inspect-plugin", 'p', POPT_ARG_STRING | POPT_ARGFLAG_STRIP, NULL, 0,
- N_("Show plugin details"), NULL},
+ N_("Show plugin details"), NULL},
{"gst-inspect-scheduler", 's', POPT_ARG_STRING | POPT_ARGFLAG_STRIP, NULL,
- 0,
- N_("Show scheduler details"), NULL},
+ 0,
+ N_("Show scheduler details"), NULL},
POPT_TABLEEND
};
g_print ("Usage: %s\t\t\tList all registered elements\n", argv[0]);
g_print (" %s element-name\tShow element details\n", argv[0]);
g_print (" %s plugin-name[.so]\tShow information about plugin\n",
- argv[0]);
+ argv[0]);
return 0;
}
/* if there's a factory, print out the info */
if (factory)
- return print_element_info (factory);
+ return print_element_info (factory);
else {
- GstPluginFeature *feature;
-
- /* FIXME implement other pretty print function for these */
- feature = gst_registry_pool_find_feature (argv[1],
- GST_TYPE_SCHEDULER_FACTORY);
- if (feature) {
- g_print ("%s: a scheduler\n", argv[1]);
- return 0;
- }
+ GstPluginFeature *feature;
+
+ /* FIXME implement other pretty print function for these */
+ feature = gst_registry_pool_find_feature (argv[1],
+ GST_TYPE_SCHEDULER_FACTORY);
+ if (feature) {
+ g_print ("%s: a scheduler\n", argv[1]);
+ return 0;
+ }
#ifndef GST_DISABLE_INDEX
- feature = gst_registry_pool_find_feature (argv[1],
- GST_TYPE_INDEX_FACTORY);
- if (feature) {
- g_print ("%s: an index\n", argv[1]);
- return 0;
- }
+ feature = gst_registry_pool_find_feature (argv[1],
+ GST_TYPE_INDEX_FACTORY);
+ if (feature) {
+ g_print ("%s: an index\n", argv[1]);
+ return 0;
+ }
#endif
- feature = gst_registry_pool_find_feature (argv[1],
- GST_TYPE_TYPE_FIND_FACTORY);
- if (feature) {
- g_print ("%s: a typefind function\n", argv[1]);
- return 0;
- }
+ feature = gst_registry_pool_find_feature (argv[1],
+ GST_TYPE_TYPE_FIND_FACTORY);
+ if (feature) {
+ g_print ("%s: a typefind function\n", argv[1]);
+ return 0;
+ }
#ifndef GST_DISABLE_URI
- feature = gst_registry_pool_find_feature (argv[1],
- GST_TYPE_URI_HANDLER);
- if (feature) {
- g_print ("%s: an uri handler\n", argv[1]);
- return 0;
- }
+ feature = gst_registry_pool_find_feature (argv[1],
+ GST_TYPE_URI_HANDLER);
+ if (feature) {
+ g_print ("%s: an uri handler\n", argv[1]);
+ return 0;
+ }
#endif
}
} else {
#include <signal.h>
#include <unistd.h>
#include <sys/wait.h>
-#include <locale.h> /* for LC_ALL */
+#include <locale.h> /* for LC_ALL */
#include "gst/gst-i18n-app.h"
#include <gst/gst.h>
max = MAX (max, diff);
if (!busy || caught_intr || (max_iterations > 0
- && iterations >= max_iterations)) {
+ && iterations >= max_iterations)) {
gst_main_quit ();
g_print (_("Execution ended after %" G_GUINT64_FORMAT " iterations (sum %"
- G_GUINT64_FORMAT " ns, average %" G_GUINT64_FORMAT " ns, min %"
- G_GUINT64_FORMAT " ns, max %" G_GUINT64_FORMAT " ns).\n"),
- iterations, sum, sum / iterations, min, max);
+ G_GUINT64_FORMAT " ns, average %" G_GUINT64_FORMAT " ns, min %"
+ G_GUINT64_FORMAT " ns, max %" G_GUINT64_FORMAT " ns).\n"),
+ iterations, sum, sum / iterations, min, max);
}
return busy;
if (!(arg = argv[0])) {
g_print (_
- ("Usage: gst-xmllaunch <file.xml> [ element.property=value ... ]\n"));
+ ("Usage: gst-xmllaunch <file.xml> [ element.property=value ... ]\n"));
exit (1);
}
l = gst_xml_get_topelements (xml);
if (!l) {
fprintf (stderr, _("ERROR: no toplevel pipeline element in file '%s'.\n"),
- arg);
+ arg);
exit (1);
}
if (l->next)
fprintf (stderr,
- _("WARNING: only one toplevel element is supported at this time."));
+ _("WARNING: only one toplevel element is supported at this time."));
pipeline = GST_ELEMENT (l->data);
if (!(element < property && property < value)) {
fprintf (stderr,
- _("ERROR: could not parse command line argument %d: %s.\n"), i,
- element);
+ _("ERROR: could not parse command line argument %d: %s.\n"), i,
+ element);
g_free (element);
exit (1);
}
g_assert (gst_tag_list_get_string_index (list, tag, i, &str));
} else {
str =
- g_strdup_value_contents (gst_tag_list_get_value_index (list, tag, i));
+ g_strdup_value_contents (gst_tag_list_get_value_index (list, tag, i));
}
if (i == 0) {
gchar *exclude_args = NULL;
struct poptOption options[] = {
{"tags", 't', POPT_ARG_NONE | POPT_ARGFLAG_STRIP, &tags, 0,
- N_("Output tags (also known as metadata)"), NULL},
+ N_("Output tags (also known as metadata)"), NULL},
{"verbose", 'v', POPT_ARG_NONE | POPT_ARGFLAG_STRIP, &verbose, 0,
- N_("Output status information and property notifications"), NULL},
+ N_("Output status information and property notifications"), NULL},
{"exclude", 'X', POPT_ARG_STRING | POPT_ARGFLAG_STRIP, &exclude_args, 0,
- N_("Do not output status information of TYPE"), N_("TYPE1,TYPE2,...")},
+ N_("Do not output status information of TYPE"), N_("TYPE1,TYPE2,...")},
#ifndef GST_DISABLE_LOADSAVE
{"output", 'o', POPT_ARG_STRING | POPT_ARGFLAG_STRIP, &savefile, 0,
- N_("Save xml representation of pipeline to FILE and exit"), N_("FILE")},
+ N_("Save xml representation of pipeline to FILE and exit"), N_("FILE")},
#endif
{"no-fault", 'f', POPT_ARG_NONE | POPT_ARGFLAG_STRIP, &no_fault, 0,
- N_("Do not install a fault handler"), NULL},
+ N_("Do not install a fault handler"), NULL},
{"trace", 'T', POPT_ARG_NONE | POPT_ARGFLAG_STRIP, &trace, 0,
- N_("Print alloc trace (if enabled at compile time)"), NULL},
+ N_("Print alloc trace (if enabled at compile time)"), NULL},
{"iterations", 'i', POPT_ARG_INT | POPT_ARGFLAG_STRIP, &max_iterations, 0,
- N_("Number of times to iterate pipeline"), NULL},
+ N_("Number of times to iterate pipeline"), NULL},
POPT_TABLEEND
};
GError *error = NULL;
gint res = 0;
- free (malloc (8)); /* -lefence */
+ free (malloc (8)); /* -lefence */
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
for (i = 1; i < argc; i++) {
if (*(argv[i]) == '-') {
if (strlen (argv[i]) == 2) {
- gchar *c = argv[i];
+ gchar *c = argv[i];
- c++;
- if (*c == 'X' || *c == 'o') {
- i++;
- }
+ c++;
+ if (*c == 'X' || *c == 'o') {
+ i++;
+ }
}
} else {
argv[j] = argv[i];
#endif
{
pipeline =
- (GstElement *) gst_parse_launchv ((const gchar **) argvn, &error);
+ (GstElement *) gst_parse_launchv ((const gchar **) argvn, &error);
}
g_free (argvn);
if (!pipeline) {
if (error) {
fprintf (stderr, _("ERROR: pipeline could not be constructed: %s.\n"),
- error->message);
+ error->message);
g_error_free (error);
} else {
fprintf (stderr, _("ERROR: pipeline could not be constructed.\n"));
if (verbose) {
gchar **exclude_list =
- exclude_args ? g_strsplit (exclude_args, ",", 0) : NULL;
+ exclude_args ? g_strsplit (exclude_args, ",", 0) : NULL;
g_signal_connect (pipeline, "deep_notify",
- G_CALLBACK (gst_element_default_deep_notify), exclude_list);
+ G_CALLBACK (gst_element_default_deep_notify), exclude_list);
}
if (tags) {
g_signal_connect (pipeline, "found-tag", G_CALLBACK (found_tag), NULL);
GstElement *real_pipeline = gst_element_factory_make ("pipeline", NULL);
if (real_pipeline == NULL) {
- fprintf (stderr, _("ERROR: the 'pipeline' element wasn't found.\n"));
- exit (1);
+ fprintf (stderr, _("ERROR: the 'pipeline' element wasn't found.\n"));
+ exit (1);
}
gst_bin_add (GST_BIN (real_pipeline), pipeline);
pipeline = real_pipeline;
fprintf (stderr, _("RUNNING pipeline ...\n"));
if (gst_element_set_state (pipeline,
- GST_STATE_PLAYING) == GST_STATE_FAILURE) {
+ GST_STATE_PLAYING) == GST_STATE_FAILURE) {
fprintf (stderr, _("ERROR: pipeline doesn't want to play.\n"));
res = -1;
goto end;
gchar *exclude_args = NULL;
struct poptOption options[] = {
{"verbose", 'v', POPT_ARG_NONE | POPT_ARGFLAG_STRIP, &verbose, 0,
- "do not output status information", NULL},
+ "do not output status information", NULL},
POPT_TABLEEND
};
GstElement *md5sink;
gchar *md5string = g_malloc0 (33);
- free (malloc (8)); /* -lefence */
+ free (malloc (8)); /* -lefence */
setlocale (LC_ALL, "");
argvn[argc - 1] = g_strdup_printf ("!");
argvn[argc] = g_strdup_printf ("md5sink");
pipeline =
- (GstElement *) gst_parse_launchv ((const gchar **) argvn, &error);
+ (GstElement *) gst_parse_launchv ((const gchar **) argvn, &error);
}
if (!pipeline) {
if (verbose) {
gchar **exclude_list = exclude_args ? g_strsplit (exclude_args, ",", 0)
- : NULL;
+ : NULL;
g_signal_connect (pipeline, "deep_notify",
- G_CALLBACK (gst_element_default_deep_notify), exclude_list);
+ G_CALLBACK (gst_element_default_deep_notify), exclude_list);
}
g_signal_connect (pipeline, "error",
G_CALLBACK (gst_element_default_error), NULL);
argv[0] = g_build_filename (dirname, file, NULL);
g_print ("running %s\n", argv[0]);
g_spawn_sync (NULL, argv, NULL, G_SPAWN_FILE_AND_ARGV_ZERO, NULL, NULL,
- NULL, NULL, NULL, NULL);
+ NULL, NULL, NULL, NULL);
g_free (argv[0]);
}
g_dir_close (dir);
main (int argc, char *argv[])
{
GList *registries;
- GList *path_spill = NULL; /* used for path spill from failing registries */
+ GList *path_spill = NULL; /* used for path spill from failing registries */
setlocale (LC_ALL, "");
* since they're spilled they probably weren't loaded correctly
* so we should give a lower priority registry the chance to do them */
for (iter = path_spill; iter; iter = iter->next) {
- g_print ("added path %s to %s \n",
- (const char *) iter->data, registry->name);
- gst_registry_add_path (registry, (const gchar *) iter->data);
+ g_print ("added path %s to %s \n",
+ (const char *) iter->data, registry->name);
+ gst_registry_add_path (registry, (const gchar *) iter->data);
}
g_list_free (path_spill);
path_spill = NULL;
}
g_signal_connect (G_OBJECT (registry), "plugin_added",
- G_CALLBACK (plugin_added_func), NULL);
+ G_CALLBACK (plugin_added_func), NULL);
if (registry->flags & GST_REGISTRY_WRITABLE) {
char *location;
} else {
g_print ("trying to load %s\n", registry->name);
if (!gst_registry_load (registry)) {
- g_print ("error loading %s\n", registry->name);
- /* move over paths from this registry to the next one */
- path_spill = g_list_concat (path_spill,
- gst_registry_get_path_list (registry));
- g_assert (path_spill != NULL);
+ g_print ("error loading %s\n", registry->name);
+ /* move over paths from this registry to the next one */
+ path_spill = g_list_concat (path_spill,
+ gst_registry_get_path_list (registry));
+ g_assert (path_spill != NULL);
}
/* also move over paths if the registry wasn't writable
* FIXME: we should check if the paths that were loaded from this
dir_list = gst_registry_get_path_list (registry);
for (iter = dir_list; iter; iter = iter->next) {
dir =
- g_build_filename ((const char *) iter->data, "register-scripts",
- NULL);
+ g_build_filename ((const char *) iter->data, "register-scripts",
+ NULL);
spawn_all_in_dir (dir);
g_free (dir);
}
if (reason == POPT_CALLBACK_REASON_OPTION) {
switch (option->val) {
case ARG_MM:
- _arg_mm = g_strdup (arg);
- break;
+ _arg_mm = g_strdup (arg);
+ break;
case ARG_LIST_MM:
- _arg_list_mm = TRUE;
- break;
+ _arg_list_mm = TRUE;
+ break;
case ARG_PRINT:
- _print = TRUE;
- break;
+ _print = TRUE;
+ break;
case ARG_HELP:
- poptPrintHelp (context, stdout, 0);
- g_print ("\n");
- break;
+ poptPrintHelp (context, stdout, 0);
+ g_print ("\n");
+ break;
}
} else {
g_print ("Unknown reason for callback\n");
/* popt options table for the wrapper */
static struct poptOption wrapper_options[] = {
{NULL, '\0',
- POPT_ARG_CALLBACK,
+ POPT_ARG_CALLBACK,
(void *) &popt_callback, 0, NULL, NULL},
{"help", '\0',
- POPT_ARG_NONE | POPT_ARGFLAG_DOC_HIDDEN,
+ POPT_ARG_NONE | POPT_ARGFLAG_DOC_HIDDEN,
NULL, ARG_HELP, ("Show help"), NULL},
{"?", '\0',
- POPT_ARG_NONE | POPT_ARGFLAG_STRIP | POPT_ARGFLAG_ONEDASH
- | POPT_ARGFLAG_DOC_HIDDEN,
+ POPT_ARG_NONE | POPT_ARGFLAG_STRIP | POPT_ARGFLAG_ONEDASH
+ | POPT_ARGFLAG_DOC_HIDDEN,
NULL, ARG_HELP, NULL, NULL},
/* We cheat by specifying -p as long "p" with onedash, so that it
also gets stripped properly from our arg flags */
{"p", '\0',
- POPT_ARG_NONE | POPT_ARGFLAG_STRIP | POPT_ARGFLAG_ONEDASH
- | POPT_ARGFLAG_DOC_HIDDEN,
+ POPT_ARG_NONE | POPT_ARGFLAG_STRIP | POPT_ARGFLAG_ONEDASH
+ | POPT_ARGFLAG_DOC_HIDDEN,
NULL, ARG_PRINT, NULL, NULL},
{"print", '\0',
- POPT_ARG_NONE | POPT_ARGFLAG_STRIP,
+ POPT_ARG_NONE | POPT_ARGFLAG_STRIP,
NULL, ARG_PRINT, ("Print wrapped command line"), NULL},
{"gst-mm", '\0',
- POPT_ARG_STRING | POPT_ARGFLAG_STRIP,
+ POPT_ARG_STRING | POPT_ARGFLAG_STRIP,
NULL, ARG_MM, ("Force major/minor version"), NULL},
{"gst-list-mm", '\0',
- POPT_ARG_NONE | POPT_ARGFLAG_STRIP,
+ POPT_ARG_NONE | POPT_ARGFLAG_STRIP,
NULL, ARG_LIST_MM, ("List found major/minor versions"), NULL},
POPT_TABLEEND
};
}
while ((entry = g_dir_read_name (gdir))) {
if (g_pattern_match_string (spec, entry)) {
- gchar *full;
-
- /* is it executable ? */
- full = g_build_filename (*cur, entry, NULL);
- if (!g_file_test (full, G_FILE_TEST_IS_EXECUTABLE)) {
- g_free (full);
- continue;
- }
- g_free (full);
-
- /* strip base and dash from it */
- suffix = g_strdup (&(entry[strlen (base) + 1]));
-
- /* stricter pattern check: check if it only contains digits or dots */
- test = g_strdup (suffix);
- g_strcanon (test, "0123456789.", 'X');
- if (strstr (test, "X")) {
- g_free (test);
- continue;
- }
- g_free (test);
- g_hash_table_insert (candidates, suffix, g_strdup (*cur));
+ gchar *full;
+
+ /* is it executable ? */
+ full = g_build_filename (*cur, entry, NULL);
+ if (!g_file_test (full, G_FILE_TEST_IS_EXECUTABLE)) {
+ g_free (full);
+ continue;
+ }
+ g_free (full);
+
+ /* strip base and dash from it */
+ suffix = g_strdup (&(entry[strlen (base) + 1]));
+
+ /* stricter pattern check: check if it only contains digits or dots */
+ test = g_strdup (suffix);
+ g_strcanon (test, "0123456789.", 'X');
+ if (strstr (test, "X")) {
+ g_free (test);
+ continue;
+ }
+ g_free (test);
+ g_hash_table_insert (candidates, suffix, g_strdup (*cur));
}
}
}
return candidates;
}
-int main (int argc, char **argv)
+int
+main (int argc, char **argv)
{
GHashTable *candidates;
gchar *dir;
gchar *base;
gchar *highest = NULL;
- gchar *binary; /* actual binary we're going to run */
- gchar *path = NULL; /* and its path */
+ gchar *binary; /* actual binary we're going to run */
+ gchar *path = NULL; /* and its path */
poptContext ctx;
int nextopt;
for (i = 0; i < argc; ++i) {
g_print ("%s", argv[i]);
if (i < argc - 1)
- g_print (" ");
+ g_print (" ");
}
g_print ("\n");
}
while (!FOUND) {
if (!gst_bin_iterate (GST_BIN (pipeline)))
- break;
+ break;
}
if (!FOUND) {
g_print ("%s - No type found\n", argv[i]);
definition = gst_format_get_details (*formats);
if (definition)
PUT_STRING (pfx, "<format id=\"%d\" nick=\"%s\">%s</format>",
- *formats, definition->nick, definition->description);
+ *formats, definition->nick, definition->description);
else
PUT_STRING (pfx, "<format id=\"%d\">unknown</format>", *formats);
definition = gst_query_type_get_details (*types);
if (definition)
PUT_STRING (pfx, "<query-type id=\"%d\" nick=\"%s\">%s</query-type>",
- *types, definition->nick, definition->description);
+ *types, definition->nick, definition->description);
else
PUT_STRING (pfx, "<query-type id=\"%d\">unknown</query-type>", *types);
switch (masks->type) {
case GST_EVENT_SEEK:
- flags = masks->flags;
- event_flags = gst_seek_type_get_type ();
- flags_class = (GFlagsClass *) g_type_class_ref (event_flags);
- break;
+ flags = masks->flags;
+ event_flags = gst_seek_type_get_type ();
+ flags_class = (GFlagsClass *) g_type_class_ref (event_flags);
+ break;
default:
- break;
+ break;
}
value = g_enum_get_value (klass, masks->type);
GFlagsValue *value;
if (flags & 1) {
- value = g_flags_get_first_value (flags_class, 1 << index);
+ value = g_flags_get_first_value (flags_class, 1 << index);
- if (value)
- PUT_ESCAPED (pfx + 1, "flag", value->value_nick);
- else
- PUT_ESCAPED (pfx + 1, "flag", "?");
+ if (value)
+ PUT_ESCAPED (pfx + 1, "flag", value->value_nick);
+ else
+ PUT_ESCAPED (pfx + 1, "flag", "?");
}
flags >>= 1;
index++;
switch (G_VALUE_TYPE (&value)) {
case G_TYPE_STRING:
- PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
- break;
+ PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
+ break;
case G_TYPE_BOOLEAN:
- PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
- break;
+ PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
+ break;
case G_TYPE_ULONG:
{
- GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (param);
+ GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (param);
- PUT_STRING (pfx + 2, "<range min=\"%lu\" max=\"%lu\"/>",
- pulong->minimum, pulong->maximum);
- PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
- break;
+ PUT_STRING (pfx + 2, "<range min=\"%lu\" max=\"%lu\"/>",
+ pulong->minimum, pulong->maximum);
+ PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
+ break;
}
case G_TYPE_LONG:
{
- GParamSpecLong *plong = G_PARAM_SPEC_LONG (param);
+ GParamSpecLong *plong = G_PARAM_SPEC_LONG (param);
- PUT_STRING (pfx + 2, "<range min=\"%ld\" max=\"%ld\"/>",
- plong->minimum, plong->maximum);
- PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
- break;
+ PUT_STRING (pfx + 2, "<range min=\"%ld\" max=\"%ld\"/>",
+ plong->minimum, plong->maximum);
+ PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
+ break;
}
case G_TYPE_UINT:
{
- GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param);
+ GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param);
- PUT_STRING (pfx + 2, "<range min=\"%u\" max=\"%u\"/>",
- puint->minimum, puint->maximum);
- PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
- break;
+ PUT_STRING (pfx + 2, "<range min=\"%u\" max=\"%u\"/>",
+ puint->minimum, puint->maximum);
+ PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
+ break;
}
case G_TYPE_INT:
{
- GParamSpecInt *pint = G_PARAM_SPEC_INT (param);
+ GParamSpecInt *pint = G_PARAM_SPEC_INT (param);
- PUT_STRING (pfx + 2, "<range min=\"%d\" max=\"%d\"/>",
- pint->minimum, pint->maximum);
- PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
- break;
+ PUT_STRING (pfx + 2, "<range min=\"%d\" max=\"%d\"/>",
+ pint->minimum, pint->maximum);
+ PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
+ break;
}
case G_TYPE_UINT64:
{
- GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64 (param);
+ GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64 (param);
- PUT_STRING (pfx + 2,
- "<range min=\"%" G_GUINT64_FORMAT "\" max=\"%" G_GUINT64_FORMAT
- "\"/>", puint64->minimum, puint64->maximum);
- PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
- break;
+ PUT_STRING (pfx + 2,
+ "<range min=\"%" G_GUINT64_FORMAT "\" max=\"%" G_GUINT64_FORMAT
+ "\"/>", puint64->minimum, puint64->maximum);
+ PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
+ break;
}
case G_TYPE_INT64:
{
- GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64 (param);
+ GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64 (param);
- PUT_STRING (pfx + 2,
- "<range min=\"%" G_GINT64_FORMAT "\" max=\"%" G_GINT64_FORMAT
- "\"/>", pint64->minimum, pint64->maximum);
- PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
- break;
+ PUT_STRING (pfx + 2,
+ "<range min=\"%" G_GINT64_FORMAT "\" max=\"%" G_GINT64_FORMAT
+ "\"/>", pint64->minimum, pint64->maximum);
+ PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
+ break;
}
case G_TYPE_FLOAT:
{
- GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (param);
+ GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (param);
- PUT_STRING (pfx + 2, "<range min=\"%f\" max=\"%f\"/>",
- pfloat->minimum, pfloat->maximum);
- PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
- break;
+ PUT_STRING (pfx + 2, "<range min=\"%f\" max=\"%f\"/>",
+ pfloat->minimum, pfloat->maximum);
+ PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
+ break;
}
case G_TYPE_DOUBLE:
{
- GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE (param);
+ GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE (param);
- PUT_STRING (pfx + 2, "<range min=\"%g\" max=\"%g\"/>",
- pdouble->minimum, pdouble->maximum);
- PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
- break;
+ PUT_STRING (pfx + 2, "<range min=\"%g\" max=\"%g\"/>",
+ pdouble->minimum, pdouble->maximum);
+ PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
+ break;
}
default:
- if (param->value_type == GST_TYPE_CAPS) {
- GstCaps *caps = g_value_peek_pointer (&value);
-
- if (!caps)
- PUT_ESCAPED (pfx + 2, "default", "NULL");
- else {
- print_caps (caps, 2);
- }
- } else if (G_IS_PARAM_SPEC_ENUM (param)) {
- GEnumValue *values;
- guint j = 0;
- gint enum_value;
-
- values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values;
- enum_value = g_value_get_enum (&value);
-
- while (values[j].value_name) {
- if (values[j].value == enum_value)
- break;
- j++;
- }
- PUT_STRING (pfx + 2, "<default>%d</default>", values[j].value);
-
- PUT_START_TAG (pfx + 2, "enum-values");
- j = 0;
- while (values[j].value_name) {
- PUT_STRING (pfx + 3, "<value value=\"%d\" nick=\"%s\"/>",
- values[j].value, values[j].value_nick);
- j++;
- }
- PUT_END_TAG (pfx + 2, "enum-values");
- } else if (G_IS_PARAM_SPEC_FLAGS (param)) {
- GFlagsValue *values;
- guint j = 0;
- gint flags_value;
-
- values = G_FLAGS_CLASS (g_type_class_ref (param->value_type))->values;
- flags_value = g_value_get_flags (&value);
-
- PUT_STRING (pfx + 2, "<default>%d</default>", flags_value);
-
- PUT_START_TAG (pfx + 2, "flags");
- j = 0;
- while (values[j].value_name) {
- PUT_STRING (pfx + 3, "<flag value=\"%d\" nick=\"%s\"/>",
- values[j].value, values[j].value_nick);
- j++;
- }
- PUT_END_TAG (pfx + 2, "flags");
- } else if (G_IS_PARAM_SPEC_OBJECT (param)) {
- PUT_ESCAPED (pfx + 2, "object-type", g_type_name (param->value_type));
- }
- break;
+ if (param->value_type == GST_TYPE_CAPS) {
+ GstCaps *caps = g_value_peek_pointer (&value);
+
+ if (!caps)
+ PUT_ESCAPED (pfx + 2, "default", "NULL");
+ else {
+ print_caps (caps, 2);
+ }
+ } else if (G_IS_PARAM_SPEC_ENUM (param)) {
+ GEnumValue *values;
+ guint j = 0;
+ gint enum_value;
+
+ values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values;
+ enum_value = g_value_get_enum (&value);
+
+ while (values[j].value_name) {
+ if (values[j].value == enum_value)
+ break;
+ j++;
+ }
+ PUT_STRING (pfx + 2, "<default>%d</default>", values[j].value);
+
+ PUT_START_TAG (pfx + 2, "enum-values");
+ j = 0;
+ while (values[j].value_name) {
+ PUT_STRING (pfx + 3, "<value value=\"%d\" nick=\"%s\"/>",
+ values[j].value, values[j].value_nick);
+ j++;
+ }
+ PUT_END_TAG (pfx + 2, "enum-values");
+ } else if (G_IS_PARAM_SPEC_FLAGS (param)) {
+ GFlagsValue *values;
+ guint j = 0;
+ gint flags_value;
+
+ values = G_FLAGS_CLASS (g_type_class_ref (param->value_type))->values;
+ flags_value = g_value_get_flags (&value);
+
+ PUT_STRING (pfx + 2, "<default>%d</default>", flags_value);
+
+ PUT_START_TAG (pfx + 2, "flags");
+ j = 0;
+ while (values[j].value_name) {
+ PUT_STRING (pfx + 3, "<flag value=\"%d\" nick=\"%s\"/>",
+ values[j].value, values[j].value_nick);
+ j++;
+ }
+ PUT_END_TAG (pfx + 2, "flags");
+ } else if (G_IS_PARAM_SPEC_OBJECT (param)) {
+ PUT_ESCAPED (pfx + 2, "object-type", g_type_name (param->value_type));
+ }
+ break;
}
PUT_END_TAG (pfx + 1, "element-property");
PUT_ESCAPED (pfx + 2, "blurb", g_param_spec_get_blurb (specs[x]));
switch (G_PARAM_SPEC_VALUE_TYPE (specs[x])) {
- case G_TYPE_INT64:
- PUT_STRING (pfx + 2,
- "<range min=\"%" G_GINT64_FORMAT "\" max=\"%" G_GINT64_FORMAT
- "\"/>", ((GParamSpecInt64 *) specs[x])->minimum,
- ((GParamSpecInt64 *) specs[x])->maximum);
- PUT_STRING (pfx + 2, "<default>%" G_GINT64_FORMAT "</default>",
- ((GParamSpecInt64 *) specs[x])->default_value);
- break;
- case G_TYPE_INT:
- PUT_STRING (pfx + 2, "<range min=\"%d\" max=\"%d\"/>",
- ((GParamSpecInt *) specs[x])->minimum,
- ((GParamSpecInt *) specs[x])->maximum);
- PUT_STRING (pfx + 2, "<default>%d</default>",
- ((GParamSpecInt *) specs[x])->default_value);
- break;
- case G_TYPE_FLOAT:
- PUT_STRING (pfx + 2, "<range min=\"%f\" max=\"%f\"/>",
- ((GParamSpecFloat *) specs[x])->minimum,
- ((GParamSpecFloat *) specs[x])->maximum);
- PUT_STRING (pfx + 2, "<default>%f</default>",
- ((GParamSpecFloat *) specs[x])->default_value);
- break;
- default:
- break;
+ case G_TYPE_INT64:
+ PUT_STRING (pfx + 2,
+ "<range min=\"%" G_GINT64_FORMAT "\" max=\"%" G_GINT64_FORMAT
+ "\"/>", ((GParamSpecInt64 *) specs[x])->minimum,
+ ((GParamSpecInt64 *) specs[x])->maximum);
+ PUT_STRING (pfx + 2, "<default>%" G_GINT64_FORMAT "</default>",
+ ((GParamSpecInt64 *) specs[x])->default_value);
+ break;
+ case G_TYPE_INT:
+ PUT_STRING (pfx + 2, "<range min=\"%d\" max=\"%d\"/>",
+ ((GParamSpecInt *) specs[x])->minimum,
+ ((GParamSpecInt *) specs[x])->maximum);
+ PUT_STRING (pfx + 2, "<default>%d</default>",
+ ((GParamSpecInt *) specs[x])->default_value);
+ break;
+ case G_TYPE_FLOAT:
+ PUT_STRING (pfx + 2, "<range min=\"%f\" max=\"%f\"/>",
+ ((GParamSpecFloat *) specs[x])->minimum,
+ ((GParamSpecFloat *) specs[x])->maximum);
+ PUT_STRING (pfx + 2, "<default>%f</default>",
+ ((GParamSpecFloat *) specs[x])->default_value);
+ break;
+ default:
+ break;
}
PUT_END_TAG (pfx + 1, "dyn-param");
}
g_signal_query (signals[i], query);
if ((k == 0 && !(query->signal_flags & G_SIGNAL_ACTION)) ||
- (k == 1 && (query->signal_flags & G_SIGNAL_ACTION))) {
- n_params = query->n_params;
- return_type = query->return_type;
- param_types = query->param_types;
+ (k == 1 && (query->signal_flags & G_SIGNAL_ACTION))) {
+ n_params = query->n_params;
+ return_type = query->return_type;
+ param_types = query->param_types;
- PUT_START_TAG (pfx + 1, "signal");
- PUT_ESCAPED (pfx + 2, "name", query->signal_name);
- PUT_ESCAPED (pfx + 2, "return-type", g_type_name (return_type));
- PUT_ESCAPED (pfx + 2, "object-type",
- g_type_name (G_OBJECT_TYPE (element)));
+ PUT_START_TAG (pfx + 1, "signal");
+ PUT_ESCAPED (pfx + 2, "name", query->signal_name);
+ PUT_ESCAPED (pfx + 2, "return-type", g_type_name (return_type));
+ PUT_ESCAPED (pfx + 2, "object-type",
+ g_type_name (G_OBJECT_TYPE (element)));
- PUT_START_TAG (pfx + 2, "params");
- for (j = 0; j < n_params; j++) {
- PUT_ESCAPED (pfx + 3, "type", g_type_name (param_types[j]));
- }
+ PUT_START_TAG (pfx + 2, "params");
+ for (j = 0; j < n_params; j++) {
+ PUT_ESCAPED (pfx + 3, "type", g_type_name (param_types[j]));
+ }
- PUT_END_TAG (pfx + 2, "params");
+ PUT_END_TAG (pfx + 2, "params");
- PUT_END_TAG (pfx + 1, "signal");
+ PUT_END_TAG (pfx + 1, "signal");
- counted++;
+ counted++;
}
g_free (query);
PUT_ESCAPED (3, "name", padtemplate->name_template);
if (padtemplate->direction == GST_PAD_SRC)
- PUT_ESCAPED (3, "direction", "src");
+ PUT_ESCAPED (3, "direction", "src");
else if (padtemplate->direction == GST_PAD_SINK)
- PUT_ESCAPED (3, "direction", "sink");
+ PUT_ESCAPED (3, "direction", "sink");
else
- PUT_ESCAPED (3, "direction", "unkown");
+ PUT_ESCAPED (3, "direction", "unkown");
if (padtemplate->presence == GST_PAD_ALWAYS)
- PUT_ESCAPED (3, "presence", "always");
+ PUT_ESCAPED (3, "presence", "always");
else if (padtemplate->presence == GST_PAD_SOMETIMES)
- PUT_ESCAPED (3, "presence", "sometimes");
+ PUT_ESCAPED (3, "presence", "sometimes");
else if (padtemplate->presence == GST_PAD_REQUEST) {
- PUT_ESCAPED (3, "presence", "request");
- PUT_ESCAPED (3, "request-function",
- GST_DEBUG_FUNCPTR_NAME (gstelement_class->request_new_pad));
+ PUT_ESCAPED (3, "presence", "request");
+ PUT_ESCAPED (3, "request-function",
+ GST_DEBUG_FUNCPTR_NAME (gstelement_class->request_new_pad));
} else
- PUT_ESCAPED (3, "presence", "unkown");
+ PUT_ESCAPED (3, "presence", "unkown");
if (padtemplate->caps) {
- print_caps (padtemplate->caps, 3);
+ print_caps (padtemplate->caps, 3);
}
PUT_END_TAG (2, "pad-template");
}
PUT_START_TAG (1, "element-implementation");
if (element->loopfunc)
PUT_STRING (2, "<loop-based function=\"%s\"/>",
- GST_DEBUG_FUNCPTR_NAME (element->loopfunc));
+ GST_DEBUG_FUNCPTR_NAME (element->loopfunc));
PUT_STRING (2, "<state-change function=\"%s\"/>",
GST_DEBUG_FUNCPTR_NAME (gstelement_class->change_state));
PUT_ESCAPED (3, "name", gst_pad_get_name (pad));
if (gst_pad_get_direction (pad) == GST_PAD_SRC)
- PUT_ESCAPED (3, "direction", "src");
+ PUT_ESCAPED (3, "direction", "src");
else if (gst_pad_get_direction (pad) == GST_PAD_SINK)
- PUT_ESCAPED (3, "direction", "sink");
+ PUT_ESCAPED (3, "direction", "sink");
else
- PUT_ESCAPED (3, "direction", "unkown");
+ PUT_ESCAPED (3, "direction", "unkown");
if (GST_IS_GHOST_PAD (pad))
- PUT_ESCAPED (3, "ghost", gst_pad_get_name (pad));
+ PUT_ESCAPED (3, "ghost", gst_pad_get_name (pad));
if (pad->padtemplate)
- PUT_ESCAPED (3, "template", pad->padtemplate->name_template);
+ PUT_ESCAPED (3, "template", pad->padtemplate->name_template);
PUT_START_TAG (3, "implementation");
if (realpad->chainfunc)
- PUT_STRING (4, "<chain-based function=\"%s\"/>",
- GST_DEBUG_FUNCPTR_NAME (realpad->chainfunc));
+ PUT_STRING (4, "<chain-based function=\"%s\"/>",
+ GST_DEBUG_FUNCPTR_NAME (realpad->chainfunc));
if (realpad->getfunc)
- PUT_STRING (4, "<get-based function=\"%s\"/>",
- GST_DEBUG_FUNCPTR_NAME (realpad->getfunc));
+ PUT_STRING (4, "<get-based function=\"%s\"/>",
+ GST_DEBUG_FUNCPTR_NAME (realpad->getfunc));
if (realpad->formatsfunc != gst_pad_get_formats_default) {
- PUT_STRING (4, "<formats-function function=\"%s\">",
- GST_DEBUG_FUNCPTR_NAME (realpad->formatsfunc));
- print_formats (gst_pad_get_formats (GST_PAD (realpad)), 5);
- PUT_END_TAG (4, "formats-function");
+ PUT_STRING (4, "<formats-function function=\"%s\">",
+ GST_DEBUG_FUNCPTR_NAME (realpad->formatsfunc));
+ print_formats (gst_pad_get_formats (GST_PAD (realpad)), 5);
+ PUT_END_TAG (4, "formats-function");
}
if (realpad->convertfunc != gst_pad_convert_default)
- PUT_STRING (4, "<convert-function function=\"%s\"/>",
- GST_DEBUG_FUNCPTR_NAME (realpad->convertfunc));
+ PUT_STRING (4, "<convert-function function=\"%s\"/>",
+ GST_DEBUG_FUNCPTR_NAME (realpad->convertfunc));
if (realpad->eventfunc != gst_pad_event_default)
- PUT_STRING (4, "<event-function function=\"%s\"/>",
- GST_DEBUG_FUNCPTR_NAME (realpad->eventfunc));
+ PUT_STRING (4, "<event-function function=\"%s\"/>",
+ GST_DEBUG_FUNCPTR_NAME (realpad->eventfunc));
if (realpad->eventmaskfunc != gst_pad_get_event_masks_default) {
- PUT_STRING (4, "<event-mask-func function=\"%s\">",
- GST_DEBUG_FUNCPTR_NAME (realpad->eventmaskfunc));
- print_event_masks (gst_pad_get_event_masks (GST_PAD (realpad)), 5);
- PUT_END_TAG (4, "event-mask-func");
+ PUT_STRING (4, "<event-mask-func function=\"%s\">",
+ GST_DEBUG_FUNCPTR_NAME (realpad->eventmaskfunc));
+ print_event_masks (gst_pad_get_event_masks (GST_PAD (realpad)), 5);
+ PUT_END_TAG (4, "event-mask-func");
}
if (realpad->queryfunc != gst_pad_query_default)
- PUT_STRING (4, "<query-function function=\"%s\"/>",
- GST_DEBUG_FUNCPTR_NAME (realpad->queryfunc));
+ PUT_STRING (4, "<query-function function=\"%s\"/>",
+ GST_DEBUG_FUNCPTR_NAME (realpad->queryfunc));
if (realpad->querytypefunc != gst_pad_get_query_types_default) {
- PUT_STRING (4, "<query-type-func function=\"%s\">",
- GST_DEBUG_FUNCPTR_NAME (realpad->querytypefunc));
- print_query_types (gst_pad_get_query_types (GST_PAD (realpad)), 5);
- PUT_END_TAG (4, "query-type-func");
+ PUT_STRING (4, "<query-type-func function=\"%s\">",
+ GST_DEBUG_FUNCPTR_NAME (realpad->querytypefunc));
+ print_query_types (gst_pad_get_query_types (GST_PAD (realpad)), 5);
+ PUT_END_TAG (4, "query-type-func");
}
if (realpad->intlinkfunc != gst_pad_get_internal_links_default)
- PUT_STRING (4, "<intlink-function function=\"%s\"/>",
- GST_DEBUG_FUNCPTR_NAME (realpad->intlinkfunc));
+ PUT_STRING (4, "<intlink-function function=\"%s\"/>",
+ GST_DEBUG_FUNCPTR_NAME (realpad->intlinkfunc));
if (realpad->bufferallocfunc)
- PUT_STRING (4, "<bufferalloc-function function=\"%s\"/>",
- GST_DEBUG_FUNCPTR_NAME (realpad->bufferallocfunc));
+ PUT_STRING (4, "<bufferalloc-function function=\"%s\"/>",
+ GST_DEBUG_FUNCPTR_NAME (realpad->bufferallocfunc));
PUT_END_TAG (3, "implementation");
if (realpad->caps) {
- print_caps (realpad->caps, 3);
+ print_caps (realpad->caps, 3);
}
PUT_END_TAG (2, "pad");
}
feature = GST_PLUGIN_FEATURE (features->data);
if (GST_IS_ELEMENT_FACTORY (feature)) {
- GstElementFactory *factory;
+ GstElementFactory *factory;
- factory = GST_ELEMENT_FACTORY (feature);
- g_print ("%s: %s: %s\n", plugin->desc.name,
- GST_PLUGIN_FEATURE_NAME (factory), factory->details.longname);
+ factory = GST_ELEMENT_FACTORY (feature);
+ g_print ("%s: %s: %s\n", plugin->desc.name,
+ GST_PLUGIN_FEATURE_NAME (factory), factory->details.longname);
}
#ifndef GST_DISABLE_INDEX
else if (GST_IS_INDEX_FACTORY (feature)) {
- GstIndexFactory *factory;
+ GstIndexFactory *factory;
- factory = GST_INDEX_FACTORY (feature);
- g_print ("%s: %s: %s\n", plugin->desc.name,
- GST_PLUGIN_FEATURE_NAME (factory), factory->longdesc);
+ factory = GST_INDEX_FACTORY (feature);
+ g_print ("%s: %s: %s\n", plugin->desc.name,
+ GST_PLUGIN_FEATURE_NAME (factory), factory->longdesc);
}
#endif
else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
- GstTypeFindFactory *factory;
-
- factory = GST_TYPE_FIND_FACTORY (feature);
- if (factory->extensions) {
- guint i = 0;
-
- g_print ("%s type: ", plugin->desc.name);
- while (factory->extensions[i]) {
- g_print ("%s%s", i > 0 ? ", " : "", factory->extensions[i]);
- i++;
- }
- } else
- g_print ("%s type: N/A\n", plugin->desc.name);
+ GstTypeFindFactory *factory;
+
+ factory = GST_TYPE_FIND_FACTORY (feature);
+ if (factory->extensions) {
+ guint i = 0;
+
+ g_print ("%s type: ", plugin->desc.name);
+ while (factory->extensions[i]) {
+ g_print ("%s%s", i > 0 ? ", " : "", factory->extensions[i]);
+ i++;
+ }
+ } else
+ g_print ("%s type: N/A\n", plugin->desc.name);
} else if (GST_IS_SCHEDULER_FACTORY (feature)) {
- GstSchedulerFactory *factory;
+ GstSchedulerFactory *factory;
- factory = GST_SCHEDULER_FACTORY (feature);
- g_print ("%s: %s: %s\n", plugin->desc.name,
- GST_PLUGIN_FEATURE_NAME (factory), factory->longdesc);
+ factory = GST_SCHEDULER_FACTORY (feature);
+ g_print ("%s: %s: %s\n", plugin->desc.name,
+ GST_PLUGIN_FEATURE_NAME (factory), factory->longdesc);
} else {
- g_print ("%s: %s (%s)\n", plugin->desc.name,
- GST_PLUGIN_FEATURE_NAME (feature),
- g_type_name (G_OBJECT_TYPE (feature)));
+ g_print ("%s: %s (%s)\n", plugin->desc.name,
+ GST_PLUGIN_FEATURE_NAME (feature),
+ g_type_name (G_OBJECT_TYPE (feature)));
}
features = g_list_next (features);
factory = GST_ELEMENT_FACTORY (feature);
g_print (" %s: %s\n", GST_OBJECT_NAME (factory),
- factory->details.longname);
+ factory->details.longname);
num_elements++;
}
#ifndef GST_DISABLE_INDEX
factory = GST_TYPE_FIND_FACTORY (feature);
if (factory->extensions) {
- guint i = 0;
+ guint i = 0;
- g_print ("%s type: ", plugin->desc.name);
- while (factory->extensions[i]) {
- g_print ("%s%s", i > 0 ? ", " : "", factory->extensions[i]);
- i++;
- }
+ g_print ("%s type: ", plugin->desc.name);
+ while (factory->extensions[i]) {
+ g_print ("%s%s", i > 0 ? ", " : "", factory->extensions[i]);
+ i++;
+ }
} else
- g_print ("%s type: N/A\n", plugin->desc.name);
+ g_print ("%s type: N/A\n", plugin->desc.name);
num_types++;
} else if (GST_IS_SCHEDULER_FACTORY (feature)) {
GstSchedulerFactory *factory;
num_schedulers++;
} else {
g_print (" %s (%s)\n", gst_object_get_name (GST_OBJECT (feature)),
- g_type_name (G_OBJECT_TYPE (feature)));
+ g_type_name (G_OBJECT_TYPE (feature)));
num_other++;
}
num_features++;
gchar *so;
struct poptOption options[] = {
{"gst-inspect-plugin", 'p', POPT_ARG_STRING | POPT_ARGFLAG_STRIP, NULL, 0,
- "Show plugin details", NULL},
+ "Show plugin details", NULL},
{"gst-inspect-scheduler", 's', POPT_ARG_STRING | POPT_ARGFLAG_STRIP, NULL,
- 0,
- "Show scheduler details", NULL},
+ 0,
+ "Show scheduler details", NULL},
POPT_TABLEEND
};
g_print ("Usage: %s\t\t\tList all registered elements\n", argv[0]);
g_print (" %s element-name\tShow element details\n", argv[0]);
g_print (" %s plugin-name[.so]\tShow information about plugin\n",
- argv[0]);
+ argv[0]);
return 0;
}
/* if there's a factory, print out the info */
if (factory)
- return print_element_info (factory);
+ return print_element_info (factory);
else {
- GstPluginFeature *feature;
-
- /* FIXME implement other pretty print function for these */
- feature = gst_registry_pool_find_feature (argv[1],
- GST_TYPE_SCHEDULER_FACTORY);
- if (feature) {
- g_print ("%s: a scheduler\n", argv[1]);
- return 0;
- }
+ GstPluginFeature *feature;
+
+ /* FIXME implement other pretty print function for these */
+ feature = gst_registry_pool_find_feature (argv[1],
+ GST_TYPE_SCHEDULER_FACTORY);
+ if (feature) {
+ g_print ("%s: a scheduler\n", argv[1]);
+ return 0;
+ }
#ifndef GST_DISABLE_INDEX
- feature = gst_registry_pool_find_feature (argv[1],
- GST_TYPE_INDEX_FACTORY);
- if (feature) {
- g_print ("%s: an index\n", argv[1]);
- return 0;
- }
+ feature = gst_registry_pool_find_feature (argv[1],
+ GST_TYPE_INDEX_FACTORY);
+ if (feature) {
+ g_print ("%s: an index\n", argv[1]);
+ return 0;
+ }
#endif
- feature = gst_registry_pool_find_feature (argv[1],
- GST_TYPE_TYPE_FIND_FACTORY);
- if (feature) {
- g_print ("%s: a type find function\n", argv[1]);
- return 0;
- }
+ feature = gst_registry_pool_find_feature (argv[1],
+ GST_TYPE_TYPE_FIND_FACTORY);
+ if (feature) {
+ g_print ("%s: a type find function\n", argv[1]);
+ return 0;
+ }
#ifndef GST_DISABLE_URI
- feature = gst_registry_pool_find_feature (argv[1],
- GST_TYPE_URI_HANDLER);
- if (feature) {
- g_print ("%s: an uri handler\n", argv[1]);
- return 0;
- }
+ feature = gst_registry_pool_find_feature (argv[1],
+ GST_TYPE_URI_HANDLER);
+ if (feature) {
+ g_print ("%s: an uri handler\n", argv[1]);
+ return 0;
+ }
#endif
}
} else {
projects / platform / upstream / gstreamer.git / commitdiff