mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-25 09:40:37 +00:00
c1d55f29a1
gst_message_parse_stream_collection() and gst_message_parse_streams_selected() actually return a reffed GstStreamCollection. https://bugzilla.gnome.org/show_bug.cgi?id=768776
327 lines
9.4 KiB
C
327 lines
9.4 KiB
C
/* sample application for testing decodebin3 w/ playbin
|
|
*
|
|
* Copyright (C) 2015 Centricular Ltd
|
|
* @author: Edward Hervey <edward@centricular.com>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <glib.h>
|
|
#include <glib-object.h>
|
|
#include <glib/gprintf.h>
|
|
#include <gst/gst.h>
|
|
|
|
/* Global structure */
|
|
|
|
typedef struct _MyDataStruct
|
|
{
|
|
GMainLoop *mainloop;
|
|
GstElement *pipeline;
|
|
GstBus *bus;
|
|
|
|
/* Current collection */
|
|
GstStreamCollection *collection;
|
|
guint notify_id;
|
|
|
|
guint current_audio;
|
|
guint current_video;
|
|
guint current_text;
|
|
|
|
glong timeout_id;
|
|
} MyDataStruct;
|
|
|
|
static void
|
|
print_tag_foreach (const GstTagList * tags, const gchar * tag,
|
|
gpointer user_data)
|
|
{
|
|
GValue val = { 0, };
|
|
gchar *str;
|
|
gint depth = GPOINTER_TO_INT (user_data);
|
|
|
|
if (!gst_tag_list_copy_value (&val, tags, tag))
|
|
return;
|
|
|
|
if (G_VALUE_HOLDS_STRING (&val))
|
|
str = g_value_dup_string (&val);
|
|
else
|
|
str = gst_value_serialize (&val);
|
|
|
|
g_print ("%*s%s: %s\n", 2 * depth, " ", gst_tag_get_nick (tag), str);
|
|
g_free (str);
|
|
|
|
g_value_unset (&val);
|
|
}
|
|
|
|
static void
|
|
dump_collection (GstStreamCollection * collection)
|
|
{
|
|
guint i;
|
|
const GstTagList *tags;
|
|
const GstCaps *caps;
|
|
|
|
for (i = 0; i < gst_stream_collection_get_size (collection); i++) {
|
|
GstStream *stream = gst_stream_collection_get_stream (collection, i);
|
|
g_print (" Stream %u type %s flags 0x%x\n", i,
|
|
gst_stream_type_get_name (gst_stream_get_stream_type (stream)),
|
|
gst_stream_get_stream_flags (stream));
|
|
g_print (" ID: %s\n", gst_stream_get_stream_id (stream));
|
|
|
|
caps = gst_stream_get_caps (stream);
|
|
if (caps) {
|
|
gchar *caps_str = gst_caps_to_string (caps);
|
|
g_print (" caps: %s\n", caps_str);
|
|
g_free (caps_str);
|
|
}
|
|
|
|
tags = gst_stream_get_tags (stream);
|
|
if (tags) {
|
|
g_print (" tags:\n");
|
|
gst_tag_list_foreach (tags, print_tag_foreach, GUINT_TO_POINTER (3));
|
|
}
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
switch_streams (MyDataStruct * data)
|
|
{
|
|
guint i, nb_streams;
|
|
gint nb_video = 0, nb_audio = 0, nb_text = 0;
|
|
GstStream *videos[256], *audios[256], *texts[256];
|
|
GList *streams = NULL;
|
|
GstEvent *ev;
|
|
|
|
g_print ("Switching Streams...\n");
|
|
|
|
/* Calculate the number of streams of each type */
|
|
nb_streams = gst_stream_collection_get_size (data->collection);
|
|
for (i = 0; i < nb_streams; i++) {
|
|
GstStream *stream = gst_stream_collection_get_stream (data->collection, i);
|
|
GstStreamType stype = gst_stream_get_stream_type (stream);
|
|
if (stype == GST_STREAM_TYPE_VIDEO) {
|
|
videos[nb_video] = stream;
|
|
nb_video += 1;
|
|
} else if (stype == GST_STREAM_TYPE_AUDIO) {
|
|
audios[nb_audio] = stream;
|
|
nb_audio += 1;
|
|
} else if (stype == GST_STREAM_TYPE_TEXT) {
|
|
texts[nb_text] = stream;
|
|
nb_text += 1;
|
|
}
|
|
}
|
|
|
|
if (nb_video) {
|
|
data->current_video = (data->current_video + 1) % nb_video;
|
|
streams =
|
|
g_list_append (streams,
|
|
(gchar *) gst_stream_get_stream_id (videos[data->current_video]));
|
|
g_print (" Selecting video channel #%d : %s\n", data->current_video,
|
|
gst_stream_get_stream_id (videos[data->current_video]));
|
|
}
|
|
if (nb_audio) {
|
|
data->current_audio = (data->current_audio + 1) % nb_audio;
|
|
streams =
|
|
g_list_append (streams,
|
|
(gchar *) gst_stream_get_stream_id (audios[data->current_audio]));
|
|
g_print (" Selecting audio channel #%d : %s\n", data->current_audio,
|
|
gst_stream_get_stream_id (audios[data->current_audio]));
|
|
}
|
|
if (nb_text) {
|
|
data->current_text = (data->current_text + 1) % nb_text;
|
|
streams =
|
|
g_list_append (streams,
|
|
(gchar *) gst_stream_get_stream_id (texts[data->current_text]));
|
|
g_print (" Selecting text channel #%d : %s\n", data->current_text,
|
|
gst_stream_get_stream_id (texts[data->current_text]));
|
|
}
|
|
|
|
ev = gst_event_new_select_streams (streams);
|
|
gst_element_send_event (data->pipeline, ev);
|
|
|
|
return G_SOURCE_CONTINUE;
|
|
}
|
|
|
|
static void
|
|
stream_notify_cb (GstStreamCollection * collection, GstStream * stream,
|
|
GParamSpec * pspec, guint * val)
|
|
{
|
|
g_print ("Got stream-notify from stream %s for %s (collection %p)\n",
|
|
stream->stream_id, pspec->name, collection);
|
|
if (g_str_equal (pspec->name, "caps")) {
|
|
GstCaps *caps = gst_stream_get_caps (stream);
|
|
gchar *caps_str = gst_caps_to_string (caps);
|
|
g_print (" New caps: %s\n", caps_str);
|
|
g_free (caps_str);
|
|
gst_caps_unref (caps);
|
|
}
|
|
}
|
|
|
|
static GstBusSyncReply
|
|
_on_bus_message (GstBus * bus, GstMessage * message, MyDataStruct * data)
|
|
{
|
|
GstObject *src = GST_MESSAGE_SRC (message);
|
|
switch (GST_MESSAGE_TYPE (message)) {
|
|
case GST_MESSAGE_ERROR:{
|
|
GError *err = NULL;
|
|
gchar *name = gst_object_get_path_string (GST_MESSAGE_SRC (message));
|
|
gst_message_parse_error (message, &err, NULL);
|
|
|
|
g_printerr ("ERROR: from element %s: %s\n", name, err->message);
|
|
g_error_free (err);
|
|
g_free (name);
|
|
|
|
g_printf ("Stopping\n");
|
|
g_main_loop_quit (data->mainloop);
|
|
break;
|
|
}
|
|
case GST_MESSAGE_EOS:
|
|
g_printf ("EOS ! Stopping \n");
|
|
g_main_loop_quit (data->mainloop);
|
|
break;
|
|
case GST_MESSAGE_STREAM_COLLECTION:
|
|
{
|
|
GstStreamCollection *collection = NULL;
|
|
gst_message_parse_stream_collection (message, &collection);
|
|
if (collection) {
|
|
g_printf ("Got a collection from %s:\n",
|
|
src ? GST_OBJECT_NAME (src) : "Unknown");
|
|
dump_collection (collection);
|
|
if (data->collection && data->notify_id) {
|
|
g_signal_handler_disconnect (data->collection, data->notify_id);
|
|
data->notify_id = 0;
|
|
}
|
|
gst_object_replace ((GstObject **) & data->collection,
|
|
(GstObject *) collection);
|
|
if (data->collection) {
|
|
data->notify_id =
|
|
g_signal_connect (data->collection, "stream-notify",
|
|
(GCallback) stream_notify_cb, data);
|
|
}
|
|
if (data->timeout_id == 0)
|
|
/* In 5s try to change streams */
|
|
data->timeout_id =
|
|
g_timeout_add_seconds (5, (GSourceFunc) switch_streams, data);
|
|
gst_object_unref (collection);
|
|
}
|
|
break;
|
|
}
|
|
case GST_MESSAGE_STREAMS_SELECTED:
|
|
{
|
|
GstStreamCollection *collection = NULL;
|
|
gst_message_parse_streams_selected (message, &collection);
|
|
if (collection) {
|
|
guint i, len;
|
|
g_printf ("Got a STREAMS_SELECTED message from %s (seqnum:%"
|
|
G_GUINT32_FORMAT "):\n", src ? GST_OBJECT_NAME (src) : "unknown",
|
|
GST_MESSAGE_SEQNUM (message));
|
|
len = gst_message_streams_selected_get_size (message);
|
|
for (i = 0; i < len; i++) {
|
|
GstStream *stream =
|
|
gst_message_streams_selected_get_stream (message, i);
|
|
g_printf (" Stream #%d : %s\n", i,
|
|
gst_stream_get_stream_id (stream));
|
|
gst_object_unref (stream);
|
|
}
|
|
gst_object_unref (collection);
|
|
}
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return GST_BUS_PASS;
|
|
}
|
|
|
|
static gchar *
|
|
cmdline_to_uri (const gchar * arg)
|
|
{
|
|
if (gst_uri_is_valid (arg))
|
|
return g_strdup (arg);
|
|
|
|
return gst_filename_to_uri (arg, NULL);
|
|
}
|
|
|
|
int
|
|
main (int argc, gchar ** argv)
|
|
{
|
|
GstBus *bus;
|
|
MyDataStruct *data;
|
|
gchar *uri;
|
|
|
|
gst_init (&argc, &argv);
|
|
|
|
data = g_new0 (MyDataStruct, 1);
|
|
|
|
uri = cmdline_to_uri (argv[1]);
|
|
|
|
if (argc < 2 || uri == NULL) {
|
|
g_print ("Usage: %s URI\n", argv[0]);
|
|
return 1;
|
|
}
|
|
|
|
data->pipeline = gst_element_factory_make ("playbin3", NULL);
|
|
if (data->pipeline == NULL) {
|
|
g_printerr ("Failed to create playbin element. Aborting");
|
|
return 1;
|
|
}
|
|
|
|
g_object_set (data->pipeline, "uri", uri, "auto-select-streams", FALSE, NULL);
|
|
g_free (uri);
|
|
|
|
#if 0
|
|
{
|
|
GstElement *sink = gst_element_factory_make ("fakesink", NULL);
|
|
g_object_set (sink, "sync", FALSE, NULL);
|
|
g_object_set (data->pipeline, "video-sink", sink, NULL);
|
|
|
|
sink = gst_element_factory_make ("fakesink", NULL);
|
|
g_object_set (sink, "sync", FALSE, NULL);
|
|
g_object_set (data->pipeline, "audio-sink", sink, NULL);
|
|
}
|
|
#endif
|
|
|
|
/* Handle other input if specified */
|
|
if (argc > 2) {
|
|
uri = cmdline_to_uri (argv[2]);
|
|
if (uri != NULL) {
|
|
g_object_set (data->pipeline, "suburi", uri, NULL);
|
|
g_free (uri);
|
|
} else {
|
|
g_warning ("Could not parse auxilliary file argument. Ignoring");
|
|
}
|
|
}
|
|
|
|
data->mainloop = g_main_loop_new (NULL, FALSE);
|
|
|
|
/* Put a bus handler */
|
|
bus = gst_pipeline_get_bus (GST_PIPELINE (data->pipeline));
|
|
gst_bus_set_sync_handler (bus, (GstBusSyncHandler) _on_bus_message, data,
|
|
NULL);
|
|
|
|
/* Start pipeline */
|
|
gst_element_set_state (data->pipeline, GST_STATE_PLAYING);
|
|
g_main_loop_run (data->mainloop);
|
|
|
|
gst_element_set_state (data->pipeline, GST_STATE_NULL);
|
|
|
|
gst_object_unref (data->pipeline);
|
|
gst_object_unref (bus);
|
|
|
|
return 0;
|
|
}
|