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

static voidgst_unaligned_audio_parse_init (GstUnalignedAudioParse * unaligned_audio_parse){  GstPad *inner_pad;  GstPad *ghostpad;  unaligned_audio_parse->inner_parser =      gst_element_factory_make ("rawaudioparse", "inner_parser");  g_assert (unaligned_audio_parse->inner_parser != NULL);  g_object_set (G_OBJECT (unaligned_audio_parse->inner_parser),      "use-sink-caps", TRUE, NULL);  gst_bin_add (GST_BIN (unaligned_audio_parse),      unaligned_audio_parse->inner_parser);  inner_pad =      gst_element_get_static_pad (unaligned_audio_parse->inner_parser, "sink");  ghostpad =      gst_ghost_pad_new_from_template ("sink", inner_pad,      gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS          (unaligned_audio_parse), "sink"));  gst_element_add_pad (GST_ELEMENT (unaligned_audio_parse), ghostpad);  gst_object_unref (GST_OBJECT (inner_pad));  inner_pad = gst_element_get_static_pad (unaligned_audio_parse->inner_parser,      "src");  ghostpad =      gst_ghost_pad_new_from_template ("src", inner_pad,      gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS          (unaligned_audio_parse), "src"));  gst_element_add_pad (GST_ELEMENT (unaligned_audio_parse), ghostpad);  gst_object_unref (GST_OBJECT (inner_pad));}

static voidgst_video_parse_init (GstVideoParse * vp){  GstPad *inner_pad;  GstPad *ghostpad;  vp->rawvideoparse =      gst_element_factory_make ("rawvideoparse", "inner_rawvideoparse");  g_assert (vp->rawvideoparse != NULL);  gst_bin_add (GST_BIN (vp), vp->rawvideoparse);  inner_pad = gst_element_get_static_pad (vp->rawvideoparse, "sink");  ghostpad =      gst_ghost_pad_new_from_template ("sink", inner_pad,      gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS (vp), "sink"));  gst_element_add_pad (GST_ELEMENT (vp), ghostpad);  gst_object_unref (GST_OBJECT (inner_pad));  inner_pad = gst_element_get_static_pad (vp->rawvideoparse, "src");  ghostpad =      gst_ghost_pad_new_from_template ("src", inner_pad,      gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS (vp), "src"));  gst_element_add_pad (GST_ELEMENT (vp), ghostpad);  gst_object_unref (GST_OBJECT (inner_pad));}

static GstEncodingContainerProfile *kms_recording_profile_create_ksr_profile (gboolean has_audio,    gboolean has_video){  GstEncodingContainerProfile *cprof;  GstPadTemplate *templ;  GstElement *mux;  GstCaps *pc;  pc = gst_caps_from_string ("application/x-ksr");  cprof = gst_encoding_container_profile_new ("Ksr", NULL, pc, NULL);  gst_caps_unref (pc);  /* Use matroska caps to define this profile */  mux = gst_element_factory_make ("matroskamux", NULL);  if (has_audio) {    GstCaps *ac;    templ =        gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS (mux),        "audio_%u");    ac = gst_pad_template_get_caps (templ);    gst_encoding_container_profile_add_profile (cprof, (GstEncodingProfile *)        gst_encoding_audio_profile_new (ac, NULL, NULL, 0));    gst_caps_unref (ac);  }  if (has_video) {    GstCaps *vc;    templ =        gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS (mux),        "video_%u");    vc = gst_pad_template_get_caps (templ);    gst_encoding_container_profile_add_profile (cprof, (GstEncodingProfile *)        gst_encoding_video_profile_new (vc, NULL, NULL, 0));    gst_caps_unref (vc);  }  g_object_unref (mux);  return cprof;}

static GstCaps *gst_osx_video_src_get_caps (GstBaseSrc * src){  GstElementClass *gstelement_class;  GstOSXVideoSrc *self;  GstPadTemplate *pad_template;  GstCaps *caps;  GstStructure *structure;  gint width, height;  gstelement_class = GST_ELEMENT_GET_CLASS (src);  self = GST_OSX_VIDEO_SRC (src);  /* if we don't have the resolution set up, return template caps */  if (!self->world)    return NULL;  pad_template = gst_element_class_get_pad_template (gstelement_class, "src");  /* i don't think this can actually fail... */  if (!pad_template)    return NULL;  width = self->rect.right;  height = self->rect.bottom;  caps = gst_caps_copy (gst_pad_template_get_caps (pad_template));  structure = gst_caps_get_structure (caps, 0);  gst_structure_set (structure, "width", G_TYPE_INT, width, NULL);  gst_structure_set (structure, "height", G_TYPE_INT, height, NULL);  return caps;}

static voidgst_rtp_rtx_receive_init (GstRtpRtxReceive * rtx){  GstElementClass *klass = GST_ELEMENT_GET_CLASS (rtx);  rtx->srcpad =      gst_pad_new_from_template (gst_element_class_get_pad_template (klass,          "src"), "src");  GST_PAD_SET_PROXY_CAPS (rtx->srcpad);  GST_PAD_SET_PROXY_ALLOCATION (rtx->srcpad);  gst_pad_set_event_function (rtx->srcpad,      GST_DEBUG_FUNCPTR (gst_rtp_rtx_receive_src_event));  gst_element_add_pad (GST_ELEMENT (rtx), rtx->srcpad);  rtx->sinkpad =      gst_pad_new_from_template (gst_element_class_get_pad_template (klass,          "sink"), "sink");  GST_PAD_SET_PROXY_CAPS (rtx->sinkpad);  GST_PAD_SET_PROXY_ALLOCATION (rtx->sinkpad);  gst_pad_set_chain_function (rtx->sinkpad,      GST_DEBUG_FUNCPTR (gst_rtp_rtx_receive_chain));  gst_element_add_pad (GST_ELEMENT (rtx), rtx->sinkpad);  rtx->ssrc2_ssrc1_map = g_hash_table_new (g_direct_hash, g_direct_equal);  rtx->seqnum_ssrc1_map = g_hash_table_new_full (g_direct_hash, g_direct_equal,      NULL, (GDestroyNotify) ssrc_assoc_free);  rtx->rtx_pt_map = g_hash_table_new (g_direct_hash, g_direct_equal);}

static voidgst_rtp_ssrc_demux_init (GstRtpSsrcDemux * demux){    GstElementClass *klass = GST_ELEMENT_GET_CLASS (demux);    demux->rtp_sink =        gst_pad_new_from_template (gst_element_class_get_pad_template (klass,                                   "sink"), "sink");    gst_pad_set_chain_function (demux->rtp_sink, gst_rtp_ssrc_demux_chain);    gst_pad_set_event_function (demux->rtp_sink, gst_rtp_ssrc_demux_sink_event);    gst_pad_set_iterate_internal_links_function (demux->rtp_sink,            gst_rtp_ssrc_demux_iterate_internal_links_sink);    gst_element_add_pad (GST_ELEMENT_CAST (demux), demux->rtp_sink);    demux->rtcp_sink =        gst_pad_new_from_template (gst_element_class_get_pad_template (klass,                                   "rtcp_sink"), "rtcp_sink");    gst_pad_set_chain_function (demux->rtcp_sink, gst_rtp_ssrc_demux_rtcp_chain);    gst_pad_set_event_function (demux->rtcp_sink, gst_rtp_ssrc_demux_sink_event);    gst_pad_set_iterate_internal_links_function (demux->rtcp_sink,            gst_rtp_ssrc_demux_iterate_internal_links_sink);    gst_element_add_pad (GST_ELEMENT_CAST (demux), demux->rtcp_sink);    g_rec_mutex_init (&demux->padlock);}

/* initialize the new element * instantiate pads and add them to element * set functions * initialize structure */static voidgst_wildmidi_init (GstWildmidi * filter, GstWildmidiClass * g_class){  GstElementClass *klass = GST_ELEMENT_GET_CLASS (filter);  filter->sinkpad =      gst_pad_new_from_template (gst_element_class_get_pad_template (klass,          "sink"), "sink");  gst_pad_set_activatepull_function (filter->sinkpad,      gst_wildmidi_activatepull);  gst_pad_set_activate_function (filter->sinkpad, gst_wildmidi_activate);  gst_pad_set_event_function (filter->sinkpad, gst_wildmidi_sink_event);  gst_pad_set_chain_function (filter->sinkpad, gst_wildmidi_chain);  gst_element_add_pad (GST_ELEMENT (filter), filter->sinkpad);  filter->srcpad =      gst_pad_new_from_template (gst_element_class_get_pad_template (klass,          "src"), "src");  gst_pad_set_query_function (filter->srcpad, gst_wildmidi_src_query);  gst_pad_set_event_function (filter->srcpad, gst_wildmidi_src_event);  gst_pad_use_fixed_caps (filter->srcpad);  gst_element_add_pad (GST_ELEMENT (filter), filter->srcpad);  gst_segment_init (filter->o_segment, GST_FORMAT_DEFAULT);  filter->adapter = gst_adapter_new ();  filter->bytes_per_frame = WILDMIDI_BPS;}

static voidgst_rtp_ssrc_demux_init (GstRtpSsrcDemux * demux,    GstRtpSsrcDemuxClass * g_class){  GstElementClass *klass = GST_ELEMENT_GET_CLASS (demux);  demux->rtp_sink =      gst_pad_new_from_template (gst_element_class_get_pad_template (klass,          "sink"), "sink");  gst_pad_set_chain_function (demux->rtp_sink, gst_rtp_ssrc_demux_chain);  gst_pad_set_event_function (demux->rtp_sink, gst_rtp_ssrc_demux_sink_event);  gst_element_add_pad (GST_ELEMENT_CAST (demux), demux->rtp_sink);  demux->rtcp_sink =      gst_pad_new_from_template (gst_element_class_get_pad_template (klass,          "rtcp_sink"), "rtcp_sink");  gst_pad_set_chain_function (demux->rtcp_sink, gst_rtp_ssrc_demux_rtcp_chain);  gst_pad_set_event_function (demux->rtcp_sink,      gst_rtp_ssrc_demux_rtcp_sink_event);  gst_element_add_pad (GST_ELEMENT_CAST (demux), demux->rtcp_sink);  demux->padlock = g_mutex_new ();  gst_segment_init (&demux->segment, GST_FORMAT_UNDEFINED);}

static voidmfw_gst_vpuenc_init(GstVPU_Enc * vpu_enc, GstVPU_EncClass * gclass){	GST_DEBUG("mfw_gst_vpuenc_init");	GstElementClass *klass = GST_ELEMENT_GET_CLASS(vpu_enc);	/* create the sink and src pads */	vpu_enc->sinkpad =	    gst_pad_new_from_template(gst_element_class_get_pad_template				      (klass, "sink"), "sink");	vpu_enc->srcpad =	    gst_pad_new_from_template(gst_element_class_get_pad_template				      (klass, "src"), "src");	gst_element_add_pad(GST_ELEMENT(vpu_enc), vpu_enc->sinkpad);	gst_element_add_pad(GST_ELEMENT(vpu_enc), vpu_enc->srcpad);	vpu_enc->parent_class = g_type_class_peek_parent(gclass);	gst_pad_set_chain_function(vpu_enc->sinkpad, mfw_gst_vpuenc_chain);	gst_pad_set_event_function(vpu_enc->sinkpad,				   GST_DEBUG_FUNCPTR				   (mfw_gst_vpuenc_sink_event));	gst_pad_set_setcaps_function(vpu_enc->sinkpad, mfw_gst_vpuenc_setcaps);	vpu_enc->codec = STD_AVC;	vpu_enc->device = g_strdup(VPU_DEVICE);	vpu_enc->framerate = DEFAULT_FRAME_RATE;	vpu_enc->bitrate = 0;	vpu_enc->gopsize = 0;	vpu_enc->codecTypeProvided = FALSE;	vpu_enc->memory = V4L2_MEMORY_USERPTR;	vpu_enc->mjpeg_quality = 50;}

static GstCaps *gst_alsasink_getcaps (GstBaseSink * bsink){    GstElementClass *element_class;    GstPadTemplate *pad_template;    GstAlsaSink *sink = GST_ALSA_SINK (bsink);    GstCaps *caps;    if (sink->handle == NULL) {        GST_DEBUG_OBJECT (sink, "device not open, using template caps");        return NULL;                /* base class will get template caps for us */    }    if (sink->cached_caps) {        GST_LOG_OBJECT (sink, "Returning cached caps");        return gst_caps_ref (sink->cached_caps);    }    element_class = GST_ELEMENT_GET_CLASS (sink);    pad_template = gst_element_class_get_pad_template (element_class, "sink");    g_return_val_if_fail (pad_template != NULL, NULL);    caps = gst_alsa_probe_supported_formats (GST_OBJECT (sink), sink->device,            sink->handle, gst_pad_template_get_caps (pad_template));    if (caps) {        sink->cached_caps = gst_caps_ref (caps);    }    GST_INFO_OBJECT (sink, "returning caps %" GST_PTR_FORMAT, caps);    return caps;}

static GstPad *gst_rdt_manager_request_new_pad (GstElement * element,    GstPadTemplate * templ, const gchar * name, const GstCaps * caps){  GstRDTManager *rdtmanager;  GstElementClass *klass;  GstPad *result;  g_return_val_if_fail (templ != NULL, NULL);  g_return_val_if_fail (GST_IS_RDT_MANAGER (element), NULL);  rdtmanager = GST_RDT_MANAGER (element);  klass = GST_ELEMENT_GET_CLASS (element);  /* figure out the template */  if (templ == gst_element_class_get_pad_template (klass, "recv_rtp_sink_%u")) {    result = create_recv_rtp (rdtmanager, templ, name);  } else if (templ == gst_element_class_get_pad_template (klass,          "recv_rtcp_sink_%u")) {    result = create_recv_rtcp (rdtmanager, templ, name);  } else if (templ == gst_element_class_get_pad_template (klass, "rtcp_src_%u")) {    result = create_rtcp (rdtmanager, templ, name);  } else    goto wrong_template;  return result;  /* ERRORS */wrong_template:  {    g_warning ("rdtmanager: this is not our template");    return NULL;  }}

static voidgst_v4lmjpegsink_init (GstV4lMjpegSink * v4lmjpegsink){  GstElementClass *klass = GST_ELEMENT_GET_CLASS (v4lmjpegsink);  v4lmjpegsink->sinkpad =      gst_pad_new_from_template (gst_element_class_get_pad_template (klass,          "sink"), "sink");  gst_element_add_pad (GST_ELEMENT (v4lmjpegsink), v4lmjpegsink->sinkpad);  gst_pad_set_chain_function (v4lmjpegsink->sinkpad, gst_v4lmjpegsink_chain);  gst_pad_set_link_function (v4lmjpegsink->sinkpad,      gst_v4lmjpegsink_sinkconnect);  v4lmjpegsink->clock = NULL;  v4lmjpegsink->width = -1;  v4lmjpegsink->height = -1;  v4lmjpegsink->x_offset = -1;  v4lmjpegsink->y_offset = -1;  v4lmjpegsink->numbufs = 64;  v4lmjpegsink->bufsize = 256;  GST_OBJECT_FLAG_SET (v4lmjpegsink, GST_ELEMENT_THREAD_SUGGESTED);}

static voidgst_tta_parse_init (GstTtaParse * ttaparse){  GstElementClass *klass = GST_ELEMENT_GET_CLASS (ttaparse);  ttaparse->sinkpad =      gst_pad_new_from_template (gst_element_class_get_pad_template (klass,          "sink"), "sink");  ttaparse->srcpad =      gst_pad_new_from_template (gst_element_class_get_pad_template (klass,          "src"), "src");  gst_pad_use_fixed_caps (ttaparse->srcpad);  gst_pad_set_query_type_function (ttaparse->srcpad,      gst_tta_parse_get_query_types);  gst_pad_set_query_function (ttaparse->srcpad, gst_tta_parse_query);  gst_pad_set_event_function (ttaparse->srcpad, gst_tta_parse_src_event);  gst_element_add_pad (GST_ELEMENT (ttaparse), ttaparse->sinkpad);  gst_element_add_pad (GST_ELEMENT (ttaparse), ttaparse->srcpad);  gst_pad_set_activate_function (ttaparse->sinkpad, gst_tta_parse_activate);  gst_pad_set_activatepull_function (ttaparse->sinkpad,      gst_tta_parse_activate_pull);  gst_tta_parse_reset (ttaparse);}

static voidgst_fake_h264_decoder_init (GstFakeH264Decoder * self){  GstPad *pad;  pad =      gst_pad_new_from_template (gst_element_class_get_pad_template      (GST_ELEMENT_GET_CLASS (self), "sink"), "sink");  gst_pad_set_event_function (pad, gst_fake_h264_decoder_sink_event);  gst_pad_set_chain_function (pad, gst_fake_h264_decoder_sink_chain);  gst_element_add_pad (GST_ELEMENT (self), pad);  pad =      gst_pad_new_from_template (gst_element_class_get_pad_template      (GST_ELEMENT_GET_CLASS (self), "src"), "src");  gst_element_add_pad (GST_ELEMENT (self), pad);}

static GstPad *gst_stream_combiner_request_new_pad (GstElement * element,    GstPadTemplate * templ, const gchar * name, const GstCaps * caps){  GstStreamCombiner *stream_combiner = (GstStreamCombiner *) element;  GstStreamCombinerPad *combiner_pad;  GstPad *sinkpad;  GstElementClass *klass = GST_ELEMENT_GET_CLASS (element);  GstPadTemplate *template =

static voidgst_dshowaudiodec_init (GstDshowAudioDec * adec,    GstDshowAudioDecClass * adec_class){  GstElementClass *element_class = GST_ELEMENT_GET_CLASS (adec);  /* setup pads */  adec->sinkpad =      gst_pad_new_from_template (gst_element_class_get_pad_template      (element_class, "sink"), "sink");  gst_pad_set_setcaps_function (adec->sinkpad, gst_dshowaudiodec_sink_setcaps);  gst_pad_set_event_function (adec->sinkpad, gst_dshowaudiodec_sink_event);  gst_pad_set_chain_function (adec->sinkpad, gst_dshowaudiodec_chain);  gst_element_add_pad (GST_ELEMENT (adec), adec->sinkpad);  adec->srcpad =      gst_pad_new_from_template (gst_element_class_get_pad_template      (element_class, "src"), "src");  gst_element_add_pad (GST_ELEMENT (adec), adec->srcpad);  adec->fakesrc = NULL;  adec->fakesink = NULL;  adec->decfilter = 0;  adec->filtergraph = 0;  adec->mediafilter = 0;  adec->timestamp = GST_CLOCK_TIME_NONE;  adec->segment = gst_segment_new ();  adec->setup = FALSE;  adec->depth = 0;  adec->bitrate = 0;  adec->block_align = 0;  adec->channels = 0;  adec->rate = 0;  adec->layer = 0;  adec->codec_data = NULL;  adec->last_ret = GST_FLOW_OK;  adec->com_init_lock = g_mutex_new();  adec->com_deinit_lock = g_mutex_new();  adec->com_initialized = g_cond_new();  adec->com_uninitialize = g_cond_new();  adec->com_uninitialized = g_cond_new();  g_mutex_lock (adec->com_init_lock);  /* create the COM initialization thread */  g_thread_create ((GThreadFunc)gst_dshowaudiodec_com_thread,      adec, FALSE, NULL);  /* wait until the COM thread signals that COM has been initialized */  g_cond_wait (adec->com_initialized, adec->com_init_lock);  g_mutex_unlock (adec->com_init_lock);}

static voidgst_fake_h264_parser_init (GstFakeH264Parser * self,    GstFakeH264ParserClass * klass){  GstPad *pad;  pad =      gst_pad_new_from_template (gst_element_class_get_pad_template      (GST_ELEMENT_GET_CLASS (self), "sink"), "sink");  gst_pad_set_setcaps_function (pad, gst_fake_h264_parser_sink_setcaps);  gst_pad_set_chain_function (pad, gst_fake_h264_parser_sink_chain);  gst_element_add_pad (GST_ELEMENT (self), pad);  pad =      gst_pad_new_from_template (gst_element_class_get_pad_template      (GST_ELEMENT_GET_CLASS (self), "src"), "src");  gst_element_add_pad (GST_ELEMENT (self), pad);}

static gbooleanelement_is_valid_filter (GstElement * element, gboolean * isdynamic){  gboolean havesink = FALSE;  gboolean havesrc = FALSE;  gboolean done = FALSE;  GstIterator *pads;  GValue item = { 0, };  if (isdynamic)    *isdynamic = FALSE;  pads = gst_element_iterate_pads (element);  while (!done) {    switch (gst_iterator_next (pads, &item)) {      case GST_ITERATOR_OK:      {        GstPad *pad = g_value_get_object (&item);        if (gst_pad_get_direction (pad) == GST_PAD_SRC)          havesrc = TRUE;        else if (gst_pad_get_direction (pad) == GST_PAD_SINK)          havesink = TRUE;        g_value_reset (&item);        break;      }      case GST_ITERATOR_RESYNC:        gst_iterator_resync (pads);        havesrc = FALSE;        havesink = FALSE;        break;      default:        /* ERROR and DONE */        done = TRUE;        break;    }  }  g_value_unset (&item);  gst_iterator_free (pads);  /* just look at the element's class, not the factory, since there might   * not be a factory (in case of python elements) or the factory is the   * wrong one (in case of a GstBin sub-class) and doesn't have complete   * information. */  {    GList *tmp =        gst_element_class_get_pad_template_list (GST_ELEMENT_GET_CLASS        (element));    while (tmp) {      GstPadTemplate *template = (GstPadTemplate *) tmp->data;      if (template->direction == GST_PAD_SRC)

static GstCaps *gst_alsasink_getcaps (GstBaseSink * bsink, GstCaps * filter){  GstElementClass *element_class;  GstPadTemplate *pad_template;  GstAlsaSink *sink = GST_ALSA_SINK (bsink);  GstCaps *caps, *templ_caps;  if (sink->handle == NULL) {    GST_DEBUG_OBJECT (sink, "device not open, using template caps");    return NULL;                /* base class will get template caps for us */  }  if (sink->cached_caps) {    if (filter) {      caps = gst_caps_intersect_full (filter, sink->cached_caps,          GST_CAPS_INTERSECT_FIRST);      GST_LOG_OBJECT (sink, "Returning cached caps %" GST_PTR_FORMAT " with "          "filter %" GST_PTR_FORMAT " applied: %" GST_PTR_FORMAT,          sink->cached_caps, filter, caps);      return caps;    } else {      GST_LOG_OBJECT (sink, "Returning cached caps %" GST_PTR_FORMAT,          sink->cached_caps);      return gst_caps_ref (sink->cached_caps);    }  }  element_class = GST_ELEMENT_GET_CLASS (sink);  pad_template = gst_element_class_get_pad_template (element_class, "sink");  g_return_val_if_fail (pad_template != NULL, NULL);  templ_caps = gst_pad_template_get_caps (pad_template);  caps = gst_alsa_probe_supported_formats (GST_OBJECT (sink), sink->device,      sink->handle, templ_caps);  gst_caps_unref (templ_caps);  if (caps) {    sink->cached_caps = gst_caps_ref (caps);  }  GST_INFO_OBJECT (sink, "returning caps %" GST_PTR_FORMAT, caps);  if (filter) {    GstCaps *intersection;    intersection =        gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);    gst_caps_unref (caps);    return intersection;  } else {    return caps;  }}

static gbooleanplay_sink_multiple_seeks_send_event (GstElement * element, GstEvent * event){  GstElementClass *klass = GST_ELEMENT_GET_CLASS (element);  GST_DEBUG ("%s", GST_EVENT_TYPE_NAME (event));  return      GST_ELEMENT_CLASS (g_type_class_peek_parent (klass))->send_event (element,      event);}

static gbooleangst_vaapiencode_set_format (GstVideoEncoder * venc, GstVideoCodecState * state){  GstVaapiEncode *const encode = GST_VAAPIENCODE_CAST (venc);  gboolean ret;  g_return_val_if_fail (state->caps != NULL, FALSE);  if (!set_codec_state (encode, state))    return FALSE;  if (!gst_vaapi_plugin_base_set_caps (GST_VAAPI_PLUGIN_BASE (encode),          state->caps, NULL))    return FALSE;  if (encode->input_state)    gst_video_codec_state_unref (encode->input_state);  encode->input_state = gst_video_codec_state_ref (state);  encode->input_state_changed = TRUE;  ret = gst_pad_start_task (GST_VAAPI_PLUGIN_BASE_SRC_PAD (encode),      (GstTaskFunction) gst_vaapiencode_buffer_loop, encode, NULL);  if (!ret)    return FALSE;  /* Store some tags */  {    GstTagList *tags = gst_tag_list_new_empty ();    const gchar *encoder, *codec;    guint bitrate = 0;    g_object_get (encode, "bitrate", &bitrate, NULL);    gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_NOMINAL_BITRATE,        bitrate, NULL);    if ((encoder =            gst_element_class_get_metadata (GST_ELEMENT_GET_CLASS (encode),                GST_ELEMENT_METADATA_LONGNAME)))      gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_ENCODER, encoder,          NULL);    if ((codec =            gst_vaapi_codec_get_name (gst_vaapi_profile_get_codec                (gst_vaapi_profile_from_caps (state->caps)))))      gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_CODEC, codec,          NULL);    gst_video_encoder_merge_tags (venc, tags, GST_TAG_MERGE_REPLACE);    gst_tag_list_unref (tags);  }  return TRUE;}

static voidgst_xine_input_sub_init (GTypeInstance * instance, gpointer g_class){  GstElementClass *klass = GST_ELEMENT_GET_CLASS (instance);  GstXineInput *xine = GST_XINE_INPUT (instance);  xine->srcpad =      gst_pad_new_from_template (gst_element_class_get_pad_template (klass,          "src"), "src");  gst_pad_set_get_function (xine->srcpad, gst_xine_input_get);  gst_element_add_pad (GST_ELEMENT (xine), xine->srcpad);}

static voidgst_dshowvideodec_init (GstDshowVideoDec * vdec,    GstDshowVideoDecClass * vdec_class){  GstElementClass *element_class = GST_ELEMENT_GET_CLASS (vdec);  /* setup pads */  vdec->sinkpad =      gst_pad_new_from_template (gst_element_class_get_pad_template      (element_class, "sink"), "sink");  gst_pad_set_setcaps_function (vdec->sinkpad, gst_dshowvideodec_sink_setcaps);  gst_pad_set_event_function (vdec->sinkpad, gst_dshowvideodec_sink_event);  gst_pad_set_chain_function (vdec->sinkpad, gst_dshowvideodec_chain);  gst_element_add_pad (GST_ELEMENT (vdec), vdec->sinkpad);  vdec->srcpad =      gst_pad_new_from_template (gst_element_class_get_pad_template      (element_class, "src"), "src");/* needed to implement caps negociation on our src pad *//*  gst_pad_set_getcaps_function (vdec->srcpad, gst_dshowvideodec_src_getcaps);  gst_pad_set_setcaps_function (vdec->srcpad, gst_dshowvideodec_src_setcaps);*/  gst_element_add_pad (GST_ELEMENT (vdec), vdec->srcpad);  vdec->fakesrc = NULL;  vdec->fakesink = NULL;  vdec->decfilter = NULL;  vdec->last_ret = GST_FLOW_OK;  vdec->filtergraph = NULL;  vdec->mediafilter = NULL;  vdec->srccaps = NULL;  vdec->segment = gst_segment_new ();  vdec->setup = FALSE;  vdec->com_init_lock = g_mutex_new();  vdec->com_deinit_lock = g_mutex_new();  vdec->com_initialized = g_cond_new();  vdec->com_uninitialize = g_cond_new();  vdec->com_uninitialized = g_cond_new();  g_mutex_lock (vdec->com_init_lock);  /* create the COM initialization thread */  g_thread_create ((GThreadFunc)gst_dshowvideodec_com_thread,      vdec, FALSE, NULL);  /* wait until the COM thread signals that COM has been initialized */  g_cond_wait (vdec->com_initialized, vdec->com_init_lock);  g_mutex_unlock (vdec->com_init_lock);}

static GstCaps *gst_alsasrc_getcaps (GstBaseSrc * bsrc, GstCaps * filter){  GstElementClass *element_class;  GstPadTemplate *pad_template;  GstAlsaSrc *src;  GstCaps *caps, *templ_caps;  src = GST_ALSA_SRC (bsrc);  if (src->handle == NULL) {    GST_DEBUG_OBJECT (src, "device not open, using template caps");    return GST_BASE_SRC_CLASS (parent_class)->get_caps (bsrc, filter);  }  if (src->cached_caps) {    GST_LOG_OBJECT (src, "Returning cached caps");    if (filter)      return gst_caps_intersect_full (filter, src->cached_caps,          GST_CAPS_INTERSECT_FIRST);    else      return gst_caps_ref (src->cached_caps);  }  element_class = GST_ELEMENT_GET_CLASS (src);  pad_template = gst_element_class_get_pad_template (element_class, "src");  g_return_val_if_fail (pad_template != NULL, NULL);  templ_caps = gst_pad_template_get_caps (pad_template);  GST_INFO_OBJECT (src, "template caps %" GST_PTR_FORMAT, templ_caps);  caps = gst_alsa_probe_supported_formats (GST_OBJECT (src),      src->device, src->handle, templ_caps);  gst_caps_unref (templ_caps);  if (caps) {    src->cached_caps = gst_caps_ref (caps);  }  GST_INFO_OBJECT (src, "returning caps %" GST_PTR_FORMAT, caps);  if (filter) {    GstCaps *intersection;    intersection =        gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);    gst_caps_unref (caps);    return intersection;  } else {    return caps;  }}

static voidgst_insert_bin_init (GstInsertBin * self){  GstProxyPad *internal;  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GST_TYPE_INSERT_BIN,      GstInsertBinPrivate);  g_queue_init (&self->priv->change_queue);  self->priv->sinkpad = gst_ghost_pad_new_no_target_from_template ("sink",      gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS (self),          "sink"));  gst_element_add_pad (GST_ELEMENT (self), self->priv->sinkpad);  internal = gst_proxy_pad_get_internal (GST_PROXY_PAD (self->priv->sinkpad));  self->priv->srcpad = gst_ghost_pad_new_from_template ("src",      GST_PAD (internal),      gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS (self), "src"));  gst_object_unref (internal);  gst_element_add_pad (GST_ELEMENT (self), self->priv->srcpad);}

static voidgst_faceblur_init (GstFaceblur * faceblur, GstFaceblurClass * g_class){  GstElementClass *klass = GST_ELEMENT_GET_CLASS (faceblur);  GST_DEBUG_OBJECT (faceblur, "gst_faceblur_init");  faceblur->storage = cvCreateMemStorage(0);  faceblur->cascade = (CvHaarClassifierCascade*)cvLoad(OPENCV_FACE_HAARCASCADE, 0, 0, 0 );  /* properties */  faceblur->face_width = DEFAULT_PROP_FACE_WIDTH;  faceblur->face_height = DEFAULT_PROP_FACE_HEIGHT;}

static gbooleanhas_sometimes_template (GstElement * element){  GstElementClass *klass = GST_ELEMENT_GET_CLASS (element);  GList *l;  for (l = klass->padtemplates; l != NULL; l = l->next) {    if (GST_PAD_TEMPLATE (l->data)->presence == GST_PAD_SOMETIMES)      return TRUE;  }  return FALSE;}

static GstElement *find_xvimagesink() {	GstIterator *iterator = gst_bin_iterate_recurse(GST_BIN(pipeline));	GstElement *xvimagesink = NULL;	gboolean done = FALSE;#if GST_CHECK_VERSION(1, 0, 0)	GValue item = G_VALUE_INIT;#else	gpointer item;#endif	while (!done) {		switch (gst_iterator_next(iterator, &item)) {		case GST_ITERATOR_OK : {#if GST_CHECK_VERSION(1, 0, 0)			GstElement *element = g_value_get_object(&item);#else			GstElement *element = GST_ELEMENT(item);#endif			GstElementClass *klass = GST_ELEMENT_GET_CLASS(element);#if GST_CHECK_VERSION(1, 0, 0)			char *s = gst_element_class_get_metadata(klass, "description");#else			char *s = klass->details.description;#endif			/* This is not the best way to check. */			if (strstr(s, "A Xv based videosink") != NULL ||			strstr(GST_OBJECT_NAME(element), "xvimage") != NULL) {				xvimagesink = element;				done = TRUE;			}#if GST_CHECK_VERSION(1, 0, 0)			g_value_reset(&item);#endif        		break;		}		case GST_ITERATOR_RESYNC :			gst_iterator_resync(iterator);			xvimagesink = NULL;			done = FALSE;			break;		case GST_ITERATOR_DONE:		case GST_ITERATOR_ERROR:		default:			done = TRUE;		}	}#if GST_CHECK_VERSION(1, 0, 0)	g_value_unset(&item);#endif	gst_iterator_free(iterator);	return xvimagesink;}

static voidgst_xine_audio_sink_sub_init (GTypeInstance * instance, gpointer g_class){  GstElementClass *klass = GST_ELEMENT_GET_CLASS (instance);  GstXineAudioSink *xine = GST_XINE_AUDIO_SINK (instance);  xine->sinkpad =      gst_pad_new_from_template (gst_element_class_get_pad_template (klass,          "sink"), "sink");  gst_pad_set_chain_function (xine->sinkpad, gst_xine_audio_sink_chain);  gst_pad_set_getcaps_function (xine->sinkpad, _xine_audio_sink_get_caps);  gst_pad_set_link_function (xine->sinkpad, _xine_audio_sink_link);  gst_element_add_pad (GST_ELEMENT (xine), xine->sinkpad);}

static GValueArray *gst_alsa_device_property_probe_get_values (GstPropertyProbe * probe,    guint prop_id, const GParamSpec * pspec){  GstElementClass *klass;  const GList *templates;  snd_pcm_stream_t mode = -1;  GValueArray *array;  GValue value = { 0, };  GList *l, *list;  if (!g_str_equal (pspec->name, "device")) {    G_OBJECT_WARN_INVALID_PROPERTY_ID (probe, prop_id, pspec);    return NULL;  }  klass = GST_ELEMENT_GET_CLASS (GST_ELEMENT (probe));  /* I'm pretty sure ALSA has a good way to do this. However, their cool   * auto-generated documentation is pretty much useless if you try to   * do function-wise look-ups. */  /* we assume one pad template at max [zero=mixer] */  templates = gst_element_class_get_pad_template_list (klass);  if (templates) {    if (GST_PAD_TEMPLATE_DIRECTION (templates->data) == GST_PAD_SRC)      mode = SND_PCM_STREAM_CAPTURE;    else      mode = SND_PCM_STREAM_PLAYBACK;  }  list = gst_alsa_get_device_list (mode);  if (list == NULL) {    GST_LOG_OBJECT (probe, "No devices found");    return NULL;  }  array = g_value_array_new (g_list_length (list));  g_value_init (&value, G_TYPE_STRING);  for (l = list; l != NULL; l = l->next) {    GST_LOG_OBJECT (probe, "Found device: %s", (gchar *) l->data);    g_value_take_string (&value, (gchar *) l->data);    l->data = NULL;    g_value_array_append (array, &value);  }  g_value_unset (&value);  g_list_free (list);  return array;}