自学教程：C++ GST_OBJECT_NAME函数代码示例

static voidgst_play_sink_convert_bin_set_targets (GstPlaySinkConvertBin * self,    gboolean passthrough){  GstPad *pad;  GstElement *head, *tail;  GST_DEBUG_OBJECT (self, "Setting pad targets with passthrough %d",      passthrough);  if (self->conversion_elements == NULL || passthrough) {    GST_DEBUG_OBJECT (self, "no conversion elements, using identity (%p) as "        "head/tail", self->identity);    if (!passthrough) {      GST_WARNING_OBJECT (self,          "Doing passthrough as no converter elements were added");    }    head = tail = self->identity;  } else {    head = GST_ELEMENT (g_list_first (self->conversion_elements)->data);    tail = GST_ELEMENT (g_list_last (self->conversion_elements)->data);    GST_DEBUG_OBJECT (self, "conversion elements in use, picking "        "head:%s and tail:%s", GST_OBJECT_NAME (head), GST_OBJECT_NAME (tail));  }  g_return_if_fail (head != NULL);  g_return_if_fail (tail != NULL);  pad = gst_element_get_static_pad (head, "sink");  GST_DEBUG_OBJECT (self, "Ghosting bin sink pad to %" GST_PTR_FORMAT, pad);  gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (self->sinkpad), pad);  gst_object_unref (pad);  pad = gst_element_get_static_pad (tail, "src");  GST_DEBUG_OBJECT (self, "Ghosting bin src pad to %" GST_PTR_FORMAT, pad);  gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (self->srcpad), pad);  gst_object_unref (pad);}

/* * helper_find_suggest: * @data: helper data struct * @probability: probability of the match * @caps: caps of the type * * If given @probability is higher, replace previously store caps. */static voidhelper_find_suggest (gpointer data, GstTypeFindProbability probability,    GstCaps * caps){  GstTypeFindHelper *helper = (GstTypeFindHelper *) data;  GST_LOG_OBJECT (helper->obj,      "'%s' called suggest (%u, %" GST_PTR_FORMAT ")",      GST_OBJECT_NAME (helper->factory), probability, caps);  if (probability > helper->best_probability) {    gst_caps_replace (&helper->caps, caps);    helper->best_probability = probability;  }}

/* on error print the error and quit the application */static voiderror_cb (GstBus * bus, GstMessage * msg, APP_STATE_T * state){  GError *err;  gchar *debug_info;  gst_message_parse_error (msg, &err, &debug_info);  g_printerr ("Error received from element %s: %s/n",      GST_OBJECT_NAME (msg->src), err->message);  g_printerr ("Debugging information: %s/n", debug_info ? debug_info : "none");  g_clear_error (&err);  g_free (debug_info);  flush_start (state);  gst_element_set_state (state->pipeline, GST_STATE_READY);}

/* This function is called when an error message is posted on the bus */static void error_cb (GstBus *bus, GstMessage *msg, CustomData *data) {    GError *err;    gchar *debug_info;    /* Print error details on the screen */    gst_message_parse_error (msg, &err, &debug_info);    g_printerr ("Error received from element %s: %s/n", GST_OBJECT_NAME (msg->src), err->message);    update_timelabel (data, err->message);    g_printerr ("Debugging information: %s/n", debug_info ? debug_info : "none");    g_clear_error (&err);    g_free (debug_info);    /* Set the pipeline to READY (which stops playback) */    audio_stop_player (data);}

/* * buf_helper_find_suggest: * @data: helper data struct * @probability: probability of the match * @caps: caps of the type * * If given @probability is higher, replace previously store caps. */static voidbuf_helper_find_suggest (gpointer data, guint probability, GstCaps * caps){  GstTypeFindBufHelper *helper = (GstTypeFindBufHelper *) data;  GST_LOG_OBJECT (helper->obj,      "'%s' called suggest (%u, %" GST_PTR_FORMAT ")",      GST_OBJECT_NAME (helper->factory), probability, caps);  /* Note: not >= as we call typefinders in order of rank, highest first */  if (probability > helper->best_probability) {    gst_caps_replace (&helper->caps, caps);    helper->best_probability = probability;  }}

/** * gst_object_replace: * @oldobj: pointer to a place of a #GstObject to replace * @newobj: a new #GstObject * * Unrefs the #GstObject pointed to by @oldobj, refs @newobj and * puts @newobj in *@oldobj. Be carefull when calling this * function, it does not take any locks. You might want to lock * the object owning @oldobj pointer before calling this * function. * * Make sure not to LOCK @oldobj because it might be unreffed * which could cause a deadlock when it is disposed. */voidgst_object_replace (GstObject ** oldobj, GstObject * newobj){  g_return_if_fail (oldobj != NULL);  g_return_if_fail (*oldobj == NULL || GST_IS_OBJECT (*oldobj));  g_return_if_fail (newobj == NULL || GST_IS_OBJECT (newobj));#ifdef DEBUG_REFCOUNT  GST_CAT_LOG (GST_CAT_REFCOUNTING, "replace %s (%d) with %s (%d)",      *oldobj ? GST_STR_NULL (GST_OBJECT_NAME (*oldobj)) : "(NONE)",      *oldobj ? G_OBJECT (*oldobj)->ref_count : 0,      newobj ? GST_STR_NULL (GST_OBJECT_NAME (newobj)) : "(NONE)",      newobj ? G_OBJECT (newobj)->ref_count : 0);#endif  if (G_LIKELY (*oldobj != newobj)) {    if (newobj)      gst_object_ref (newobj);    if (*oldobj)      gst_object_unref (*oldobj);    *oldobj = newobj;  }}

static voidconnect_sink (GstElement * element, GstPad * pad, gpointer user_data){  KmsConnectData *data = user_data;  GST_DEBUG_OBJECT (pad, "New pad %" GST_PTR_FORMAT, element);  if (g_strcmp0 (GST_OBJECT_NAME (pad), data->pad_name)) {    return;  }  connect_pads_and_remove_on_unlinked (data->src, element, data->pad_name);  GST_INFO_OBJECT (pad, "Linking %s", data->pad_name);}

/* must be called with monitor lock */static gbooleanis_provider_hidden (GstDeviceMonitor * monitor, GList * hidden,                    GstDeviceProvider * provider){    GstDeviceProviderFactory *factory;    if (monitor->priv->show_all)        return FALSE;    factory = gst_device_provider_get_factory (provider);    if (g_list_find_custom (hidden, GST_OBJECT_NAME (factory),                            (GCompareFunc) g_strcmp0))        return TRUE;    return FALSE;}

static voidrtp_ssrc_demux_new_ssrc_pad (GstElement * ssrcdemux, guint ssrc, GstPad * pad,    KmsBaseRtpSession * self){  const gchar *rtp_pad_name = GST_OBJECT_NAME (pad);  gchar *rtcp_pad_name;  SdpMediaConfig *mconf;  GstPad *src, *sink;  GST_DEBUG_OBJECT (self, "pad: %" GST_PTR_FORMAT " ssrc: %" G_GUINT32_FORMAT,      pad, ssrc);  KMS_SDP_SESSION_LOCK (self);  if (self->remote_audio_ssrc == ssrc      || ssrcs_are_mapped (ssrcdemux, self->local_audio_ssrc, ssrc)) {    mconf = self->audio_neg_mconf;  } else if (self->remote_video_ssrc == ssrc      || ssrcs_are_mapped (ssrcdemux, self->local_video_ssrc, ssrc)) {    mconf = self->video_neg_mconf;  } else {    if (!kms_i_rtp_session_manager_custom_ssrc_management (self->manager, self,            ssrcdemux, ssrc, pad)) {      GST_ERROR_OBJECT (pad, "SSRC %" G_GUINT32_FORMAT " not matching.", ssrc);    }    goto end;  }  /* RTP */  sink =      kms_i_rtp_session_manager_request_rtp_sink (self->manager, self, mconf);  kms_base_rtp_session_link_pads (pad, sink);  g_object_unref (sink);  /* RTCP */  rtcp_pad_name = g_strconcat ("rtcp_", rtp_pad_name, NULL);  src = gst_element_get_static_pad (ssrcdemux, rtcp_pad_name);  g_free (rtcp_pad_name);  sink =      kms_i_rtp_session_manager_request_rtcp_sink (self->manager, self, mconf);  kms_base_rtp_session_link_pads (src, sink);  g_object_unref (src);  g_object_unref (sink);end:  KMS_SDP_SESSION_UNLOCK (self);}

static gbooleanbus_call(GstBus     *bus,GstMessage *msg,gpointer    data){	GMainLoop *loop = (GMainLoop *)data;	GstState old_state, new_state;	switch (GST_MESSAGE_TYPE(msg)) {	case GST_MESSAGE_STATE_CHANGED:		gst_message_parse_state_changed (msg, &old_state, &new_state, NULL);		if(msg->src == GST_OBJECT(app.pipeline) && new_state == GST_STATE_READY && old_state == GST_STATE_NULL) {			g_debug ("Element %s changed state from %s to %s./n",				GST_OBJECT_NAME (msg->src),				gst_element_state_get_name (old_state),				gst_element_state_get_name (new_state));			if(app.ready_callback) {				app.ready_callback();			}		}		break;	case GST_MESSAGE_EOS:		g_warning("End of stream/n");		g_main_loop_quit(loop);		break;	case GST_MESSAGE_ERROR: {		gchar  *debug;		GError *error;		gst_message_parse_error(msg, &error, &debug);		// g_free(debug);		g_printerr("Error: %s/n", error->message);		g_printerr("Debug: %s/n", debug);		g_error_free(error);		g_main_loop_quit(loop);		break;	}	default:		break;	}	return TRUE;}

void error_cb(GstBus *bus, GstMessage *msg, CustomData *data){	GError *err;	gchar *debug_info;	gchar *message_string;	gst_message_parse_error(msg, &err, &debug_info);	GPlayerDEBUG("ERROR from element %s: %s/n", GST_OBJECT_NAME(msg->src), err->message);	GPlayerDEBUG("Debugging info: %s/n", (debug_info) ? debug_info : "none");	if (strcasestr(err->message, "not") != NULL && strcasestr(err->message, "found") != NULL)	{		gplayer_error(NOT_FOUND, data);		data->target_state = GST_STATE_NULL;		data->is_live = (gst_element_set_state(data->pipeline, data->target_state) == GST_STATE_CHANGE_NO_PREROLL);	}	else if ((strstr(err->message, "missing") != NULL && strstr(err->message, "plug-in") != NULL)			|| (strstr(err->message, "No URI handler implemented for") != NULL))	{		gplayer_error(NOT_SUPPORTED, data);		data->target_state = GST_STATE_NULL;		data->is_live = (gst_element_set_state(data->pipeline, data->target_state) == GST_STATE_CHANGE_NO_PREROLL);	}	else if (strstr(err->message, "type") != NULL && strstr(err->message, "stream") != NULL)	{		gplayer_error(UNKNOWN_ERROR, data);		data->target_state = GST_STATE_NULL;		data->is_live = (gst_element_set_state(data->pipeline, data->target_state) == GST_STATE_CHANGE_NO_PREROLL);	}	else if (strstr(err->message, "Stream") != NULL && strstr(err->message, "enough") != NULL)	{		if (!data->flow_error)		{			gplayer_error(UNKNOWN_ERROR, data);			data->target_state = GST_STATE_PAUSED;			data->is_live = (gst_element_set_state(data->pipeline, data->target_state) == GST_STATE_CHANGE_NO_PREROLL);		}	}	else if (strstr(err->message, "Internal") != NULL && strstr(err->message, "flow") != NULL)	{		data->flow_error = TRUE;	}	g_error_free(err);	g_free(debug_info);}

static voidgst_ss_demux_stream_init (GstSSDemux *demux, GstSSDemuxStream *stream, SS_STREAM_TYPE stream_type){  stream->cond = g_cond_new ();  stream->lock = g_mutex_new ();  stream->queue = g_queue_new ();  stream->parent = demux;  stream->pipe = NULL;  stream->urisrc = NULL;  stream->parser = NULL;  stream->sink = NULL;  stream->frag_cnt = 0;  stream->type = stream_type ;  stream->uri = NULL;  stream->start_ts = -1;  stream->sent_ns = FALSE;  stream->switch_ts = GST_CLOCK_TIME_NONE;  stream->avg_dur = GST_CLOCK_TIME_NONE;  if (stream->type == SS_STREAM_VIDEO) {    stream->pad = gst_pad_new_from_static_template (&ssdemux_videosrc_template, "video");    stream->name = g_strdup("video");  } else if (stream->type == SS_STREAM_AUDIO) {    stream->pad = gst_pad_new_from_static_template (&ssdemux_audiosrc_template, "audio");    stream->name = g_strdup("audio");  } else if (stream->type == SS_STREAM_TEXT) {    stream->pad = gst_pad_new_from_static_template (&ssdemux_subsrc_template, "subtitle");    stream->name = g_strdup("text");  }  GST_PAD_ELEMENT_PRIVATE (stream->pad) = stream;  gst_pad_use_fixed_caps (stream->pad);  gst_pad_set_event_function (stream->pad, gst_ss_demux_handle_src_event);  gst_pad_set_query_function (stream->pad, gst_ss_demux_handle_src_query);  stream->caps = ssm_parse_get_stream_caps (demux->parser, stream->type);  g_print ("prepare video caps = %s", gst_caps_to_string(stream->caps));  GST_DEBUG_OBJECT (demux, "setting caps %" GST_PTR_FORMAT, stream->caps);  gst_pad_set_caps (stream->pad, stream->caps);  GST_DEBUG_OBJECT (demux, "adding pad %s %p to demux %p", GST_OBJECT_NAME (stream->pad), stream->pad, demux);  gst_pad_set_active (stream->pad, TRUE);  gst_element_add_pad (GST_ELEMENT_CAST (demux), stream->pad);}

/** * gst_pipeline_use_clock: * @pipeline: a [GstPipeline]() * @clock: (transfer none) (allow-none): the clock to use * * Force _pipeline_ to use the given _clock_. The pipeline will * always use the given clock even if new clock providers are added * to this pipeline. * * If _clock_ is [NULL]() all clocking will be disabled which will make * the pipeline run as fast as possible. * * MT safe. */voidgst_pipeline_use_clock (GstPipeline * pipeline, GstClock * clock){  GstClock **clock_p;  g_return_if_fail (GST_IS_PIPELINE (pipeline));  GST_OBJECT_LOCK (pipeline);  GST_OBJECT_FLAG_SET (pipeline, GST_PIPELINE_FLAG_FIXED_CLOCK);  clock_p = &pipeline->fixed_clock;  gst_object_replace ((GstObject **) clock_p, (GstObject *) clock);  GST_OBJECT_UNLOCK (pipeline);  GST_CAT_DEBUG (GST_CAT_CLOCK, "pipeline using fixed clock %p (%s)", clock,      (clock ? GST_OBJECT_NAME (clock) : "nil"));}

voidgss_program_add_stream_table (GssProgram * program, GString * s){  GList *g;  gboolean have_hls = FALSE;  GSS_A ("<table class='table table-striped table-bordered "      "table-condensed'>/n");  GSS_A ("<thead>/n");  GSS_A ("<tr>/n");  GSS_A ("<th>Type</th>/n");  GSS_A ("<th>Size</th>/n");  GSS_A ("<th>Bitrate</th>/n");  GSS_A ("</tr>/n");  GSS_A ("</thead>/n");  GSS_A ("<tbody>/n");  for (g = program->streams; g; g = g_list_next (g)) {    GssStream *stream = g->data;    GSS_A ("<tr>/n");    GSS_P ("<td>%s</td>/n", gss_stream_type_get_name (stream->type));    GSS_P ("<td>%dx%d</td>/n", stream->width, stream->height);    GSS_P ("<td>%d kbps</td>/n", stream->bitrate / 1000);    GSS_P ("<td><a href=/"%s/">stream</a></td>/n", stream->location);    GSS_P ("<td><a href=/"%s/">playlist</a></td>/n", stream->playlist_location);    GSS_A ("</tr>/n");    if (stream->type == GSS_STREAM_TYPE_M2TS_H264BASE_AAC ||        stream->type == GSS_STREAM_TYPE_M2TS_H264MAIN_AAC) {      have_hls = TRUE;    }  }  if (have_hls) {    GSS_A ("<tr>/n");    GSS_P ("<td colspan='7'><a href='/%s.m3u8'>HLS</a></td>/n",        GST_OBJECT_NAME (program));    GSS_A ("</tr>/n");  }  GSS_A ("<tr>/n");  GSS_P ("<td colspan='7'><a class='btn btn-mini' href='/'>"      "<i class='icon-plus'></i>Add</a></td>/n");  GSS_A ("</tr>/n");  GSS_A ("</tbody>/n");  GSS_A ("</table>/n");}

gbooleangst_task_pool_need_schedule_thread (GstTaskPool * pool, gboolean needed){  gboolean ret;  g_return_val_if_fail (GST_IS_TASK_POOL (pool), FALSE);  g_return_val_if_fail (needed || pool->priv->need_schedule_thread > 0, FALSE);  /* We don't allow this for the default pool */  if (pool == gst_task_pool_get_default ()) {    gst_object_unref (pool);    return FALSE;  }  g_mutex_lock (&pool->priv->schedule_lock);  if (needed) {    ret = TRUE;    if (pool->priv->need_schedule_thread == 0) {      pool->priv->schedule_context = g_main_context_new ();      pool->priv->schedule_loop =          g_main_loop_new (pool->priv->schedule_context, FALSE);      pool->priv->schedule_thread =          g_thread_new (GST_OBJECT_NAME (pool), gst_task_pool_schedule_func,          pool);      g_cond_wait (&pool->priv->schedule_cond, &pool->priv->schedule_lock);    }    pool->priv->need_schedule_thread++;  } else {    ret = FALSE;    pool->priv->need_schedule_thread--;    if (pool->priv->need_schedule_thread == 0) {      g_main_loop_quit (pool->priv->schedule_loop);      g_thread_join (pool->priv->schedule_thread);      g_main_loop_unref (pool->priv->schedule_loop);      pool->priv->schedule_loop = NULL;      g_main_context_unref (pool->priv->schedule_context);      pool->priv->schedule_context = NULL;      pool->priv->schedule_thread = NULL;    }  }  g_mutex_unlock (&pool->priv->schedule_lock);  return ret;}

static gbooleanlink_unlinked_pads (GstElement *bin,    GstPadDirection dir,    const gchar *pad_name,    guint *pad_count,    GError **error){  GstPad *pad = NULL;  guint i = 0;  while ((pad = gst_bin_find_unlinked_pad (GST_BIN (bin), dir)))  {    GstPad *ghostpad;    gchar *tmp;    if (i)      tmp = g_strdup_printf ("%s%d", pad_name, i);    else      tmp = g_strdup (pad_name);    i++;    ghostpad = gst_ghost_pad_new (tmp, pad);    gst_object_unref (pad);    g_free (tmp);    if (!ghostpad)    {      g_set_error (error, FS_ERROR, FS_ERROR_CONSTRUCTION,          "Could not create ghostpad for pad %s:%s",          GST_DEBUG_PAD_NAME (pad));      return FALSE;    }    if (!gst_element_add_pad (bin, ghostpad))    {      g_set_error (error, FS_ERROR, FS_ERROR_CONSTRUCTION,          "Could not add pad %s to bin", GST_OBJECT_NAME (ghostpad));      return FALSE;    }  }  if (pad_count)    *pad_count = i;  return TRUE;}

static voidon_error_video (GstBus     *bus,          GstMessage *message,          gpointer    user_data){	  GError *err;	  gchar *debug_info;	  gchar *message_string;	  gst_message_parse_error (message, &err, &debug_info);	  message_string = g_strdup_printf ("Error received from element %s: %s", GST_OBJECT_NAME (message->src), err->message);	  g_message ("debug_info = %s /n message_string = %s/n", debug_info, message_string);	  g_clear_error (&err);	  g_free (debug_info);	  g_free (message_string);}

void GstPlayer::handleStateChangeMessage(GstMessage *msg){    GstState old_state, new_state;    gst_message_parse_state_changed (msg, &old_state, &new_state, NULL);    QString objectNamePlayer = gstObjectName;    if( objectNamePlayer == GST_OBJECT_NAME (msg->src)){        if(new_state == GST_STATE_PLAYING || old_state == GST_STATE_PLAYING){            QLOG_TRACE() << "[GST] "<< this <<                            gst_element_state_get_name (old_state) <<                            "->"<<  gst_element_state_get_name (new_state);        }        switch(new_state){            case GST_STATE_VOID_PENDING:                loaded=false;                playing=false;                break;            case GST_STATE_READY:                loaded=true;                playing=false;                break;            case GST_STATE_NULL:                loaded=false;                playing=false;                break;            case GST_STATE_PAUSED:                loaded=true;                playing=false;                if(playingRequested){                    QLOG_TRACE() << "Queued request. Ask to play!";                    playingRequested = false;                    this->requestPlay();                }                break;            case GST_STATE_PLAYING:                loaded=true;                playing=true;                break;        }        //QLOG_TRACE() << "GstPlayer: emit state change";        this->stateChanged();    }}

/* should be called with the object LOCK */static voidgst_task_configure_name (GstTask * task){#ifdef HAVE_SYS_PRCTL_H  const gchar *name;  gchar thread_name[17] = { 0, };  name = GST_OBJECT_NAME (task);  /* set the thread name to something easily identifiable */  if (!snprintf (thread_name, 17, "%s", GST_STR_NULL (name))) {    GST_DEBUG_OBJECT (task, "Could not create thread name for '%s'", name);  } else {    GST_DEBUG_OBJECT (task, "Setting thread name to '%s'", thread_name);    if (prctl (PR_SET_NAME, (unsigned long int) thread_name, 0, 0, 0))      GST_DEBUG_OBJECT (task, "Failed to set thread name");  }#endif}

static GstElement *gst_auto_video_src_create_element_with_pretty_name (GstAutoVideoSrc * src,    GstElementFactory * factory){  GstElement *element;  gchar *name, *marker;  marker = g_strdup (GST_PLUGIN_FEATURE (factory)->name);  if (g_str_has_suffix (marker, "src"))    marker[strlen (marker) - 4] = '/0';  if (g_str_has_prefix (marker, "gst"))    g_memmove (marker, marker + 3, strlen (marker + 3) + 1);  name = g_strdup_printf ("%s-actual-src-%s", GST_OBJECT_NAME (src), marker);  g_free (marker);  element = gst_element_factory_create (factory, name);  g_free (name);  return element;}

static voidremove_on_unlinked_async (gpointer data, gpointer not_used){  GstElement *elem = GST_ELEMENT_CAST (data);  GstObject *parent = gst_object_get_parent (GST_OBJECT (elem));  gst_element_set_locked_state (elem, TRUE);  if (g_strcmp0 (GST_OBJECT_NAME (gst_element_get_factory (elem)),          "queue") == 0) {    g_object_set (G_OBJECT (elem), "flush-on-eos", TRUE, NULL);    gst_element_send_event (elem, gst_event_new_eos ());  }  gst_element_set_state (elem, GST_STATE_NULL);  if (parent != NULL) {    gst_bin_remove (GST_BIN (parent), elem);    g_object_unref (parent);  }  g_object_unref (data);}

static voidkms_enc_tree_bin_create_encoder_for_caps (KmsEncTreeBin * self,    const GstCaps * caps, gint target_bitrate){  GList *encoder_list, *filtered_list, *l;  GstElementFactory *encoder_factory = NULL;  encoder_list =      gst_element_factory_list_get_elements (GST_ELEMENT_FACTORY_TYPE_ENCODER,      GST_RANK_NONE);  /* HACK: Augment the openh264 rank */  for (l = encoder_list; l != NULL; l = l->next) {    encoder_factory = GST_ELEMENT_FACTORY (l->data);    if (g_str_has_prefix (GST_OBJECT_NAME (encoder_factory), "openh264")) {      encoder_list = g_list_remove (encoder_list, l->data);      encoder_list = g_list_prepend (encoder_list, encoder_factory);      break;    }  }  encoder_factory = NULL;  filtered_list =      gst_element_factory_list_filter (encoder_list, caps, GST_PAD_SRC, FALSE);  for (l = filtered_list; l != NULL && encoder_factory == NULL; l = l->next) {    encoder_factory = GST_ELEMENT_FACTORY (l->data);    if (gst_element_factory_get_num_pad_templates (encoder_factory) != 2)      encoder_factory = NULL;  }  if (encoder_factory != NULL) {    self->priv->enc = gst_element_factory_create (encoder_factory, NULL);    kms_enc_tree_bin_set_encoder_type (self);    configure_encoder (self->priv->enc, self->priv->enc_type, target_bitrate);  }  gst_plugin_feature_list_free (filtered_list);  gst_plugin_feature_list_free (encoder_list);}

static GObject *gst_child_proxy_default_get_child_by_name (GstChildProxy * parent,    const gchar * name){  guint count, i;  GObject *object, *result;  gchar *object_name;  g_return_val_if_fail (GST_IS_CHILD_PROXY (parent), NULL);  g_return_val_if_fail (name != NULL, NULL);  result = NULL;  count = gst_child_proxy_get_children_count (parent);  for (i = 0; i < count; i++) {    gboolean eq;    if (!(object = gst_child_proxy_get_child_by_index (parent, i)))      continue;    if (!GST_IS_OBJECT (object)) {      goto next;    }    object_name = gst_object_get_name (GST_OBJECT_CAST (object));    if (object_name == NULL) {      g_warning ("child %u of parent %s has no name", i,          GST_OBJECT_NAME (parent));      goto next;    }    eq = g_str_equal (object_name, name);    g_free (object_name);    if (eq) {      result = object;      break;    }  next:    g_object_unref (object);  }  return result;}

static voiddebug_dump_header (GstBin * bin, GstDebugGraphDetails details, GString * str){  gchar *state_name = NULL;  gchar *param_name = NULL;  if (details & GST_DEBUG_GRAPH_SHOW_STATES) {    state_name = debug_dump_get_element_state (GST_ELEMENT (bin));  }  if (details & GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS) {    param_name = debug_dump_get_object_params (G_OBJECT (bin), details, NULL);  }  /* write header */  g_string_append_printf (str,      "digraph pipeline {/n"      "  rankdir=LR;/n"      "  fontname=/"sans/";/n"      "  fontsize=/"10/";/n"      "  labelloc=t;/n"      "  nodesep=.1;/n"      "  ranksep=.2;/n"      "  label=/"<%s>//n%s%s%s/";/n"      "  node [style=/"filled,rounded/", shape=box, fontsize=/"9/", fontname=/"sans/", margin=/"0.0,0.0/"];/n"      "  edge [labelfontsize=/"6/", fontsize=/"9/", fontname=/"monospace/"];/n"      "  /n"      "  legend [/n"      "    pos=/"0,0!/",/n"      "    margin=/"0.05,0.05/",/n"      "    style=/"filled/",/n"      "    label=/"Legend//lElement-States: [~] void-pending, [0] null, [-] ready, [=] paused, [>] playing//lPad-Activation: [-] none, [>] push, [<] pull//lPad-Flags: [b]locked, [f]lushing, [b]locking; upper-case is set//lPad-Task: [T] has started task, [t] has paused task//l/",/n"      "  ];"      "/n", G_OBJECT_TYPE_NAME (bin), GST_OBJECT_NAME (bin),      (state_name ? state_name : ""), (param_name ? param_name : "")      );  if (state_name)    g_free (state_name);  if (param_name)    g_free (param_name);}

static gboolean handle_pipeline_message(GstBus *bus, GstMessage *msg, gpointer video_decoder){    SpiceGstDecoder *decoder = video_decoder;    if (GST_MESSAGE_TYPE(msg) == GST_MESSAGE_ERROR) {        GError *err = NULL;        gchar *debug_info = NULL;        gst_message_parse_error(msg, &err, &debug_info);        spice_warning("GStreamer error from element %s: %s",                      GST_OBJECT_NAME(msg->src), err->message);        if (debug_info) {            SPICE_DEBUG("debug information: %s", debug_info);            g_free(debug_info);        }        g_clear_error(&err);        /* We won't be able to process any more frame anyway */        free_pipeline(decoder);    }    return TRUE;}

gboolean on_pipeline_msg(GstBus * bus, GstMessage * msg, gpointer loop){    gchar  * debug;    GError * error;;    switch(GST_MESSAGE_TYPE(msg))    {    // Mensaje de finalización del stream    case GST_MESSAGE_EOS:        fprintf(stderr, "End of stream/n");        kill(getpid(), SIGUSR1);        break;    // Mensaje que indica que se ha producido un error    case GST_MESSAGE_ERROR:        gst_message_parse_error(msg, & error, & debug);        g_free(debug);        g_printerr("Error: %s/n", error->message);        g_error_free(error);        kill(getpid(), SIGUSR1);        break;    case GST_MESSAGE_STATE_CHANGED: {        GstState old_state, new_state;        gst_message_parse_state_changed(msg, &old_state, &new_state, NULL);        g_print("Element %s changed state from %s to %s./n",                GST_OBJECT_NAME(msg->src),                gst_element_state_get_name(old_state),                gst_element_state_get_name(new_state));        break;    }    default:        break;    }    return TRUE;}

/* takes a snapshot of the running_time of the pipeline and store this as the * element start_time. This is the time we will set as the running_time of the * pipeline when we go to PLAYING next. */static voidpipeline_update_start_time (GstElement * element){  GstPipeline *pipeline = GST_PIPELINE_CAST (element);  GstClock *clock;  GST_OBJECT_LOCK (element);  if ((clock = element->clock)) {    GstClockTime now;    gst_object_ref (clock);    GST_OBJECT_UNLOCK (element);    /* calculate the time when we stopped */    now = gst_clock_get_time (clock);    gst_object_unref (clock);    GST_OBJECT_LOCK (element);    /* store the current running time */    if (GST_ELEMENT_START_TIME (pipeline) != GST_CLOCK_TIME_NONE) {      if (now != GST_CLOCK_TIME_NONE)        GST_ELEMENT_START_TIME (pipeline) = now - element->base_time;      else        GST_WARNING_OBJECT (element,            "Clock %s returned invalid time, can't calculate "            "running_time when going to the PAUSED state",            GST_OBJECT_NAME (clock));      /* we went to PAUSED, when going to PLAYING select clock and new       * base_time */      pipeline->priv->update_clock = TRUE;    }    GST_DEBUG_OBJECT (element,        "start_time=%" GST_TIME_FORMAT ", now=%" GST_TIME_FORMAT        ", base_time %" GST_TIME_FORMAT,        GST_TIME_ARGS (GST_ELEMENT_START_TIME (pipeline)),        GST_TIME_ARGS (now), GST_TIME_ARGS (element->base_time));  }  GST_OBJECT_UNLOCK (element);}

/** * gst_bus_remove_signal_watch: * @bus: a #GstBus you previously added a signal watch to * * Removes a signal watch previously added with gst_bus_add_signal_watch(). * * MT safe. */voidgst_bus_remove_signal_watch (GstBus * bus){  GSource *source = NULL;  g_return_if_fail (GST_IS_BUS (bus));  /* I know the callees don't take this lock, so go ahead and abuse it */  GST_OBJECT_LOCK (bus);  if (bus->priv->num_signal_watchers == 0)    goto error;  bus->priv->num_signal_watchers--;  if (bus->priv->num_signal_watchers > 0)    goto done;  GST_DEBUG_OBJECT (bus, "removing signal watch %u",      g_source_get_id (bus->priv->signal_watch));  source = bus->priv->signal_watch;done:  GST_OBJECT_UNLOCK (bus);  if (source)    g_source_destroy (source);  return;  /* ERRORS */error:  {    g_critical ("Bus %s has no signal watches attached", GST_OBJECT_NAME (bus));    GST_OBJECT_UNLOCK (bus);    return;  }}

/** * gst_bus_remove_signal_watch: * @bus: a #GstBus you previously added a signal watch to * * Removes a signal watch previously added with gst_bus_add_signal_watch(). * * MT safe. */voidgst_bus_remove_signal_watch (GstBus * bus){  guint id = 0;  g_return_if_fail (GST_IS_BUS (bus));  /* I know the callees don't take this lock, so go ahead and abuse it */  GST_OBJECT_LOCK (bus);  if (bus->num_signal_watchers == 0)    goto error;  bus->num_signal_watchers--;  if (bus->num_signal_watchers > 0)    goto done;  id = bus->signal_watch_id;  bus->signal_watch_id = 0;  GST_DEBUG_OBJECT (bus, "removing signal watch %u", id);done:  GST_OBJECT_UNLOCK (bus);  if (id)    g_source_remove (id);  return;  /* ERRORS */error:  {    g_critical ("Bus %s has no signal watches attached", GST_OBJECT_NAME (bus));    GST_OBJECT_UNLOCK (bus);    return;  }}

static voidgst_tee_set_property (GObject * object, guint prop_id, const GValue * value,    GParamSpec * pspec){  GstTee *tee = GST_TEE (object);  GST_OBJECT_LOCK (tee);  switch (prop_id) {    case PROP_HAS_CHAIN:      tee->has_chain = g_value_get_boolean (value);      break;    case PROP_SILENT:      tee->silent = g_value_get_boolean (value);      break;    case PROP_PULL_MODE:      tee->pull_mode = (GstTeePullMode) g_value_get_enum (value);      break;    case PROP_ALLOC_PAD:    {      GstPad *pad = g_value_get_object (value);      GST_OBJECT_LOCK (pad);      if (GST_OBJECT_PARENT (pad) == GST_OBJECT_CAST (object))        tee->allocpad = pad;      else        GST_WARNING_OBJECT (object, "Tried to set alloc pad %s which"            " is not my pad", GST_OBJECT_NAME (pad));      GST_OBJECT_UNLOCK (pad);      break;    }    case PROP_ALLOW_NOT_LINKED:      tee->allow_not_linked = g_value_get_boolean (value);      break;    default:      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);      break;  }  GST_OBJECT_UNLOCK (tee);}