/**
* helper for gst_goo_util_find_goo_component() to iterate and search
* the members of a bin
*/
static GooComponent *
find_goo_component_in_bin (GstBin *bin, SearchContext *ctx)
{
GstIterator *itr;
gpointer item;
GooComponent *component = NULL;
GST_INFO ("bin=%s (%s)", gst_element_get_name (bin), G_OBJECT_TYPE_NAME (bin));
/* note: we don't handle the case of the underlying data structure changing
* while iterating.. we just bail out and the user needs to restart.
*/
for( itr = gst_bin_iterate_elements (bin);
gst_iterator_next (itr, &item) == GST_ITERATOR_OK && !component;
gst_object_unref (item) )
{
GstElement *elem = GST_ELEMENT (item);
component = check_for_goo_component (elem, ctx);
if( component == NULL )
{
component = find_goo_component (elem, ctx);
}
}
gst_iterator_free (itr);
return component;
}
/**
* gst_camerabin_remove_elements_from_bin:
* @bin: removes all elements from this bin
*
* Removes all elements from this @bin.
*/
void
gst_camerabin_remove_elements_from_bin (GstBin * bin)
{
GstIterator *iter = NULL;
gpointer data = NULL;
GstElement *elem = NULL;
gboolean done = FALSE;
iter = gst_bin_iterate_elements (bin);
while (!done) {
switch (gst_iterator_next (iter, &data)) {
case GST_ITERATOR_OK:
elem = GST_ELEMENT (data);
gst_bin_remove (bin, elem);
/* Iterator increased the element refcount, so unref */
gst_object_unref (elem);
break;
case GST_ITERATOR_RESYNC:
gst_iterator_resync (iter);
break;
case GST_ITERATOR_ERROR:
GST_WARNING_OBJECT (bin, "error in iterating elements");
done = TRUE;
break;
case GST_ITERATOR_DONE:
done = TRUE;
break;
}
}
gst_iterator_free (iter);
}
static guint
watch_container (InsanityGstPipelineTest * ptest, GstBin * bin)
{
GstIterator *it;
gboolean done = FALSE;
GValue data = { 0, };
GstElement *e;
it = gst_bin_iterate_elements (bin);
while (!done) {
switch (gst_iterator_next (it, &data)) {
case GST_ITERATOR_OK:
e = GST_ELEMENT_CAST (g_value_get_object (&data));
add_element_used (ptest, e);
if (GST_IS_BIN (e)) {
watch_container (ptest, GST_BIN (e));
}
g_value_reset (&data);
break;
case GST_ITERATOR_RESYNC:
gst_iterator_resync (it);
break;
case GST_ITERATOR_DONE:
default:
done = TRUE;
break;
}
}
g_value_unset (&data);
gst_iterator_free (it);
return g_signal_connect (bin, "element-added", (GCallback) on_element_added,
ptest);
}
static gboolean
gst_validate_bin_monitor_setup (GstValidateMonitor * monitor)
{
GstIterator *iterator;
gboolean done;
GstElement *element;
GstValidateBinMonitor *bin_monitor = GST_VALIDATE_BIN_MONITOR_CAST (monitor);
GstBin *bin = GST_VALIDATE_BIN_MONITOR_GET_BIN (bin_monitor);
if (!GST_IS_BIN (bin)) {
GST_WARNING_OBJECT (monitor, "Trying to create bin monitor with other "
"type of object");
return FALSE;
}
GST_DEBUG_OBJECT (bin_monitor, "Setting up monitor for bin %" GST_PTR_FORMAT,
bin);
if (g_object_get_data ((GObject *) bin, "validate-monitor")) {
GST_DEBUG_OBJECT (bin_monitor,
"Bin already has a validate-monitor associated");
return FALSE;
}
bin_monitor->element_added_id =
g_signal_connect (bin, "element-added",
G_CALLBACK (_validate_bin_element_added), monitor);
iterator = gst_bin_iterate_elements (bin);
done = FALSE;
while (!done) {
GValue value = { 0, };
switch (gst_iterator_next (iterator, &value)) {
case GST_ITERATOR_OK:
element = g_value_get_object (&value);
gst_validate_bin_monitor_wrap_element (bin_monitor, element);
g_value_reset (&value);
break;
case GST_ITERATOR_RESYNC:
/* TODO how to handle this? */
gst_iterator_resync (iterator);
break;
case GST_ITERATOR_ERROR:
done = TRUE;
break;
case GST_ITERATOR_DONE:
done = TRUE;
break;
}
}
gst_iterator_free (iterator);
return TRUE;
}
GstElement *create_audio_sink()
{
GstElement *bin, *decoder = NULL;
GstIterator *iter;
GstIteratorResult res;
GError *error = NULL;
GstPad *pad;
gpointer element = NULL;
bin = gst_parse_launch_full("decodebin ! queue ! audioconvert \
! audioresample \
! autoaudiosink",
NULL, 0, &error);
if (!bin) {
g_error("GStreamer: failed to parse audio sink pipeline\n");
return NULL;
}
gst_object_set_name(GST_OBJECT(bin), "audio-sink");
iter = gst_bin_iterate_elements(GST_BIN(bin));
res = gst_iterator_next (iter, &element);
while (res == GST_ITERATOR_OK) {
gchar *name;
name = gst_object_get_name(GST_OBJECT (element));
if (name) {
if (!strncmp(name, "decodebin", strlen("decodebin"))) {
decoder = GST_ELEMENT(element);
}
g_printf("GS: audio sink element: %s \n", name);
g_free (name);
}
gst_object_unref (element);
element = NULL;
res = gst_iterator_next (iter, &element);
}
gst_iterator_free (iter);
if (!decoder) {
/* mem leak */
g_printf("decoder element not found\n");
return NULL;
}
/* add ghostpad */
pad = gst_element_get_static_pad(decoder, "sink");
gst_element_add_pad(bin, gst_ghost_pad_new("sink", pad));
gst_object_unref(GST_OBJECT(pad));
return bin;
}
static void
_element_added_callback (GstBin *parent, GstElement *element,
gpointer user_data)
{
FsElementAddedNotifier *notifier = FS_ELEMENT_ADDED_NOTIFIER (user_data);
if (GST_IS_BIN (element)) {
GstIterator *iter = NULL;
gboolean done;
g_signal_connect_object (element, "element-added",
G_CALLBACK (_element_added_callback), notifier, 0);
if (parent)
g_signal_connect_object (element, "parent-unset",
G_CALLBACK (_bin_unparented_cb), notifier, 0);
iter = gst_bin_iterate_elements (GST_BIN (element));
done = FALSE;
while (!done)
{
gpointer item = NULL;
switch (gst_iterator_next (iter, &item)) {
case GST_ITERATOR_OK:
/* We make sure the callback has not already been added */
if (g_signal_handler_find (item,
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA,
0, 0, NULL, /* id, detail, closure */
_element_added_callback, notifier) == 0)
_element_added_callback (GST_BIN_CAST (element), item, notifier);
gst_object_unref (item);
break;
case GST_ITERATOR_RESYNC:
// We don't rollback anything, we just ignore already processed ones
gst_iterator_resync (iter);
break;
case GST_ITERATOR_ERROR:
g_error ("Wrong parameters were given?");
done = TRUE;
break;
case GST_ITERATOR_DONE:
done = TRUE;
break;
}
}
gst_iterator_free (iter);
}
g_signal_emit (notifier, signals[ELEMENT_ADDED], 0, parent, element);
}
static void
gst_wrapper_camera_bin_reset_video_src_caps (GstWrapperCameraBinSrc * self,
GstCaps * caps)
{
GstClock *clock;
gint64 base_time;
GST_DEBUG_OBJECT (self, "Resetting src caps to %" GST_PTR_FORMAT, caps);
if (self->src_vid_src) {
clock = gst_element_get_clock (self->src_vid_src);
base_time = gst_element_get_base_time (self->src_vid_src);
gst_element_set_state (self->src_vid_src, GST_STATE_READY);
set_capsfilter_caps (self, caps);
self->drop_newseg = TRUE;
GST_DEBUG_OBJECT (self, "Bringing source up");
gst_element_sync_state_with_parent (self->src_vid_src);
if (clock) {
gst_element_set_clock (self->src_vid_src, clock);
gst_element_set_base_time (self->src_vid_src, base_time);
if (GST_IS_BIN (self->src_vid_src)) {
GstIterator *it =
gst_bin_iterate_elements (GST_BIN (self->src_vid_src));
gpointer item = NULL;
gboolean done = FALSE;
while (!done) {
switch (gst_iterator_next (it, &item)) {
case GST_ITERATOR_OK:
gst_element_set_base_time (GST_ELEMENT (item), base_time);
gst_object_unref (item);
break;
case GST_ITERATOR_RESYNC:
gst_iterator_resync (it);
break;
case GST_ITERATOR_ERROR:
done = TRUE;
break;
case GST_ITERATOR_DONE:
done = TRUE;
break;
}
}
gst_iterator_free (it);
}
gst_object_unref (clock);
}
}
}
gboolean gstreamer_run_pipeline(GMainLoop *loop, const char *s, StartupState state) {
main_set_real_time_scheduling_policy();
GError *error = NULL;
pipeline = gst_parse_launch(s, &error);
if (!pipeline) {
printf("Error: Could not create gstreamer pipeline.\n");
printf("Parse error: %s\n", error->message);
return FALSE;
}
bus_quit_on_playing = FALSE;
GstBus *bus;
bus = gst_pipeline_get_bus(GST_PIPELINE(pipeline));
bus_watch_id = gst_bus_add_watch(bus, bus_callback, loop);
if (main_have_gui())
#if GST_CHECK_VERSION(1, 0, 0)
gst_bus_set_sync_handler(bus, (GstBusSyncHandler)bus_sync_handler, NULL, NULL);
#else
gst_bus_set_sync_handler(bus, (GstBusSyncHandler)bus_sync_handler, NULL);
#endif
gst_object_unref(bus);
// Iterate over all elements of the pipeline to hook a handler
// listing newly created pads.
if (created_pads_list != NULL) {
g_list_free(created_pads_list);
created_pads_list = NULL;
}
GstIterator *iterator = gst_bin_iterate_elements(GST_BIN(pipeline));
gst_iterator_foreach(iterator, for_each_pipeline_element, NULL);
gst_iterator_free(iterator);
stats_reset();
gst_element_set_state(pipeline, GST_STATE_READY);
state_change_to_playing_already_occurred = FALSE;
if (state == STARTUP_PLAYING)
gst_element_set_state(pipeline, GST_STATE_PLAYING);
else
gst_element_set_state(pipeline, GST_STATE_PAUSED);
pipeline_description = s;
end_of_stream = FALSE;
inform_pipeline_destroyed_cb_list = NULL;
return TRUE;
}
static void hook_element (GstElement *elem, PipelineChangeListenerContext *ctx)
{
GstIterator *itr;
gpointer item;
/* check if we've already examined this element, to prevent loops: */
if (!already_visited (ctx->visited_nodes, elem))
{
GST_INFO_OBJECT (elem, "");
g_signal_connect (elem, "pad-added", (GCallback)pad_added, ctx);
/* Since it is likely that some pads are already hooked, let's iterate them
* (since there will be no pad-added signal for them) and simulate the
* the missed signal
*
* XXX here we probably should do something sane if the underlying data
* structure changes as we iterate.. hmm
*/
for( itr = gst_element_iterate_pads (elem);
gst_iterator_next (itr, &item) == GST_ITERATOR_OK;
gst_object_unref (item) )
{
pad_added (elem, GST_PAD(item), ctx);
}
gst_iterator_free (itr);
/* in case this elem is a bin, we need to hook all the elements within
* the bin too:
*/
if( GST_IS_BIN (elem) )
{
for( itr = gst_bin_iterate_elements (GST_BIN (elem));
gst_iterator_next (itr, &item) == GST_ITERATOR_OK;
gst_object_unref (item) )
{
hook_element (GST_ELEMENT (item), ctx);
}
gst_iterator_free (itr);
}
ctx->needs_cb = TRUE;
}
}
void
MediaPipelineImpl::setLatencyStats (bool latencyStats)
{
GstIterator *it;
gboolean done = FALSE;
GValue item = G_VALUE_INIT;
std::unique_lock <std::recursive_mutex> lock (recMutex);
if (this->latencyStats == latencyStats) {
return;
}
this->latencyStats = latencyStats;
it = gst_bin_iterate_elements (GST_BIN (pipeline) );
while (!done) {
switch (gst_iterator_next (it, &item) ) {
case GST_ITERATOR_OK: {
GstElement *element = GST_ELEMENT (g_value_get_object (&item) );
if (KMS_IS_ELEMENT (element) ) {
g_object_set (element, "media-stats", latencyStats, NULL);
}
g_value_reset (&item);
break;
}
case GST_ITERATOR_RESYNC:
gst_iterator_resync (it);
break;
case GST_ITERATOR_ERROR:
case GST_ITERATOR_DONE:
done = TRUE;
break;
}
}
g_value_unset (&item);
gst_iterator_free (it);
}
static GstElement *
gst_auto_convert_get_element_by_type (GstAutoConvert * autoconvert, GType type)
{
GstIterator *iter = NULL;
GstElement *elem = NULL;
gboolean done;
g_return_val_if_fail (type != 0, NULL);
iter = gst_bin_iterate_elements (GST_BIN (autoconvert));
if (!iter)
return NULL;
done = FALSE;
while (!done) {
switch (gst_iterator_next (iter, (gpointer) & elem)) {
case GST_ITERATOR_OK:
if (G_OBJECT_TYPE (elem) == type)
done = TRUE;
else
gst_object_unref (elem);
break;
case GST_ITERATOR_RESYNC:
gst_iterator_resync (iter);
elem = NULL;
break;
case GST_ITERATOR_ERROR:
GST_ERROR ("Error iterating elements in bin");
elem = NULL;
done = TRUE;
break;
case GST_ITERATOR_DONE:
elem = NULL;
done = TRUE;
break;
}
}
gst_iterator_free (iter);
return elem;
}
static void
_bin_unparented_cb (GstObject *object, GstObject *parent, gpointer user_data)
{
GstIterator *iter = NULL;
gboolean done;
/* Return if there was no handler connected */
if (g_signal_handlers_disconnect_by_func (object, _element_added_callback,
user_data) == 0)
return;
iter = gst_bin_iterate_elements (GST_BIN (object));
done = FALSE;
while (!done)
{
gpointer item;
switch (gst_iterator_next (iter, &item)) {
case GST_ITERATOR_OK:
if (GST_IS_BIN (item))
_bin_unparented_cb (GST_OBJECT (item), object, user_data);
gst_object_unref (item);
break;
case GST_ITERATOR_RESYNC:
// We don't rollback anything, we just ignore already processed ones
gst_iterator_resync (iter);
break;
case GST_ITERATOR_ERROR:
g_error ("Wrong parameters were given?");
done = TRUE;
break;
case GST_ITERATOR_DONE:
done = TRUE;
break;
}
}
gst_iterator_free (iter);
}
static int cleanup_pipeline()
{
GError *error = NULL;
GstIterator *iter;
GstIteratorResult res;
gpointer elts[2], element = NULL;
int i, ct;
ct = 0;
memset(elts, 0, sizeof(elts));
iter = gst_bin_iterate_elements(GST_BIN(g_pipeline));
res = gst_iterator_next(iter, &element);
while (res == GST_ITERATOR_OK) {
gchar *name;
assert(ct < (sizeof elts / sizeof(elts[0])));
elts[ct] = element;
ct++;
name = gst_object_get_name(GST_OBJECT(element));
if (name) {
g_printf("GS: removing pipe element: %s \n", name);
g_free (name);
}
gst_object_unref(element);
element = NULL;
res = gst_iterator_next(iter, &element);
}
gst_iterator_free (iter);
for (i = 0; i < ct; i++) {
gst_bin_remove(GST_BIN(g_pipeline), elts[i]);
}
}
MbEvent *
handle_application_message (GstMessage *message)
{
MbEvent *mb_event = NULL;
const GstStructure *msg_struct = NULL;
int evt_type;
msg_struct = gst_message_get_structure(message);
gst_structure_get_int (msg_struct, "event_type", &evt_type);
switch (evt_type)
{
case APP_EVT_MEDIA_END:
{
if (gst_structure_has_field(msg_struct, "data"))
{
MbMedia *media = NULL;
GstElement *bin = NULL, *element = NULL;
GstIterator *bin_it = NULL;
GValue data = G_VALUE_INIT;
gboolean done = FALSE;
gst_structure_get (msg_struct, "data", G_TYPE_POINTER, &media,
NULL);
g_assert (media);
bin = gst_bin_get_by_name(GST_BIN(_mb_global_data.pipeline),
media->name);
g_assert (bin);
gst_element_set_state(bin, GST_STATE_NULL);
gst_bin_remove (GST_BIN (_mb_global_data.pipeline), bin);
bin_it = gst_bin_iterate_elements(GST_BIN(bin));
while (!done)
{
switch (gst_iterator_next (bin_it, &data))
{
case GST_ITERATOR_OK:
{
element = GST_ELEMENT(g_value_get_object (&data));
g_assert (element);
/* we increment the ref_count to destroy this element
* only when calling the function mb_media_free ()
*/
g_debug ("Removing %s from pipeline.\n", media->name);
gst_object_ref(element);
gst_bin_remove(GST_BIN(bin), element);
gst_element_set_state(element, GST_STATE_NULL);
break;
}
case GST_ITERATOR_RESYNC:
{
gst_iterator_resync (bin_it);
break;
}
case GST_ITERATOR_ERROR:
case GST_ITERATOR_DONE:
{
done = TRUE;
break;
}
default:
break;
}
}
gst_iterator_free(bin_it);
gst_object_unref(bin);
mb_event = create_state_change_event (MB_REMOVED, media->name);
}
break;
}
}
return mb_event;
}
/*
* debug_dump_element:
* @bin: the bin that should be analyzed
* @out: file to write to
* @indent: level of graph indentation
*
* Helper for _gst_debug_bin_to_dot_file() to recursively dump a pipeline.
*/
static void
debug_dump_element (GstBin * bin, GstDebugGraphDetails details, FILE * out,
const gint indent)
{
GstIterator *element_iter, *pad_iter;
gboolean elements_done, pads_done;
GstElement *element, *peer_element, *target_element;
GstPad *pad, *peer_pad, *target_pad;
GstPadDirection dir;
GstCaps *caps;
GstStructure *structure;
gboolean free_caps, free_media;
guint src_pads, sink_pads;
gchar *media = NULL;
gchar *pad_name, *element_name;
gchar *peer_pad_name, *peer_element_name;
gchar *target_pad_name, *target_element_name;
gchar *color_name;
gchar *state_name = NULL;
gchar *param_name = NULL;
gchar *spc = NULL;
spc = g_malloc (1 + indent * 2);
memset (spc, 32, indent * 2);
spc[indent * 2] = '\0';
element_iter = gst_bin_iterate_elements (bin);
elements_done = FALSE;
while (!elements_done) {
switch (gst_iterator_next (element_iter, (gpointer) & element)) {
case GST_ITERATOR_OK:
element_name = debug_dump_make_object_name (GST_OBJECT (element));
if (details & GST_DEBUG_GRAPH_SHOW_STATES) {
state_name = debug_dump_get_element_state (GST_ELEMENT (element));
}
if (details & GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS) {
param_name = debug_dump_get_element_params (GST_ELEMENT (element));
}
/* elements */
fprintf (out, "%ssubgraph cluster_%s {\n", spc, element_name);
fprintf (out, "%s fontname=\"Bitstream Vera Sans\";\n", spc);
fprintf (out, "%s fontsize=\"8\";\n", spc);
fprintf (out, "%s style=filled;\n", spc);
fprintf (out, "%s color=black;\n\n", spc);
fprintf (out, "%s label=\"<%s>\\n%s%s%s\";\n", spc,
G_OBJECT_TYPE_NAME (element), GST_OBJECT_NAME (element),
(state_name ? state_name : ""), (param_name ? param_name : "")
);
if (state_name) {
g_free (state_name);
state_name = NULL;
}
if (param_name) {
g_free (param_name);
param_name = NULL;
}
g_free (element_name);
src_pads = sink_pads = 0;
if ((pad_iter = gst_element_iterate_pads (element))) {
pads_done = FALSE;
while (!pads_done) {
switch (gst_iterator_next (pad_iter, (gpointer) & pad)) {
case GST_ITERATOR_OK:
dir = gst_pad_get_direction (pad);
pad_name = debug_dump_make_object_name (GST_OBJECT (pad));
element_name =
debug_dump_make_object_name (GST_OBJECT (element));
if (GST_IS_GHOST_PAD (pad)) {
color_name =
(dir == GST_PAD_SRC) ? "#ffdddd" : ((dir ==
GST_PAD_SINK) ? "#ddddff" : "#ffffff");
} else {
color_name =
(dir == GST_PAD_SRC) ? "#ffaaaa" : ((dir ==
GST_PAD_SINK) ? "#aaaaff" : "#cccccc");
}
/* pads */
fprintf (out,
"%s %s_%s [color=black, fillcolor=\"%s\", label=\"%s\"];\n",
spc, element_name, pad_name, color_name,
GST_OBJECT_NAME (pad));
if (dir == GST_PAD_SRC)
src_pads++;
else if (dir == GST_PAD_SINK)
sink_pads++;
g_free (pad_name);
g_free (element_name);
gst_object_unref (pad);
break;
case GST_ITERATOR_RESYNC:
gst_iterator_resync (pad_iter);
break;
case GST_ITERATOR_ERROR:
case GST_ITERATOR_DONE:
pads_done = TRUE;
break;
}
}
gst_iterator_free (pad_iter);
}
if (GST_IS_BIN (element)) {
fprintf (out, "%s fillcolor=\"#ffffff\";\n", spc);
/* recurse */
debug_dump_element (GST_BIN (element), details, out, indent + 1);
} else {
if (src_pads && !sink_pads)
fprintf (out, "%s fillcolor=\"#ffaaaa\";\n", spc);
else if (!src_pads && sink_pads)
fprintf (out, "%s fillcolor=\"#aaaaff\";\n", spc);
else if (src_pads && sink_pads)
fprintf (out, "%s fillcolor=\"#aaffaa\";\n", spc);
else
fprintf (out, "%s fillcolor=\"#ffffff\";\n", spc);
}
fprintf (out, "%s}\n\n", spc);
if ((pad_iter = gst_element_iterate_pads (element))) {
pads_done = FALSE;
while (!pads_done) {
switch (gst_iterator_next (pad_iter, (gpointer) & pad)) {
case GST_ITERATOR_OK:
if (gst_pad_is_linked (pad)
&& gst_pad_get_direction (pad) == GST_PAD_SRC) {
if ((peer_pad = gst_pad_get_peer (pad))) {
free_media = FALSE;
if ((details & GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE) ||
(details & GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS)
) {
if ((caps = gst_pad_get_negotiated_caps (pad))) {
free_caps = TRUE;
} else {
free_caps = FALSE;
if (!(caps = (GstCaps *)
gst_pad_get_pad_template_caps (pad))) {
/* this should not happen */
media = "?";
}
}
if (caps) {
if (details & GST_DEBUG_GRAPH_SHOW_CAPS_DETAILS) {
gchar *tmp =
g_strdelimit (gst_caps_to_string (caps), ",",
'\n');
media = g_strescape (tmp, NULL);
free_media = TRUE;
g_free (tmp);
} else {
if (GST_CAPS_IS_SIMPLE (caps)) {
structure = gst_caps_get_structure (caps, 0);
media =
(gchar *) gst_structure_get_name (structure);
} else
media = "*";
}
if (free_caps) {
gst_caps_unref (caps);
}
}
}
pad_name = debug_dump_make_object_name (GST_OBJECT (pad));
element_name =
debug_dump_make_object_name (GST_OBJECT (element));
peer_pad_name =
debug_dump_make_object_name (GST_OBJECT (peer_pad));
if ((peer_element = gst_pad_get_parent_element (peer_pad))) {
peer_element_name =
debug_dump_make_object_name (GST_OBJECT
(peer_element));
} else {
peer_element_name = "";
}
/* pad link */
if (media) {
fprintf (out, "%s%s_%s -> %s_%s [label=\"%s\"]\n", spc,
element_name, pad_name, peer_element_name,
peer_pad_name, media);
if (free_media) {
g_free (media);
}
} else {
fprintf (out, "%s%s_%s -> %s_%s\n", spc,
element_name, pad_name, peer_element_name,
peer_pad_name);
}
if (GST_IS_GHOST_PAD (pad)) {
if ((target_pad =
gst_ghost_pad_get_target (GST_GHOST_PAD (pad)))) {
target_pad_name =
debug_dump_make_object_name (GST_OBJECT
(target_pad));
if ((target_element =
gst_pad_get_parent_element (target_pad))) {
target_element_name =
debug_dump_make_object_name (GST_OBJECT
(target_element));
} else {
target_element_name = "";
}
/* src ghostpad relationship */
fprintf (out, "%s%s_%s -> %s_%s [style=dashed]\n", spc,
target_element_name, target_pad_name, element_name,
pad_name);
g_free (target_pad_name);
if (target_element) {
g_free (target_element_name);
gst_object_unref (target_element);
}
gst_object_unref (target_pad);
}
}
if (GST_IS_GHOST_PAD (peer_pad)) {
if ((target_pad =
gst_ghost_pad_get_target (GST_GHOST_PAD
(peer_pad)))) {
target_pad_name =
debug_dump_make_object_name (GST_OBJECT
(target_pad));
if ((target_element =
gst_pad_get_parent_element (target_pad))) {
target_element_name =
debug_dump_make_object_name (GST_OBJECT
(target_element));
} else {
target_element_name = "";
}
/* sink ghostpad relationship */
fprintf (out, "%s%s_%s -> %s_%s [style=dashed]\n", spc,
peer_element_name, peer_pad_name,
target_element_name, target_pad_name);
g_free (target_pad_name);
if (target_element) {
g_free (target_element_name);
gst_object_unref (target_element);
}
gst_object_unref (target_pad);
}
}
g_free (pad_name);
g_free (element_name);
g_free (peer_pad_name);
if (peer_element) {
g_free (peer_element_name);
gst_object_unref (peer_element);
}
gst_object_unref (peer_pad);
}
}
gst_object_unref (pad);
break;
case GST_ITERATOR_RESYNC:
gst_iterator_resync (pad_iter);
break;
case GST_ITERATOR_ERROR:
case GST_ITERATOR_DONE:
pads_done = TRUE;
break;
}
}
gst_iterator_free (pad_iter);
}
gst_object_unref (element);
break;
case GST_ITERATOR_RESYNC:
gst_iterator_resync (element_iter);
break;
case GST_ITERATOR_ERROR:
case GST_ITERATOR_DONE:
elements_done = TRUE;
break;
}
}
gst_iterator_free (element_iter);
g_free (spc);
}
/*
* debug_dump_element:
* @bin: the bin that should be analyzed
* @out: file to write to
* @indent: level of graph indentation
*
* Helper for gst_debug_bin_to_dot_file() to recursively dump a pipeline.
*/
static void
debug_dump_element (GstBin * bin, GstDebugGraphDetails details,
GString * str, const gint indent)
{
GstIterator *element_iter, *pad_iter;
gboolean elements_done, pads_done;
GValue item = { 0, };
GValue item2 = { 0, };
GstElement *element;
GstPad *pad = NULL;
guint src_pads, sink_pads;
gchar *element_name;
gchar *state_name = NULL;
gchar *param_name = NULL;
const gchar *spc = &spaces[MAX (sizeof (spaces) - (1 + indent * 2), 0)];
element_iter = gst_bin_iterate_elements (bin);
elements_done = FALSE;
while (!elements_done) {
switch (gst_iterator_next (element_iter, &item)) {
case GST_ITERATOR_OK:
element = g_value_get_object (&item);
element_name = debug_dump_make_object_name (GST_OBJECT (element));
if (details & GST_DEBUG_GRAPH_SHOW_STATES) {
state_name = debug_dump_get_element_state (GST_ELEMENT (element));
}
if (details & GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS) {
param_name = debug_dump_get_element_params (GST_ELEMENT (element),
details);
}
/* elements */
g_string_append_printf (str, "%ssubgraph cluster_%s {\n", spc,
element_name);
g_string_append_printf (str, "%s fontname=\"Bitstream Vera Sans\";\n",
spc);
g_string_append_printf (str, "%s fontsize=\"8\";\n", spc);
g_string_append_printf (str, "%s style=filled;\n", spc);
g_string_append_printf (str, "%s color=black;\n\n", spc);
g_string_append_printf (str, "%s label=\"%s\\n%s%s%s\";\n", spc,
G_OBJECT_TYPE_NAME (element), GST_OBJECT_NAME (element),
(state_name ? state_name : ""), (param_name ? param_name : "")
);
if (state_name) {
g_free (state_name);
state_name = NULL;
}
if (param_name) {
g_free (param_name);
param_name = NULL;
}
g_free (element_name);
src_pads = sink_pads = 0;
if ((pad_iter = gst_element_iterate_sink_pads (element))) {
debug_dump_element_pads (pad_iter, pad, element, details, str,
indent, &src_pads, &sink_pads);
gst_iterator_free (pad_iter);
}
if ((pad_iter = gst_element_iterate_src_pads (element))) {
debug_dump_element_pads (pad_iter, pad, element, details, str,
indent, &src_pads, &sink_pads);
gst_iterator_free (pad_iter);
}
if (GST_IS_BIN (element)) {
g_string_append_printf (str, "%s fillcolor=\"#ffffff\";\n", spc);
/* recurse */
debug_dump_element (GST_BIN (element), details, str, indent + 1);
} else {
if (src_pads && !sink_pads)
g_string_append_printf (str, "%s fillcolor=\"#ffaaaa\";\n", spc);
else if (!src_pads && sink_pads)
g_string_append_printf (str, "%s fillcolor=\"#aaaaff\";\n", spc);
else if (src_pads && sink_pads)
g_string_append_printf (str, "%s fillcolor=\"#aaffaa\";\n", spc);
else
g_string_append_printf (str, "%s fillcolor=\"#ffffff\";\n", spc);
}
g_string_append_printf (str, "%s}\n\n", spc);
if ((pad_iter = gst_element_iterate_pads (element))) {
pads_done = FALSE;
while (!pads_done) {
switch (gst_iterator_next (pad_iter, &item2)) {
case GST_ITERATOR_OK:
pad = g_value_get_object (&item2);
if (gst_pad_is_linked (pad)) {
if (gst_pad_get_direction (pad) == GST_PAD_SRC) {
debug_dump_element_pad_link (pad, element, details, str,
indent);
} else {
GstPad *peer_pad = gst_pad_get_peer (pad);
if (peer_pad) {
if (!GST_IS_GHOST_PAD (peer_pad)
&& GST_IS_PROXY_PAD (peer_pad)) {
debug_dump_element_pad_link (peer_pad, NULL, details,
str, indent);
}
gst_object_unref (peer_pad);
}
}
}
g_value_reset (&item2);
break;
case GST_ITERATOR_RESYNC:
gst_iterator_resync (pad_iter);
break;
case GST_ITERATOR_ERROR:
case GST_ITERATOR_DONE:
pads_done = TRUE;
break;
}
}
g_value_unset (&item2);
gst_iterator_free (pad_iter);
}
g_value_reset (&item);
break;
case GST_ITERATOR_RESYNC:
gst_iterator_resync (element_iter);
break;
case GST_ITERATOR_ERROR:
case GST_ITERATOR_DONE:
elements_done = TRUE;
break;
}
}
g_value_unset (&item);
gst_iterator_free (element_iter);
}
GstElement *create_video_sink()
{
GstElement *bin, *decoder = NULL;
GstIterator *iter;
GstIteratorResult res;
GError *error = NULL;
GstPad *pad;
gpointer element = NULL;
const char* decoder_name;
#ifndef DESKTOP
/* create pipeline */
decoder_name = "tividdec20";
bin = gst_parse_launch_full("TIViddec2 genTimeStamps=FALSE \
engineName=decode \
codecName=h264dec numFrames=-1 \
! videoscale method=0 \
! video/x-raw-yuv, format=(fourcc)I420, width=320, height=240 \
! ffmpegcolorspace \
! video/x-raw-rgb, bpp=16 \
! TIDmaiVideoSink displayStd=fbdev displayDevice=/dev/fb0 videoStd=QVGA \
videoOutput=LCD resizer=FALSE accelFrameCopy=TRUE",
NULL, 0, &error);
#else
decoder_name = "decodebin";
bin = gst_parse_launch_full("decodebin \
! videoscale method=0 \
! video/x-raw-yuv, format=(fourcc)I420, width=320, height=240 \
! xvimagesink",
NULL, 0, &error);
#endif
if (!bin) {
g_error("GStreamer: failed to parse video sink pipeline\n");
return NULL;
}
gst_object_set_name(GST_OBJECT(bin), "video-sink");
iter = gst_bin_iterate_elements(GST_BIN(bin));
res = gst_iterator_next (iter, &element);
while (res == GST_ITERATOR_OK) {
gchar *name;
name = gst_object_get_name(GST_OBJECT (element));
if (name) {
if (!strncmp(name, decoder_name, strlen(decoder_name))) {
decoder = GST_ELEMENT(element);
}
g_printf("GS: video sink element: %s \n", name);
g_free (name);
}
gst_object_unref (element);
element = NULL;
res = gst_iterator_next (iter, &element);
}
gst_iterator_free (iter);
if (!decoder) {
/* mem leak */
g_printf("decoder element not found\n");
return NULL;
}
/* add ghostpad */
pad = gst_element_get_static_pad (decoder, "sink");
gst_element_add_pad(bin, gst_ghost_pad_new("sink", pad));
gst_object_unref(GST_OBJECT(pad));
return bin;
}
static void
gst_wrapper_camera_bin_reset_video_src_caps (GstWrapperCameraBinSrc * self,
GstCaps * caps)
{
GstClock *clock;
gint64 base_time;
GST_DEBUG_OBJECT (self, "Resetting src caps to %" GST_PTR_FORMAT, caps);
if (self->src_vid_src) {
GstCaps *old_caps;
g_object_get (G_OBJECT (self->src_filter), "caps", &old_caps, NULL);
if (gst_caps_is_equal (caps, old_caps)) {
GST_DEBUG_OBJECT (self, "old and new caps are same, do not reset it");
if (old_caps)
gst_caps_unref (old_caps);
return;
}
if (old_caps)
gst_caps_unref (old_caps);
clock = gst_element_get_clock (self->src_vid_src);
base_time = gst_element_get_base_time (self->src_vid_src);
/* Ideally, we should only need to get the source to READY here,
* but it seems v4l2src isn't happy with this. Putting to NULL makes
* it work.
*
* TODO fix this in v4l2src
*/
gst_element_set_state (self->src_vid_src, GST_STATE_NULL);
set_capsfilter_caps (self, caps);
self->drop_newseg = TRUE;
GST_DEBUG_OBJECT (self, "Bringing source up");
if (!gst_element_sync_state_with_parent (self->src_vid_src)) {
GST_WARNING_OBJECT (self, "Failed to reset source caps");
gst_element_set_state (self->src_vid_src, GST_STATE_NULL);
}
if (clock) {
gst_element_set_clock (self->src_vid_src, clock);
gst_element_set_base_time (self->src_vid_src, base_time);
if (GST_IS_BIN (self->src_vid_src)) {
GstIterator *it =
gst_bin_iterate_elements (GST_BIN (self->src_vid_src));
gpointer item = NULL;
gboolean done = FALSE;
while (!done) {
switch (gst_iterator_next (it, &item)) {
case GST_ITERATOR_OK:
gst_element_set_base_time (GST_ELEMENT (item), base_time);
gst_object_unref (item);
break;
case GST_ITERATOR_RESYNC:
gst_iterator_resync (it);
break;
case GST_ITERATOR_ERROR:
done = TRUE;
break;
case GST_ITERATOR_DONE:
done = TRUE;
break;
}
}
gst_iterator_free (it);
}
gst_object_unref (clock);
}
}
}
