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

static gboolean gst_a2dp_sink_init_ghost_pad(GstA2dpSink *self){	GstPad *capsfilter_pad;	/* we search for the capsfilter sinkpad */	capsfilter_pad = gst_element_get_static_pad(self->capsfilter, "sink");	/* now we add a ghostpad */	self->ghostpad = GST_GHOST_PAD(gst_ghost_pad_new("sink",		capsfilter_pad));	g_object_unref(capsfilter_pad);	/* the getcaps of our ghostpad must reflect the device caps */	gst_pad_set_getcaps_function(GST_PAD(self->ghostpad),				gst_a2dp_sink_get_caps);	self->ghostpad_setcapsfunc = GST_PAD_SETCAPSFUNC(self->ghostpad);	gst_pad_set_setcaps_function(GST_PAD(self->ghostpad),			GST_DEBUG_FUNCPTR(gst_a2dp_sink_set_caps));	/* we need to handle events on our own and we also need the eventfunc	 * of the ghostpad for forwarding calls */	self->ghostpad_eventfunc = GST_PAD_EVENTFUNC(GST_PAD(self->ghostpad));	gst_pad_set_event_function(GST_PAD(self->ghostpad),			gst_a2dp_sink_handle_event);	if (!gst_element_add_pad(GST_ELEMENT(self), GST_PAD(self->ghostpad)))		GST_ERROR_OBJECT(self, "failed to add ghostpad");	return TRUE;}

static gbooleangst_freeze_sink_event (GstPad * pad, GstEvent * event){  gboolean ret = TRUE;  GstFreeze *freeze = GST_FREEZE (gst_pad_get_parent (pad));  switch (GST_EVENT_TYPE (event)) {    case GST_EVENT_EOS:      GST_DEBUG_OBJECT (freeze, "EOS on sink pad %s",          gst_pad_get_name (GST_PAD (freeze->sinkpad)));      gst_event_unref (event);      break;    case GST_EVENT_NEWSEGMENT:      /* FALL TROUGH */    case GST_EVENT_FLUSH_STOP:      gst_freeze_clear_buffer (freeze);      /* FALL TROUGH */    default:      ret = gst_pad_event_default (GST_PAD (freeze->sinkpad), event);      break;  }  gst_object_unref (freeze);  return ret;}

static voidmpegts_parse_sync_program_pads (MpegTSParse2 * parse){  GList *walk;  GST_INFO_OBJECT (parse, "begin sync pads");  for (walk = parse->pads_to_remove; walk; walk = walk->next)    gst_element_remove_pad (GST_ELEMENT (parse), GST_PAD (walk->data));  for (walk = parse->pads_to_add; walk; walk = walk->next)    gst_element_add_pad (GST_ELEMENT (parse), GST_PAD (walk->data));  if (parse->pads_to_add)    g_list_free (parse->pads_to_add);  if (parse->pads_to_remove)    g_list_free (parse->pads_to_remove);  GST_OBJECT_LOCK (parse);  parse->pads_to_remove = NULL;  parse->pads_to_add = NULL;  parse->need_sync_program_pads = FALSE;  GST_OBJECT_UNLOCK (parse);  GST_INFO_OBJECT (parse, "end sync pads");}

static voidkms_audio_mixer_remove_sometimes_src_pad (KmsAudioMixer * self,    GstElement * adder){  GstProxyPad *internal;  GstPad *srcpad, *peer;  srcpad = gst_element_get_static_pad (adder, "src");  peer = gst_pad_get_peer (srcpad);  if (peer == NULL)    goto end_phase_1;  internal = gst_proxy_pad_get_internal ((GstProxyPad *) peer);  if (internal == NULL)    goto end_phase_2;  gst_ghost_pad_set_target (GST_GHOST_PAD (internal), NULL);  if (GST_STATE (self) < GST_STATE_PAUSED      || GST_STATE_PENDING (self) < GST_STATE_PAUSED      || GST_STATE_TARGET (self) < GST_STATE_PAUSED) {    gst_pad_set_active (GST_PAD (internal), FALSE);  }  GST_DEBUG ("Removing source pad %" GST_PTR_FORMAT, internal);  gst_element_remove_pad (GST_ELEMENT (self), GST_PAD (internal));  gst_object_unref (internal);end_phase_2:  gst_object_unref (peer);end_phase_1:  gst_object_unref (srcpad);}

/**************************************************** *              GstElement vmetods                  * ****************************************************/static GstPad *_request_new_pad (GstElement * element, GstPadTemplate * templ,    const gchar * name, const GstCaps * caps){  GstPad *audioresample_srcpad, *audioconvert_sinkpad, *tmpghost;  GstPad *ghost;  GstElement *audioconvert, *audioresample;  PadInfos *infos = g_slice_new0 (PadInfos);  GESSmartAdder *self = GES_SMART_ADDER (element);  infos->adder_pad = gst_element_request_pad (self->adder, templ, NULL, caps);  if (infos->adder_pad == NULL) {    GST_WARNING_OBJECT (element, "Could not get any pad from GstAdder");    return NULL;  }  infos->self = self;  infos->bin = gst_bin_new (NULL);  audioconvert = gst_element_factory_make ("audioconvert", NULL);  audioresample = gst_element_factory_make ("audioresample", NULL);  gst_bin_add_many (GST_BIN (infos->bin), audioconvert, audioresample, NULL);  gst_element_link_many (audioconvert, audioresample, NULL);  audioconvert_sinkpad = gst_element_get_static_pad (audioconvert, "sink");  tmpghost = GST_PAD (gst_ghost_pad_new (NULL, audioconvert_sinkpad));  gst_object_unref (audioconvert_sinkpad);  gst_pad_set_active (tmpghost, TRUE);  gst_element_add_pad (GST_ELEMENT (infos->bin), tmpghost);  gst_bin_add (GST_BIN (self), infos->bin);  ghost = gst_ghost_pad_new (NULL, tmpghost);  gst_pad_set_active (ghost, TRUE);  if (!gst_element_add_pad (GST_ELEMENT (self), ghost))    goto could_not_add;  audioresample_srcpad = gst_element_get_static_pad (audioresample, "src");  tmpghost = GST_PAD (gst_ghost_pad_new (NULL, audioresample_srcpad));  gst_object_unref (audioresample_srcpad);  gst_pad_set_active (tmpghost, TRUE);  gst_element_add_pad (GST_ELEMENT (infos->bin), tmpghost);  gst_pad_link (tmpghost, infos->adder_pad);  LOCK (self);  g_hash_table_insert (self->pads_infos, ghost, infos);  UNLOCK (self);  GST_DEBUG_OBJECT (self, "Returning new pad %" GST_PTR_FORMAT, ghost);  return ghost;could_not_add:  {    GST_ERROR_OBJECT (self, "could not add pad");    destroy_pad (infos);    return NULL;  }}

static gboolean_create_input_chain (GstGLMixerBin * self, struct input_chain *chain,    GstPad * mixer_pad){  GstGLMixerBinClass *klass = GST_GL_MIXER_BIN_GET_CLASS (self);  GstPad *pad;  gboolean res = TRUE;  gchar *name;  chain->self = self;  chain->mixer_pad = mixer_pad;  chain->upload = gst_element_factory_make ("glupload", NULL);  chain->in_convert = gst_element_factory_make ("glcolorconvert", NULL);  res &= gst_bin_add (GST_BIN (self), chain->in_convert);  res &= gst_bin_add (GST_BIN (self), chain->upload);  pad = gst_element_get_static_pad (chain->in_convert, "src");  if (gst_pad_link (pad, mixer_pad) != GST_PAD_LINK_OK) {    gst_object_unref (pad);    return FALSE;  }  gst_object_unref (pad);  res &=      gst_element_link_pads (chain->upload, "src", chain->in_convert, "sink");  pad = gst_element_get_static_pad (chain->upload, "sink");  if (!pad) {    return FALSE;  } else {    GST_DEBUG_OBJECT (self, "setting target sink pad %" GST_PTR_FORMAT, pad);    name = gst_object_get_name (GST_OBJECT (mixer_pad));    if (klass->create_input_pad) {      chain->ghost_pad = klass->create_input_pad (self, chain->mixer_pad);      gst_object_set_name (GST_OBJECT (chain->ghost_pad), name);      gst_ghost_pad_set_target (chain->ghost_pad, pad);    } else {      chain->ghost_pad =          GST_GHOST_PAD (gst_ghost_pad_new (GST_PAD_NAME (chain->mixer_pad),              pad));    }    g_free (name);    GST_OBJECT_LOCK (self);    if (self->priv->running)      gst_pad_set_active (GST_PAD (chain->ghost_pad), TRUE);    GST_OBJECT_UNLOCK (self);    gst_element_add_pad (GST_ELEMENT_CAST (self), GST_PAD (chain->ghost_pad));    gst_object_unref (pad);  }  gst_element_sync_state_with_parent (chain->upload);  gst_element_sync_state_with_parent (chain->in_convert);  return TRUE;}

static gboolean gst_imx_compositor_sink_query(GstImxBPAggregator *aggregator, GstImxBPAggregatorPad *pad, GstQuery *query){	switch (GST_QUERY_TYPE(query))	{		case GST_QUERY_CAPS:		{			/* Custom caps query response. Take the sinkpad template caps,			 * optionally filter them, and return them as the result.			 * This ensures that the caps that the derived class supports			 * for input data are actually used (by default, the aggregator			 * base classes try to keep input and output caps equal) */			GstCaps *filter, *caps;			gst_query_parse_caps(query, &filter);			caps = gst_pad_get_pad_template_caps(GST_PAD(pad));			if (filter != NULL)			{				GstCaps *unfiltered_caps = gst_caps_make_writable(caps);				caps = gst_caps_intersect(unfiltered_caps, filter);				gst_caps_unref(unfiltered_caps);			}			GST_DEBUG_OBJECT(aggregator, "responding to CAPS query with caps %" GST_PTR_FORMAT, (gpointer)caps);			gst_query_set_caps_result(query, caps);			gst_caps_unref(caps);			return TRUE;		}		case GST_QUERY_ACCEPT_CAPS:		{			/* Custom accept_caps query response. Simply check if			 * the supplied caps are a valid subset of the sinkpad's			 * template caps. This is done for the same reasons			 * as the caps query response above. */			GstCaps *accept_caps = NULL, *template_caps = NULL;			gboolean ret;			gst_query_parse_accept_caps(query, &accept_caps);			template_caps = gst_pad_get_pad_template_caps(GST_PAD(pad));			ret = gst_caps_is_subset(accept_caps, template_caps);			GST_DEBUG_OBJECT(aggregator, "responding to ACCEPT_CAPS query with value %d  (acceptcaps: %" GST_PTR_FORMAT "  template caps %" GST_PTR_FORMAT ")", ret, (gpointer)accept_caps, (gpointer)template_caps);			gst_query_set_accept_caps_result(query, ret);			return TRUE;		}		default:			return GST_IMXBP_AGGREGATOR_CLASS(gst_imx_compositor_parent_class)->sink_query(aggregator, pad, query);	}}

bool ofGstVideoPlayer::allocate(int bpp){	if(bIsAllocated) return true;	guint64 durationNanos = videoUtils.getDurationNanos();	nFrames		  = 0;	if(GstPad* pad = gst_element_get_static_pad(videoUtils.getSink(), "sink")){#if GST_VERSION_MAJOR==0		int width,height;		if(gst_video_get_size(GST_PAD(pad), &width, &height)){			if(!videoUtils.allocate(width,height,bpp)) return false;		}else{			ofLogError("ofGstVideoPlayer") << "allocate(): couldn't query width and height";			return false;		}		const GValue *framerate = gst_video_frame_rate(pad);		fps_n=0;		fps_d=0;		if(framerate && GST_VALUE_HOLDS_FRACTION (framerate)){			fps_n = gst_value_get_fraction_numerator (framerate);			fps_d = gst_value_get_fraction_denominator (framerate);			nFrames = (float)(durationNanos / (float)GST_SECOND) * (float)fps_n/(float)fps_d;			ofLogVerbose("ofGstVideoPlayer") << "allocate(): framerate: " << fps_n << "/" << fps_d;		}else{			ofLogWarning("ofGstVideoPlayer") << "allocate(): cannot get framerate, frame seek won't work";		}		bIsAllocated = true;#else		if(GstCaps *caps = gst_pad_get_current_caps (GST_PAD (pad))){			GstVideoInfo info;			gst_video_info_init (&info);			if (gst_video_info_from_caps (&info, caps)){				if(!videoUtils.allocate(info.width,info.height,bpp)) return false;			}else{				ofLogError("ofGstVideoPlayer") << "allocate(): couldn't query width and height";				return false;			}			fps_n = info.fps_n;			fps_d = info.fps_d;			nFrames = (float)(durationNanos / (float)GST_SECOND) * (float)fps_n/(float)fps_d;			gst_caps_unref(caps);			bIsAllocated = true;		}else{			ofLogError("ofGstVideoPlayer") << "allocate(): cannot get pipeline caps";			bIsAllocated = false;		}#endif		gst_object_unref(GST_OBJECT(pad));	}else{		ofLogError("ofGstVideoPlayer") << "allocate(): cannot get sink pad";		bIsAllocated = false;	}	return bIsAllocated;}

static gbooleangst_tcp_mix_src_pad_start (GstTCPMixSrcPad * pad){  gboolean res = FALSE;  if (GST_PAD_TASK (pad) == NULL) {    GstTaskFunction func = (GstTaskFunction) gst_tcp_mix_src_loop;    res = gst_pad_start_task (GST_PAD (pad), func, GST_PAD (pad), NULL);  }  return res;}

static voidsplitmux_part_pad_constructed (GObject * pad){  gst_pad_set_chain_function (GST_PAD (pad),      GST_DEBUG_FUNCPTR (splitmux_part_pad_chain));  gst_pad_set_event_function (GST_PAD (pad),      GST_DEBUG_FUNCPTR (splitmux_part_pad_event));  gst_pad_set_query_function (GST_PAD (pad),      GST_DEBUG_FUNCPTR (splitmux_part_pad_query));  G_OBJECT_CLASS (gst_splitmux_part_pad_parent_class)->constructed (pad);}

static GstPad *_request_new_pad (GstElement * element,    GstPadTemplate * templ, const gchar * req_name, const GstCaps * caps){  GstAggregator *self;  GstAggregatorPad *agg_pad;  GstElementClass *klass = GST_ELEMENT_GET_CLASS (element);  GstAggregatorPrivate *priv = GST_AGGREGATOR (element)->priv;  self = GST_AGGREGATOR (element);  if (templ == gst_element_class_get_pad_template (klass, "sink_%u")) {    gint serial = 0;    gchar *name = NULL;    GST_OBJECT_LOCK (element);    if (req_name == NULL || strlen (req_name) < 6        || !g_str_has_prefix (req_name, "sink_")) {      /* no name given when requesting the pad, use next available int */      priv->padcount++;    } else {      /* parse serial number from requested padname */      serial = g_ascii_strtoull (&req_name[5], NULL, 10);      if (serial >= priv->padcount)        priv->padcount = serial;    }    name = g_strdup_printf ("sink_%u", priv->padcount);    agg_pad = g_object_new (GST_AGGREGATOR_GET_CLASS (self)->sinkpads_type,        "name", name, "direction", GST_PAD_SINK, "template", templ, NULL);    g_free (name);    GST_OBJECT_UNLOCK (element);  } else {    return NULL;  }  GST_DEBUG_OBJECT (element, "Adding pad %s", GST_PAD_NAME (agg_pad));  if (priv->running)    gst_pad_set_active (GST_PAD (agg_pad), TRUE);  /* add the pad to the element */  gst_element_add_pad (element, GST_PAD (agg_pad));  return GST_PAD (agg_pad);}

static GstPad *gst_switch_request_new_pad (GstElement * element,    GstPadTemplate * templ, const gchar * name, const GstCaps * caps){  GstSwitch *swit = GST_SWITCH (element);  GstGhostPad *pad;  INFO ("requesting: %s.%s (%d=%d+%d)", GST_ELEMENT_NAME (swit),      name ? name : GST_PAD_TEMPLATE_NAME_TEMPLATE (templ),      element->numpads, element->numsrcpads, element->numsinkpads);  GST_SWITCH_LOCK (swit);  switch (GST_PAD_TEMPLATE_DIRECTION (templ)) {    case GST_PAD_SRC:      pad = gst_switch_request_new_src_pad (swit, templ, name, caps);      break;    case GST_PAD_SINK:      pad = gst_switch_request_new_sink_pad (swit, templ, name, caps);      break;    default:      pad = NULL;      break;  }  if (pad) {    gst_pad_set_active (GST_PAD (pad), TRUE);    if (gst_element_add_pad (GST_ELEMENT (swit), GST_PAD (pad))) {      GstPad *basepad = gst_ghost_pad_get_target (pad);      GstElement *swcase = GST_ELEMENT (GST_PAD_PARENT (basepad));      GST_OBJECT_FLAG_SET (basepad, GST_SWITCH_PAD_FLAG_GHOSTED);      GST_DEBUG_OBJECT (swit, "New %s:%s on %s:%s",          GST_ELEMENT_NAME (swit), GST_PAD_NAME (pad),          GST_ELEMENT_NAME (swcase), GST_PAD_NAME (basepad));      INFO ("requested %s.%s on %s.%s",          GST_ELEMENT_NAME (swit), GST_PAD_NAME (pad),          GST_ELEMENT_NAME (swcase), GST_PAD_NAME (basepad));    }  }  GST_SWITCH_UNLOCK (swit);  return GST_PAD (pad);}

static voidgst_gl_mixer_bin_release_pad (GstElement * element, GstPad * pad){  GstGLMixerBin *self = GST_GL_MIXER_BIN (element);  GList *l = self->priv->input_chains;  gboolean released = FALSE;  GST_OBJECT_LOCK (element);  while (l) {    struct input_chain *chain = l->data;    if (GST_PAD (chain->ghost_pad) == pad) {      self->priv->input_chains =          g_list_delete_link (self->priv->input_chains, l);      GST_OBJECT_UNLOCK (element);      _free_input_chain (chain);      gst_element_remove_pad (element, pad);      released = TRUE;      break;    }    l = l->next;  }  if (!released)    GST_OBJECT_UNLOCK (element);}

static void gst_imx_compositor_pad_update_canvas(GstImxCompositorPad *compositor_pad, GstImxRegion const *source_region){	GstImxCompositor *compositor;	GstVideoInfo *info = &(GST_IMXBP_VIDEO_AGGREGATOR_PAD(compositor_pad)->info);	/* Catch redundant calls */	if (!(compositor_pad->canvas_needs_update))		return;	compositor = GST_IMX_COMPOSITOR(gst_pad_get_parent_element(GST_PAD(compositor_pad)));	/* (Re)compute the outer region */	gst_imx_compositor_pad_compute_outer_region(compositor_pad);	/* (Re)computer the inner region */	gst_imx_canvas_calculate_inner_region(&(compositor_pad->canvas), info);	/* Next, clip the canvas against the overall region,	 * which describes the output frame's size	 * This way, it is ensured that only the parts that are "within"	 * the output frame are blit */	gst_imx_canvas_clip(		&(compositor_pad->canvas),		&(compositor->overall_region),		info,		source_region,		&(compositor_pad->source_subset)	);	/* Canvas updated, mark it as such */	compositor_pad->canvas_needs_update = FALSE;	gst_object_unref(GST_OBJECT(compositor));}

static GstElement *gst_switch_select (GstSwitch * swit,    GstPadTemplate * templ, const gchar * name, const GstCaps * caps){  GList *item = GST_BIN_CHILDREN (GST_BIN (swit));  GstElement *swcase = NULL;  for (; item; item = g_list_next (item)) {    GList *paditem = GST_ELEMENT_PADS (GST_ELEMENT (item->data));    GstPad *basepad = NULL, *pad = NULL;    for (; paditem; paditem = g_list_next (paditem)) {      pad = GST_PAD (paditem->data);      if (GST_PAD_IS_SINK (pad) && !gst_pad_is_linked (pad) &&          !GST_OBJECT_FLAG_IS_SET (GST_OBJECT (pad),              GST_SWITCH_PAD_FLAG_GHOSTED)) {        basepad = pad;        break;      }    }    if (basepad) {      swcase = GST_ELEMENT (item->data);      break;    }  }  if (!swcase) {    swcase = gst_switch_request_new_case (swit, templ, caps);  }  return swcase;}

static GstPad *gst_gl_mixer_bin_request_new_pad (GstElement * element, GstPadTemplate * templ,    const gchar * req_name, const GstCaps * caps){  GstGLMixerBin *self = GST_GL_MIXER_BIN (element);  GstPadTemplate *mixer_templ;  struct input_chain *chain;  GstPad *mixer_pad;  chain = g_new0 (struct input_chain, 1);  mixer_templ = _find_element_pad_template (self->mixer,      GST_PAD_TEMPLATE_DIRECTION (templ), GST_PAD_TEMPLATE_PRESENCE (templ));  g_return_val_if_fail (mixer_templ, NULL);  mixer_pad =      gst_element_request_pad (self->mixer, mixer_templ, req_name, NULL);  g_return_val_if_fail (mixer_pad, NULL);  if (!_create_input_chain (self, chain, mixer_pad)) {    gst_element_release_request_pad (self->mixer, mixer_pad);    _free_input_chain (chain);    return NULL;  }  GST_OBJECT_LOCK (element);  self->priv->input_chains = g_list_prepend (self->priv->input_chains, chain);  GST_OBJECT_UNLOCK (element);  gst_child_proxy_child_added (GST_CHILD_PROXY (self),      G_OBJECT (chain->ghost_pad), GST_OBJECT_NAME (chain->ghost_pad));  return GST_PAD (chain->ghost_pad);}

gboolean eos_callback(GstPad *pad,                      GstObject *parent,                      GstEvent *event){    GstEvent *seek_event;    GstElement *bkgdec;    GValue v=G_VALUE_INIT;    GstPad *srcpad;    GstIterator *srcpads;    gboolean result;    g_print("Decodebin received EOS. Someone should handle that.../n");        bkgdec=gst_pad_get_parent_element(pad);    if(bkgdec->numsrcpads>0) {        srcpads=gst_element_iterate_src_pads(bkgdec);        gst_iterator_next(srcpads,&v);        srcpad=GST_PAD(g_value_get_object(&v));        seek_event=gst_event_new_seek ( 1.0, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH,                         GST_SEEK_TYPE_SET, 0,                         GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);             result=gst_pad_send_event(srcpad,seek_event);        if(result==TRUE) {            g_print("seek event sent OK./n");        } else {           g_print("seek sent FAILED./n");        }        g_value_reset(&v);        g_value_unset(&v);        gst_iterator_free(srcpads);        return TRUE;    }    return gst_pad_event_default(pad,parent,event);}

voidkms_tree_bin_unlink_input_element_from_tee (KmsTreeBin * self){  GstPad *queue_sink, *peer, *tee_src;  GstElement *tee;  queue_sink = gst_element_get_static_pad (self->priv->input_element, "sink");  peer = gst_pad_get_peer (queue_sink);  if (GST_IS_PROXY_PAD (peer)) {    GstProxyPad *ghost;    ghost = gst_proxy_pad_get_internal (GST_PROXY_PAD (peer));    tee_src = gst_pad_get_peer (GST_PAD (ghost));    g_object_unref (peer);    g_object_unref (ghost);  } else {    tee_src = peer;  }  gst_pad_unlink (tee_src, queue_sink);  tee = gst_pad_get_parent_element (tee_src);  if (tee != NULL) {    gst_element_release_request_pad (tee, tee_src);    g_object_unref (tee);  }  g_object_unref (tee_src);  g_object_unref (queue_sink);}

		/// Constructor.		inline explicit SourcePadJitterEntry(const GstPad* pSourcePad)			: m_pPad(GST_PAD(gst_object_ref(GST_OBJECT(pSourcePad))))			, m_ElementName(GetPadParentElementName(pSourcePad))			, m_PadName(gst_pad_get_name(pSourcePad))			, m_LastSourceTimestamp(0)			, m_StatsCollection(PipelineTracer::STATS_COLLECTION_SIZE)		{}

static gboolean_unresponsive_timeout (GstClock * clock, GstClockTime time, GstClockID id,    gpointer user_data){  GstAggregatorPad *aggpad;  GstAggregator *self;  if (user_data == NULL)    return FALSE;  aggpad = GST_AGGREGATOR_PAD (user_data);  /* avoid holding the last reference to the parent element here */  PAD_LOCK_EVENT (aggpad);  self = GST_AGGREGATOR (gst_pad_get_parent (GST_PAD (aggpad)));  GST_DEBUG_OBJECT (aggpad, "marked unresponsive");  g_atomic_int_set (&aggpad->unresponsive, TRUE);  if (self) {    QUEUE_PUSH (self);    gst_object_unref (self);  }  PAD_UNLOCK_EVENT (aggpad);  return TRUE;}

static voidgst_gl_video_mixer_pad_set_property (GObject * object, guint prop_id,    const GValue * value, GParamSpec * pspec){  GstGLVideoMixerPad *pad = GST_GL_VIDEO_MIXER_PAD (object);  GstGLMixer *mix = GST_GL_MIXER (gst_pad_get_parent (GST_PAD (pad)));  switch (prop_id) {    case PROP_PAD_XPOS:      pad->xpos = g_value_get_int (value);      pad->geometry_change = TRUE;      break;    case PROP_PAD_YPOS:      pad->ypos = g_value_get_int (value);      pad->geometry_change = TRUE;      break;    case PROP_PAD_WIDTH:      pad->width = g_value_get_int (value);      pad->geometry_change = TRUE;      break;    case PROP_PAD_HEIGHT:      pad->height = g_value_get_int (value);      pad->geometry_change = TRUE;      break;    case PROP_PAD_ALPHA:      pad->alpha = g_value_get_double (value);      break;    default:      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);      break;  }  gst_object_unref (mix);}

static GstPad *gst_ghost_pad_new_full (const gchar * name, GstPadDirection dir,    GstPadTemplate * templ){  GstGhostPad *ret;  g_return_val_if_fail (dir != GST_PAD_UNKNOWN, NULL);  /* OBJECT CREATION */  if (templ) {    ret = g_object_new (GST_TYPE_GHOST_PAD, "name", name,        "direction", dir, "template", templ, NULL);  } else {    ret = g_object_new (GST_TYPE_GHOST_PAD, "name", name,        "direction", dir, NULL);  }  if (!gst_ghost_pad_construct (ret))    goto construct_failed;  return GST_PAD (ret);construct_failed:  /* already logged */  gst_object_unref (ret);  return NULL;}

/* used for catching newsegment events while we don't have a sink, for * later forwarding it to the sink */static gboolean gst_a2dp_sink_handle_event(GstPad *pad, GstEvent *event){	GstA2dpSink *self;	GstTagList *taglist = NULL;	GstObject *parent;	self = GST_A2DP_SINK(GST_PAD_PARENT(pad));	parent = gst_element_get_parent(GST_ELEMENT(self->sink));	if (GST_EVENT_TYPE(event) == GST_EVENT_NEWSEGMENT &&			parent != GST_OBJECT_CAST(self)) {		if (self->newseg_event != NULL)			gst_event_unref(self->newseg_event);		self->newseg_event = gst_event_ref(event);	} else if (GST_EVENT_TYPE(event) == GST_EVENT_TAG &&			parent != GST_OBJECT_CAST(self)) {		if (self->taglist == NULL)			gst_event_parse_tag(event, &self->taglist);		else {			gst_event_parse_tag(event, &taglist);			gst_tag_list_insert(self->taglist, taglist,					GST_TAG_MERGE_REPLACE);		}	}	if (parent != NULL)		gst_object_unref(GST_OBJECT(parent));	return self->ghostpad_eventfunc(GST_PAD(self->ghostpad), event);}

static gbooleangst_audiomixer_sink_query (GstAggregator * agg, GstAggregatorPad * aggpad,    GstQuery * query){  gboolean res = FALSE;  switch (GST_QUERY_TYPE (query)) {    case GST_QUERY_CAPS:    {      GstCaps *filter, *caps;      gst_query_parse_caps (query, &filter);      caps = gst_audiomixer_sink_getcaps (agg, GST_PAD (aggpad), filter);      gst_query_set_caps_result (query, caps);      gst_caps_unref (caps);      res = TRUE;      break;    }    default:      res =          GST_AGGREGATOR_CLASS (parent_class)->sink_query (agg, aggpad, query);      break;  }  return res;}

/* Push buffers and switch for each selector pad */static voidpush_switched_buffers (GList * input_pads,    GstElement * elem, GList * peer_pads, gint num_buffers){  GstBuffer *buf = NULL;  GList *l = peer_pads;  GstPad *selpad = NULL;  /* setup dummy buffer */  buf = gst_buffer_new_and_alloc (1);  while (l != NULL) {    /* set selector pad */    selpad = gst_pad_get_peer (GST_PAD (l->data));    selector_set_active_pad (elem, selpad);    if (selpad) {      gst_object_unref (selpad);    }    /* push buffers */    push_input_buffers (input_pads, buf, num_buffers);    /* switch to next selector pad */    l = g_list_next (l);  }  /* cleanup buffer */  gst_buffer_unref (buf);}

static gboolean_sink_query (GstAggregator * self, GstAggregatorPad * aggpad, GstQuery * query){  GstPad *pad = GST_PAD (aggpad);  return gst_pad_query_default (pad, GST_OBJECT (self), query);}

static voiddynamic_link (GstPadTemplate * templ, GstPad * newpad, gpointer user_data){  GstPad *target = GST_PAD (user_data);  gst_pad_link (newpad, target);  gst_object_unref (target);}

/* generate queries to adaptive demux */static gbooleantestQueryCheckDataReceived (GstAdaptiveDemuxTestEngine * engine,    GstAdaptiveDemuxTestOutputStream * stream,    GstBuffer * buffer, gpointer user_data){  GList *pads;  GstPad *pad;  GstQuery *query;  gboolean ret;  gint64 duration;  gboolean seekable;  gint64 segment_start;  gint64 segment_end;  gchar *uri;  gchar *redirect_uri;  gboolean redirect_permanent;  pads = GST_ELEMENT_PADS (stream->appsink);  /* AppSink should have only 1 pad */  fail_unless (pads != NULL);  fail_unless (g_list_length (pads) == 1);  pad = GST_PAD (pads->data);  query = gst_query_new_duration (GST_FORMAT_TIME);  ret = gst_pad_peer_query (pad, query);  fail_unless (ret == TRUE);  gst_query_parse_duration (query, NULL, &duration);  fail_unless (duration == 135743 * GST_MSECOND);  gst_query_unref (query);  query = gst_query_new_seeking (GST_FORMAT_TIME);  ret = gst_pad_peer_query (pad, query);  fail_unless (ret == TRUE);  gst_query_parse_seeking (query, NULL, &seekable, &segment_start,      &segment_end);  fail_unless (seekable == TRUE);  fail_unless (segment_start == 0);  fail_unless (segment_end == duration);  gst_query_unref (query);  query = gst_query_new_uri ();  ret = gst_pad_peer_query (pad, query);  fail_unless (ret == TRUE);  gst_query_parse_uri (query, &uri);  gst_query_parse_uri_redirection (query, &redirect_uri);  gst_query_parse_uri_redirection_permanent (query, &redirect_permanent);  fail_unless (strcmp (uri, "http://unit.test/test.mpd") == 0);  /* adaptive demux does not reply with redirect information */  fail_unless (redirect_uri == NULL);  fail_unless (redirect_permanent == FALSE);  g_free (uri);  g_free (redirect_uri);  gst_query_unref (query);  return gst_adaptive_demux_test_check_received_data (engine,      stream, buffer, user_data);}