static void
gst_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 void
gst_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 void
gst_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 void
gst_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 void
gst_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 void
gst_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 void
mfw_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 void
gst_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 void
gst_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 void
gst_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 void
gst_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 void
gst_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 gboolean
element_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 gboolean
play_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 gboolean
gst_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 void
gst_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 void
gst_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 void
gst_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 void
gst_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 gboolean
has_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 void
gst_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;
}
