static void gst_gdk_pixbuf_dec_init (GstGdkPixbufDec * filter) { filter->sinkpad = gst_pad_new_from_static_template (&gst_gdk_pixbuf_dec_sink_template, "sink"); gst_pad_set_query_function (filter->sinkpad, GST_DEBUG_FUNCPTR (gst_gdk_pixbuf_dec_sink_query)); gst_pad_set_chain_function (filter->sinkpad, GST_DEBUG_FUNCPTR (gst_gdk_pixbuf_dec_chain)); gst_pad_set_event_function (filter->sinkpad, GST_DEBUG_FUNCPTR (gst_gdk_pixbuf_dec_sink_event)); gst_element_add_pad (GST_ELEMENT (filter), filter->sinkpad); filter->srcpad = gst_pad_new_from_static_template (&gst_gdk_pixbuf_dec_src_template, "src"); gst_pad_use_fixed_caps (filter->srcpad); gst_element_add_pad (GST_ELEMENT (filter), filter->srcpad); filter->last_timestamp = GST_CLOCK_TIME_NONE; filter->pixbuf_loader = NULL; filter->packetized = FALSE; }
static void gst_vorbis_enc_init (GstVorbisEnc * vorbisenc, GstVorbisEncClass * klass) { vorbisenc->sinkpad = gst_pad_new_from_template (gst_vorbis_enc_sink_template, "sink"); gst_pad_set_event_function (vorbisenc->sinkpad, GST_DEBUG_FUNCPTR (gst_vorbis_enc_sink_event)); gst_pad_set_chain_function (vorbisenc->sinkpad, GST_DEBUG_FUNCPTR (gst_vorbis_enc_chain)); gst_pad_set_setcaps_function (vorbisenc->sinkpad, GST_DEBUG_FUNCPTR (gst_vorbis_enc_sink_setcaps)); gst_pad_set_getcaps_function (vorbisenc->sinkpad, GST_DEBUG_FUNCPTR (gst_vorbis_enc_sink_getcaps)); gst_pad_set_query_function (vorbisenc->sinkpad, GST_DEBUG_FUNCPTR (gst_vorbis_enc_sink_query)); gst_element_add_pad (GST_ELEMENT (vorbisenc), vorbisenc->sinkpad); vorbisenc->srcpad = gst_pad_new_from_template (gst_vorbis_enc_src_template, "src"); gst_pad_set_query_function (vorbisenc->srcpad, GST_DEBUG_FUNCPTR (gst_vorbis_enc_src_query)); gst_pad_set_query_type_function (vorbisenc->srcpad, GST_DEBUG_FUNCPTR (gst_vorbis_enc_get_query_types)); gst_element_add_pad (GST_ELEMENT (vorbisenc), vorbisenc->srcpad); vorbisenc->channels = -1; vorbisenc->frequency = -1; vorbisenc->managed = FALSE; vorbisenc->max_bitrate = MAX_BITRATE_DEFAULT; vorbisenc->bitrate = BITRATE_DEFAULT; vorbisenc->min_bitrate = MIN_BITRATE_DEFAULT; vorbisenc->quality = QUALITY_DEFAULT; vorbisenc->quality_set = FALSE; vorbisenc->last_message = NULL; }
static void gst_rrparser_init (GstRRParser * rrparser, GstRRParserClass * gclass) { rrparser->set_codec_data = FALSE; rrparser->SPS_PPS_end = -1; rrparser->PPS_start = -1; rrparser->single_Nalu = FALSE; rrparser->sink_pad = gst_pad_new_from_static_template (&sink_factory, "sink"); gst_pad_set_setcaps_function (rrparser->sink_pad, GST_DEBUG_FUNCPTR(gst_rrparser_set_caps)); gst_pad_set_chain_function (rrparser->sink_pad, GST_DEBUG_FUNCPTR(gst_rrparser_chain)); gst_pad_set_event_function( rrparser->sink_pad, GST_DEBUG_FUNCPTR(gst_rrparser_sink_event)); rrparser->src_pad = gst_pad_new_from_static_template (&src_factory, "src"); gst_element_add_pad (GST_ELEMENT (rrparser), rrparser->sink_pad); gst_element_add_pad (GST_ELEMENT (rrparser), rrparser->src_pad); }
/* initialize the new element * instantiate pads and add them to element * set pad calback functions * initialize instance structure */ static void gst_dwt_filter_init (GstDwtFilter * filter) { filter->sinkpad = gst_pad_new_from_static_template (&sink_factory, "sink"); gst_pad_set_event_function (filter->sinkpad, GST_DEBUG_FUNCPTR(gst_dwt_filter_sink_event)); gst_pad_set_chain_function (filter->sinkpad, GST_DEBUG_FUNCPTR(gst_dwt_filter_chain)); GST_PAD_SET_PROXY_CAPS (filter->sinkpad); gst_element_add_pad (GST_ELEMENT (filter), filter->sinkpad); filter->srcpad = gst_pad_new_from_static_template (&src_factory, "src"); GST_PAD_SET_PROXY_CAPS (filter->srcpad); gst_element_add_pad (GST_ELEMENT (filter), filter->srcpad); gst_pad_set_event_function (filter->srcpad, GST_DEBUG_FUNCPTR(gst_dwt_filter_src_event)); filter->phof = FALSE; filter->silent = FALSE; filter->inverse = TRUE; filter->cutoff = 1; filter->band = GST_DWTFILTER_LOWPASS; filter->wavelet_name = "h2"; filter->phof_window.x = 0; filter->phof_window.y = 0; filter->phof_window.w = 0; filter->phof_window.h = 0; filter->w = gsl_wavelet_alloc (gsl_wavelet_haar, 2); gst_pad_set_query_function (filter->srcpad, gst_dwt_filter_query); }
static void gst_wavpack_parse_init (GstWavpackParse * parse, GstWavpackParseClass * gclass) { GstElementClass *klass = GST_ELEMENT_GET_CLASS (parse); GstPadTemplate *tmpl; tmpl = gst_element_class_get_pad_template (klass, "sink"); parse->sinkpad = gst_pad_new_from_template (tmpl, "sink"); gst_pad_set_activate_function (parse->sinkpad, GST_DEBUG_FUNCPTR (gst_wavpack_parse_sink_activate)); gst_pad_set_activatepull_function (parse->sinkpad, GST_DEBUG_FUNCPTR (gst_wavpack_parse_sink_activate_pull)); gst_pad_set_event_function (parse->sinkpad, GST_DEBUG_FUNCPTR (gst_wavpack_parse_sink_event)); gst_pad_set_chain_function (parse->sinkpad, GST_DEBUG_FUNCPTR (gst_wavpack_parse_chain)); gst_element_add_pad (GST_ELEMENT (parse), parse->sinkpad); parse->srcpad = NULL; gst_wavpack_parse_reset (parse); }
static void gst_jasper_dec_init (GstJasperDec * dec, GstJasperDecClass * klass) { dec->sinkpad = gst_pad_new_from_static_template (&gst_jasper_dec_sink_template, "sink"); gst_pad_set_setcaps_function (dec->sinkpad, GST_DEBUG_FUNCPTR (gst_jasper_dec_sink_setcaps)); gst_pad_set_chain_function (dec->sinkpad, GST_DEBUG_FUNCPTR (gst_jasper_dec_chain)); gst_pad_set_event_function (dec->sinkpad, GST_DEBUG_FUNCPTR (gst_jasper_dec_sink_event)); gst_element_add_pad (GST_ELEMENT (dec), dec->sinkpad); dec->srcpad = gst_pad_new_from_static_template (&gst_jasper_dec_src_template, "src"); gst_pad_use_fixed_caps (dec->srcpad); gst_pad_set_event_function (dec->srcpad, GST_DEBUG_FUNCPTR (gst_jasper_dec_src_event)); gst_element_add_pad (GST_ELEMENT (dec), dec->srcpad); dec->codec_data = NULL; dec->buf = NULL; gst_jasper_dec_reset (dec); }
static void gst_interlace_init (GstInterlace * interlace) { GST_DEBUG ("gst_interlace_init"); interlace->sinkpad = gst_pad_new_from_static_template (&gst_interlace_sink_template, "sink"); gst_element_add_pad (GST_ELEMENT (interlace), interlace->sinkpad); gst_pad_set_chain_function (interlace->sinkpad, gst_interlace_chain); gst_pad_set_setcaps_function (interlace->sinkpad, gst_interlace_setcaps); gst_pad_set_getcaps_function (interlace->sinkpad, gst_interlace_getcaps); gst_pad_set_event_function (interlace->sinkpad, gst_interlace_sink_event); interlace->srcpad = gst_pad_new_from_static_template (&gst_interlace_src_template, "src"); gst_element_add_pad (GST_ELEMENT (interlace), interlace->srcpad); gst_pad_set_setcaps_function (interlace->srcpad, gst_interlace_setcaps); gst_pad_set_getcaps_function (interlace->srcpad, gst_interlace_getcaps); interlace->top_field_first = FALSE; interlace->allow_rff = FALSE; interlace->pattern = GST_INTERLACE_PATTERN_2_3; interlace->pattern_offset = 0; gst_interlace_reset (interlace); }
static void speed_init (GstSpeed * filter) { filter->sinkpad = gst_pad_new_from_static_template (&gst_speed_sink_template, "sink"); gst_pad_set_setcaps_function (filter->sinkpad, speed_setcaps); gst_pad_set_chain_function (filter->sinkpad, speed_chain); gst_element_add_pad (GST_ELEMENT (filter), filter->sinkpad); gst_pad_set_event_function (filter->sinkpad, speed_sink_event); filter->srcpad = gst_pad_new_from_static_template (&gst_speed_src_template, "src"); gst_pad_set_setcaps_function (filter->srcpad, speed_setcaps); gst_pad_set_query_type_function (filter->srcpad, speed_get_query_types); gst_pad_set_query_function (filter->srcpad, speed_src_query); gst_element_add_pad (GST_ELEMENT (filter), filter->srcpad); gst_pad_set_event_function (filter->srcpad, speed_src_event); filter->offset = 0; filter->timestamp = 0; filter->sample_size = 0; }
static void gst_mim_enc_init (GstMimEnc * mimenc) { mimenc->sinkpad = gst_pad_new_from_static_template (&sink_factory, "sink"); gst_pad_set_chain_function (mimenc->sinkpad, GST_DEBUG_FUNCPTR (gst_mim_enc_chain)); gst_pad_set_event_function (mimenc->sinkpad, GST_DEBUG_FUNCPTR (gst_mim_enc_event)); gst_element_add_pad (GST_ELEMENT (mimenc), mimenc->sinkpad); mimenc->srcpad = gst_pad_new_from_static_template (&src_factory, "src"); gst_pad_use_fixed_caps (mimenc->srcpad); gst_element_add_pad (GST_ELEMENT (mimenc), mimenc->srcpad); mimenc->enc = NULL; gst_segment_init (&mimenc->segment, GST_FORMAT_TIME); mimenc->res = MIMIC_RES_HIGH; mimenc->buffer_size = -1; mimenc->width = 0; mimenc->height = 0; mimenc->frames = 0; }
/* initialize the new element * instantiate pads and add them to element * set functions * initialize structure */ static void gst_midi_parse_init (GstMidiParse * filter) { filter->sinkpad = gst_pad_new_from_static_template (&sink_factory, "sink"); gst_pad_set_activatemode_function (filter->sinkpad, gst_midi_parse_activatemode); gst_pad_set_activate_function (filter->sinkpad, gst_midi_parse_activate); gst_pad_set_event_function (filter->sinkpad, gst_midi_parse_sink_event); gst_pad_set_chain_function (filter->sinkpad, gst_midi_parse_chain); gst_element_add_pad (GST_ELEMENT (filter), filter->sinkpad); filter->srcpad = gst_pad_new_from_static_template (&src_factory, "src"); gst_pad_set_query_function (filter->srcpad, gst_midi_parse_src_query); gst_pad_set_event_function (filter->srcpad, gst_midi_parse_src_event); gst_pad_use_fixed_caps (filter->srcpad); gst_element_add_pad (GST_ELEMENT (filter), filter->srcpad); gst_segment_init (&filter->segment, GST_FORMAT_TIME); filter->adapter = gst_adapter_new (); }
static void gst_theora_dec_init (GstTheoraDec * dec, GstTheoraDecClass * g_class) { dec->sinkpad = gst_pad_new_from_static_template (&theora_dec_sink_factory, "sink"); gst_pad_set_query_function (dec->sinkpad, theora_dec_sink_query); gst_pad_set_event_function (dec->sinkpad, theora_dec_sink_event); gst_pad_set_chain_function (dec->sinkpad, theora_dec_chain); gst_element_add_pad (GST_ELEMENT (dec), dec->sinkpad); dec->srcpad = gst_pad_new_from_static_template (&theora_dec_src_factory, "src"); gst_pad_set_event_function (dec->srcpad, theora_dec_src_event); gst_pad_set_query_type_function (dec->srcpad, theora_get_query_types); gst_pad_set_query_function (dec->srcpad, theora_dec_src_query); gst_pad_use_fixed_caps (dec->srcpad); gst_element_add_pad (GST_ELEMENT (dec), dec->srcpad); dec->crop = THEORA_DEF_CROP; dec->gather = NULL; dec->decode = NULL; dec->queued = NULL; }
static GstPad * fs_funnel_request_new_pad (GstElement * element, GstPadTemplate * templ, const gchar * name) { GstPad *sinkpad; FsFunnelPadPrivate *priv = g_slice_alloc0 (sizeof(FsFunnelPadPrivate)); GST_DEBUG_OBJECT (element, "requesting pad"); sinkpad = gst_pad_new_from_template (templ, name); gst_pad_set_chain_function (sinkpad, GST_DEBUG_FUNCPTR (fs_funnel_chain)); gst_pad_set_event_function (sinkpad, GST_DEBUG_FUNCPTR (fs_funnel_event)); gst_pad_set_getcaps_function (sinkpad, GST_DEBUG_FUNCPTR (fs_funnel_getcaps)); gst_segment_init (&priv->segment, GST_FORMAT_UNDEFINED); gst_pad_set_element_private (sinkpad, priv); gst_pad_set_active (sinkpad, TRUE); gst_element_add_pad (element, sinkpad); return sinkpad; }
static void gst_hls_demux_init (GstHLSDemux * demux) { /* sink pad */ demux->sinkpad = gst_pad_new_from_static_template (&sinktemplate, "sink"); gst_pad_set_chain_function (demux->sinkpad, GST_DEBUG_FUNCPTR (gst_hls_demux_chain)); gst_pad_set_event_function (demux->sinkpad, GST_DEBUG_FUNCPTR (gst_hls_demux_sink_event)); gst_element_add_pad (GST_ELEMENT (demux), demux->sinkpad); /* Downloader */ demux->downloader = gst_uri_downloader_new (); demux->do_typefind = TRUE; /* Properties */ demux->fragments_cache = DEFAULT_FRAGMENTS_CACHE; demux->bitrate_limit = DEFAULT_BITRATE_LIMIT; demux->connection_speed = DEFAULT_CONNECTION_SPEED; demux->queue = g_queue_new (); /* Updates task */ g_rec_mutex_init (&demux->updates_lock); demux->updates_task = gst_task_new ((GstTaskFunction) gst_hls_demux_updates_loop, demux, NULL); gst_task_set_lock (demux->updates_task, &demux->updates_lock); g_mutex_init (&demux->updates_timed_lock); /* Streaming task */ g_rec_mutex_init (&demux->stream_lock); demux->stream_task = gst_task_new ((GstTaskFunction) gst_hls_demux_stream_loop, demux, NULL); gst_task_set_lock (demux->stream_task, &demux->stream_lock); }
static void gst_dvdec_init (GstDVDec * dvdec, GstDVDecClass * g_class) { dvdec->sinkpad = gst_pad_new_from_static_template (&sink_temp, "sink"); gst_pad_set_setcaps_function (dvdec->sinkpad, GST_DEBUG_FUNCPTR (gst_dvdec_sink_setcaps)); gst_pad_set_chain_function (dvdec->sinkpad, gst_dvdec_chain); gst_pad_set_event_function (dvdec->sinkpad, gst_dvdec_sink_event); gst_element_add_pad (GST_ELEMENT (dvdec), dvdec->sinkpad); dvdec->srcpad = gst_pad_new_from_static_template (&src_temp, "src"); gst_pad_use_fixed_caps (dvdec->srcpad); gst_element_add_pad (GST_ELEMENT (dvdec), dvdec->srcpad); dvdec->framerate_numerator = 0; dvdec->framerate_denominator = 0; dvdec->wide = FALSE; dvdec->drop_factor = 1; dvdec->clamp_luma = FALSE; dvdec->clamp_chroma = FALSE; dvdec->quality = DV_DEFAULT_QUALITY; dvdec->segment = gst_segment_new (); }
static void gst_audio_rate_init (GstAudioRate * audiorate) { audiorate->sinkpad = gst_pad_new_from_static_template (&gst_audio_rate_sink_template, "sink"); gst_pad_set_event_function (audiorate->sinkpad, gst_audio_rate_sink_event); gst_pad_set_chain_function (audiorate->sinkpad, gst_audio_rate_chain); gst_pad_set_setcaps_function (audiorate->sinkpad, gst_audio_rate_setcaps); gst_pad_set_getcaps_function (audiorate->sinkpad, gst_pad_proxy_getcaps); gst_element_add_pad (GST_ELEMENT (audiorate), audiorate->sinkpad); audiorate->srcpad = gst_pad_new_from_static_template (&gst_audio_rate_src_template, "src"); gst_pad_set_event_function (audiorate->srcpad, gst_audio_rate_src_event); gst_pad_set_setcaps_function (audiorate->srcpad, gst_audio_rate_setcaps); gst_pad_set_getcaps_function (audiorate->srcpad, gst_pad_proxy_getcaps); gst_element_add_pad (GST_ELEMENT (audiorate), audiorate->srcpad); audiorate->in = 0; audiorate->out = 0; audiorate->drop = 0; audiorate->add = 0; audiorate->silent = DEFAULT_SILENT; }
static void gst_theora_enc_init (GstTheoraEnc * enc, GstTheoraEncClass * g_class) { enc->sinkpad = gst_pad_new_from_static_template (&theora_enc_sink_factory, "sink"); gst_pad_set_chain_function (enc->sinkpad, theora_enc_chain); gst_pad_set_event_function (enc->sinkpad, theora_enc_sink_event); gst_pad_set_getcaps_function (enc->sinkpad, theora_enc_sink_getcaps); gst_pad_set_setcaps_function (enc->sinkpad, theora_enc_sink_setcaps); gst_element_add_pad (GST_ELEMENT (enc), enc->sinkpad); enc->srcpad = gst_pad_new_from_static_template (&theora_enc_src_factory, "src"); gst_pad_set_event_function (enc->srcpad, theora_enc_src_event); gst_element_add_pad (GST_ELEMENT (enc), enc->srcpad); gst_segment_init (&enc->segment, GST_FORMAT_UNDEFINED); enc->video_bitrate = THEORA_DEF_BITRATE; enc->video_quality = THEORA_DEF_QUALITY; enc->keyframe_auto = THEORA_DEF_KEYFRAME_AUTO; enc->keyframe_freq = THEORA_DEF_KEYFRAME_FREQ; enc->keyframe_force = THEORA_DEF_KEYFRAME_FREQ_FORCE; enc->expected_ts = GST_CLOCK_TIME_NONE; /* enc->speed_level is set to the libtheora default by the constructor */ enc->vp3_compatible = THEORA_DEF_VP3_COMPATIBLE; enc->drop_frames = THEORA_DEF_DROP_FRAMES; enc->cap_overflow = THEORA_DEF_CAP_OVERFLOW; enc->cap_underflow = THEORA_DEF_CAP_UNDERFLOW; enc->rate_buffer = THEORA_DEF_RATE_BUFFER; enc->multipass_mode = THEORA_DEF_MULTIPASS_MODE; enc->multipass_cache_file = THEORA_DEF_MULTIPASS_CACHE_FILE; }
static void gst_dtls_dec_init (GstDtlsDec * self) { GstPad *sink; self->agent = get_agent_by_pem (NULL); self->connection_id = NULL; self->connection = NULL; self->peer_pem = NULL; self->decoder_key = NULL; self->srtp_cipher = DEFAULT_SRTP_CIPHER; self->srtp_auth = DEFAULT_SRTP_AUTH; g_mutex_init (&self->src_mutex); self->src = NULL; sink = gst_pad_new_from_static_template (&sink_template, "sink"); g_return_if_fail (sink); gst_pad_set_chain_function (sink, GST_DEBUG_FUNCPTR (sink_chain)); gst_pad_set_chain_list_function (sink, GST_DEBUG_FUNCPTR (sink_chain_list)); gst_element_add_pad (GST_ELEMENT (self), sink); }
static void gst_nuv_demux_init (GstNuvDemux * nuv, GstNuvDemuxClass * nuv_class) { nuv->sinkpad = gst_pad_new_from_static_template (&sink_template, "sink"); gst_pad_set_activate_function (nuv->sinkpad, gst_nuv_demux_sink_activate); gst_pad_set_activatepull_function (nuv->sinkpad, gst_nuv_demux_sink_activate_pull); gst_pad_set_chain_function (nuv->sinkpad, GST_DEBUG_FUNCPTR (gst_nuv_demux_chain)); gst_pad_set_event_function (nuv->sinkpad, gst_nuv_demux_handle_sink_event); gst_element_add_pad (GST_ELEMENT (nuv), nuv->sinkpad); nuv->adapter = NULL; nuv->mpeg_buffer = NULL; nuv->h = NULL; nuv->eh = NULL; nuv->fh = NULL; gst_nuv_demux_reset (nuv); }
/** * hls_progress_buffer_init() * * Initializer. Automatically declared in the GST_BOILERPLATE macro above. Should be * only called by GStreamer. */ static void hls_progress_buffer_init(HLSProgressBuffer *element, HLSProgressBufferClass *element_klass) { GstElementClass *klass = GST_ELEMENT_CLASS (element_klass); int i = 0; element->sinkpad = gst_pad_new_from_template (gst_element_class_get_pad_template (klass, "sink"), "sink"); gst_pad_set_chain_function(element->sinkpad, hls_progress_buffer_chain); gst_pad_set_event_function(element->sinkpad, hls_progress_buffer_sink_event); gst_element_add_pad (GST_ELEMENT (element), element->sinkpad); element->srcpad = gst_pad_new_from_template (gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS(element), "src"), "src"); gst_pad_set_activatepush_function(element->srcpad, hls_progress_buffer_activatepush_src); gst_pad_set_event_function(element->srcpad, hls_progress_buffer_src_event); gst_element_add_pad (GST_ELEMENT (element), element->srcpad); element->lock = g_mutex_new(); element->add_cond = g_cond_new(); element->del_cond = g_cond_new(); for (i = 0; i < NUM_OF_CACHED_SEGMENTS; i++) { element->cache[i] = create_cache(); element->cache_size[i] = 0; element->cache_write_ready[i] = TRUE; } element->cache_write_index = -1; element->cache_read_index = 0; element->send_new_segment = TRUE; element->is_flushing = FALSE; element->is_eos = FALSE; element->srcresult = GST_FLOW_OK; }
static void gst_vtenc_init (GstVTEnc * self) { GstVTEncClass *klass = (GstVTEncClass *) G_OBJECT_GET_CLASS (self); GstElementClass *element_klass = GST_ELEMENT_CLASS (klass); GstElement *element = GST_ELEMENT (self); self->details = GST_VTENC_CLASS_GET_CODEC_DETAILS (klass); self->sinkpad = gst_pad_new_from_template (gst_element_class_get_pad_template (element_klass, "sink"), "sink"); gst_element_add_pad (element, self->sinkpad); gst_pad_set_setcaps_function (self->sinkpad, gst_vtenc_sink_setcaps); gst_pad_set_chain_function (self->sinkpad, gst_vtenc_chain); self->srcpad = gst_pad_new_from_template (gst_element_class_get_pad_template (element_klass, "src"), "src"); gst_pad_set_event_function (self->srcpad, gst_vtenc_src_event); gst_element_add_pad (element, self->srcpad); /* These could be controlled by properties later */ self->dump_properties = FALSE; self->dump_attributes = FALSE; }
static void gst_theora_enc_init (GstTheoraEnc * enc, GstTheoraEncClass * g_class) { enc->sinkpad = gst_pad_new_from_static_template (&theora_enc_sink_factory, "sink"); gst_pad_set_chain_function (enc->sinkpad, theora_enc_chain); gst_pad_set_event_function (enc->sinkpad, theora_enc_sink_event); gst_pad_set_setcaps_function (enc->sinkpad, theora_enc_sink_setcaps); gst_element_add_pad (GST_ELEMENT (enc), enc->sinkpad); enc->srcpad = gst_pad_new_from_static_template (&theora_enc_src_factory, "src"); gst_element_add_pad (GST_ELEMENT (enc), enc->srcpad); gst_segment_init (&enc->segment, GST_FORMAT_UNDEFINED); enc->center = THEORA_DEF_CENTER; enc->border = THEORA_DEF_BORDER; enc->video_bitrate = THEORA_DEF_BITRATE; enc->video_quality = THEORA_DEF_QUALITY; enc->quick = THEORA_DEF_QUICK; enc->keyframe_auto = THEORA_DEF_KEYFRAME_AUTO; enc->keyframe_freq = THEORA_DEF_KEYFRAME_FREQ; enc->keyframe_force = THEORA_DEF_KEYFRAME_FREQ_FORCE; enc->keyframe_threshold = THEORA_DEF_KEYFRAME_THRESHOLD; enc->keyframe_mindistance = THEORA_DEF_KEYFRAME_MINDISTANCE; enc->noise_sensitivity = THEORA_DEF_NOISE_SENSITIVITY; enc->sharpness = THEORA_DEF_SHARPNESS; enc->granule_shift = _ilog (enc->info.keyframe_frequency_force - 1); GST_DEBUG_OBJECT (enc, "keyframe_frequency_force is %d, granule shift is %d", enc->info.keyframe_frequency_force, enc->granule_shift); enc->expected_ts = GST_CLOCK_TIME_NONE; }
static void gst_videodrop_init (GstVideodrop * videodrop) { GST_OBJECT_FLAG_SET (videodrop, GST_ELEMENT_EVENT_AWARE); GST_DEBUG ("gst_videodrop_init"); videodrop->sinkpad = gst_pad_new_from_static_template (&gst_videodrop_sink_template, "sink"); gst_element_add_pad (GST_ELEMENT (videodrop), videodrop->sinkpad); gst_pad_set_chain_function (videodrop->sinkpad, gst_videodrop_chain); gst_pad_set_getcaps_function (videodrop->sinkpad, gst_videodrop_getcaps); gst_pad_set_link_function (videodrop->sinkpad, gst_videodrop_link); videodrop->srcpad = gst_pad_new_from_static_template (&gst_videodrop_src_template, "src"); gst_element_add_pad (GST_ELEMENT (videodrop), videodrop->srcpad); gst_pad_set_getcaps_function (videodrop->srcpad, gst_videodrop_getcaps); gst_pad_set_link_function (videodrop->srcpad, gst_videodrop_link); videodrop->inited = FALSE; videodrop->total = videodrop->pass = 0; videodrop->speed = 1.; videodrop->time_adjust = 0; }
//static void MediaParserGst::cb_pad_added(GstElement* /* element */, GstPad* new_pad, gpointer data) { MediaParserGst* parser = static_cast<MediaParserGst*>(data); GstCaps* caps = gst_pad_get_caps(new_pad); print_caps(caps); GstStructure* str = gst_caps_get_structure (caps, 0); if (!str) { log_error(_("MediaParserGst: couldn't get structure name.")); parser->link_to_fakesink(new_pad); return; } const gchar* caps_name = gst_structure_get_name (str); bool media_type_audio; if (std::equal(caps_name, caps_name+5, "audio")) { media_type_audio = true; } else if (std::equal(caps_name, caps_name+5, "video")) { media_type_audio = false; } else { log_error(_("MediaParserGst: ignoring stream of type %s."), caps_name); parser->link_to_fakesink(new_pad); return; } gboolean parsed = false; gboolean framed = false; gst_structure_get_boolean(str, "parsed", &parsed); gst_structure_get_boolean(str, "framed", &framed); bool already_parsed = parsed || framed; GstPad* final_pad = 0; if (already_parsed) { final_pad = new_pad; } else { // We'll try to find a parser, so that we will eventually receive // timestamped buffers, on which the MediaParser system relies. GstElementFactory* parserfactory = swfdec_gst_get_parser_factory (caps); if (!parserfactory) { log_error(_("MediaParserGst: Failed to find a parser (media: %s)."), caps_name); parser->link_to_fakesink(new_pad); return; } GstElement* parserel = gst_element_factory_create (parserfactory, NULL); gst_object_unref (parserfactory); if (!parserel) { log_error(_("MediaParserGst: Failed to find a parser. We'll continue, " "but either audio or video will not work!")); parser->link_to_fakesink(new_pad); return; } gboolean success = gst_bin_add(GST_BIN(parser->_bin), parserel); if (!success) { gst_object_unref(parserel); log_error(_("MediaParserGst: couldn't add parser.")); parser->link_to_fakesink(new_pad); return; } GstPad* sinkpad = gst_element_get_static_pad (parserel, "sink"); assert(sinkpad); GstPadLinkReturn ret = gst_pad_link(new_pad, sinkpad); gst_object_unref(GST_OBJECT(sinkpad)); if (!GST_PAD_LINK_SUCCESSFUL(ret)) { log_error(_("MediaParserGst: couldn't link parser.")); parser->link_to_fakesink(new_pad); return; } final_pad = gst_element_get_static_pad (parserel, "src"); } if (media_type_audio) { parser->_audiosink = swfdec_gst_connect_sinkpad_by_pad (final_pad, caps); if (!parser->_audiosink) { log_error(_("MediaParserGst: couldn't link \"fake\" sink.")); return; } gst_pad_set_chain_function(parser->_audiosink, MediaParserGst::cb_chain_func_audio); g_object_set_data(G_OBJECT (parser->_audiosink), "mediaparser-obj", parser); LOG_ONCE( log_unimpl("MediaParserGst won't set codec, sampleRate, " "sampleSize, stereo and duration in AudioInfo"); ); AudioInfo* audioinfo = new AudioInfo(0, 0, 0, false, 0, CODEC_TYPE_CUSTOM); audioinfo->extra.reset(new ExtraInfoGst(caps)); parser->_audioInfo.reset(audioinfo); log_debug(_("MediaParserGst: Linked audio source (type: %s)"), caps_name); } else {
/* initialize the new element * instantiate pads and add them to element * set pad callback functions * initialize instance structure */ static void gst_motion_cells_init (GstMotioncells * filter, GstMotioncellsClass * gclass) { filter->propset_mutex = g_mutex_new (); filter->sinkpad = gst_pad_new_from_static_template (&sink_factory, "sink"); gst_pad_set_setcaps_function (filter->sinkpad, GST_DEBUG_FUNCPTR (gst_motion_cells_set_caps)); gst_pad_set_getcaps_function (filter->sinkpad, GST_DEBUG_FUNCPTR (gst_pad_proxy_getcaps)); gst_pad_set_chain_function (filter->sinkpad, GST_DEBUG_FUNCPTR (gst_motion_cells_chain)); filter->srcpad = gst_pad_new_from_static_template (&src_factory, "src"); gst_pad_set_getcaps_function (filter->srcpad, GST_DEBUG_FUNCPTR (gst_pad_proxy_getcaps)); gst_element_add_pad (GST_ELEMENT (filter), filter->sinkpad); gst_element_add_pad (GST_ELEMENT (filter), filter->srcpad); filter->display = TRUE; filter->calculate_motion = TRUE; filter->prevgridx = 0; filter->prevgridy = 0; filter->gridx = GRID_DEF; filter->gridy = GRID_DEF; filter->gap = GAP_DEF; filter->postnomotion = POST_NO_MOTION_DEF; filter->minimum_motion_frames = MINIMUM_MOTION_FRAMES_DEF; filter->prev_datafile = g_strdup (NULL); filter->cur_datafile = g_strdup (NULL); filter->basename_datafile = g_strdup (NULL); filter->datafile_extension = g_strdup (DEF_DATAFILEEXT); filter->sensitivity = SENSITIVITY_DEFAULT; filter->threshold = THRESHOLD_DEFAULT; filter->motionmaskcoord_count = 0; filter->motionmaskcoords = NULL; filter->motionmaskcells_count = 0; filter->motionmaskcellsidx = NULL; filter->motioncellscolor = g_new0 (cellscolor, 1); filter->motioncellscolor->R_channel_value = 255; filter->motioncellscolor->G_channel_value = 255; filter->motioncellscolor->B_channel_value = 0; filter->motioncellsidx = NULL; filter->motioncells_count = 0; filter->motion_begin_timestamp = 0; filter->last_motion_timestamp = 0; filter->last_nomotion_notified = 0; filter->consecutive_motion = 0; filter->motion_timestamp = 0; filter->prev_buff_timestamp = 0; filter->cur_buff_timestamp = 0; filter->diff_timestamp = -1; gettimeofday (&filter->tv, NULL); filter->starttime = 1000 * filter->tv.tv_sec; filter->previous_motion = false; filter->changed_datafile = false; filter->postallmotion = false; filter->usealpha = true; filter->firstdatafile = false; filter->firstgridx = true; filter->firstgridy = true; filter->changed_gridx = false; filter->changed_gridy = false; filter->firstframe = true; filter->changed_startime = false; filter->sent_init_error_msg = false; filter->sent_save_error_msg = false; filter->thickness = THICKNESS_DEF; filter->datafileidx = 0; g_mutex_lock (filter->propset_mutex); filter->id = instanceCounter; motion_cells_init (); g_mutex_unlock (filter->propset_mutex); }
static void run_output_order_test (gint n_linked) { /* This test creates a multiqueue with 2 linked output, and 3 outputs that * return 'not-linked' when data is pushed, then verifies that all buffers * are received on not-linked pads only after earlier buffers on the * 'linked' pads are made */ GstElement *pipe; GstElement *mq; GstPad *inputpads[5]; GstPad *sinkpads[5]; struct PadData pad_data[5]; guint32 max_linked_id; guint32 eos_seen; GMutex *mutex; GCond *cond; gint i; const gint NPADS = 5; const gint NBUFFERS = 1000; mutex = g_mutex_new (); cond = g_cond_new (); pipe = gst_bin_new ("testbin"); mq = gst_element_factory_make ("multiqueue", NULL); fail_unless (mq != NULL); gst_bin_add (GST_BIN (pipe), mq); /* No limits */ g_object_set (mq, "max-size-bytes", (guint) 0, "max-size-buffers", (guint) 0, "max-size-time", (guint64) 0, "extra-size-bytes", (guint) 0, "extra-size-buffers", (guint) 0, "extra-size-time", (guint64) 0, NULL); /* Construct NPADS dummy output pads. The first 'n_linked' return FLOW_OK, the rest * return NOT_LINKED. The not-linked ones check the expected ordering of * output buffers */ for (i = 0; i < NPADS; i++) { GstPad *mq_srcpad, *mq_sinkpad; gchar *name; name = g_strdup_printf ("dummysrc%d", i); inputpads[i] = gst_pad_new (name, GST_PAD_SRC); g_free (name); gst_pad_set_getcaps_function (inputpads[i], mq_dummypad_getcaps); mq_sinkpad = gst_element_get_request_pad (mq, "sink%d"); fail_unless (mq_sinkpad != NULL); gst_pad_link (inputpads[i], mq_sinkpad); gst_pad_set_active (inputpads[i], TRUE); mq_srcpad = mq_sinkpad_to_srcpad (mq, mq_sinkpad); name = g_strdup_printf ("dummysink%d", i); sinkpads[i] = gst_pad_new (name, GST_PAD_SINK); g_free (name); gst_pad_set_chain_function (sinkpads[i], mq_dummypad_chain); gst_pad_set_event_function (sinkpads[i], mq_dummypad_event); gst_pad_set_getcaps_function (sinkpads[i], mq_dummypad_getcaps); pad_data[i].pad_num = i; pad_data[i].max_linked_id_ptr = &max_linked_id; pad_data[i].eos_count_ptr = &eos_seen; pad_data[i].is_linked = (i < n_linked ? TRUE : FALSE); pad_data[i].n_linked = n_linked; pad_data[i].cond = cond; pad_data[i].mutex = mutex; pad_data[i].first_buf = TRUE; gst_pad_set_element_private (sinkpads[i], pad_data + i); gst_pad_link (mq_srcpad, sinkpads[i]); gst_pad_set_active (sinkpads[i], TRUE); gst_object_unref (mq_sinkpad); gst_object_unref (mq_srcpad); } /* Run the test. Push 1000 buffers through the multiqueue in a pattern */ max_linked_id = 0; eos_seen = 0; gst_element_set_state (pipe, GST_STATE_PLAYING); for (i = 0; i < NBUFFERS; i++) { const guint8 pad_pattern[] = { 0, 0, 0, 0, 1, 1, 2, 1, 0, 2, 3, 2, 3, 1, 4 }; const guint n = sizeof (pad_pattern) / sizeof (guint8); guint8 cur_pad; GstBuffer *buf; GstFlowReturn ret; cur_pad = pad_pattern[i % n]; buf = gst_buffer_new_and_alloc (4); g_static_mutex_lock (&_check_lock); fail_if (buf == NULL); g_static_mutex_unlock (&_check_lock); GST_WRITE_UINT32_BE (GST_BUFFER_DATA (buf), i + 1); GST_BUFFER_TIMESTAMP (buf) = (i + 1) * GST_SECOND; ret = gst_pad_push (inputpads[cur_pad], buf); g_static_mutex_lock (&_check_lock); if (pad_data[cur_pad].is_linked) { fail_unless (ret == GST_FLOW_OK, "Push on pad %d returned %d when FLOW_OK was expected", cur_pad, ret); } else { /* Expect OK initially, then NOT_LINKED when the srcpad starts pushing */ fail_unless (ret == GST_FLOW_OK || ret == GST_FLOW_NOT_LINKED, "Push on pad %d returned %d when FLOW_OK or NOT_LINKED was expected", cur_pad, ret); } g_static_mutex_unlock (&_check_lock); } for (i = 0; i < NPADS; i++) { gst_pad_push_event (inputpads[i], gst_event_new_eos ()); } /* Wait while the buffers are processed */ g_mutex_lock (mutex); while (eos_seen < 5) { g_cond_wait (cond, mutex); } g_mutex_unlock (mutex); /* Clean up */ for (i = 0; i < 5; i++) { GstPad *mq_input = gst_pad_get_peer (inputpads[i]); gst_pad_unlink (inputpads[i], mq_input); gst_element_release_request_pad (mq, mq_input); gst_object_unref (mq_input); gst_object_unref (inputpads[i]); gst_object_unref (sinkpads[i]); } gst_element_set_state (pipe, GST_STATE_NULL); gst_object_unref (pipe); g_cond_free (cond); g_mutex_free (mutex); }
static HRESULT Gstreamer_transform_ConnectInput(GstTfImpl *This, const AM_MEDIA_TYPE *amt, GstCaps *capsin, GstCaps *capsout) { GstIterator *it; BOOL done = FALSE, found = FALSE; int ret; TRACE("%p %p %p %p\n", This, amt, capsin, capsout); mark_wine_thread(); This->filter = gst_element_factory_make(This->gstreamer_name, NULL); if (!This->filter) { FIXME("Could not make %s filter\n", This->gstreamer_name); return E_FAIL; } This->my_src = gst_pad_new("yuvsrc", GST_PAD_SRC); gst_pad_set_element_private (This->my_src, This); gst_pad_set_active(This->my_src, 1); This->my_sink = gst_pad_new("yuvsink", GST_PAD_SINK); gst_pad_set_chain_function(This->my_sink, got_data_wrapper); gst_pad_set_element_private (This->my_sink, This); gst_pad_set_active(This->my_sink, 1); it = gst_element_iterate_sink_pads(This->filter); while (!done) { GValue item = {0}; switch (gst_iterator_next(it, &item)) { case GST_ITERATOR_RESYNC: gst_iterator_resync (it); break; case GST_ITERATOR_OK: This->their_sink = g_value_get_object(&item); gst_object_ref(This->their_sink); g_value_reset(&item); case GST_ITERATOR_ERROR: case GST_ITERATOR_DONE: done = TRUE; break; } } gst_iterator_free(it); if (!This->their_sink) { ERR("Could not find sink on filter %s\n", This->gstreamer_name); return E_FAIL; } it = gst_element_iterate_src_pads(This->filter); gst_iterator_resync(it); done = FALSE; while (!done) { GValue item = {0}; switch (gst_iterator_next(it, &item)) { case GST_ITERATOR_RESYNC: gst_iterator_resync (it); break; case GST_ITERATOR_OK: This->their_src = g_value_get_object(&item); gst_object_ref(This->their_src); g_value_reset(&item); case GST_ITERATOR_ERROR: case GST_ITERATOR_DONE: done = TRUE; break; } } gst_iterator_free(it); found = !!This->their_src; if (!found) g_signal_connect(This->filter, "pad-added", G_CALLBACK(Gstreamer_transform_pad_added_wrapper), This); ret = gst_pad_link(This->my_src, This->their_sink); if (ret < 0) { WARN("Failed to link with %i\n", ret); return E_FAIL; } ret = gst_pad_set_caps(This->my_src, capsin); if (ret < 0) { WARN("Failed to set caps on own source with %i\n", ret); return E_FAIL; } if (found) Gstreamer_transform_pad_added(This->filter, This->their_src, This); if (!gst_pad_is_linked(This->my_sink)) return E_FAIL; ret = gst_pad_set_caps(This->my_sink, capsout); if (ret < 0) { WARN("Failed to set caps on own sink with %i\n", ret); return E_FAIL; } TRACE("Connected\n"); return S_OK; }
static void _setup_test (gboolean link_h264, gboolean link_yuy2, gboolean link_nv12, gboolean link_jpg) { GstBus *bus = gst_bus_new (); GstPad *sinkpad, *h264pad, *yuy2pad, *nv12pad, *jpgpad; have_h264_eos = have_yuy2_eos = have_nv12_eos = have_jpg_eos = FALSE; buffer_h264 = buffer_yuy2 = buffer_nv12 = buffer_jpg = NULL; demux = gst_element_factory_make ("uvch264_mjpgdemux", NULL); fail_unless (demux != NULL); gst_element_set_bus (demux, bus); gst_bus_set_sync_handler (bus, _bus_sync_handler, NULL); mjpg_pad = gst_pad_new_from_static_template (&mjpg_template, "src"); fail_unless (mjpg_pad != NULL); sinkpad = gst_element_get_static_pad (demux, "sink"); fail_unless (sinkpad != NULL); fail_unless (gst_pad_link (mjpg_pad, sinkpad) == GST_PAD_LINK_OK); gst_object_unref (sinkpad); gst_pad_set_active (mjpg_pad, TRUE); if (link_h264) { h264pad = gst_element_get_static_pad (demux, "h264"); fail_unless (h264pad != NULL); h264_pad = gst_pad_new_from_static_template (&sink_template, "h264"); fail_unless (h264_pad != NULL); gst_pad_set_chain_function (h264_pad, _sink_h264_chain); gst_pad_set_event_function (h264_pad, _sink_h264_event); fail_unless (gst_pad_link (h264pad, h264_pad) == GST_PAD_LINK_OK); gst_object_unref (h264pad); gst_pad_set_active (h264_pad, TRUE); } if (link_yuy2) { yuy2pad = gst_element_get_static_pad (demux, "yuy2"); fail_unless (yuy2pad != NULL); yuy2_pad = gst_pad_new_from_static_template (&sink_template, "yuy2"); fail_unless (yuy2_pad != NULL); gst_pad_set_chain_function (yuy2_pad, _sink_yuy2_chain); gst_pad_set_event_function (yuy2_pad, _sink_yuy2_event); fail_unless (gst_pad_link (yuy2pad, yuy2_pad) == GST_PAD_LINK_OK); gst_object_unref (yuy2pad); gst_pad_set_active (yuy2_pad, TRUE); } if (link_nv12) { nv12pad = gst_element_get_static_pad (demux, "nv12"); fail_unless (nv12pad != NULL); nv12_pad = gst_pad_new_from_static_template (&sink_template, "nv12"); fail_unless (nv12_pad != NULL); gst_pad_set_chain_function (nv12_pad, _sink_nv12_chain); gst_pad_set_event_function (nv12_pad, _sink_nv12_event); fail_unless (gst_pad_link (nv12pad, nv12_pad) == GST_PAD_LINK_OK); gst_object_unref (nv12pad); gst_pad_set_active (nv12_pad, TRUE); } if (link_jpg) { jpgpad = gst_element_get_static_pad (demux, "jpeg"); fail_unless (jpgpad != NULL); jpg_pad = gst_pad_new_from_static_template (&sink_template, "jpeg"); fail_unless (jpg_pad != NULL); gst_pad_set_chain_function (jpg_pad, _sink_jpg_chain); gst_pad_set_event_function (jpg_pad, _sink_jpg_event); fail_unless (gst_pad_link (jpgpad, jpg_pad) == GST_PAD_LINK_OK); gst_object_unref (jpgpad); gst_pad_set_active (jpg_pad, TRUE); } gst_element_set_state (demux, GST_STATE_PLAYING); }
static HRESULT Gstreamer_transform_ConnectInput(GstTfImpl *This, const AM_MEDIA_TYPE *amt, GstCaps *capsin, GstCaps *capsout) { GstIterator *it; int done = 0, found = 0, ret; This->filter = gst_element_factory_make(This->gstreamer_name, NULL); if (!This->filter) { FIXME("Could not make %s filter\n", This->gstreamer_name); return E_FAIL; } This->my_src = gst_pad_new(NULL, GST_PAD_SRC); gst_pad_set_element_private (This->my_src, This); This->my_sink = gst_pad_new(NULL, GST_PAD_SINK); gst_pad_set_chain_function(This->my_sink, got_data); gst_pad_set_bufferalloc_function(This->my_sink, request_buffer); gst_pad_set_element_private (This->my_sink, This); ret = gst_pad_set_caps(This->my_src, capsin); if (ret < 0) { WARN("Failed to set caps on own source with %i\n", ret); return E_FAIL; } ret = gst_pad_set_caps(This->my_sink, capsout); if (ret < 0) { WARN("Failed to set caps on own sink with %i\n", ret); return E_FAIL; } it = gst_element_iterate_sink_pads(This->filter); while (!done) { gpointer item; switch (gst_iterator_next(it, &item)) { case GST_ITERATOR_RESYNC: gst_iterator_resync (it); break; case GST_ITERATOR_OK: This->their_sink = item; case GST_ITERATOR_ERROR: case GST_ITERATOR_DONE: done = 1; break; } } gst_iterator_free(it); if (!This->their_sink) { ERR("Could not find sink on filter %s\n", This->gstreamer_name); return E_FAIL; } it = gst_element_iterate_src_pads(This->filter); gst_iterator_resync(it); done = 0; while (!done) { gpointer item; switch (gst_iterator_next(it, &item)) { case GST_ITERATOR_RESYNC: gst_iterator_resync (it); break; case GST_ITERATOR_OK: This->their_src = item; case GST_ITERATOR_ERROR: case GST_ITERATOR_DONE: done = 1; break; } } gst_iterator_free(it); found = !!This->their_src; if (!found) g_signal_connect(This->filter, "pad-added", G_CALLBACK(Gstreamer_transform_pad_added), This); ret = gst_pad_link(This->my_src, This->their_sink); if (ret < 0) { WARN("Failed to link with %i\n", ret); return E_FAIL; } if (found) Gstreamer_transform_pad_added(This->filter, This->their_src, This); if (!gst_pad_is_linked(This->my_sink)) return E_FAIL; TRACE("Connected\n"); return S_OK; }
static GstElement * gst_auto_convert_add_element (GstAutoConvert * autoconvert, GstElementFactory * factory) { GstElement *element = NULL; GstPad *internal_sinkpad = NULL; GstPad *internal_srcpad = NULL; GstPad *sinkpad = NULL; GstPad *srcpad = NULL; GstPadLinkReturn padlinkret; GST_DEBUG_OBJECT (autoconvert, "Adding element %s to the autoconvert bin", gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory))); element = gst_element_factory_create (factory, NULL); if (!element) return NULL; if (!gst_bin_add (GST_BIN (autoconvert), element)) { GST_ERROR_OBJECT (autoconvert, "Could not add element %s to the bin", GST_OBJECT_NAME (element)); gst_object_unref (element); return NULL; } srcpad = get_pad_by_direction (element, GST_PAD_SRC); if (!srcpad) { GST_ERROR_OBJECT (autoconvert, "Could not find source in %s", GST_OBJECT_NAME (element)); goto error; } sinkpad = get_pad_by_direction (element, GST_PAD_SINK); if (!sinkpad) { GST_ERROR_OBJECT (autoconvert, "Could not find sink in %s", GST_OBJECT_NAME (element)); goto error; } internal_sinkpad = gst_pad_new_from_static_template (&sink_internal_template, "sink_internal"); internal_srcpad = gst_pad_new_from_static_template (&src_internal_template, "src_internal"); if (!internal_sinkpad || !internal_srcpad) { GST_ERROR_OBJECT (autoconvert, "Could not create internal pads"); if (internal_srcpad) gst_object_unref (internal_srcpad); if (internal_sinkpad) gst_object_unref (internal_sinkpad); goto error; } g_object_weak_ref (G_OBJECT (element), (GWeakNotify) gst_object_unref, internal_sinkpad); g_object_weak_ref (G_OBJECT (element), (GWeakNotify) gst_object_unref, internal_srcpad); gst_pad_set_active (internal_sinkpad, TRUE); gst_pad_set_active (internal_srcpad, TRUE); g_object_set_qdata (G_OBJECT (internal_srcpad), parent_quark, autoconvert); g_object_set_qdata (G_OBJECT (internal_sinkpad), parent_quark, autoconvert); gst_pad_set_chain_function (internal_sinkpad, GST_DEBUG_FUNCPTR (gst_auto_convert_internal_sink_chain)); gst_pad_set_chain_list_function (internal_sinkpad, GST_DEBUG_FUNCPTR (gst_auto_convert_internal_sink_chain_list)); gst_pad_set_event_function (internal_sinkpad, GST_DEBUG_FUNCPTR (gst_auto_convert_internal_sink_event)); gst_pad_set_query_function (internal_sinkpad, GST_DEBUG_FUNCPTR (gst_auto_convert_internal_sink_query)); gst_pad_set_event_function (internal_srcpad, GST_DEBUG_FUNCPTR (gst_auto_convert_internal_src_event)); gst_pad_set_query_function (internal_srcpad, GST_DEBUG_FUNCPTR (gst_auto_convert_internal_src_query)); padlinkret = gst_pad_link_full (internal_srcpad, sinkpad, GST_PAD_LINK_CHECK_NOTHING); if (GST_PAD_LINK_FAILED (padlinkret)) { GST_WARNING_OBJECT (autoconvert, "Could not links pad %s:%s to %s:%s" " for reason %d", GST_DEBUG_PAD_NAME (internal_srcpad), GST_DEBUG_PAD_NAME (sinkpad), padlinkret); goto error; } padlinkret = gst_pad_link_full (srcpad, internal_sinkpad, GST_PAD_LINK_CHECK_NOTHING); if (GST_PAD_LINK_FAILED (padlinkret)) { GST_WARNING_OBJECT (autoconvert, "Could not links pad %s:%s to %s:%s" " for reason %d", GST_DEBUG_PAD_NAME (internal_srcpad), GST_DEBUG_PAD_NAME (sinkpad), padlinkret); goto error; } g_object_set_qdata (G_OBJECT (element), internal_srcpad_quark, internal_srcpad); g_object_set_qdata (G_OBJECT (element), internal_sinkpad_quark, internal_sinkpad); /* Iffy */ gst_element_sync_state_with_parent (element); /* Increment the reference count we will return to the caller */ gst_object_ref (element); /* unref sink and src pad */ gst_object_unref (srcpad); gst_object_unref (sinkpad); return element; error: gst_element_set_locked_state (element, TRUE); gst_element_set_state (element, GST_STATE_NULL); gst_bin_remove (GST_BIN (autoconvert), element); if (srcpad) gst_object_unref (srcpad); if (sinkpad) gst_object_unref (sinkpad); return NULL; }
static void gst_decklink_sink_init (GstDecklinkSink * decklinksink) { GstDecklinkSinkClass *decklinksink_class; decklinksink_class = GST_DECKLINK_SINK_GET_CLASS (decklinksink_class); decklinksink->videosinkpad = gst_pad_new_from_template (gst_element_class_get_pad_template (GST_ELEMENT_CLASS (decklinksink_class), "videosink"), "videosink"); gst_pad_set_chain_function (decklinksink->videosinkpad, GST_DEBUG_FUNCPTR (gst_decklink_sink_videosink_chain)); gst_pad_set_event_function (decklinksink->videosinkpad, GST_DEBUG_FUNCPTR (gst_decklink_sink_videosink_event)); gst_pad_set_query_function (decklinksink->videosinkpad, GST_DEBUG_FUNCPTR (gst_decklink_sink_videosink_query)); gst_element_add_pad (GST_ELEMENT (decklinksink), decklinksink->videosinkpad); decklinksink->audiosinkpad = gst_pad_new_from_static_template (&gst_decklink_sink_audiosink_template, "audiosink"); gst_pad_set_chain_function (decklinksink->audiosinkpad, GST_DEBUG_FUNCPTR (gst_decklink_sink_audiosink_chain)); gst_pad_set_event_function (decklinksink->audiosinkpad, GST_DEBUG_FUNCPTR (gst_decklink_sink_audiosink_event)); gst_pad_set_query_function (decklinksink->audiosinkpad, GST_DEBUG_FUNCPTR (gst_decklink_sink_audiosink_query)); gst_element_add_pad (GST_ELEMENT (decklinksink), decklinksink->audiosinkpad); GST_OBJECT_FLAG_SET (decklinksink, GST_ELEMENT_FLAG_SINK); g_cond_init (&decklinksink->cond); g_mutex_init (&decklinksink->mutex); g_mutex_init (&decklinksink->audio_mutex); g_cond_init (&decklinksink->audio_cond); decklinksink->mode = GST_DECKLINK_MODE_NTSC; decklinksink->device = 0; decklinksink->callback = new Output; decklinksink->callback->decklinksink = decklinksink; #ifdef _MSC_VER g_mutex_init (&decklinksink->com_init_lock); g_mutex_init (&decklinksink->com_deinit_lock); g_cond_init (&decklinksink->com_initialized); g_cond_init (&decklinksink->com_uninitialize); g_cond_init (&decklinksink->com_uninitialized); g_mutex_lock (&decklinksink->com_init_lock); /* create the COM initialization thread */ g_thread_create ((GThreadFunc) gst_decklink_sink_com_thread, decklinksink, FALSE, NULL); /* wait until the COM thread signals that COM has been initialized */ g_cond_wait (&decklinksink->com_initialized, &decklinksink->com_init_lock); g_mutex_unlock (&decklinksink->com_init_lock); #endif /* _MSC_VER */ }