static void
link_sinks (GstElement * mpegtsmux,
GstPad ** src1, GstPad ** src2, GstPad ** src3, TestData * test_data)
{
GstPad *mux_sink1, *mux_sink2, *mux_sink3;
/* link 3 sink pads, 2 video 1 audio */
*src1 = gst_pad_new_from_static_template (&video_src_template, "src1");
gst_pad_set_active (*src1, TRUE);
gst_pad_set_element_private (*src1, test_data);
gst_pad_set_event_function (*src1, src_event);
mux_sink1 = gst_element_get_request_pad (mpegtsmux, "sink_1");
fail_unless (gst_pad_link (*src1, mux_sink1) == GST_PAD_LINK_OK);
*src2 = gst_pad_new_from_static_template (&video_src_template, "src2");
gst_pad_set_active (*src2, TRUE);
gst_pad_set_element_private (*src2, test_data);
gst_pad_set_event_function (*src2, src_event);
mux_sink2 = gst_element_get_request_pad (mpegtsmux, "sink_2");
fail_unless (gst_pad_link (*src2, mux_sink2) == GST_PAD_LINK_OK);
*src3 = gst_pad_new_from_static_template (&audio_src_template, "src3");
gst_pad_set_active (*src3, TRUE);
gst_pad_set_element_private (*src3, test_data);
gst_pad_set_event_function (*src3, src_event);
mux_sink3 = gst_element_get_request_pad (mpegtsmux, "sink_3");
fail_unless (gst_pad_link (*src3, mux_sink3) == GST_PAD_LINK_OK);
gst_object_unref (mux_sink1);
gst_object_unref (mux_sink2);
gst_object_unref (mux_sink3);
}
bool CDFKAFU050::InstantiateGSTElements()
{
#ifdef USE_AFU050
bool success = true;
InstantiateGSTElement("appsrc", "appsrc", &success);
InstantiateGSTElement("capsfilter", "filter", &success);
InstantiateGSTElement("jpegdec", "jpegdec", &success);
InstantiateGSTElement("tee","tee", &success);
InstantiateGSTElement("ximagesink", "ximagesink", &success);
InstantiateGSTElement("queue", "queue1", &success);
InstantiateGSTElement("queue", "queue2", &success);
InstantiateGSTElement("videoscale","videoscale1", &success);
InstantiateGSTElement("cogcolorspace","cogcolorspace", &success);
InstantiateGSTElement("fakesink", "image_sink", &success);
tee_q1_pad = gst_element_get_request_pad(GetElement( "tee"), "src%d");
tee_q2_pad = gst_element_get_request_pad(GetElement( "tee"), "src%d");
q1_pad = gst_element_get_static_pad (GetElement( "queue1"), "sink");
q2_pad = gst_element_get_static_pad (GetElement( "queue2"), "sink");
#ifdef RaspberryPI
InstantiateGSTElement("videorate", "videorate", &success);
#endif
if( !success)
return false;
// Set the callback for our fakesing "image_sink"
#endif
return true;
}
static void
link_new_agnosticbin (gchar * key, GstElement * adder, GstElement * agnosticbin)
{
GstPad *srcpad = NULL, *sinkpad = NULL;
char *padname;
padname = g_object_get_data (G_OBJECT (agnosticbin), KEY_SINK_PAD_NAME);
if (padname == NULL) {
GST_ERROR ("No pad associated with %" GST_PTR_FORMAT, agnosticbin);
goto end;
}
if (g_str_equal (key, padname)) {
/* Do not connect the origin audio input */
GST_TRACE ("Do not connect echo audio input %" GST_PTR_FORMAT, agnosticbin);
goto end;
}
srcpad = gst_element_get_request_pad (agnosticbin, "src_%u");
if (srcpad == NULL) {
GST_ERROR ("Could not get src pad in %" GST_PTR_FORMAT, agnosticbin);
goto end;
}
sinkpad = gst_element_get_request_pad (adder, "sink_%u");
if (srcpad == NULL) {
GST_ERROR ("Could not get sink pad in %" GST_PTR_FORMAT, adder);
gst_element_release_request_pad (agnosticbin, srcpad);
goto end;
}
GST_DEBUG ("Linking %" GST_PTR_FORMAT " to %" GST_PTR_FORMAT, srcpad,
sinkpad);
if (gst_pad_link (srcpad, sinkpad) != GST_PAD_LINK_OK) {
GST_ERROR ("Could not link %" GST_PTR_FORMAT " to %" GST_PTR_FORMAT, srcpad,
sinkpad);
gst_element_release_request_pad (agnosticbin, srcpad);
gst_element_release_request_pad (adder, sinkpad);
}
end:
if (srcpad != NULL) {
g_object_unref (srcpad);
}
if (sinkpad != NULL) {
g_object_unref (sinkpad);
}
}
/* Create and link output pad: selector:src%d ! output_pad */
GstPad *
setup_output_pad (GstElement * element)
{
GstPad *srcpad = NULL, *output_pad = NULL;
gulong probe_id = 0;
/* create output_pad */
output_pad = gst_pad_new_from_static_template (&sinktemplate, "sink");
fail_if (output_pad == NULL, "Could not create a output_pad");
/* add probe */
probe_id = gst_pad_add_data_probe (output_pad, G_CALLBACK (probe_cb), NULL);
g_object_set_data (G_OBJECT (output_pad), "probe_id",
GINT_TO_POINTER (probe_id));
/* request src pad */
srcpad = gst_element_get_request_pad (element, "src%d");
fail_if (srcpad == NULL, "Could not get source pad from %s",
GST_ELEMENT_NAME (element));
/* link pads and activate */
fail_unless (gst_pad_link (srcpad, output_pad) == GST_PAD_LINK_OK,
"Could not link %s source and output pad", GST_ELEMENT_NAME (element));
gst_pad_set_active (output_pad, TRUE);
GST_DEBUG_OBJECT (output_pad, "set up %" GST_PTR_FORMAT " ! %" GST_PTR_FORMAT,
srcpad, output_pad);
gst_object_unref (srcpad);
ASSERT_OBJECT_REFCOUNT (srcpad, "srcpad", 1);
return output_pad;
}
/*
* Method: get_request_pad(name)
* name: the name of the request Gst::Pad to retrieve.
*
* Retrieves a pad from the element by name. This version only retrieves
* request pads.
*
* Returns: the requested Gst::Pad if found, otherwise nil.
*/
static VALUE
rg_get_request_pad(VALUE self, VALUE name)
{
GstPad *pad =
gst_element_get_request_pad(SELF(self), RVAL2CSTR(name));
return pad != NULL ? GST_PAD2RVAL_UNREF(pad) : Qnil;
}
static GstPad *
connect_thru_mq (RsnDvdBin * dvdbin, GstPad * pad)
{
GstPad *mq_sink;
GstPad *mq_src;
gchar *tmp, *sinkname, *srcname;
/* Request a pad from multiqueue, then connect this one, then
* discover the corresponding output pad and return it */
mq_sink = gst_element_get_request_pad (dvdbin->pieces[DVD_ELEM_MQUEUE],
"sink%d");
if (mq_sink == NULL)
return FALSE;
dvdbin->mq_req_pads = g_list_prepend (dvdbin->mq_req_pads, mq_sink);
if (gst_pad_link (pad, mq_sink) != GST_PAD_LINK_OK)
return FALSE;
sinkname = gst_pad_get_name (mq_sink);
tmp = sinkname + 4;
srcname = g_strdup_printf ("src%s", tmp);
mq_src = gst_element_get_static_pad (dvdbin->pieces[DVD_ELEM_MQUEUE],
srcname);
g_free (sinkname);
g_free (srcname);
return mq_src;
}
/* dynamically add the source to the pipeline and link it to a new pad on
* adder */
static SourceInfo *
add_source (gdouble freq)
{
SourceInfo *info;
info = g_new0 (SourceInfo, 1);
info->freq = freq;
/* make source with unique name */
info->element = gst_element_factory_make ("audiotestsrc", NULL);
g_object_set (info->element, "freq", freq, NULL);
/* add to the bin */
gst_bin_add (GST_BIN (pipeline), info->element);
/* get pad from the element */
info->srcpad = gst_element_get_static_pad (info->element, "src");
/* get new pad from adder, adder will now wait for data on this pad */
info->sinkpad = gst_element_get_request_pad (adder, "sink_%u");
/* link pad to adder */
gst_pad_link (info->srcpad, info->sinkpad);
/* and play the element */
gst_element_set_state (info->element, GST_STATE_PLAYING);
g_print ("added freq %f\n", info->freq);
return info;
}
static void
agnosticbin_added_cb (GstElement * element, gpointer data)
{
struct tmp_data *tmp = data;
GstPad *pad;
g_rec_mutex_lock (&tmp->rmutex);
if (tmp->handler == 0L) {
goto end;
}
pad = gst_element_get_request_pad (element, tmp->src_pad_name);
if (pad == NULL) {
goto end;
}
GST_DEBUG_OBJECT (element, "Connecting pad %s", tmp->src_pad_name);
connect_to_sink (tmp->sink, tmp->sink_pad_name, pad);
gst_object_unref (pad);
g_signal_handler_disconnect (element, tmp->handler);
tmp->handler = 0L;
end:
g_rec_mutex_unlock (&tmp->rmutex);
}
gboolean
scope_parser_attach_to_tee(ScopeParser *parser, GstElement *tee)
{
GstPad *sink_pad;
if(parser == NULL) {
return FALSE;
}
parser->tee_pad = gst_element_get_request_pad(tee, "src1");
if(parser->tee_pad == NULL) {
g_warning("Could not get a source pad from the tee");
return FALSE;
}
parser->fakesink = gst_element_factory_make("fakesink", "fakesink");
if(parser->fakesink == NULL) {
g_warning("Could not create fakesink element");
return FALSE;
}
sink_pad = gst_element_get_pad(parser->fakesink, "sink");
gst_pad_link(parser->tee_pad, sink_pad);
parser->buffer_probe_id = gst_pad_add_buffer_probe(parser->tee_pad,
G_CALLBACK(scope_parser_buffer_probe), parser);
parser->event_probe_id = gst_pad_add_event_probe(parser->tee_pad,
G_CALLBACK(scope_parser_event_probe), parser);
gst_object_unref(parser->tee_pad);
gst_object_unref(sink_pad);
return TRUE;
}
static GstPad *
dvb_base_bin_request_new_pad (GstElement * element,
GstPadTemplate * templ, const gchar * name)
{
GstPad *pad;
GstPad *ghost;
gchar *pad_name;
if (name == NULL)
name = GST_PAD_TEMPLATE_NAME_TEMPLATE (templ);
pad =
gst_element_get_request_pad (GST_DVB_BASE_BIN (element)->mpegtsparse,
name);
if (pad == NULL)
return NULL;
pad_name = gst_pad_get_name (pad);
ghost = gst_ghost_pad_new (pad_name, pad);
g_free (pad_name);
gst_element_add_pad (element, ghost);
gst_element_no_more_pads (element);
return ghost;
}
static gboolean
connect_branch (gpointer pipeline)
{
GstElement *tee = gst_bin_get_by_name (GST_BIN (pipeline), "tee");
GstElement *queue, *sink;
GstPad *tee_src;
if (tee == NULL) {
g_atomic_int_set (&error, TRUE);
goto end;
}
queue = gst_element_factory_make ("queue", NULL);
sink = gst_element_factory_make ("appsink", NULL);
g_object_set (G_OBJECT (sink), "emit-signals", TRUE, "sync", FALSE, NULL);
g_signal_connect_data (G_OBJECT (sink), "new-sample", G_CALLBACK (new_sample),
NULL, NULL, 0);
gst_bin_add_many (GST_BIN (pipeline), queue, sink, NULL);
gst_element_link (queue, sink);
gst_element_sync_state_with_parent (queue);
gst_element_sync_state_with_parent (sink);
tee_src = gst_element_get_request_pad (tee, "src_%u");
gst_pad_add_probe (tee_src, GST_PAD_PROBE_TYPE_BLOCKING, link_to_tee,
g_object_ref (queue), g_object_unref);
g_object_unref (tee);
end:
return G_SOURCE_REMOVE;
}
static GstPad *
dvb_base_bin_request_new_pad (GstElement * element,
GstPadTemplate * templ, const gchar * name, const GstCaps * caps)
{
DvbBaseBin *dvbbasebin = GST_DVB_BASE_BIN (element);
GstPad *pad;
GstPad *ghost;
gchar *pad_name;
GST_DEBUG_OBJECT (dvbbasebin, "New pad requested %s", GST_STR_NULL (name));
if (dvbbasebin->tsparse == NULL)
return NULL;
if (name == NULL)
name = GST_PAD_TEMPLATE_NAME_TEMPLATE (templ);
pad = gst_element_get_request_pad (dvbbasebin->tsparse, name);
if (pad == NULL)
return NULL;
pad_name = gst_pad_get_name (pad);
ghost = gst_ghost_pad_new (pad_name, pad);
g_free (pad_name);
gst_element_add_pad (element, ghost);
return ghost;
}
/* Create and link input pad: input_pad ! selector:sink%d */
static GstPad *
setup_input_pad (GstElement * element)
{
GstPad *sinkpad = NULL, *input_pad = NULL;
/* create input_pad */
input_pad = gst_pad_new_from_static_template (&srctemplate, "src");
fail_if (input_pad == NULL, "Could not create a input_pad");
/* request sink pad */
sinkpad = gst_element_get_request_pad (element, "sink_%u");
fail_if (sinkpad == NULL, "Could not get sink pad from %s",
GST_ELEMENT_NAME (element));
/* link pads and activate */
fail_unless (gst_pad_link (input_pad, sinkpad) == GST_PAD_LINK_OK,
"Could not link input_pad and %s sink", GST_ELEMENT_NAME (element));
gst_pad_set_active (input_pad, TRUE);
GST_DEBUG_OBJECT (input_pad, "set up %" GST_PTR_FORMAT " ! %" GST_PTR_FORMAT,
input_pad, sinkpad);
gst_object_unref (sinkpad);
ASSERT_OBJECT_REFCOUNT (sinkpad, "sinkpad", 1);
return input_pad;
}
static gboolean
get_pads_from_mq (GstSplitMuxSink * splitmux, GstPad ** sink_pad,
GstPad ** src_pad)
{
GstPad *mq_sink;
GstPad *mq_src;
/* Request a pad from multiqueue, then connect this one, then
* discover the corresponding output pad and return both */
mq_sink = gst_element_get_request_pad (splitmux->mq, "sink_%u");
if (mq_sink == NULL)
return FALSE;
mq_src = mq_sink_to_src (splitmux->mq, mq_sink);
if (mq_src == NULL)
goto fail;
*sink_pad = mq_sink;
*src_pad = mq_src;
return TRUE;
fail:
gst_element_release_request_pad (splitmux->mq, mq_sink);
return FALSE;
}
static GstPad *
gst_hls_sink2_request_new_pad (GstElement * element, GstPadTemplate * templ,
const gchar * name, const GstCaps * caps)
{
GstHlsSink2 *sink = GST_HLS_SINK2_CAST (element);
GstPad *pad, *peer;
gboolean is_audio;
g_return_val_if_fail (strcmp (templ->name_template, "audio") == 0
|| strcmp (templ->name_template, "video") == 0, NULL);
g_return_val_if_fail (strcmp (templ->name_template, "audio") != 0
|| !sink->audio_sink, NULL);
g_return_val_if_fail (strcmp (templ->name_template, "video") != 0
|| !sink->video_sink, NULL);
is_audio = strcmp (templ->name_template, "audio") == 0;
peer =
gst_element_get_request_pad (sink->splitmuxsink,
is_audio ? "audio_0" : "video");
if (!peer)
return NULL;
pad = gst_ghost_pad_new_from_template (templ->name_template, peer, templ);
gst_pad_set_active (pad, TRUE);
gst_element_add_pad (element, pad);
gst_object_unref (peer);
if (is_audio)
sink->audio_sink = pad;
else
sink->video_sink = pad;
return pad;
}
static GObject *
link_element_to_mixer_with_smpte (GstBin * bin, GstElement * element,
GstElement * mixer, gint type, GstElement ** smpteref)
{
GstPad *srcpad, *sinkpad;
GstElement *smptealpha = gst_element_factory_make ("smptealpha", NULL);
g_object_set (G_OBJECT (smptealpha),
"type", (gint) type, "invert", (gboolean) TRUE, NULL);
gst_bin_add (bin, smptealpha);
fast_element_link (element, smptealpha);
/* crack */
if (smpteref) {
*smpteref = smptealpha;
}
srcpad = gst_element_get_static_pad (smptealpha, "src");
sinkpad = gst_element_get_request_pad (mixer, "sink_%u");
gst_pad_link_full (srcpad, sinkpad, GST_PAD_LINK_CHECK_NOTHING);
gst_object_unref (srcpad);
return G_OBJECT (sinkpad);
}
static void
connect_to_sink (GstElement * sink, const gchar * sinkname, GstPad * srcpad)
{
GstPad *sinkpad;
GST_DEBUG ("Getting pad %s from %" GST_PTR_FORMAT, sinkname, sink);
sinkpad = gst_element_get_static_pad (sink, sinkname);
if (sinkpad == NULL)
sinkpad = gst_element_get_request_pad (sink, sinkname);
if (sinkpad == NULL) {
GST_ERROR ("Can not get sink pad.");
return;
}
if (gst_pad_is_linked (sinkpad)) {
GST_ERROR ("Pad %" GST_PTR_FORMAT " is already linked.", sinkpad);
goto end;
}
if (gst_pad_link (srcpad, sinkpad) != GST_PAD_LINK_OK)
GST_ERROR ("Can not link pad %" GST_PTR_FORMAT " to %" GST_PTR_FORMAT,
srcpad, sinkpad);
else
GST_DEBUG ("Connected %" GST_PTR_FORMAT " to %" GST_PTR_FORMAT,
srcpad, sinkpad);
end:
g_object_unref (sinkpad);
}
static void
dvb_base_bin_init_cam (DvbBaseBin * dvbbasebin)
{
gint adapter;
gchar *ca_file;
g_object_get (dvbbasebin->dvbsrc, "adapter", &adapter, NULL);
/* TODO: handle multiple cams */
ca_file = g_strdup_printf ("/dev/dvb/adapter%d/ca0", adapter);
if (g_file_test (ca_file, G_FILE_TEST_EXISTS)) {
dvbbasebin->hwcam = cam_device_new ();
if (cam_device_open (dvbbasebin->hwcam, ca_file)) {
/* HACK: poll the cam in a buffer probe */
dvbbasebin->ts_pad =
gst_element_get_request_pad (dvbbasebin->mpegtsparse, "src%d");
gst_pad_add_buffer_probe (dvbbasebin->ts_pad,
G_CALLBACK (dvb_base_bin_ts_pad_probe_cb), dvbbasebin);
} else {
GST_ERROR_OBJECT (dvbbasebin, "could not open %s", ca_file);
cam_device_free (dvbbasebin->hwcam);
dvbbasebin->hwcam = NULL;
}
}
g_free (ca_file);
}
void FarsightChannel::onStreamCreated(TfChannel *tfChannel, TfStream *stream, FarsightChannel *self)
{
guint media_type;
GstPad *sink;
g_signal_connect(stream, "src-pad-added", G_CALLBACK(&FarsightChannel::onSrcPadAdded), self);
g_signal_connect(stream, "request-resource", G_CALLBACK(&FarsightChannel::onRequestResource), NULL);
g_object_get(stream, "media-type", &media_type, "sink-pad", &sink, NULL);
GstPad *pad;
switch (media_type)
{
case TP_MEDIA_STREAM_TYPE_AUDIO:
gst_bin_add(GST_BIN(self->pipeline_), self->audio_input_);
gst_element_set_state(self->audio_input_, GST_STATE_PLAYING);
pad = gst_element_get_static_pad(self->audio_input_, "src");
gst_pad_link(pad, sink);
break;
case TP_MEDIA_STREAM_TYPE_VIDEO:
pad = gst_element_get_request_pad(self->video_tee_, "src%d");
gst_pad_link(pad, sink);
break;
default:
Q_ASSERT(false);
}
gst_object_unref(sink);
}
static GstPad *
kms_webrtc_sctp_connection_request_data_sink (KmsIRtpConnection * base_conn)
{
KmsWebRtcSctpConnection *self = KMS_WEBRTC_SCTP_CONNECTION (base_conn);
return gst_element_get_request_pad (self->priv->tr->sink->dtlssrtpenc,
"data_sink");
}
static gboolean
kms_base_hub_link_src_pad (KmsBaseHub * mixer, const gchar * gp_name,
const gchar * template_name, GstElement * internal_element,
const gchar * pad_name, gboolean remove_on_unlink)
{
GstPad *gp, *target;
gboolean ret;
if (GST_OBJECT_PARENT (internal_element) != GST_OBJECT (mixer)) {
GST_ERROR_OBJECT (mixer, "Cannot link %" GST_PTR_FORMAT " wrong hierarchy",
internal_element);
return FALSE;
}
target = gst_element_get_static_pad (internal_element, pad_name);
if (target == NULL) {
target = gst_element_get_request_pad (internal_element, pad_name);
if (target != NULL && remove_on_unlink) {
g_signal_connect (G_OBJECT (target), "unlinked",
G_CALLBACK (remove_unlinked_pad), NULL);
}
}
if (target == NULL) {
GST_ERROR_OBJECT (mixer, "Cannot get target pad");
return FALSE;
}
gp = gst_element_get_static_pad (GST_ELEMENT (mixer), gp_name);
if (gp == NULL) {
GstPadTemplate *templ;
templ =
gst_element_class_get_pad_template (GST_ELEMENT_CLASS
(G_OBJECT_GET_CLASS (mixer)), template_name);
gp = gst_ghost_pad_new_from_template (gp_name, target, templ);
if (GST_STATE (mixer) >= GST_STATE_PAUSED
|| GST_STATE_PENDING (mixer) >= GST_STATE_PAUSED
|| GST_STATE_TARGET (mixer) >= GST_STATE_PAUSED) {
gst_pad_set_active (gp, TRUE);
}
ret = gst_element_add_pad (GST_ELEMENT (mixer), gp);
if (!ret) {
g_object_unref (gp);
}
} else {
ret = set_target (gp, target);
g_object_unref (gp);
}
g_object_unref (target);
return ret;
}
static void
setup_test_objects (struct TestData *td, GstPadChainFunction chain_func, GstPadBufferAllocFunction alloc_func)
{
td->mycaps = gst_caps_new_simple ("test/test", NULL);
td->funnel = gst_element_factory_make ("fsfunnel", NULL);
td->funnelsrc = gst_element_get_static_pad (td->funnel, "src");
fail_unless (td->funnelsrc != NULL);
td->funnelsink11 = gst_element_get_request_pad (td->funnel, "sink11");
fail_unless (td->funnelsink11 != NULL);
fail_unless (!strcmp (GST_OBJECT_NAME (td->funnelsink11), "sink11"));
td->funnelsink22 = gst_element_get_request_pad (td->funnel, "sink22");
fail_unless (td->funnelsink22 != NULL);
fail_unless (!strcmp (GST_OBJECT_NAME (td->funnelsink22), "sink22"));
fail_unless (gst_element_set_state (td->funnel, GST_STATE_PLAYING) ==
GST_STATE_CHANGE_SUCCESS);
td->mysink = gst_pad_new ("sink", GST_PAD_SINK);
gst_pad_set_chain_function (td->mysink, chain_func);
gst_pad_set_bufferalloc_function (td->mysink, alloc_func);
gst_pad_set_active (td->mysink, TRUE);
gst_pad_set_caps (td->mysink, td->mycaps);
td->mysrc1 = gst_pad_new ("src1", GST_PAD_SRC);
gst_pad_set_active (td->mysrc1, TRUE);
gst_pad_set_caps (td->mysrc1, td->mycaps);
td->mysrc2 = gst_pad_new ("src2", GST_PAD_SRC);
gst_pad_set_active (td->mysrc2, TRUE);
gst_pad_set_caps (td->mysrc2, td->mycaps);
fail_unless (GST_PAD_LINK_SUCCESSFUL(
gst_pad_link (td->funnelsrc, td->mysink)));
fail_unless (GST_PAD_LINK_SUCCESSFUL(
gst_pad_link (td->mysrc1, td->funnelsink11)));
fail_unless (GST_PAD_LINK_SUCCESSFUL(
gst_pad_link (td->mysrc2, td->funnelsink22)));
}
static void
setup_test_objects (struct TestData *td, GstPadChainFunction chain_func)
{
td->mycaps = gst_caps_new_empty_simple ("test/test");
td->funnel = gst_element_factory_make ("funnel", NULL);
td->funnelsrc = gst_element_get_static_pad (td->funnel, "src");
fail_unless (td->funnelsrc != NULL);
td->funnelsink11 = gst_element_get_request_pad (td->funnel, "sink_11");
fail_unless (td->funnelsink11 != NULL);
fail_unless (!strcmp (GST_OBJECT_NAME (td->funnelsink11), "sink_11"));
td->funnelsink22 = gst_element_get_request_pad (td->funnel, "sink_22");
fail_unless (td->funnelsink22 != NULL);
fail_unless (!strcmp (GST_OBJECT_NAME (td->funnelsink22), "sink_22"));
fail_unless (gst_element_set_state (td->funnel, GST_STATE_PLAYING) ==
GST_STATE_CHANGE_SUCCESS);
td->mysink = gst_pad_new ("sink", GST_PAD_SINK);
gst_pad_set_chain_function (td->mysink, chain_func);
gst_pad_set_active (td->mysink, TRUE);
td->mysrc1 = gst_pad_new ("src1", GST_PAD_SRC);
gst_pad_set_active (td->mysrc1, TRUE);
gst_check_setup_events_with_stream_id (td->mysrc1, td->funnel, td->mycaps,
GST_FORMAT_BYTES, "test1");
td->mysrc2 = gst_pad_new ("src2", GST_PAD_SRC);
gst_pad_set_active (td->mysrc2, TRUE);
gst_check_setup_events_with_stream_id (td->mysrc2, td->funnel, td->mycaps,
GST_FORMAT_BYTES, "test2");
fail_unless (GST_PAD_LINK_SUCCESSFUL (gst_pad_link (td->funnelsrc,
td->mysink)));
fail_unless (GST_PAD_LINK_SUCCESSFUL (gst_pad_link (td->mysrc1,
td->funnelsink11)));
fail_unless (GST_PAD_LINK_SUCCESSFUL (gst_pad_link (td->mysrc2,
td->funnelsink22)));
}
GstPad * GetRequestPad(GstElement * inElement, const char * inName)
{
ScopedObject<GstPad> pad(gst_element_get_request_pad(inElement, inName));
if (!pad)
{
std::string msg(Gst::MakeString() << "Failed to get request pad of type. ");
throw std::runtime_error(msg);
}
return pad.release();
}
static GObject *
link_element_to_mixer (GstElement * element, GstElement * mixer)
{
GstPad *sinkpad = gst_element_get_request_pad (mixer, "sink_%u");
GstPad *srcpad = gst_element_get_static_pad (element, "src");
gst_pad_link_full (srcpad, sinkpad, GST_PAD_LINK_CHECK_NOTHING);
gst_object_unref (srcpad);
return G_OBJECT (sinkpad);
}
static void
link_sinks (GstElement * mpegtsmux,
GstPad ** src1, GstPad ** src2, GstPad ** src3, TestData * test_data)
{
GstPad *mux_sink1, *mux_sink2, *mux_sink3;
GstCaps *caps;
/* link 3 sink pads, 2 video 1 audio */
*src1 = gst_pad_new_from_static_template (&video_src_template, "src1");
gst_pad_set_active (*src1, TRUE);
gst_pad_set_element_private (*src1, test_data);
gst_pad_set_event_function (*src1, src_event);
mux_sink1 = gst_element_get_request_pad (mpegtsmux, "sink_1");
fail_unless (gst_pad_link (*src1, mux_sink1) == GST_PAD_LINK_OK);
*src2 = gst_pad_new_from_static_template (&video_src_template, "src2");
gst_pad_set_active (*src2, TRUE);
gst_pad_set_element_private (*src2, test_data);
gst_pad_set_event_function (*src2, src_event);
mux_sink2 = gst_element_get_request_pad (mpegtsmux, "sink_2");
fail_unless (gst_pad_link (*src2, mux_sink2) == GST_PAD_LINK_OK);
*src3 = gst_pad_new_from_static_template (&audio_src_template, "src3");
gst_pad_set_active (*src3, TRUE);
gst_pad_set_element_private (*src3, test_data);
gst_pad_set_event_function (*src3, src_event);
mux_sink3 = gst_element_get_request_pad (mpegtsmux, "sink_3");
fail_unless (gst_pad_link (*src3, mux_sink3) == GST_PAD_LINK_OK);
caps = gst_caps_new_simple ("video/x-h264", NULL);
gst_pad_set_caps (mux_sink1, caps);
gst_pad_set_caps (mux_sink2, caps);
gst_caps_unref (caps);
caps = gst_caps_new_simple ("audio/mpeg", "mpegversion", G_TYPE_INT, 4, NULL);
gst_pad_set_caps (mux_sink3, caps);
gst_caps_unref (caps);
gst_object_unref (mux_sink1);
gst_object_unref (mux_sink2);
gst_object_unref (mux_sink3);
}
static gboolean
reconnect_elements (gpointer data)
{
ElementsData *elements = data;
GstPad *pad = gst_element_get_request_pad (elements->agnosticbin, "src_%u");
gst_element_link_pads (elements->agnosticbin, GST_OBJECT_NAME (pad),
elements->fakesink, NULL);
g_object_unref (pad);
return FALSE;
}
static void
connect_pads_and_remove_on_unlinked (GstElement * agnosticbin,
GstElement * elem, const gchar * sink_name)
{
GstPad *src;
src = gst_element_get_request_pad (agnosticbin, "src_%u");
g_assert (src != NULL);
g_signal_connect (src, "unlinked", G_CALLBACK (remove_on_unlinked), NULL);
gst_element_link_pads (agnosticbin, GST_OBJECT_NAME (src), elem, sink_name);
g_object_unref (src);
}
GST_END_TEST static void
cb_new_pad (GstElement * element, GstPad * pad, gpointer data)
{
GstPad *sink_pad;
GstElement *endpoint;
endpoint = GST_ELEMENT (data);
sink_pad = gst_element_get_request_pad (endpoint, "video_sink");
gst_pad_link (pad, sink_pad);
gst_object_unref (GST_OBJECT (sink_pad));
}
GST_END_TEST
GST_START_TEST (create_test)
{
GstElement *agnosticbin = gst_element_factory_make ("agnosticbin", NULL);
GstPad *pad;
pad = gst_element_get_request_pad (agnosticbin, "src_%u");
GST_DEBUG_OBJECT (pad, "Pad created");
gst_element_release_request_pad (agnosticbin, pad);
g_object_unref (agnosticbin);
}