static void
mixer_pad_added (KmsBaseHub * mixer, GstPad * pad, gpointer data)
{
if (gst_pad_get_direction (pad) != GST_PAD_SRC) {
return;
}
KMS_BASE_HUB_LOCK (mixer);
if (g_str_has_prefix (GST_OBJECT_NAME (pad), VIDEO_SRC_PAD_PREFIX)) {
KmsBaseHubPortData *port;
gint64 id;
const gchar *pad_name;
pad_name = GST_OBJECT_NAME (pad);
id = g_ascii_strtoll (pad_name + LENGTH_VIDEO_SRC_PAD_PREFIX, NULL, 10);
port = g_hash_table_lookup (mixer->priv->ports, &id);
gst_element_link_pads (GST_ELEMENT (mixer), GST_OBJECT_NAME (pad),
port->port, "mixer_video_sink");
} else if (g_str_has_prefix (GST_OBJECT_NAME (pad), AUDIO_SRC_PAD_PREFIX)) {
KmsBaseHubPortData *port;
gint64 id;
const gchar *pad_name;
pad_name = GST_OBJECT_NAME (pad);
id = g_ascii_strtoll (pad_name + LENGTH_AUDIO_SRC_PAD_PREFIX, NULL, 10);
port = g_hash_table_lookup (mixer->priv->ports, &id);
gst_element_link_pads (GST_ELEMENT (mixer), GST_OBJECT_NAME (pad),
port->port, "mixer_audio_sink");
}
KMS_BASE_HUB_UNLOCK (mixer);
}
int
main (int argc,
char *argv[])
{
GstElement *bin, *rtpbin, *encoder, *payloader;
GMainLoop *loop;
gst_init (&argc, &argv);
loop = g_main_loop_new(NULL, FALSE);
bin = gst_pipeline_new("pipe");
fprintf(stderr,"bin: %p\n",bin);
if (argc != 3)
{
printf("Usage : gsmsend [rtcplocalport-1] [destaddr:port]\n");
return 0;
}
int port = atoi (argv[1]);
char *addr = argv[2];
// first we create our rtpbin object
rtpbin = gst_element_factory_make("rtpbin", "rtpbin");
fprintf(stderr,"rtpbin: %p\n",rtpbin);
g_object_set(G_OBJECT(rtpbin), "destinations", addr, NULL);
g_object_set(G_OBJECT(rtpbin), "rtcp-support", TRUE, NULL);
g_object_set(G_OBJECT(rtpbin), "localport", port, NULL);
// then our encoder/payloader
encoder = gst_element_factory_make("gsmenc", "gsmenc");
payloader = gst_element_factory_make("rtpgsmpay", "rtpgsmpay");
// add both to the piepline and link them
gst_bin_add_many(GST_BIN(bin), rtpbin, encoder, payloader, NULL);
gst_element_link_pads(encoder, "src", payloader, "sink");
gst_element_link_pads(payloader, "src", rtpbin, "sink%d");
// our videotestsrc and link it to the encoder
GstElement *testsrc = gst_element_factory_make("alsasrc", "alsasrc");
g_object_set(G_OBJECT(testsrc), "blocksize", 320, NULL);
gst_bin_add_many(GST_BIN(bin), testsrc, NULL);
gst_element_link_pads(testsrc, "src", encoder, "sink");
// let's start playing
gst_element_set_state (bin, GST_STATE_PLAYING);
//gst_debug_set_threshold_for_name ("rtpbin", 1);
//gst_debug_set_threshold_for_name ("rtpsend", 5);
//gst_debug_set_threshold_for_name ("*pad*", 5);
g_main_loop_run(loop);
return 0;
}
GST_END_TEST
GST_START_TEST (connect_sinks)
{
GstBin *pipe = (GstBin *) gst_pipeline_new ("connect_sinks");
GstElement *mixerport = gst_element_factory_make ("mixerport", NULL);
GstElement *videosrc = gst_element_factory_make ("videotestsrc", NULL);
GstElement *audiosrc = gst_element_factory_make ("audiotestsrc", NULL);
GstElement *valve0, *valve1;
gboolean drop;
gst_bin_add_many (pipe, mixerport, videosrc, audiosrc, NULL);
g_signal_connect (mixerport, "pad-added",
G_CALLBACK (connect_sinks_pad_added), pipe);
gst_element_link_pads (videosrc, "src", mixerport, "video_sink");
gst_element_link_pads (audiosrc, "src", mixerport, "audio_sink");
/* Check if valves have been opened because of fakesink link */
valve0 = gst_bin_get_by_name (GST_BIN (mixerport), "valve0");
fail_unless (valve0 != NULL);
GST_DEBUG ("Got valve: %" GST_PTR_FORMAT, valve0);
drop = TRUE;
g_object_get (G_OBJECT (valve0), "drop", &drop, NULL);
fail_unless (drop == FALSE);
GST_DEBUG ("Drop value: %d", drop);
valve1 = gst_bin_get_by_name (GST_BIN (mixerport), "valve1");
fail_unless (valve1 != NULL);
GST_DEBUG ("Got valve: %" GST_PTR_FORMAT, valve1);
drop = TRUE;
g_object_get (G_OBJECT (valve1), "drop", &drop, NULL);
fail_unless (drop == FALSE);
GST_DEBUG ("Drop value: %d", drop);
/* Now check that valves are closed when mixer_src pads are unlinked */
unlink_src_pad (mixerport, "mixer_video_src");
unlink_src_pad (mixerport, "mixer_audio_src");
drop = FALSE;
g_object_get (G_OBJECT (valve0), "drop", &drop, NULL);
fail_unless (drop == TRUE);
GST_DEBUG_OBJECT (valve0, "Drop value: %d", drop);
drop = FALSE;
g_object_get (G_OBJECT (valve1), "drop", &drop, NULL);
fail_unless (drop == TRUE);
GST_DEBUG_OBJECT (valve0, "Drop value: %d", drop);
g_object_unref (valve0);
g_object_unref (valve1);
g_object_unref (pipe);
}
static void
type_found (GstElement * typefind, guint probability,
GstCaps * caps, GstSplitMuxPartReader * reader)
{
GstElement *demux;
GST_INFO_OBJECT (reader, "Got type %" GST_PTR_FORMAT, caps);
/* typefind found a type. Look for the demuxer to handle it */
demux = reader->demux = find_demuxer (caps);
if (reader->demux == NULL) {
GST_ERROR_OBJECT (reader, "Failed to create demuxer element");
return;
}
/* Connect to demux signals */
g_signal_connect (demux,
"pad-added", G_CALLBACK (new_decoded_pad_added_cb), reader);
g_signal_connect (demux, "no-more-pads", G_CALLBACK (no_more_pads), reader);
gst_element_set_locked_state (demux, TRUE);
gst_bin_add (GST_BIN_CAST (reader), demux);
gst_element_link_pads (reader->typefind, "src", demux, NULL);
gst_element_set_state (reader->demux, GST_STATE_TARGET (reader));
gst_element_set_locked_state (demux, FALSE);
}
static void
connect_sink (GstElement * element, GstPad * pad, gpointer user_data)
{
KmsConnectData *data = user_data;
GST_DEBUG_OBJECT (pad, "New pad %" GST_PTR_FORMAT, element);
if (!g_str_has_prefix (GST_OBJECT_NAME (pad), data->pad_prefix)) {
return;
}
gst_bin_add_many (GST_BIN (data->pipe), data->src, data->enc, NULL);
if (data->caps != NULL) {
gst_bin_add (GST_BIN (data->pipe), data->caps);
gst_element_link_many (data->src, data->caps, data->enc, NULL);
} else {
gst_element_link_many (data->src, data->enc, NULL);
}
gst_element_link_pads (data->enc, NULL, element, GST_OBJECT_NAME (pad));
gst_element_sync_state_with_parent (data->enc);
if (data->caps != NULL) {
gst_element_sync_state_with_parent (data->caps);
}
gst_element_sync_state_with_parent (data->src);
GST_INFO_OBJECT (pad, "Linking %s", data->pad_prefix);
if (data->id != 0) {
g_signal_handler_disconnect (element, data->id);
}
}
static void
gst_gl_mixer_bin_init (GstGLMixerBin * self)
{
gboolean res = TRUE;
GstPad *pad;
self->priv = GST_GL_MIXER_BIN_GET_PRIVATE (self);
self->out_convert = gst_element_factory_make ("glcolorconvert", NULL);
self->download = gst_element_factory_make ("gldownload", NULL);
res &= gst_bin_add (GST_BIN (self), self->out_convert);
res &= gst_bin_add (GST_BIN (self), self->download);
res &=
gst_element_link_pads (self->out_convert, "src", self->download, "sink");
pad = gst_element_get_static_pad (self->download, "src");
if (!pad) {
res = FALSE;
} else {
GST_DEBUG_OBJECT (self, "setting target src pad %" GST_PTR_FORMAT, pad);
self->srcpad = gst_ghost_pad_new ("src", pad);
gst_element_add_pad (GST_ELEMENT_CAST (self), self->srcpad);
gst_object_unref (pad);
}
if (!res)
GST_ERROR_OBJECT (self, "failed to create output chain");
}
int
main (int argc,
char *argv[])
{
GstElement *pipeline, *source, *demux;
GMainLoop *loop;
/* init */
gst_init (&argc, &argv);
/* create elements */
pipeline = gst_pipeline_new ("my_pipeline");
source = gst_element_factory_make ("filesrc", "source");
g_object_set (source, "location", argv[1], NULL);
demux = gst_element_factory_make ("oggdemux", "demuxer");
/* you would normally check that the elements were created properly */
/* put together a pipeline */
gst_bin_add_many (GST_BIN (pipeline), source, demux, NULL);
gst_element_link_pads (source, "src", demux, "sink");
/* listen for newly created pads */
g_signal_connect (demux, "pad-added", G_CALLBACK (cb_new_pad), NULL);
/* start the pipeline */
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_PLAYING);
loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (loop);
return 0;
/*** block d from ../../../docs/manual/basics-pads.xml ***/
}
int
main (int argc, char *argv[])
{
TestPipeline *pipeline = test_pipeline_new (argc, argv);
if (!pipeline) {
return 1;
}
g_object_set (pipeline->src, "mode", 2, NULL);
GstElement *filesink = gst_element_factory_make ("filesink", NULL);
gst_element_set_locked_state (filesink, TRUE);
g_object_set (filesink, "location", "foo.yuv", NULL);
gst_bin_add (GST_BIN (pipeline->pipeline), filesink);
if (!gst_element_link_pads (pipeline->src, "vidsrc", filesink, "sink")) {
g_printerr ("Failed to link filesink");
return 1;
}
GstPad *pad = gst_element_get_static_pad (pipeline->src, "vidsrc");
gst_pad_add_data_probe (pad, G_CALLBACK (vidsrc_data_probe), filesink);
gst_object_unref (pad);
g_timeout_add (5000, start_video_capture, pipeline);
g_timeout_add (10000, stop_video_capture, pipeline);
return test_pipeline_exec (pipeline, 11000);
}
bool MediaNode::linkMediaNodeList(QList<QObject *> &list, GstElement *bin, GstElement *tee, GstElement *fakesink, GstElement *src)
{
if (!GST_ELEMENT_PARENT(tee)) {
gst_bin_add(GST_BIN(bin), tee);
if (!gst_element_link_pads(src, "src", tee, "sink"))
return false;
gst_element_set_state(tee, GST_STATE(bin));
}
if (list.isEmpty()) {
//connect node to a fake sink to avoid clogging the pipeline
if (!connectToFakeSink(tee, fakesink, bin))
return false;
} else {
// Remove fake sink if previously connected
if (!releaseFakeSinkIfConnected(tee, fakesink, bin))
return false;
for (int i = 0 ; i < list.size() ; ++i) {
QObject *sink = list[i];
if (MediaNode *output = qobject_cast<MediaNode*>(sink)) {
if (!addOutput(output, tee))
return false;
}
}
}
return true;
}
// setups audio visualization
// a modified version of totem's bacon video widget
static void
setup_vis (gstPlay *play)
{
if (play->xid == 0)
return;
GstElement *vis_bin = NULL;
GstElement *vis_element = NULL;
GstElement *vis_capsfilter = NULL;
GstPad *pad = NULL;
GstElementFactory *fac = NULL;
fac = setup_vis_find_factory (play->vis_name);
if (fac == NULL)
goto beach; //cant find the visualisation
vis_element = gst_element_factory_create (fac, "vis_element");
if (!GST_IS_ELEMENT (vis_element))
goto beach; //cant create visualisation element
vis_capsfilter = gst_element_factory_make ("capsfilter", "vis_capsfilter");
if (!GST_IS_ELEMENT (vis_capsfilter))
{
gst_object_unref (vis_element);
goto beach; //cant create visualisation capsfilter element
}
vis_bin = gst_bin_new ("vis_bin");
if (!GST_IS_ELEMENT (vis_bin))
{
gst_object_unref (vis_element);
gst_object_unref (vis_capsfilter);
goto beach; //cant create visualisation bin
}
gst_bin_add_many (GST_BIN (vis_bin), vis_element, vis_capsfilter, NULL);
// sink ghostpad
pad = gst_element_get_static_pad (vis_element, "sink");
gst_element_add_pad (vis_bin, gst_ghost_pad_new ("sink", pad));
gst_object_unref (pad);
// source ghostpad, link with vis_element
pad = gst_element_get_static_pad (vis_capsfilter, "src");
gst_element_add_pad (vis_bin, gst_ghost_pad_new ("src", pad));
gst_element_link_pads (vis_element, "src", vis_capsfilter, "sink");
gst_object_unref (pad);
beach:
g_object_set (play->element, "vis-plugin", vis_bin, NULL);
return;
}
static gboolean
connect_output_sink (gpointer data)
{
GstElement *pipeline = data;
GstElement *rtpendpointreceiver = gst_bin_get_by_name (GST_BIN (pipeline),
"receiver");
GstElement *outputfakesink = gst_element_factory_make ("fakesink", NULL);
GMainLoop *loop = g_object_get_data (G_OBJECT (pipeline), "loop");
GstElement *agnosticbin = gst_bin_get_by_name (GST_BIN (pipeline),
"agnosticbin");
GstElement *rtpendpointsender = gst_bin_get_by_name (GST_BIN (pipeline),
"sender");
gst_element_link_pads (agnosticbin, NULL, rtpendpointsender, "video_sink");
g_object_unref (agnosticbin);
g_object_unref (rtpendpointsender);
g_object_set (G_OBJECT (outputfakesink), "signal-handoffs", TRUE, NULL);
g_signal_connect (G_OBJECT (outputfakesink), "handoff",
G_CALLBACK (fakesink_hand_off), loop);
gst_bin_add (GST_BIN (pipeline), outputfakesink);
gst_element_sync_state_with_parent (outputfakesink);
kms_element_link_pads (rtpendpointreceiver, "video_src_%u", outputfakesink,
"sink");
g_object_unref (rtpendpointreceiver);
return FALSE;
}
static void
connect_sink_async (GstElement * passthrough, GstElement * src,
GstElement * pipe, const gchar * pad_prefix)
{
GstPad *pad = gst_element_get_static_pad (passthrough, pad_prefix);
if (pad) {
gst_bin_add (GST_BIN (pipe), src);
gst_element_link_pads (src, NULL, passthrough, pad_prefix);
gst_element_sync_state_with_parent (src);
g_object_unref (pad);
} else {
KmsConnectData *data = g_slice_new (KmsConnectData);
data->src = src;
data->pipe = GST_BIN (pipe);
data->pad_prefix = pad_prefix;
data->id =
g_signal_connect_data (passthrough, "pad-added",
G_CALLBACK (connect_sink), data,
(GClosureNotify) kms_connect_data_destroy, 0);
}
}
static void
gst_gl_src_bin_init (GstGLSrcBin * self)
{
gboolean res = TRUE;
GstPad *pad;
self->download = gst_element_factory_make ("gldownload", NULL);
self->convert = gst_element_factory_make ("glcolorconvert", NULL);
res &= gst_bin_add (GST_BIN (self), self->download);
res &= gst_bin_add (GST_BIN (self), self->convert);
res &= gst_element_link_pads (self->convert, "src", self->download, "sink");
pad = gst_element_get_static_pad (self->download, "src");
if (!pad) {
res = FALSE;
} else {
GST_DEBUG_OBJECT (self, "setting target src pad %" GST_PTR_FORMAT, pad);
self->srcpad = gst_ghost_pad_new ("src", pad);
gst_element_add_pad (GST_ELEMENT_CAST (self), self->srcpad);
gst_object_unref (pad);
}
if (!res) {
GST_WARNING_OBJECT (self, "Failed to add/connect the necessary machinery");
}
}
static GstPadProbeReturn
link_to_tee (GstPad * pad, GstPadProbeInfo * info, gpointer queue)
{
GstElement *tee;
if (gst_pad_is_linked (pad)) {
return GST_PAD_PROBE_PASS;
}
GST_OBJECT_LOCK (pad);
if (g_object_get_data (G_OBJECT (pad), "linking")) {
GST_OBJECT_UNLOCK (pad);
return GST_PAD_PROBE_PASS;
}
g_object_set_data (G_OBJECT (pad), "linking", GINT_TO_POINTER (TRUE));
GST_OBJECT_UNLOCK (pad);
tee = gst_pad_get_parent_element (pad);
if (tee == NULL) {
return GST_PAD_PROBE_PASS;
}
gst_element_link_pads (tee, GST_OBJECT_NAME (pad), queue, NULL);
g_object_unref (tee);
return GST_PAD_PROBE_REMOVE;
}
static gboolean
timer_cb (gpointer data)
{
/* Agnostic bin might be now ready to go to Playing state */
GST_INFO ("Connecting appsink to receive buffers");
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (test_pipeline),
GST_DEBUG_GRAPH_SHOW_ALL, "timer_dot");
fakesink = gst_element_factory_make ("fakesink", NULL);
gst_bin_add (GST_BIN (test_pipeline), fakesink);
gst_element_set_state (fakesink, GST_STATE_PLAYING);
gst_element_set_state (httpep, GST_STATE_PLAYING);
gst_element_link_pads (httpep, "video_src_%u", fakesink, "sink");
/* Start getting data from Internet */
gst_element_set_state (src_pipeline, GST_STATE_PLAYING);
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (src_pipeline),
GST_DEBUG_GRAPH_SHOW_ALL, "src_getting_data");
return FALSE;
}
static GstElement *
setup_vp8dec (const gchar * src_caps_str)
{
GstElement *bin;
GstElement *vp8enc, *vp8dec;
GstCaps *srccaps = NULL;
GstBus *bus;
GstPad *ghostpad, *targetpad;
if (src_caps_str) {
srccaps = gst_caps_from_string (src_caps_str);
fail_unless (srccaps != NULL);
}
bin = gst_bin_new ("bin");
vp8enc = gst_check_setup_element ("vp8enc");
fail_unless (vp8enc != NULL);
vp8dec = gst_check_setup_element ("vp8dec");
fail_unless (vp8dec != NULL);
g_object_set (vp8enc, "name", "encoder", NULL);
g_object_set (vp8dec, "name", "decoder", NULL);
gst_bin_add_many (GST_BIN (bin), vp8enc, vp8dec, NULL);
fail_unless (gst_element_link_pads (vp8enc, "src", vp8dec, "sink"));
targetpad = gst_element_get_static_pad (vp8enc, "sink");
fail_unless (targetpad != NULL);
ghostpad = gst_ghost_pad_new ("sink", targetpad);
fail_unless (ghostpad != NULL);
gst_element_add_pad (bin, ghostpad);
gst_object_unref (targetpad);
targetpad = gst_element_get_static_pad (vp8dec, "src");
fail_unless (targetpad != NULL);
ghostpad = gst_ghost_pad_new ("src", targetpad);
fail_unless (ghostpad != NULL);
gst_element_add_pad (bin, ghostpad);
gst_object_unref (targetpad);
srcpad = gst_check_setup_src_pad (bin, &srctemplate);
sinkpad = gst_check_setup_sink_pad (bin, &sinktemplate);
gst_pad_set_active (srcpad, TRUE);
gst_pad_set_active (sinkpad, TRUE);
gst_check_setup_events (srcpad, bin, srccaps, GST_FORMAT_TIME);
bus = gst_bus_new ();
gst_element_set_bus (bin, bus);
fail_unless (gst_element_set_state (bin,
GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE,
"could not set to playing");
if (srccaps)
gst_caps_unref (srccaps);
buffers = NULL;
return bin;
}
static gboolean
_create_input_chain (GstGLMixerBin * self, struct input_chain *chain,
GstPad * mixer_pad)
{
GstGLMixerBinClass *klass = GST_GL_MIXER_BIN_GET_CLASS (self);
GstPad *pad;
gboolean res = TRUE;
gchar *name;
chain->self = self;
chain->mixer_pad = mixer_pad;
chain->upload = gst_element_factory_make ("glupload", NULL);
chain->in_convert = gst_element_factory_make ("glcolorconvert", NULL);
res &= gst_bin_add (GST_BIN (self), chain->in_convert);
res &= gst_bin_add (GST_BIN (self), chain->upload);
pad = gst_element_get_static_pad (chain->in_convert, "src");
if (gst_pad_link (pad, mixer_pad) != GST_PAD_LINK_OK) {
gst_object_unref (pad);
return FALSE;
}
gst_object_unref (pad);
res &=
gst_element_link_pads (chain->upload, "src", chain->in_convert, "sink");
pad = gst_element_get_static_pad (chain->upload, "sink");
if (!pad) {
return FALSE;
} else {
GST_DEBUG_OBJECT (self, "setting target sink pad %" GST_PTR_FORMAT, pad);
name = gst_object_get_name (GST_OBJECT (mixer_pad));
if (klass->create_input_pad) {
chain->ghost_pad = klass->create_input_pad (self, chain->mixer_pad);
gst_object_set_name (GST_OBJECT (chain->ghost_pad), name);
gst_ghost_pad_set_target (chain->ghost_pad, pad);
} else {
chain->ghost_pad =
GST_GHOST_PAD (gst_ghost_pad_new (GST_PAD_NAME (chain->mixer_pad),
pad));
}
g_free (name);
GST_OBJECT_LOCK (self);
if (self->priv->running)
gst_pad_set_active (GST_PAD (chain->ghost_pad), TRUE);
GST_OBJECT_UNLOCK (self);
gst_element_add_pad (GST_ELEMENT_CAST (self), GST_PAD (chain->ghost_pad));
gst_object_unref (pad);
}
gst_element_sync_state_with_parent (chain->upload);
gst_element_sync_state_with_parent (chain->in_convert);
return TRUE;
}
/* Create an encoder element.
* We make a bin containing:
*
* audioresample ! <enccaps> ! identity
*
* The sinkpad of audioresample and source pad of identity are ghosted on the
* bin.
*/
static GstElement *
make_encoder (const GstCaps * caps)
{
GstElement *result;
GstElement *audioresample;
GstElement *capsfilter;
GstElement *identity;
GstPad *pad;
/* create result bin */
result = gst_bin_new (NULL);
g_assert (result);
/* create elements */
audioresample = gst_element_factory_make ("audioresample", NULL);
g_assert (audioresample);
capsfilter = gst_element_factory_make ("capsfilter", NULL);
g_assert (capsfilter);
g_object_set (capsfilter, "caps", caps, NULL);
identity = gst_element_factory_make ("identity", NULL);
g_assert (identity);
g_object_set (identity, "silent", TRUE, NULL);
/* add elements to result bin */
gst_bin_add (GST_BIN (result), audioresample);
gst_bin_add (GST_BIN (result), capsfilter);
gst_bin_add (GST_BIN (result), identity);
/* link elements */
gst_element_link_pads (audioresample, "src", capsfilter, "sink");
gst_element_link_pads (capsfilter, "src", identity, "sink");
/* ghost src and sink pads */
pad = gst_element_get_static_pad (audioresample, "sink");
gst_element_add_pad (result, gst_ghost_pad_new ("sink", pad));
gst_object_unref (pad);
pad = gst_element_get_static_pad (identity, "src");
gst_element_add_pad (result, gst_ghost_pad_new ("src", pad));
gst_object_unref (pad);
return result;
}
/*
* Method: link_pads(source_pad_name, element, destination_pad_name)
* element: a Gst::Element.
*
* Links the source_pad_name pad of the current element to the
* destination_pad_name pad of the destination element, returning
* true on success.
*
* Returns: true on success, false on failure.
*/
static VALUE
rg_link_pads(VALUE self, VALUE source_pad_name,
VALUE other_element, VALUE destination_pad_name)
{
return CBOOL2RVAL(gst_element_link_pads(SELF(self),
RVAL2CSTR(source_pad_name),
SELF(other_element),
RVAL2CSTR(destination_pad_name)));
}
static void
add_pad(GstElement *element , GstPad *pad , gpointer data)
{
gchar *name;
GstElement *sink = (GstElement*)data;
name = gst_pad_get_name(pad);
gst_element_link_pads(element, name, sink, "sink");
g_free(name);
}
/*
gboolean intro_eos_callback(GstPad *pad,
GstObject *parent,
GstEvent *event)
{
GstEvent *seek_event;
GstElement *bkgdec;
GValue v=G_VALUE_INIT;
GstPad *srcpad;
GstIterator *srcpads;
gboolean result;
g_print("Introbin received EOS. ...\n");
bkgdec=gst_pad_get_parent_element(pad);
if(bkgdec->numsrcpads>0) {
srcpads=gst_element_iterate_src_pads(bkgdec);
gst_iterator_next(srcpads,&v);
srcpad=GST_PAD(g_value_get_object(&v));
seek_event=gst_event_new_seek ( 1.0, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH,
GST_SEEK_TYPE_SET, 0,
GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
result=gst_pad_send_event(srcpad,seek_event);
if(result==TRUE) {
g_print("seek event sent OK.\n");
} else {
g_print("seek sent FAILED.\n");
}
g_value_reset(&v);
g_value_unset(&v);
gst_iterator_free(srcpads);
return TRUE;
}
return gst_pad_event_default(pad,parent,event);
}
*/
int play_intro(gpointer app)
{
CustomData *d=(CustomData*)app;
GstElement *mixer=gst_bin_get_by_name(GST_BIN(d->pipeline),"mixer1");
GstElement *vvalve=gst_bin_get_by_name(GST_BIN(d->introbin),"introvvalve");
GstElement *avalve=gst_bin_get_by_name(GST_BIN(d->introbin),"introavalve");
gst_bin_add_many(GST_BIN(d->pipeline),d->introbin,NULL);
gst_element_link_pads(d->introbin,"vsrc",mixer,NULL);
gst_element_link_pads(d->introbin,"asrc",d->adder,NULL);
g_object_set(G_OBJECT(vvalve),"drop",FALSE,NULL);
g_object_set(G_OBJECT(avalve),"drop",FALSE,NULL);
gst_element_set_state(d->introbin,GST_STATE_PAUSED);
g_object_unref(mixer);
g_object_unref(vvalve);
g_object_unref(avalve);
return 0;
}
void KGSTWavPlayer::add_pad(GstElement *element , GstPad *pad , gpointer data)
{
gchar *name;
GstElement *sink =(GstElement*)data;
name = gst_pad_get_name(pad);
gst_element_link_pads(element , name , sink , "sink");
//gst_element_link_pads(element , name , sink , "volume");
g_free(name);
}
static void
kms_muxing_pipeline_prepare_pipeline (KmsMuxingPipeline * self)
{
self->priv->pipeline = gst_pipeline_new (KMS_MUXING_PIPELINE_NAME);
self->priv->videosrc = gst_element_factory_make ("appsrc", "videoSrc");
self->priv->audiosrc = gst_element_factory_make ("appsrc", "audioSrc");
self->priv->encodebin = gst_element_factory_make ("encodebin", NULL);
kms_muxing_pipeline_add_injector_probe (self, self->priv->videosrc);
kms_muxing_pipeline_add_injector_probe (self, self->priv->audiosrc);
kms_muxing_pipeline_configure (self);
gst_bin_add_many (GST_BIN (self->priv->pipeline), self->priv->videosrc,
self->priv->audiosrc, self->priv->encodebin, self->priv->sink, NULL);
if (!gst_element_link (self->priv->encodebin, self->priv->sink)) {
GST_ERROR_OBJECT (self, "Could not link elements: %"
GST_PTR_FORMAT ", %" GST_PTR_FORMAT,
self->priv->encodebin, self->priv->sink);
}
if (kms_recording_profile_supports_type (self->priv->profile,
KMS_ELEMENT_PAD_TYPE_VIDEO)) {
if (!gst_element_link_pads (self->priv->videosrc, "src",
self->priv->encodebin, "video_%u")) {
GST_ERROR_OBJECT (self,
"Could not link elements: %" GST_PTR_FORMAT ", %" GST_PTR_FORMAT,
self->priv->videosrc, self->priv->encodebin);
}
}
if (kms_recording_profile_supports_type (self->priv->profile,
KMS_ELEMENT_PAD_TYPE_AUDIO)) {
if (!gst_element_link_pads (self->priv->audiosrc, "src",
self->priv->encodebin, "audio_%u")) {
GST_ERROR_OBJECT (self,
"Could not link elements: %" GST_PTR_FORMAT ", %" GST_PTR_FORMAT,
self->priv->audiosrc, self->priv->encodebin);
}
}
}
static void
kms_base_rtp_session_add_bundle_connection (KmsBaseRtpSession * self,
KmsIRtpConnection * conn, SdpMediaConfig * mconf, gboolean active)
{
gboolean added;
GstElement *ssrcdemux;
GstElement *rtcpdemux; /* FIXME: Useful for local and remote ssrcs mapping */
GstPad *src, *sink;
if (GPOINTER_TO_UINT (g_object_get_qdata (G_OBJECT (conn),
bundle_conn_added_quark ()))) {
GST_DEBUG_OBJECT (self, "Connection configured");
return;
}
g_object_set_qdata (G_OBJECT (conn), bundle_conn_added_quark (),
GUINT_TO_POINTER (TRUE));
g_object_get (conn, "added", &added, NULL);
if (!added) {
kms_i_rtp_connection_add (conn, GST_BIN (self), active);
}
ssrcdemux = gst_element_factory_make ("rtpssrcdemux", NULL);
rtcpdemux = gst_element_factory_make ("rtcpdemux", NULL);
g_object_set_qdata_full (G_OBJECT (ssrcdemux), rtcp_demux_peer_quark (),
g_object_ref (rtcpdemux), g_object_unref);
g_signal_connect (ssrcdemux, "new-ssrc-pad",
G_CALLBACK (rtp_ssrc_demux_new_ssrc_pad), self);
kms_i_rtp_connection_sink_sync_state_with_parent (conn);
gst_bin_add_many (GST_BIN (self), ssrcdemux, rtcpdemux, NULL);
/* RTP */
src = kms_i_rtp_connection_request_rtp_src (conn);
sink = gst_element_get_static_pad (ssrcdemux, "sink");
kms_base_rtp_session_link_pads (src, sink);
g_object_unref (src);
g_object_unref (sink);
/* RTCP */
src = kms_i_rtp_connection_request_rtcp_src (conn);
sink = gst_element_get_static_pad (rtcpdemux, "sink");
kms_base_rtp_session_link_pads (src, sink);
g_object_unref (src);
g_object_unref (sink);
gst_element_link_pads (rtcpdemux, "rtcp_src", ssrcdemux, "rtcp_sink");
gst_element_sync_state_with_parent_target_state (ssrcdemux);
gst_element_sync_state_with_parent_target_state (rtcpdemux);
kms_i_rtp_connection_src_sync_state_with_parent (conn);
}
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);
}
static void
gst_gl_sink_bin_init (GstGLSinkBin * self)
{
gboolean res = TRUE;
GstPad *pad;
self->upload = gst_element_factory_make ("glupload", NULL);
self->convert = gst_element_factory_make ("glcolorconvert", NULL);
self->balance = gst_element_factory_make ("glcolorbalance", NULL);
res &= gst_bin_add (GST_BIN (self), self->upload);
res &= gst_bin_add (GST_BIN (self), self->convert);
res &= gst_bin_add (GST_BIN (self), self->balance);
res &= gst_element_link_pads (self->upload, "src", self->convert, "sink");
res &= gst_element_link_pads (self->convert, "src", self->balance, "sink");
pad = gst_element_get_static_pad (self->upload, "sink");
if (!pad) {
res = FALSE;
} else {
GST_DEBUG_OBJECT (self, "setting target sink pad %" GST_PTR_FORMAT, pad);
self->sinkpad = gst_ghost_pad_new ("sink", pad);
gst_element_add_pad (GST_ELEMENT_CAST (self), self->sinkpad);
gst_object_unref (pad);
}
gst_gl_object_add_control_binding_proxy (GST_OBJECT (self->balance),
GST_OBJECT (self), "contrast");
gst_gl_object_add_control_binding_proxy (GST_OBJECT (self->balance),
GST_OBJECT (self), "brightness");
gst_gl_object_add_control_binding_proxy (GST_OBJECT (self->balance),
GST_OBJECT (self), "hue");
gst_gl_object_add_control_binding_proxy (GST_OBJECT (self->balance),
GST_OBJECT (self), "saturation");
if (!res) {
GST_WARNING_OBJECT (self, "Failed to add/connect the necessary machinery");
}
}
static void
connect_sink_on_srcpad_added (GstElement * playerep, GstPad * new_pad,
gpointer user_data)
{
gchar *padname;
gboolean ret;
GST_INFO_OBJECT (playerep, "Pad added %" GST_PTR_FORMAT, new_pad);
padname = gst_pad_get_name (new_pad);
fail_if (padname == NULL);
if (g_str_has_prefix (padname, KMS_VIDEO_PREFIX)) {
ret = gst_element_link_pads (playerep, padname, filter, "sink");
fail_if (ret == FALSE);
ret = gst_element_link (filter, fakesink_video);
fail_if (ret == FALSE);
} else if (g_str_has_prefix (padname, KMS_AUDIO_PREFIX)) {
ret = gst_element_link_pads (playerep, padname, fakesink_audio, "sink");
fail_if (ret == FALSE);
}
g_free (padname);
}
video_server_t * video_server_create(config_t *conf)
{
video_server_t * server = (video_server_t *)malloc(sizeof(video_server_t));
/* Create gstreamer elements */
server->pipeline = gst_pipeline_new("bonecam-video");
create_input_source(server, conf);
create_h264_caps(server, conf);
server->vqueue = gst_element_factory_make("queue", "video-queue");
server->parser = gst_element_factory_make("h264parse", "video-parser");
server->payloader = gst_element_factory_make("rtph264pay", "video-rtppay");
create_udp_sink(server, conf);
if (!server->pipeline || !server->source || !server->parser ||
!server->vqueue || !server->payloader || !server->udpsink)
{
fprintf(stderr, "%s: At least one element could not be created.\n",
__func__);
}
/* Add elements to pipeline */
gst_bin_add_many(GST_BIN(server->pipeline),
server->source, server->vqueue, server->parser,
server->payloader, server->udpsink, NULL);
/* Link elements */
gst_element_link_pads(server->source, "vidsrc", server->vqueue, "sink");
if (!gst_element_link_filtered(server->vqueue,
server->parser,
server->h264caps))
{
fprintf(stderr, "%s: Failed to link elements\n", __func__);
}
gst_caps_unref(server->h264caps);
if (!gst_element_link_many(server->parser, server->payloader,
server->udpsink, NULL))
fprintf(stderr, "%s: Failed to link elements\n", __func__);
/* keep reference to config */
server->conf = conf;
return server;
}
static gboolean
gst_face_overlay_create_children (GstFaceOverlay * filter)
{
gboolean ret = TRUE;
if ((filter->colorspace = gst_element_factory_make ("ffmpegcolorspace",
NULL)) == NULL) {
return FALSE;
}
if ((filter->face_detect = gst_element_factory_make ("facedetect",
NULL)) == NULL) {
return FALSE;
}
g_object_set (filter->face_detect, "display", 0, NULL);
if ((filter->svg_overlay = gst_element_factory_make ("rsvgoverlay",
NULL)) == NULL) {
return FALSE;
}
gst_bin_add_many (GST_BIN (filter),
filter->face_detect, filter->colorspace, filter->svg_overlay, NULL);
ret &= gst_element_link_pads (filter->face_detect, "src",
filter->colorspace, "sink");
ret &= gst_element_link_pads (filter->colorspace, "src",
filter->svg_overlay, "sink");
ret &= gst_face_overlay_create_pad (filter, filter->sinkpad, "sink",
filter->face_detect);
ret &= gst_face_overlay_create_pad (filter, filter->srcpad, "src",
filter->svg_overlay);
return ret;
}
