static void
gst_frame_store_init (GstFrameStore * filter, GstFrameStoreClass * klass)
{
gst_element_create_all_pads (GST_ELEMENT(filter));
filter->srcpad = gst_element_get_pad (GST_ELEMENT(filter), "src");
gst_pad_set_link_function (filter->srcpad, gst_frame_store_link_src);
gst_pad_set_getcaps_function (filter->srcpad, gst_frame_store_getcaps);
filter->sinkpad = gst_element_get_pad (GST_ELEMENT(filter), "sink");
gst_pad_set_chain_function (filter->sinkpad, gst_frame_store_chain);
gst_pad_set_event_function (filter->sinkpad, gst_frame_store_sink_event);
gst_pad_set_getcaps_function (filter->sinkpad, gst_frame_store_getcaps);
gst_frame_store_reset (filter);
filter->range_offset = 0;
filter->range_size = 10;
filter->frames = g_malloc0(sizeof(GstBuffer*)*filter->range_size);
filter->frame_number = 0;
filter->pushed_frame_number = -1;
filter->need_newsegment = TRUE;
filter->cond = g_cond_new ();
filter->lock = g_mutex_new ();
filter->srcresult = GST_FLOW_WRONG_STATE;
}
gint
main (gint argc, gchar ** argv)
{
GstCaps *caps;
GstElement *sink, *identity;
GstElement *pipeline;
gst_init (&argc, &argv);
pipeline = gst_pipeline_new ("pipeline");
g_assert (pipeline);
identity = gst_element_factory_make ("identity", NULL);
g_assert (identity);
sink = gst_element_factory_make ("fakesink", NULL);
g_assert (sink);
gst_bin_add_many (GST_BIN (pipeline), identity, sink, NULL);
gst_element_link_filtered (identity, sink,
gst_caps_new_simple ("audio/x-raw-int", NULL));
caps = gst_pad_get_caps (gst_element_get_pad (identity, "sink"));
g_print ("caps: %s\n", gst_caps_to_string (caps));
g_assert (!gst_caps_is_any (caps));
caps = gst_pad_get_allowed_caps (gst_element_get_pad (identity, "sink"));
g_print ("allowed caps: %s\n", gst_caps_to_string (caps));
/* get_allowed_caps doesn't mean anything if you aren't connected */
g_assert (!caps);
return 0;
}
void on_pad_added(GstElement * element, GstPad * pad)
{
GstCaps * caps;
GstStructure * str;
GstPad * targetsink = NULL;
caps = gst_pad_get_caps(pad);
g_assert(caps != NULL);
str = gst_caps_get_structure(caps, 0);
g_assert(str != NULL);
/* if the file has video and the media type is video connect it to the pipewriter */
if(g_strrstr(gst_structure_get_name(str), "video"))
{
targetsink = gst_element_get_pad(videodec, "sink");
}
/* if the file has audio and the media type is audio connect it to the pipewriter */
else if(g_strrstr(gst_structure_get_name (str), "audio"))
{
targetsink = gst_element_get_pad(audiodec, "sink");
}
if (targetsink != 0) {
gst_pad_link(pad, targetsink);
gst_object_unref(targetsink);
}
gst_caps_unref(caps);
}
bool MediaNode::disconnectNode(QObject *obj)
{
MediaNode *sink = qobject_cast<MediaNode*>(obj);
if (root()) {
// Disconnecting elements while playing or paused seems to cause
// potential deadlock. Hence we force the pipeline into ready state
// before any nodes are disconnected.
gst_element_set_state(root()->pipeline(), GST_STATE_READY);
Q_ASSERT(sink->root()); //sink has to have a root since it is onnected
if (sink->description() & (AudioSink)) {
GstPad *sinkPad = gst_element_get_pad(sink->audioElement(), "sink");
// Release requested src pad from tee
GstPad *requestedPad = gst_pad_get_peer(sinkPad);
if (requestedPad) {
gst_element_release_request_pad(m_audioTee, requestedPad);
gst_object_unref(requestedPad);
}
if (GST_ELEMENT_PARENT(sink->audioElement()))
gst_bin_remove(GST_BIN(root()->audioGraph()), sink->audioElement());
gst_object_unref(sinkPad);
}
if (sink->description() & (VideoSink)) {
GstPad *sinkPad = gst_element_get_pad(sink->videoElement(), "sink");
// Release requested src pad from tee
GstPad *requestedPad = gst_pad_get_peer(sinkPad);
if (requestedPad) {
gst_element_release_request_pad(m_videoTee, requestedPad);
gst_object_unref(requestedPad);
}
if (GST_ELEMENT_PARENT(sink->videoElement()))
gst_bin_remove(GST_BIN(root()->videoGraph()), sink->videoElement());
gst_object_unref(sinkPad);
}
sink->breakGraph();
sink->setRoot(0);
}
m_videoSinkList.removeAll(obj);
m_audioSinkList.removeAll(obj);
if (sink->m_description & AudioSink) {
// Remove sink from graph
MediaNodeEvent event(MediaNodeEvent::AudioSinkRemoved, sink);
mediaNodeEvent(&event);
return true;
}
if ((m_description & VideoSource) && (sink->m_description & VideoSink)) {
// Remove sink from graph
MediaNodeEvent event(MediaNodeEvent::VideoSinkRemoved, sink);
mediaNodeEvent(&event);
return true;
}
return false;
}
/* Init the video interface. Start GStreamer and create all the elements. */
int video_init(int flags)
{
GstElement *dec, *vqueue, *vconv, *vscale, *aqueue, *aconv, *ascale;
if (!gst_init_check(NULL, NULL)) return VIDEO_ERROR;
status = 0;
status_mutex = g_mutex_new();
video_width = video_height = 0;
apeer = NULL;
audio_disabled = flags & VIDEO_INIT_NOAUDIO;
/* Main pipeline */
pipeline = gst_thread_new("pipeline");
g_signal_connect(pipeline, "eos", G_CALLBACK (cb_eos), NULL);
g_signal_connect(pipeline, "error", G_CALLBACK (cb_error), NULL);
g_signal_connect(pipeline, "state-change", G_CALLBACK (cb_state_change), NULL);
src = gst_element_factory_make("filesrc", "src");
dec = gst_element_factory_make("decodebin", "dec");
g_signal_connect (dec, "new-decoded-pad", G_CALLBACK(cb_new_pad), NULL);
if (!gst_element_link_many(src, dec, NULL)) return VIDEO_ERROR;
gst_bin_add_many(GST_BIN(pipeline), src, dec, NULL);
/* Video thread */
vthread = gst_thread_new("vthread");
vqueue = gst_element_factory_make("queue", "vqueue");
vqueuesink = gst_element_get_pad(vqueue, "sink");
vconv = gst_element_factory_make("ffmpegcolorspace", "vconv");
vscale = gst_element_factory_make("videoscale", "vscale");
vdrop = gst_element_factory_make("videodrop", "vdrop");
xvsink = gst_element_factory_make("xvimagesink", "xvsink");
gst_bin_add_many(GST_BIN(vthread), vqueue, vconv, vscale, vdrop, xvsink, NULL);
if (!gst_element_link_many(vqueue, vconv, vscale, vdrop, xvsink, NULL))
return VIDEO_ERROR;
gst_object_ref(GST_OBJECT(vthread));
/* Audio thread */
if (audio_disabled) return VIDEO_OK;
athread = gst_thread_new("athread");
aqueue = gst_element_factory_make("queue", "aqueue");
aqueuesink = gst_element_get_pad(aqueue, "sink");
aconv = gst_element_factory_make("audioconvert", "aconv");
ascale = gst_element_factory_make ("audioscale", "ascale");
asink = gst_element_factory_make ("alsasink", "asink");
gst_bin_add_many (GST_BIN (athread), aqueue, aconv, ascale, asink, NULL);
if (!gst_element_link_many (aqueue, aconv, ascale, asink, NULL))
return VIDEO_ERROR;
gst_object_ref(GST_OBJECT(athread));
return VIDEO_OK;
}
static void
rb_mtp_sink_init (RBMTPSink *sink, RBMTPSinkClass *klass)
{
GstPad *pad;
sink->upload_mutex = g_mutex_new ();
sink->upload_cond = g_cond_new ();
/* create actual sink */
sink->fdsink = gst_element_factory_make ("fdsink", NULL);
if (sink->fdsink == NULL) {
g_warning ("couldn't create fdsink element");
return;
}
gst_bin_add (GST_BIN (sink), sink->fdsink);
gst_object_ref (sink->fdsink);
/* create ghost pad */
pad = gst_element_get_pad (sink->fdsink, "sink");
sink->ghostpad = gst_ghost_pad_new ("sink", pad);
gst_element_add_pad (GST_ELEMENT (sink), sink->ghostpad);
gst_object_ref (sink->ghostpad);
gst_object_unref (pad);
}
static GstElement *
make_wav_pipeline (const gchar * location)
{
GstElement *pipeline;
GstElement *src, *decoder, *audiosink;
pipeline = gst_pipeline_new ("app");
src = gst_element_factory_make_or_warn (SOURCE, "src");
decoder = gst_element_factory_make_or_warn ("wavparse", "decoder");
audiosink = gst_element_factory_make_or_warn (ASINK, "sink");
g_object_set (G_OBJECT (src), "location", location, NULL);
gst_bin_add (GST_BIN (pipeline), src);
gst_bin_add (GST_BIN (pipeline), decoder);
gst_bin_add (GST_BIN (pipeline), audiosink);
gst_element_link (src, decoder);
setup_dynamic_link (decoder, "src", gst_element_get_pad (audiosink, "sink"),
NULL);
return pipeline;
}
//
// connect decodebin's dynamically created source pads to colourconverter
//
static void icvNewPad(GstElement *decodebin, GstPad *pad, gboolean last, gpointer data)
{
GstElement *sink = GST_ELEMENT(data);
GstStructure *str;
GstPad *sinkpad;
GstCaps *caps;
/* link only once */
sinkpad = gst_element_get_pad(sink, "sink");
if(GST_PAD_IS_LINKED(sinkpad)) {
g_print("sink is already linked\n");
g_object_unref(sinkpad);
return;
}
/* check media type */
caps = gst_pad_get_caps(pad);
str = gst_caps_get_structure(caps, 0);
const char *structname = gst_structure_get_name(str);
// g_print("new pad %s\n", structname);
if(!g_strrstr(structname, "video")) {
gst_caps_unref(caps);
gst_object_unref(sinkpad);
return;
}
printf("linking pad %s\n", structname);
/* link'n'play */
gst_pad_link (pad, sinkpad);
gst_caps_unref(caps);
gst_object_unref(sinkpad);
}
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 void
bbd_new_decoded_pad(GstElement *decodebin, GstPad *pad,
gboolean last, gpointer data)
{
GstCaps *caps;
GstStructure *str;
GstPad *audiopad;
BansheeBpmDetector *detector = (BansheeBpmDetector *)data;
g_return_if_fail(detector != NULL);
audiopad = gst_element_get_pad(detector->audioconvert, "sink");
if(GST_PAD_IS_LINKED(audiopad)) {
g_object_unref(audiopad);
return;
}
caps = gst_pad_get_caps(pad);
str = gst_caps_get_structure(caps, 0);
if(!g_strrstr(gst_structure_get_name(str), "audio")) {
gst_caps_unref(caps);
gst_object_unref(audiopad);
return;
}
gst_caps_unref(caps);
gst_pad_link(pad, audiopad);
}
static GstElement *
create_thread_ghostpads (void)
{
GstElement *thread;
GstElement *element1, *element2;
thread = gst_thread_new ("testthread");
element1 = gst_element_new ();
gst_element_set_name (element1, "test1");
gst_element_add_pad (element1,
gst_pad_new_from_template (gst_static_pad_template_get (&srctemplate),
"src1"));
gst_bin_add (GST_BIN (thread), element1);
element2 = gst_element_new ();
gst_element_set_name (element2, "test2");
gst_element_add_pad (element1,
gst_pad_new_from_template (gst_static_pad_template_get (&sinktemplate),
"sink1"));
gst_bin_add (GST_BIN (thread), element2);
gst_element_link (element1, "src1", element2, "sink1");
gst_element_add_ghost_pad (thread, gst_element_get_pad (element2, "sink1"),
"sink1");
return thread;
}
static void
brasero_transcode_stop_pipeline (BraseroTranscode *transcode)
{
BraseroTranscodePrivate *priv;
GstPad *sinkpad;
priv = BRASERO_TRANSCODE_PRIVATE (transcode);
if (!priv->pipeline)
return;
sinkpad = gst_element_get_pad (priv->sink, "sink");
if (priv->probe)
gst_pad_remove_buffer_probe (sinkpad, priv->probe);
gst_object_unref (sinkpad);
gst_element_set_state (priv->pipeline, GST_STATE_NULL);
gst_object_unref (GST_OBJECT (priv->pipeline));
priv->link = NULL;
priv->sink = NULL;
priv->source = NULL;
priv->convert = NULL;
priv->pipeline = NULL;
priv->set_active_state = 0;
}
static GstStateChangeReturn
gst_parse_test_element_change_state (GstElement * element,
GstStateChange transition)
{
GstParseTestElement *src = (GstParseTestElement *) element;
if (transition == GST_STATE_CHANGE_READY_TO_PAUSED) {
/* Add our pad */
GstPad *pad;
GstPad *ghost;
if (src->fakesrc == NULL)
return GST_STATE_CHANGE_FAILURE;
pad = gst_element_get_pad (src->fakesrc, "src");
if (pad == NULL)
return GST_STATE_CHANGE_FAILURE;
ghost = gst_ghost_pad_new ("src", pad);
fail_if (ghost == NULL, "Failed to create ghost pad");
/* activate and add */
gst_pad_set_active (ghost, TRUE);
gst_element_add_pad (GST_ELEMENT (src), ghost);
gst_object_unref (pad);
}
return GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
}
static void
gst_transcoder_new_decoded_pad(GstElement *decodebin, GstPad *pad,
gboolean last, gpointer data)
{
GstCaps *caps;
GstStructure *str;
GstPad *audiopad;
GstTranscoder *transcoder = (GstTranscoder *)data;
g_return_if_fail(transcoder != NULL);
audiopad = gst_element_get_pad(transcoder->sink_bin, "sink");
if(GST_PAD_IS_LINKED(audiopad)) {
g_object_unref(audiopad);
return;
}
caps = gst_pad_get_caps(pad);
str = gst_caps_get_structure(caps, 0);
if(!g_strrstr(gst_structure_get_name(str), "audio")) {
gst_caps_unref(caps);
gst_object_unref(audiopad);
return;
}
gst_caps_unref(caps);
gst_pad_link(pad, audiopad);
}
static void
new_decoded_pad_cb(GstElement *demuxer,
GstPad *new_pad,
gpointer user_data)
{
GstElement *decoder;
GstPad *pad;
GstCaps *caps;
gchar *str;
caps = gst_pad_get_caps(new_pad);
str = gst_caps_to_string(caps);
if (g_str_has_prefix(str, "video/"))
{
decoder = GST_ELEMENT(user_data);
pad = gst_element_get_pad(decoder, "sink");
if (GST_PAD_LINK_FAILED(gst_pad_link(new_pad, pad)))
{
g_warning("Failed to link %s:%s to %s:%s", GST_DEBUG_PAD_NAME(new_pad),
GST_DEBUG_PAD_NAME(pad));
}
}
g_free(str);
gst_caps_unref(caps);
}
static void
Lastfmfp_cb_newpad(GstElement *decodebin, GstPad *pad, gboolean last, LastfmfpAudio *ma)
{
GstCaps *caps;
GstStructure *str;
GstPad *audiopad;
// only link once
audiopad = gst_element_get_pad(ma->audio, "sink");
if (GST_PAD_IS_LINKED(audiopad)) {
g_object_unref(audiopad);
return;
}
// check media type
caps = gst_pad_get_caps(pad);
str = gst_caps_get_structure(caps, 0);
if (!g_strrstr(gst_structure_get_name(str), "audio")) {
gst_caps_unref(caps);
gst_object_unref(audiopad);
return;
}
gst_caps_unref(caps);
// link
gst_pad_link(pad, audiopad);
gst_object_unref(audiopad);
}
int
main (int argc, char *argv[])
{
GstElement *a;
GstElement *b;
GstElement *pipeline;
GstPad *pad;
gst_init (&argc, &argv);
pipeline = gst_pipeline_new (NULL);
a = gst_element_factory_make ("fakesrc", NULL);
g_assert (a);
b = gst_element_factory_make ("fakesink", NULL);
g_assert (b);
gst_bin_add_many (GST_BIN (pipeline), a, b, NULL);
gst_element_link (a, b);
pad = gst_element_get_pad (a, "src");
g_signal_connect (G_OBJECT (pad), "fixate", G_CALLBACK (handler),
(void *) 0xdeadbeef);
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_PLAYING);
return 0;
}
static void
cb_newpad (GstElement *decodebin,
GstPad *pad,
gboolean last,
gpointer data)
{
GstCaps *caps;
GstStructure *str;
GstPad *audiopad;
/* only link once */
audiopad = gst_element_get_pad (audio, "sink");
if (GST_PAD_IS_LINKED (audiopad)) {
g_object_unref (audiopad);
return;
}
/* check media type */
caps = gst_pad_get_caps (pad);
str = gst_caps_get_structure (caps, 0);
if (!g_strrstr (gst_structure_get_name (str), "audio")) {
gst_caps_unref (caps);
gst_object_unref (audiopad);
return;
}
gst_caps_unref (caps);
/* link'n'play */
gst_pad_link (pad, audiopad);
}
static gboolean
gst_auto_video_sink_detect (GstAutoVideoSink * sink)
{
GstElement *esink;
GstPad *targetpad;
gst_auto_video_sink_clear_kid (sink);
/* find element */
GST_DEBUG_OBJECT (sink, "Creating new kid");
if (!(esink = gst_auto_video_sink_find_best (sink)))
goto no_sink;
sink->kid = esink;
gst_bin_add (GST_BIN (sink), esink);
/* attach ghost pad */
GST_DEBUG_OBJECT (sink, "Re-assigning ghostpad");
targetpad = gst_element_get_pad (sink->kid, "sink");
gst_ghost_pad_set_target (GST_GHOST_PAD (sink->pad), targetpad);
gst_object_unref (targetpad);
GST_DEBUG_OBJECT (sink, "done changing auto video sink");
return TRUE;
/* ERRORS */
no_sink:
{
GST_ELEMENT_ERROR (sink, LIBRARY, INIT, (NULL),
("Failed to find a supported video sink"));
return FALSE;
}
}
void Pipeline::cb_new_pad (GstElement* decodebin, GstPad* pad, gboolean last, GstElement* glimagesink)
{
GstPad* glpad = gst_element_get_pad (glimagesink, "sink");
//only link once
if (GST_PAD_IS_LINKED (glpad))
{
gst_object_unref (glpad);
return;
}
GstCaps* caps = gst_pad_get_caps (pad);
GstStructure* str = gst_caps_get_structure (caps, 0);
if (!g_strrstr (gst_structure_get_name (str), "video"))
{
gst_caps_unref (caps);
gst_object_unref (glpad);
return;
}
gst_caps_unref (caps);
GstPadLinkReturn ret = gst_pad_link (pad, glpad);
if (ret != GST_PAD_LINK_OK)
g_warning ("Failed to link with decodebin!\n");
}
static gboolean pad_event_handler(GstPad *pad, GstEvent *event) {
// Establish thread-local.
MpfComponent *component = MPF_COMPONENT(GST_OBJECT_PARENT(pad));
mpf_component_set_curcomponent(component);
GstElement *element = gst_pad_get_parent_element(pad);
gchar *elementname = gst_element_get_name(element);
gchar *padname = gst_pad_get_name(pad);
const gchar *eventname = gst_event_type_get_name(event->type);
MPF_PRIVATE_ALWAYS("element=%s pad=%s event=%s\n", elementname, padname,
eventname);
// If EOS, poke a message out of the events pad.
if (event->type == GST_EVENT_EOS) {
GstPad *events = gst_element_get_pad(element, "events");
printf("GstPad *events=%p\n", events);
GString *string = g_string_new("");
g_string_printf(string, "%s: EOS buffer_count=%d\n", elementname,
mpf_private.buffer_count);
mpf_voidstar_push("events", mpf_voidstar_stralloc(string->str));
mpf_voidstar_send_outbuffers();
gst_pad_push_event(events, gst_event_new_eos());
}
g_free(elementname);
g_free(padname);
return gst_pad_event_default(pad, event);
}
static void get_device_data (ofGstDevice &webcam_device, int desired_framerate)
{
string pipeline_desc = webcam_device.gstreamer_src + " name=source device=" +
webcam_device.video_device + " ! fakesink";
GError * err = NULL;
GstElement * pipeline = gst_parse_launch (pipeline_desc.c_str(), &err);
if ((pipeline == NULL) || (err != NULL)){
if (err){
ofLog(OF_LOG_ERROR, "ofGstUtils: error getting device data: %s", err->message);
g_error_free (err);
}else{
ofLog(OF_LOG_ERROR, "ofGstUtils: error getting device data, cannot get pipeline");
}
if(pipeline)
gst_object_unref (pipeline);
return;
}
// TODO: try to lower seconds,
// Start the pipeline and wait for max. 10 seconds for it to start up
gst_element_set_state (pipeline, GST_STATE_PLAYING);
GstStateChangeReturn ret = gst_element_get_state (pipeline, NULL, NULL, 10 * GST_SECOND);
// Check if any error messages were posted on the bus
GstBus * bus = gst_element_get_bus (pipeline);
GstMessage * msg = gst_bus_poll (bus, GST_MESSAGE_ERROR, 0);
gst_object_unref (bus);
if ((msg == NULL) && (ret == GST_STATE_CHANGE_SUCCESS)){
gst_element_set_state (pipeline, GST_STATE_PAUSED);
GstElement *src = gst_bin_get_by_name (GST_BIN (pipeline), "source");
char *name;
g_object_get (G_OBJECT (src), "device-name", &name, (void*)NULL);
ofLog(OF_LOG_VERBOSE, "Device: %s (%s)\n", name==NULL?"":name, webcam_device.video_device.c_str());
GstPad *pad = gst_element_get_pad (src, "src");
GstCaps *caps = gst_pad_get_caps (pad);
gst_object_unref (pad);
get_supported_video_formats (webcam_device, *caps, desired_framerate);
gst_caps_unref (caps);
}else if(msg){
gchar *debug;
gst_message_parse_error(msg, &err, &debug);
ofLog(OF_LOG_ERROR, "ofGstUtils: error getting device data; module %s reported: %s",
gst_element_get_name(GST_MESSAGE_SRC (msg)), err->message);
g_error_free(err);
g_free(debug);
}
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_object_unref (pipeline);
}
static void
get_device_data (ofGstDevice &webcam_device)
{
char *pipeline_desc;
GstElement *pipeline;
GError *err;
GstStateChangeReturn ret;
GstMessage *msg;
GstBus *bus;
{
pipeline_desc = g_strdup_printf ("%s name=source device=%s ! fakesink",
webcam_device.gstreamer_src,
webcam_device.video_device);
err = NULL;
pipeline = gst_parse_launch (pipeline_desc, &err);
if ((pipeline != NULL) && (err == NULL))
{
/* Start the pipeline and wait for max. 10 seconds for it to start up */
gst_element_set_state (pipeline, GST_STATE_PLAYING);
ret = gst_element_get_state (pipeline, NULL, NULL, 10 * GST_SECOND);
/* Check if any error messages were posted on the bus */
bus = gst_element_get_bus (pipeline);
msg = gst_bus_poll (bus, GST_MESSAGE_ERROR, 0);
gst_object_unref (bus);
if ((msg == NULL) && (ret == GST_STATE_CHANGE_SUCCESS))
{
GstElement *src;
GstPad *pad;
char *name;
GstCaps *caps;
gst_element_set_state (pipeline, GST_STATE_PAUSED);
src = gst_bin_get_by_name (GST_BIN (pipeline), "source");
g_object_get (G_OBJECT (src), "device-name", &name, (void*)NULL);
if (name == NULL)
name = "Unknown";
// ofLog(OF_LOG_VERBOSE,"Device: %s (%s)\n", name, webcam_device.video_device);
pad = gst_element_get_pad (src, "src");
caps = gst_pad_get_caps (pad);
gst_object_unref (pad);
get_supported_video_formats (webcam_device, *caps);
gst_caps_unref (caps);
}
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_object_unref (pipeline);
}
if (err)
g_error_free (err);
g_free (pipeline_desc);
}
}
/***
* Creates an instance of a playbin with "audio-src" and
* "video-src" ghost pads to allow redirected output streams.
*
* ### This function is probably not required now that MediaObject is based
* on decodebin directly.
*/
GstElement* GstHelper::createPluggablePlaybin()
{
GstElement *playbin = 0;
//init playbin and add to our pipeline
playbin = gst_element_factory_make("playbin2", NULL);
//Create an identity element to redirect sound
GstElement *audioSinkBin = gst_bin_new (NULL);
GstElement *audioPipe = gst_element_factory_make("identity", NULL);
gst_bin_add(GST_BIN(audioSinkBin), audioPipe);
//Create a sinkpad on the identity
GstPad *audiopad = gst_element_get_pad (audioPipe, "sink");
gst_element_add_pad (audioSinkBin, gst_ghost_pad_new ("sink", audiopad));
gst_object_unref (audiopad);
//Create an "audio_src" source pad on the playbin
GstPad *audioPlaypad = gst_element_get_pad (audioPipe, "src");
gst_element_add_pad (playbin, gst_ghost_pad_new ("audio_src", audioPlaypad));
gst_object_unref (audioPlaypad);
//Done with our audio redirection
g_object_set (G_OBJECT(playbin), "audio-sink", audioSinkBin, (const char*)NULL);
// * * Redirect video to "video_src" pad : * *
//Create an identity element to redirect sound
GstElement *videoSinkBin = gst_bin_new (NULL);
GstElement *videoPipe = gst_element_factory_make("identity", NULL);
gst_bin_add(GST_BIN(videoSinkBin), videoPipe);
//Create a sinkpad on the identity
GstPad *videopad = gst_element_get_pad (videoPipe, "sink");
gst_element_add_pad (videoSinkBin, gst_ghost_pad_new ("sink", videopad));
gst_object_unref (videopad);
//Create an "audio_src" source pad on the playbin
GstPad *videoPlaypad = gst_element_get_pad (videoPipe, "src");
gst_element_add_pad (playbin, gst_ghost_pad_new ("video_src", videoPlaypad));
gst_object_unref (videoPlaypad);
//Done with our video redirection
g_object_set (G_OBJECT(playbin), "video-sink", videoSinkBin, (const char*)NULL);
return playbin;
}
/*
* Method: get_pad(name)
* name: the name of a pad.
*
* Retrieves a Gst::Pad object from the element by name.
*
* Returns: a Gst::Pad object, or nil if the pad cannot be found.
*/
static VALUE
rg_get_pad(VALUE self, VALUE pad_name)
{
GstPad *pad = gst_element_get_pad(SELF(self),
RVAL2CSTR(pad_name));
return pad != NULL ? RGST_PAD_NEW(pad)
: Qnil;
}
static void
on_composition_pad_added_cb (GstElement * composition, GstPad * pad,
GstElement * sink)
{
GstPad *s = gst_element_get_pad (sink, "sink");
gst_pad_link (pad, s);
++composition_pad_added;
gst_object_unref (s);
}
/* Component instance initialization and parameter handling. */
component_setup() {
mpf_private.loglevel = mpf_param_get_int("loglevel");
mpf_logger_init(&mpf_private.logger, mpf_private.loglevel,
gst_element_get_name(GST_ELEMENT(component)));
GstPad *input = gst_element_get_pad(GST_ELEMENT(
mpf_component_get_curcomponent()), "input");
gst_pad_set_event_function(input, pad_event_handler);
if (mpf_param_get_int("mpf-debug"))
mpf_component_get_curcomponent()->flags = MPF_DEBUG;
}
gint
main (gint argc,
gchar *argv[])
{
GMainLoop *loop;
GstElement *src, *dec, *conv, *sink;
GstPad *audiopad;
GstBus *bus;
/* init GStreamer */
gst_init (&argc, &argv);
loop = g_main_loop_new (NULL, FALSE);
/* make sure we have input */
if (argc != 2) {
g_print ("Usage: %s <filename>\n", argv[0]);
return -1;
}
/* setup */
pipeline = gst_pipeline_new ("pipeline");
bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
gst_bus_add_watch (bus, my_bus_callback, loop);
gst_object_unref (bus);
src = gst_element_factory_make ("filesrc", "source");
g_object_set (G_OBJECT (src), "location", argv[1], NULL);
dec = gst_element_factory_make ("decodebin", "decoder");
g_signal_connect (dec, "new-decoded-pad", G_CALLBACK (cb_newpad), NULL);
gst_bin_add_many (GST_BIN (pipeline), src, dec, NULL);
gst_element_link (src, dec);
/* create audio output */
audio = gst_bin_new ("audiobin");
conv = gst_element_factory_make ("audioconvert", "aconv");
audiopad = gst_element_get_pad (conv, "sink");
sink = gst_element_factory_make ("alsasink", "sink");
gst_bin_add_many (GST_BIN (audio), conv, sink, NULL);
gst_element_link (conv, sink);
gst_element_add_pad (audio,
gst_ghost_pad_new ("sink", audiopad));
gst_object_unref (audiopad);
gst_bin_add (GST_BIN (pipeline), audio);
/* run */
gst_element_set_state (pipeline, GST_STATE_PLAYING);
g_main_loop_run (loop);
/* cleanup */
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_object_unref (GST_OBJECT (pipeline));
return 0;
}
void StreamPipeline::NewPadCallback(
GstElement* decodebin, GstPad* pad, gpointer self) {
qLog(Debug) << "Linking pads";
StreamPipeline* me = reinterpret_cast<StreamPipeline*>(self);
GstPad* const audiopad = gst_element_get_pad(me->convert_bin_, "sink");
gst_pad_link(pad, audiopad);
gst_object_unref(audiopad);
QMetaObject::invokeMethod(me, "StartPipeline", Qt::QueuedConnection);
}
static void
new_pad(GstElement *element, GstPad *pad, gpointer data) {
GstPad *sinkpad;
/* We can now link this pad with the audio decoder */
g_print("Dynamic pad created, linking parser/decoder\n");
sinkpad = gst_element_get_pad(decoder, "sink");
gst_pad_link(pad, sinkpad);
gst_object_unref(sinkpad);
}
