1807 lines
50 KiB
C
1807 lines
50 KiB
C
/* GStreamer command line playback testing utility
|
|
*
|
|
* Copyright (C) 2013-2014 Tim-Philipp Müller <tim centricular net>
|
|
* Copyright (C) 2013 Collabora Ltd.
|
|
* Copyright (C) 2015 Centricular Ltd
|
|
*
|
|
* 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 <locale.h>
|
|
|
|
#include <gst/gst.h>
|
|
#include <gst/gst-i18n-app.h>
|
|
#include <gst/audio/audio.h>
|
|
#include <gst/video/video.h>
|
|
#include <gst/pbutils/pbutils.h>
|
|
#include <gst/tag/tag.h>
|
|
#include <gst/math-compat.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include <glib/gprintf.h>
|
|
|
|
#ifdef HAVE_WINMM
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <windows.h>
|
|
#include <timeapi.h>
|
|
#endif
|
|
|
|
#include "gst-play-kb.h"
|
|
|
|
#define VOLUME_STEPS 20
|
|
|
|
static gboolean wait_on_eos = FALSE;
|
|
|
|
GST_DEBUG_CATEGORY (play_debug);
|
|
#define GST_CAT_DEFAULT play_debug
|
|
|
|
typedef enum
|
|
{
|
|
GST_PLAY_TRICK_MODE_NONE = 0,
|
|
GST_PLAY_TRICK_MODE_DEFAULT,
|
|
GST_PLAY_TRICK_MODE_DEFAULT_NO_AUDIO,
|
|
GST_PLAY_TRICK_MODE_KEY_UNITS,
|
|
GST_PLAY_TRICK_MODE_KEY_UNITS_NO_AUDIO,
|
|
GST_PLAY_TRICK_MODE_LAST,
|
|
|
|
/* The instant-rate setting is a flag,
|
|
* applied on top of the trick-mode enum value.
|
|
* It needs to have a 2^n value bigger than
|
|
* any of the enum values so setting it
|
|
* won't affect the trickmode value */
|
|
GST_PLAY_TRICK_MODE_INSTANT_RATE = (1 << 3)
|
|
} GstPlayTrickMode;
|
|
|
|
typedef enum
|
|
{
|
|
GST_PLAY_TRACK_TYPE_INVALID = 0,
|
|
GST_PLAY_TRACK_TYPE_AUDIO,
|
|
GST_PLAY_TRACK_TYPE_VIDEO,
|
|
GST_PLAY_TRACK_TYPE_SUBTITLE
|
|
} GstPlayTrackType;
|
|
|
|
typedef struct
|
|
{
|
|
gchar **uris;
|
|
guint num_uris;
|
|
gint cur_idx;
|
|
|
|
GstElement *playbin;
|
|
|
|
/* playbin3 variables */
|
|
gboolean is_playbin3;
|
|
GstStreamCollection *collection;
|
|
gchar *cur_audio_sid;
|
|
gchar *cur_video_sid;
|
|
gchar *cur_text_sid;
|
|
GMutex selection_lock;
|
|
|
|
GMainLoop *loop;
|
|
guint bus_watch;
|
|
guint timeout;
|
|
|
|
/* missing plugin messages */
|
|
GList *missing;
|
|
|
|
gboolean buffering;
|
|
gboolean is_live;
|
|
|
|
GstState desired_state; /* as per user interaction, PAUSED or PLAYING */
|
|
|
|
gulong deep_notify_id;
|
|
|
|
/* configuration */
|
|
gboolean gapless;
|
|
|
|
GstPlayTrickMode trick_mode;
|
|
gdouble rate;
|
|
gdouble start_position;
|
|
|
|
/* keyboard state tracking */
|
|
gboolean shift_pressed;
|
|
} GstPlay;
|
|
|
|
static gboolean quiet = FALSE;
|
|
static gboolean instant_rate_changes = FALSE;
|
|
|
|
static gboolean play_bus_msg (GstBus * bus, GstMessage * msg, gpointer data);
|
|
static gboolean play_next (GstPlay * play);
|
|
static gboolean play_prev (GstPlay * play);
|
|
static gboolean play_timeout (gpointer user_data);
|
|
static void play_about_to_finish (GstElement * playbin, gpointer user_data);
|
|
static void play_reset (GstPlay * play);
|
|
static void play_set_relative_volume (GstPlay * play, gdouble volume_step);
|
|
static gboolean play_do_seek (GstPlay * play, gint64 pos, gdouble rate,
|
|
GstPlayTrickMode mode);
|
|
|
|
/* *INDENT-OFF* */
|
|
static void gst_play_printf (const gchar * format, ...) G_GNUC_PRINTF (1, 2);
|
|
/* *INDENT-ON* */
|
|
|
|
static void keyboard_cb (const gchar * key_input, gpointer user_data);
|
|
static void relative_seek (GstPlay * play, gdouble percent);
|
|
|
|
static void
|
|
gst_play_printf (const gchar * format, ...)
|
|
{
|
|
gchar *str = NULL;
|
|
va_list args;
|
|
int len;
|
|
|
|
if (quiet)
|
|
return;
|
|
|
|
va_start (args, format);
|
|
|
|
len = g_vasprintf (&str, format, args);
|
|
|
|
va_end (args);
|
|
|
|
if (len > 0 && str != NULL)
|
|
gst_print ("%s", str);
|
|
|
|
g_free (str);
|
|
}
|
|
|
|
#define gst_print gst_play_printf
|
|
|
|
static GstPlay *
|
|
play_new (gchar ** uris, const gchar * audio_sink, const gchar * video_sink,
|
|
gboolean gapless, gdouble initial_volume, gboolean verbose,
|
|
const gchar * flags_string, gboolean use_playbin3, gdouble start_position)
|
|
{
|
|
GstElement *sink, *playbin;
|
|
GstPlay *play;
|
|
|
|
|
|
if (use_playbin3) {
|
|
playbin = gst_element_factory_make ("playbin3", "playbin");
|
|
} else {
|
|
playbin = gst_element_factory_make ("playbin", "playbin");
|
|
}
|
|
|
|
if (playbin == NULL)
|
|
return NULL;
|
|
|
|
play = g_new0 (GstPlay, 1);
|
|
|
|
play->uris = uris;
|
|
play->num_uris = g_strv_length (uris);
|
|
play->cur_idx = -1;
|
|
|
|
play->playbin = playbin;
|
|
|
|
if (use_playbin3) {
|
|
play->is_playbin3 = TRUE;
|
|
} else {
|
|
const gchar *env = g_getenv ("USE_PLAYBIN3");
|
|
if (env && g_str_has_prefix (env, "1"))
|
|
play->is_playbin3 = TRUE;
|
|
}
|
|
|
|
g_mutex_init (&play->selection_lock);
|
|
|
|
if (audio_sink != NULL) {
|
|
if (strchr (audio_sink, ' ') != NULL)
|
|
sink = gst_parse_bin_from_description (audio_sink, TRUE, NULL);
|
|
else
|
|
sink = gst_element_factory_make (audio_sink, NULL);
|
|
|
|
if (sink != NULL)
|
|
g_object_set (play->playbin, "audio-sink", sink, NULL);
|
|
else
|
|
g_warning ("Couldn't create specified audio sink '%s'", audio_sink);
|
|
}
|
|
if (video_sink != NULL) {
|
|
if (strchr (video_sink, ' ') != NULL)
|
|
sink = gst_parse_bin_from_description (video_sink, TRUE, NULL);
|
|
else
|
|
sink = gst_element_factory_make (video_sink, NULL);
|
|
|
|
if (sink != NULL)
|
|
g_object_set (play->playbin, "video-sink", sink, NULL);
|
|
else
|
|
g_warning ("Couldn't create specified video sink '%s'", video_sink);
|
|
}
|
|
|
|
if (flags_string != NULL) {
|
|
GParamSpec *pspec;
|
|
GValue val = { 0, };
|
|
|
|
pspec =
|
|
g_object_class_find_property (G_OBJECT_GET_CLASS (playbin), "flags");
|
|
g_value_init (&val, pspec->value_type);
|
|
if (gst_value_deserialize (&val, flags_string))
|
|
g_object_set_property (G_OBJECT (play->playbin), "flags", &val);
|
|
else
|
|
gst_printerr ("Couldn't convert '%s' to playbin flags!\n", flags_string);
|
|
g_value_unset (&val);
|
|
}
|
|
|
|
if (verbose) {
|
|
play->deep_notify_id =
|
|
gst_element_add_property_deep_notify_watch (play->playbin, NULL, TRUE);
|
|
}
|
|
|
|
play->loop = g_main_loop_new (NULL, FALSE);
|
|
|
|
play->bus_watch = gst_bus_add_watch (GST_ELEMENT_BUS (play->playbin),
|
|
play_bus_msg, play);
|
|
|
|
/* FIXME: make configurable incl. 0 for disable */
|
|
play->timeout = g_timeout_add (100, play_timeout, play);
|
|
|
|
play->missing = NULL;
|
|
play->buffering = FALSE;
|
|
play->is_live = FALSE;
|
|
|
|
play->desired_state = GST_STATE_PLAYING;
|
|
|
|
play->gapless = gapless;
|
|
if (gapless) {
|
|
g_signal_connect (play->playbin, "about-to-finish",
|
|
G_CALLBACK (play_about_to_finish), play);
|
|
}
|
|
|
|
if (initial_volume != -1)
|
|
play_set_relative_volume (play, initial_volume - 1.0);
|
|
|
|
play->rate = 1.0;
|
|
play->trick_mode = GST_PLAY_TRICK_MODE_NONE;
|
|
play->start_position = start_position;
|
|
return play;
|
|
}
|
|
|
|
static void
|
|
play_free (GstPlay * play)
|
|
{
|
|
/* No need to see all those pad caps going to NULL etc., it's just noise */
|
|
if (play->deep_notify_id != 0)
|
|
g_signal_handler_disconnect (play->playbin, play->deep_notify_id);
|
|
|
|
play_reset (play);
|
|
|
|
gst_element_set_state (play->playbin, GST_STATE_NULL);
|
|
gst_object_unref (play->playbin);
|
|
|
|
g_source_remove (play->bus_watch);
|
|
g_source_remove (play->timeout);
|
|
g_main_loop_unref (play->loop);
|
|
|
|
g_strfreev (play->uris);
|
|
|
|
if (play->collection)
|
|
gst_object_unref (play->collection);
|
|
g_free (play->cur_audio_sid);
|
|
g_free (play->cur_video_sid);
|
|
g_free (play->cur_text_sid);
|
|
|
|
g_mutex_clear (&play->selection_lock);
|
|
|
|
g_free (play);
|
|
}
|
|
|
|
/* reset for new file/stream */
|
|
static void
|
|
play_reset (GstPlay * play)
|
|
{
|
|
g_list_foreach (play->missing, (GFunc) gst_message_unref, NULL);
|
|
play->missing = NULL;
|
|
|
|
play->buffering = FALSE;
|
|
play->is_live = FALSE;
|
|
}
|
|
|
|
static void
|
|
play_set_relative_volume (GstPlay * play, gdouble volume_step)
|
|
{
|
|
gdouble volume;
|
|
|
|
volume = gst_stream_volume_get_volume (GST_STREAM_VOLUME (play->playbin),
|
|
GST_STREAM_VOLUME_FORMAT_CUBIC);
|
|
|
|
volume = round ((volume + volume_step) * VOLUME_STEPS) / VOLUME_STEPS;
|
|
volume = CLAMP (volume, 0.0, 10.0);
|
|
|
|
gst_stream_volume_set_volume (GST_STREAM_VOLUME (play->playbin),
|
|
GST_STREAM_VOLUME_FORMAT_CUBIC, volume);
|
|
|
|
gst_print (_("Volume: %.0f%%"), volume * 100);
|
|
gst_print (" \n");
|
|
}
|
|
|
|
static void
|
|
play_toggle_audio_mute (GstPlay * play)
|
|
{
|
|
gboolean mute;
|
|
|
|
mute = gst_stream_volume_get_mute (GST_STREAM_VOLUME (play->playbin));
|
|
|
|
mute = !mute;
|
|
gst_stream_volume_set_mute (GST_STREAM_VOLUME (play->playbin), mute);
|
|
|
|
if (mute)
|
|
gst_print (_("Mute: on"));
|
|
else
|
|
gst_print (_("Mute: off"));
|
|
gst_print (" \n");
|
|
}
|
|
|
|
/* returns TRUE if something was installed and we should restart playback */
|
|
static gboolean
|
|
play_install_missing_plugins (GstPlay * play)
|
|
{
|
|
/* FIXME: implement: try to install any missing plugins we haven't
|
|
* tried to install before */
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
play_bus_msg (GstBus * bus, GstMessage * msg, gpointer user_data)
|
|
{
|
|
GstPlay *play = user_data;
|
|
|
|
switch (GST_MESSAGE_TYPE (msg)) {
|
|
case GST_MESSAGE_ASYNC_DONE:
|
|
|
|
/* dump graph on preroll */
|
|
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (play->playbin),
|
|
GST_DEBUG_GRAPH_SHOW_ALL, "gst-play.async-done");
|
|
|
|
gst_print ("Prerolled.\r");
|
|
if (play->missing != NULL && play_install_missing_plugins (play)) {
|
|
gst_print ("New plugins installed, trying again...\n");
|
|
--play->cur_idx;
|
|
play_next (play);
|
|
}
|
|
if (play->start_position > 0.0) {
|
|
play_do_seek (play, play->start_position * GST_SECOND,
|
|
play->rate, play->trick_mode);
|
|
play->start_position = 0;
|
|
}
|
|
break;
|
|
case GST_MESSAGE_BUFFERING:{
|
|
gint percent;
|
|
|
|
if (!play->buffering)
|
|
gst_print ("\n");
|
|
|
|
gst_message_parse_buffering (msg, &percent);
|
|
gst_print ("%s %d%% \r", _("Buffering..."), percent);
|
|
|
|
if (percent == 100) {
|
|
/* a 100% message means buffering is done */
|
|
if (play->buffering) {
|
|
play->buffering = FALSE;
|
|
/* no state management needed for live pipelines */
|
|
if (!play->is_live)
|
|
gst_element_set_state (play->playbin, play->desired_state);
|
|
}
|
|
} else {
|
|
/* buffering... */
|
|
if (!play->buffering) {
|
|
if (!play->is_live)
|
|
gst_element_set_state (play->playbin, GST_STATE_PAUSED);
|
|
play->buffering = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GST_MESSAGE_CLOCK_LOST:{
|
|
gst_print (_("Clock lost, selecting a new one\n"));
|
|
gst_element_set_state (play->playbin, GST_STATE_PAUSED);
|
|
gst_element_set_state (play->playbin, GST_STATE_PLAYING);
|
|
break;
|
|
}
|
|
case GST_MESSAGE_LATENCY:
|
|
gst_print ("Redistribute latency...\n");
|
|
gst_bin_recalculate_latency (GST_BIN (play->playbin));
|
|
break;
|
|
case GST_MESSAGE_REQUEST_STATE:{
|
|
GstState state;
|
|
gchar *name;
|
|
|
|
name = gst_object_get_path_string (GST_MESSAGE_SRC (msg));
|
|
|
|
gst_message_parse_request_state (msg, &state);
|
|
|
|
gst_print ("Setting state to %s as requested by %s...\n",
|
|
gst_element_state_get_name (state), name);
|
|
|
|
gst_element_set_state (play->playbin, state);
|
|
g_free (name);
|
|
break;
|
|
}
|
|
case GST_MESSAGE_EOS:
|
|
/* print final position at end */
|
|
play_timeout (play);
|
|
gst_print ("\n");
|
|
/* and switch to next item in list */
|
|
if (!wait_on_eos && !play_next (play)) {
|
|
gst_print ("%s\n", _("Reached end of play list."));
|
|
g_main_loop_quit (play->loop);
|
|
}
|
|
break;
|
|
case GST_MESSAGE_WARNING:{
|
|
GError *err;
|
|
gchar *dbg = NULL;
|
|
|
|
/* dump graph on warning */
|
|
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (play->playbin),
|
|
GST_DEBUG_GRAPH_SHOW_ALL, "gst-play.warning");
|
|
|
|
gst_message_parse_warning (msg, &err, &dbg);
|
|
gst_printerr ("WARNING %s\n", err->message);
|
|
if (dbg != NULL)
|
|
gst_printerr ("WARNING debug information: %s\n", dbg);
|
|
g_clear_error (&err);
|
|
g_free (dbg);
|
|
break;
|
|
}
|
|
case GST_MESSAGE_ERROR:{
|
|
GError *err;
|
|
gchar *dbg;
|
|
|
|
/* dump graph on error */
|
|
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (play->playbin),
|
|
GST_DEBUG_GRAPH_SHOW_ALL, "gst-play.error");
|
|
|
|
gst_message_parse_error (msg, &err, &dbg);
|
|
gst_printerr ("ERROR %s for %s\n", err->message,
|
|
play->uris[play->cur_idx]);
|
|
if (dbg != NULL)
|
|
gst_printerr ("ERROR debug information: %s\n", dbg);
|
|
g_clear_error (&err);
|
|
g_free (dbg);
|
|
|
|
/* flush any other error messages from the bus and clean up */
|
|
gst_element_set_state (play->playbin, GST_STATE_NULL);
|
|
|
|
if (play->missing != NULL && play_install_missing_plugins (play)) {
|
|
gst_print ("New plugins installed, trying again...\n");
|
|
--play->cur_idx;
|
|
play_next (play);
|
|
break;
|
|
}
|
|
/* try next item in list then */
|
|
if (!play_next (play)) {
|
|
gst_print ("%s\n", _("Reached end of play list."));
|
|
g_main_loop_quit (play->loop);
|
|
}
|
|
break;
|
|
}
|
|
case GST_MESSAGE_ELEMENT:
|
|
{
|
|
GstNavigationMessageType mtype = gst_navigation_message_get_type (msg);
|
|
if (mtype == GST_NAVIGATION_MESSAGE_EVENT) {
|
|
GstEvent *ev = NULL;
|
|
|
|
if (gst_navigation_message_parse_event (msg, &ev)) {
|
|
GstNavigationEventType e_type = gst_navigation_event_get_type (ev);
|
|
switch (e_type) {
|
|
case GST_NAVIGATION_EVENT_KEY_PRESS:
|
|
{
|
|
const gchar *key;
|
|
const gchar *key_input;
|
|
gchar key_adjusted[2];
|
|
|
|
if (gst_navigation_event_parse_key_event (ev, &key)) {
|
|
GST_INFO ("Key press: %s", key);
|
|
|
|
if (strcmp (key, "Left") == 0)
|
|
key = GST_PLAY_KB_ARROW_LEFT;
|
|
else if (strcmp (key, "Right") == 0)
|
|
key = GST_PLAY_KB_ARROW_RIGHT;
|
|
else if (strcmp (key, "Up") == 0)
|
|
key = GST_PLAY_KB_ARROW_UP;
|
|
else if (strcmp (key, "Down") == 0)
|
|
key = GST_PLAY_KB_ARROW_DOWN;
|
|
else if (strncmp (key, "Shift", 5) == 0) {
|
|
play->shift_pressed = TRUE;
|
|
break;
|
|
} else if (strcmp (key, "space") == 0 ||
|
|
strcmp (key, "Space") == 0) {
|
|
key = " ";
|
|
} else if (strcmp (key, "minus") == 0) {
|
|
key = "-";
|
|
} else if (strcmp (key, "plus") == 0
|
|
/* TODO: That's not universally correct at all, but still handy */
|
|
|| (strcmp (key, "equal") == 0 && play->shift_pressed)) {
|
|
key = "+";
|
|
} else if (strlen (key) > 1) {
|
|
break;
|
|
}
|
|
|
|
/* In the case of a simple single-char input,
|
|
* make it lower or upper as needed, and
|
|
* send that instead */
|
|
if (key[0] != '\0' && key[1] == '\0') {
|
|
if (play->shift_pressed)
|
|
key_adjusted[0] = g_ascii_toupper (key[0]);
|
|
else
|
|
key_adjusted[0] = g_ascii_tolower (key[0]);
|
|
key_adjusted[1] = '\0';
|
|
key_input = key_adjusted;
|
|
} else {
|
|
key_input = key;
|
|
}
|
|
|
|
keyboard_cb (key_input, user_data);
|
|
}
|
|
break;
|
|
}
|
|
case GST_NAVIGATION_EVENT_KEY_RELEASE:
|
|
{
|
|
const gchar *key;
|
|
|
|
if (gst_navigation_event_parse_key_event (ev, &key)) {
|
|
GST_INFO ("Key release: %s", key);
|
|
if (strncmp (key, "Shift", 5) == 0) {
|
|
play->shift_pressed = FALSE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case GST_NAVIGATION_EVENT_MOUSE_BUTTON_PRESS:
|
|
{
|
|
gint button;
|
|
if (gst_navigation_event_parse_mouse_button_event (ev, &button,
|
|
NULL, NULL)) {
|
|
if (button == 4) {
|
|
/* wheel up */
|
|
relative_seek (play, +0.08);
|
|
} else if (button == 5) {
|
|
/* wheel down */
|
|
relative_seek (play, -0.01);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (ev)
|
|
gst_event_unref (ev);
|
|
}
|
|
break;
|
|
}
|
|
case GST_MESSAGE_PROPERTY_NOTIFY:{
|
|
const GValue *val;
|
|
const gchar *name;
|
|
GstObject *obj;
|
|
gchar *val_str = NULL;
|
|
gchar *obj_name;
|
|
|
|
gst_message_parse_property_notify (msg, &obj, &name, &val);
|
|
|
|
obj_name = gst_object_get_path_string (GST_OBJECT (obj));
|
|
if (val != NULL) {
|
|
if (G_VALUE_HOLDS_STRING (val))
|
|
val_str = g_value_dup_string (val);
|
|
else if (G_VALUE_TYPE (val) == GST_TYPE_CAPS)
|
|
val_str = gst_caps_to_string (g_value_get_boxed (val));
|
|
else if (G_VALUE_TYPE (val) == GST_TYPE_TAG_LIST)
|
|
val_str = gst_tag_list_to_string (g_value_get_boxed (val));
|
|
else
|
|
val_str = gst_value_serialize (val);
|
|
} else {
|
|
val_str = g_strdup ("(no value)");
|
|
}
|
|
|
|
gst_play_printf ("%s: %s = %s\n", obj_name, name, val_str);
|
|
g_free (obj_name);
|
|
g_free (val_str);
|
|
break;
|
|
}
|
|
case GST_MESSAGE_STREAM_COLLECTION:
|
|
{
|
|
GstStreamCollection *collection = NULL;
|
|
gst_message_parse_stream_collection (msg, &collection);
|
|
|
|
if (collection) {
|
|
g_mutex_lock (&play->selection_lock);
|
|
gst_object_replace ((GstObject **) & play->collection,
|
|
(GstObject *) collection);
|
|
g_mutex_unlock (&play->selection_lock);
|
|
}
|
|
break;
|
|
}
|
|
case GST_MESSAGE_STREAMS_SELECTED:
|
|
{
|
|
GstStreamCollection *collection = NULL;
|
|
guint i, len;
|
|
|
|
gst_message_parse_streams_selected (msg, &collection);
|
|
if (collection) {
|
|
g_mutex_lock (&play->selection_lock);
|
|
gst_object_replace ((GstObject **) & play->collection,
|
|
(GstObject *) collection);
|
|
|
|
/* Free all last stream-ids */
|
|
g_free (play->cur_audio_sid);
|
|
g_free (play->cur_video_sid);
|
|
g_free (play->cur_text_sid);
|
|
play->cur_audio_sid = NULL;
|
|
play->cur_video_sid = NULL;
|
|
play->cur_text_sid = NULL;
|
|
|
|
len = gst_message_streams_selected_get_size (msg);
|
|
for (i = 0; i < len; i++) {
|
|
GstStream *stream = gst_message_streams_selected_get_stream (msg, i);
|
|
if (stream) {
|
|
GstStreamType type = gst_stream_get_stream_type (stream);
|
|
const gchar *stream_id = gst_stream_get_stream_id (stream);
|
|
|
|
if (type & GST_STREAM_TYPE_AUDIO) {
|
|
play->cur_audio_sid = g_strdup (stream_id);
|
|
} else if (type & GST_STREAM_TYPE_VIDEO) {
|
|
play->cur_video_sid = g_strdup (stream_id);
|
|
} else if (type & GST_STREAM_TYPE_TEXT) {
|
|
play->cur_text_sid = g_strdup (stream_id);
|
|
} else {
|
|
gst_print ("Unknown stream type with stream-id %s", stream_id);
|
|
}
|
|
gst_object_unref (stream);
|
|
}
|
|
}
|
|
|
|
gst_object_unref (collection);
|
|
g_mutex_unlock (&play->selection_lock);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
if (gst_is_missing_plugin_message (msg)) {
|
|
gchar *desc;
|
|
|
|
desc = gst_missing_plugin_message_get_description (msg);
|
|
gst_print ("Missing plugin: %s\n", desc);
|
|
g_free (desc);
|
|
play->missing = g_list_append (play->missing, gst_message_ref (msg));
|
|
}
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
play_timeout (gpointer user_data)
|
|
{
|
|
GstPlay *play = user_data;
|
|
gint64 pos = -1, dur = -1;
|
|
const gchar *paused = _("Paused");
|
|
gchar *status;
|
|
|
|
if (play->buffering)
|
|
return TRUE;
|
|
|
|
gst_element_query_position (play->playbin, GST_FORMAT_TIME, &pos);
|
|
gst_element_query_duration (play->playbin, GST_FORMAT_TIME, &dur);
|
|
|
|
if (play->desired_state == GST_STATE_PAUSED) {
|
|
status = (gchar *) paused;
|
|
} else {
|
|
gint len = g_utf8_strlen (paused, -1);
|
|
status = g_newa (gchar, len + 1);
|
|
memset (status, ' ', len);
|
|
status[len] = '\0';
|
|
}
|
|
|
|
if (pos >= 0 && dur > 0) {
|
|
gchar dstr[32], pstr[32];
|
|
|
|
/* FIXME: pretty print in nicer format */
|
|
g_snprintf (pstr, 32, "%" GST_TIME_FORMAT, GST_TIME_ARGS (pos));
|
|
pstr[9] = '\0';
|
|
g_snprintf (dstr, 32, "%" GST_TIME_FORMAT, GST_TIME_ARGS (dur));
|
|
dstr[9] = '\0';
|
|
gst_print ("%s / %s %s\r", pstr, dstr, status);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gchar *
|
|
play_uri_get_display_name (GstPlay * play, const gchar * uri)
|
|
{
|
|
gchar *loc;
|
|
|
|
if (gst_uri_has_protocol (uri, "file")) {
|
|
loc = g_filename_from_uri (uri, NULL, NULL);
|
|
} else if (gst_uri_has_protocol (uri, "pushfile")) {
|
|
loc = g_filename_from_uri (uri + 4, NULL, NULL);
|
|
} else {
|
|
loc = g_strdup (uri);
|
|
}
|
|
|
|
/* Maybe additionally use glib's filename to display name function */
|
|
return loc;
|
|
}
|
|
|
|
static void
|
|
play_uri (GstPlay * play, const gchar * next_uri)
|
|
{
|
|
gchar *loc;
|
|
|
|
gst_element_set_state (play->playbin, GST_STATE_READY);
|
|
play_reset (play);
|
|
|
|
loc = play_uri_get_display_name (play, next_uri);
|
|
gst_print (_("Now playing %s\n"), loc);
|
|
g_free (loc);
|
|
|
|
g_object_set (play->playbin, "uri", next_uri, NULL);
|
|
|
|
switch (gst_element_set_state (play->playbin, GST_STATE_PAUSED)) {
|
|
case GST_STATE_CHANGE_FAILURE:
|
|
/* ignore, we should get an error message posted on the bus */
|
|
break;
|
|
case GST_STATE_CHANGE_NO_PREROLL:
|
|
gst_print ("Pipeline is live.\n");
|
|
play->is_live = TRUE;
|
|
break;
|
|
case GST_STATE_CHANGE_ASYNC:
|
|
gst_print ("Prerolling...\r");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (play->desired_state != GST_STATE_PAUSED)
|
|
gst_element_set_state (play->playbin, play->desired_state);
|
|
}
|
|
|
|
/* returns FALSE if we have reached the end of the playlist */
|
|
static gboolean
|
|
play_next (GstPlay * play)
|
|
{
|
|
if ((play->cur_idx + 1) >= play->num_uris)
|
|
return FALSE;
|
|
|
|
play_uri (play, play->uris[++play->cur_idx]);
|
|
return TRUE;
|
|
}
|
|
|
|
/* returns FALSE if we have reached the beginning of the playlist */
|
|
static gboolean
|
|
play_prev (GstPlay * play)
|
|
{
|
|
if (play->cur_idx == 0 || play->num_uris <= 1)
|
|
return FALSE;
|
|
|
|
play_uri (play, play->uris[--play->cur_idx]);
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
play_about_to_finish (GstElement * playbin, gpointer user_data)
|
|
{
|
|
GstPlay *play = user_data;
|
|
const gchar *next_uri;
|
|
gchar *loc;
|
|
guint next_idx;
|
|
|
|
if (!play->gapless)
|
|
return;
|
|
|
|
next_idx = play->cur_idx + 1;
|
|
if (next_idx >= play->num_uris)
|
|
return;
|
|
|
|
next_uri = play->uris[next_idx];
|
|
loc = play_uri_get_display_name (play, next_uri);
|
|
gst_print (_("About to finish, preparing next title: %s"), loc);
|
|
gst_print ("\n");
|
|
g_free (loc);
|
|
|
|
g_object_set (play->playbin, "uri", next_uri, NULL);
|
|
play->cur_idx = next_idx;
|
|
}
|
|
|
|
static void
|
|
do_play (GstPlay * play)
|
|
{
|
|
gint i;
|
|
|
|
/* dump playlist */
|
|
for (i = 0; i < play->num_uris; ++i)
|
|
GST_INFO ("%4u : %s", i, play->uris[i]);
|
|
|
|
if (!play_next (play))
|
|
return;
|
|
|
|
g_main_loop_run (play->loop);
|
|
}
|
|
|
|
static gint
|
|
compare (gconstpointer a, gconstpointer b)
|
|
{
|
|
gchar *a1, *b1;
|
|
gint ret;
|
|
|
|
a1 = g_utf8_collate_key_for_filename ((gchar *) a, -1);
|
|
b1 = g_utf8_collate_key_for_filename ((gchar *) b, -1);
|
|
ret = strcmp (a1, b1);
|
|
g_free (a1);
|
|
g_free (b1);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
add_to_playlist (GPtrArray * playlist, const gchar * filename)
|
|
{
|
|
GDir *dir;
|
|
gchar *uri;
|
|
|
|
if (gst_uri_is_valid (filename)) {
|
|
g_ptr_array_add (playlist, g_strdup (filename));
|
|
return;
|
|
}
|
|
|
|
if ((dir = g_dir_open (filename, 0, NULL))) {
|
|
const gchar *entry;
|
|
GList *l, *files = NULL;
|
|
|
|
while ((entry = g_dir_read_name (dir))) {
|
|
gchar *path;
|
|
|
|
path = g_build_filename (filename, entry, NULL);
|
|
files = g_list_insert_sorted (files, path, compare);
|
|
}
|
|
|
|
g_dir_close (dir);
|
|
|
|
for (l = files; l != NULL; l = l->next) {
|
|
gchar *path = (gchar *) l->data;
|
|
|
|
add_to_playlist (playlist, path);
|
|
g_free (path);
|
|
}
|
|
g_list_free (files);
|
|
return;
|
|
}
|
|
|
|
uri = gst_filename_to_uri (filename, NULL);
|
|
if (uri != NULL)
|
|
g_ptr_array_add (playlist, uri);
|
|
else
|
|
g_warning ("Could not make URI out of filename '%s'", filename);
|
|
}
|
|
|
|
static void
|
|
shuffle_uris (gchar ** uris, guint num)
|
|
{
|
|
gchar *tmp;
|
|
guint i, j;
|
|
|
|
if (num < 2)
|
|
return;
|
|
|
|
for (i = num - 1; i >= 1; i--) {
|
|
/* +1 because number returned will be in range [a;b[ so excl. stop */
|
|
j = g_random_int_range (0, i + 1);
|
|
tmp = uris[j];
|
|
uris[j] = uris[i];
|
|
uris[i] = tmp;
|
|
}
|
|
}
|
|
|
|
static void
|
|
restore_terminal (void)
|
|
{
|
|
gst_play_kb_set_key_handler (NULL, NULL);
|
|
}
|
|
|
|
static void
|
|
toggle_paused (GstPlay * play)
|
|
{
|
|
if (play->desired_state == GST_STATE_PLAYING)
|
|
play->desired_state = GST_STATE_PAUSED;
|
|
else
|
|
play->desired_state = GST_STATE_PLAYING;
|
|
|
|
if (!play->buffering) {
|
|
gst_element_set_state (play->playbin, play->desired_state);
|
|
} else if (play->desired_state == GST_STATE_PLAYING) {
|
|
gst_print ("\nWill play as soon as buffering finishes)\n");
|
|
}
|
|
}
|
|
|
|
static void
|
|
relative_seek (GstPlay * play, gdouble percent)
|
|
{
|
|
GstQuery *query;
|
|
gboolean seekable = FALSE;
|
|
gint64 dur = -1, pos = -1, step;
|
|
|
|
g_return_if_fail (percent >= -1.0 && percent <= 1.0);
|
|
|
|
if (!gst_element_query_position (play->playbin, GST_FORMAT_TIME, &pos))
|
|
goto seek_failed;
|
|
|
|
query = gst_query_new_seeking (GST_FORMAT_TIME);
|
|
if (!gst_element_query (play->playbin, query)) {
|
|
gst_query_unref (query);
|
|
goto seek_failed;
|
|
}
|
|
|
|
gst_query_parse_seeking (query, NULL, &seekable, NULL, &dur);
|
|
gst_query_unref (query);
|
|
|
|
if (!seekable || dur <= 0)
|
|
goto seek_failed;
|
|
|
|
step = dur * percent;
|
|
if (ABS (step) < GST_SECOND)
|
|
step = (percent < 0) ? -GST_SECOND : GST_SECOND;
|
|
|
|
pos = pos + step;
|
|
if (pos > dur) {
|
|
if (!play_next (play)) {
|
|
gst_print ("\n%s\n", _("Reached end of play list."));
|
|
g_main_loop_quit (play->loop);
|
|
}
|
|
} else {
|
|
if (pos < 0)
|
|
pos = 0;
|
|
|
|
play_do_seek (play, pos, play->rate, play->trick_mode);
|
|
}
|
|
|
|
return;
|
|
|
|
seek_failed:
|
|
{
|
|
gst_print ("\nCould not seek.\n");
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
play_set_rate_and_trick_mode (GstPlay * play, gdouble rate,
|
|
GstPlayTrickMode mode)
|
|
{
|
|
gint64 pos = -1;
|
|
|
|
g_return_val_if_fail (rate != 0, FALSE);
|
|
|
|
if (!gst_element_query_position (play->playbin, GST_FORMAT_TIME, &pos))
|
|
return FALSE;
|
|
|
|
return play_do_seek (play, pos, rate, mode);
|
|
}
|
|
|
|
static gboolean
|
|
play_do_seek (GstPlay * play, gint64 pos, gdouble rate, GstPlayTrickMode mode)
|
|
{
|
|
GstSeekFlags seek_flags;
|
|
GstQuery *query;
|
|
GstEvent *seek;
|
|
gboolean seekable = FALSE;
|
|
|
|
query = gst_query_new_seeking (GST_FORMAT_TIME);
|
|
if (!gst_element_query (play->playbin, query)) {
|
|
gst_query_unref (query);
|
|
return FALSE;
|
|
}
|
|
|
|
gst_query_parse_seeking (query, NULL, &seekable, NULL, NULL);
|
|
gst_query_unref (query);
|
|
|
|
if (!seekable)
|
|
return FALSE;
|
|
|
|
seek_flags = 0;
|
|
|
|
switch (mode) {
|
|
case GST_PLAY_TRICK_MODE_DEFAULT:
|
|
seek_flags |= GST_SEEK_FLAG_TRICKMODE;
|
|
break;
|
|
case GST_PLAY_TRICK_MODE_DEFAULT_NO_AUDIO:
|
|
seek_flags |= GST_SEEK_FLAG_TRICKMODE | GST_SEEK_FLAG_TRICKMODE_NO_AUDIO;
|
|
break;
|
|
case GST_PLAY_TRICK_MODE_KEY_UNITS:
|
|
seek_flags |= GST_SEEK_FLAG_TRICKMODE_KEY_UNITS;
|
|
break;
|
|
case GST_PLAY_TRICK_MODE_KEY_UNITS_NO_AUDIO:
|
|
seek_flags |=
|
|
GST_SEEK_FLAG_TRICKMODE_KEY_UNITS | GST_SEEK_FLAG_TRICKMODE_NO_AUDIO;
|
|
break;
|
|
case GST_PLAY_TRICK_MODE_NONE:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* See if we can do an instant rate change (not changing dir) */
|
|
if (mode & GST_PLAY_TRICK_MODE_INSTANT_RATE && rate * play->rate > 0) {
|
|
seek = gst_event_new_seek (rate, GST_FORMAT_TIME,
|
|
seek_flags | GST_SEEK_FLAG_INSTANT_RATE_CHANGE,
|
|
GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE,
|
|
GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
|
|
if (gst_element_send_event (play->playbin, seek)) {
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
/* No instant rate change, need to do a flushing seek */
|
|
seek_flags |= GST_SEEK_FLAG_FLUSH;
|
|
if (rate >= 0)
|
|
seek = gst_event_new_seek (rate, GST_FORMAT_TIME,
|
|
seek_flags | GST_SEEK_FLAG_ACCURATE,
|
|
/* start */ GST_SEEK_TYPE_SET, pos,
|
|
/* stop */ GST_SEEK_TYPE_SET, GST_CLOCK_TIME_NONE);
|
|
else
|
|
seek = gst_event_new_seek (rate, GST_FORMAT_TIME,
|
|
seek_flags | GST_SEEK_FLAG_ACCURATE,
|
|
/* start */ GST_SEEK_TYPE_SET, 0,
|
|
/* stop */ GST_SEEK_TYPE_SET, pos);
|
|
|
|
if (!gst_element_send_event (play->playbin, seek))
|
|
return FALSE;
|
|
|
|
done:
|
|
play->rate = rate;
|
|
play->trick_mode = mode & ~GST_PLAY_TRICK_MODE_INSTANT_RATE;
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
play_set_playback_rate (GstPlay * play, gdouble rate)
|
|
{
|
|
GstPlayTrickMode mode = play->trick_mode;
|
|
|
|
if (instant_rate_changes)
|
|
mode |= GST_PLAY_TRICK_MODE_INSTANT_RATE;
|
|
|
|
if (play_set_rate_and_trick_mode (play, rate, mode)) {
|
|
gst_print (_("Playback rate: %.2f"), rate);
|
|
gst_print (" \n");
|
|
} else {
|
|
gst_print ("\n");
|
|
gst_print (_("Could not change playback rate to %.2f"), rate);
|
|
gst_print (".\n");
|
|
}
|
|
}
|
|
|
|
static void
|
|
play_set_relative_playback_rate (GstPlay * play, gdouble rate_step,
|
|
gboolean reverse_direction)
|
|
{
|
|
gdouble new_rate = play->rate + rate_step;
|
|
|
|
if (reverse_direction)
|
|
new_rate *= -1.0;
|
|
|
|
play_set_playback_rate (play, new_rate);
|
|
}
|
|
|
|
static const gchar *
|
|
trick_mode_get_description (GstPlayTrickMode mode)
|
|
{
|
|
switch (mode) {
|
|
case GST_PLAY_TRICK_MODE_NONE:
|
|
return "normal playback, trick modes disabled";
|
|
case GST_PLAY_TRICK_MODE_DEFAULT:
|
|
return "trick mode: default";
|
|
case GST_PLAY_TRICK_MODE_DEFAULT_NO_AUDIO:
|
|
return "trick mode: default, no audio";
|
|
case GST_PLAY_TRICK_MODE_KEY_UNITS:
|
|
return "trick mode: key frames only";
|
|
case GST_PLAY_TRICK_MODE_KEY_UNITS_NO_AUDIO:
|
|
return "trick mode: key frames only, no audio";
|
|
default:
|
|
break;
|
|
}
|
|
return "unknown trick mode";
|
|
}
|
|
|
|
static void
|
|
play_switch_trick_mode (GstPlay * play)
|
|
{
|
|
GstPlayTrickMode new_mode = ++play->trick_mode;
|
|
const gchar *mode_desc;
|
|
|
|
if (new_mode == GST_PLAY_TRICK_MODE_LAST)
|
|
new_mode = GST_PLAY_TRICK_MODE_NONE;
|
|
|
|
mode_desc = trick_mode_get_description (new_mode);
|
|
|
|
if (play_set_rate_and_trick_mode (play, play->rate, new_mode)) {
|
|
gst_print ("Rate: %.2f (%s) \n", play->rate,
|
|
mode_desc);
|
|
} else {
|
|
gst_print ("\nCould not change trick mode to %s.\n", mode_desc);
|
|
}
|
|
}
|
|
|
|
static GstStream *
|
|
play_get_nth_stream_in_collection (GstPlay * play, guint index,
|
|
GstPlayTrackType track_type)
|
|
{
|
|
guint len, i, n_streams = 0;
|
|
GstStreamType target_type;
|
|
|
|
switch (track_type) {
|
|
case GST_PLAY_TRACK_TYPE_AUDIO:
|
|
target_type = GST_STREAM_TYPE_AUDIO;
|
|
break;
|
|
case GST_PLAY_TRACK_TYPE_VIDEO:
|
|
target_type = GST_STREAM_TYPE_VIDEO;
|
|
break;
|
|
case GST_PLAY_TRACK_TYPE_SUBTITLE:
|
|
target_type = GST_STREAM_TYPE_TEXT;
|
|
break;
|
|
default:
|
|
return NULL;
|
|
}
|
|
|
|
len = gst_stream_collection_get_size (play->collection);
|
|
|
|
for (i = 0; i < len; i++) {
|
|
GstStream *stream = gst_stream_collection_get_stream (play->collection, i);
|
|
GstStreamType type = gst_stream_get_stream_type (stream);
|
|
|
|
if (type & target_type) {
|
|
if (index == n_streams)
|
|
return stream;
|
|
|
|
n_streams++;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
play_cycle_track_selection (GstPlay * play, GstPlayTrackType track_type,
|
|
gboolean forward)
|
|
{
|
|
const gchar *prop_cur, *prop_n, *prop_get, *name;
|
|
gint cur = -1, n = -1;
|
|
guint flag, cur_flags;
|
|
|
|
/* playbin3 variables */
|
|
GList *selected_streams = NULL;
|
|
gint cur_audio_idx = -1, cur_video_idx = -1, cur_text_idx = -1;
|
|
gint nb_audio = 0, nb_video = 0, nb_text = 0;
|
|
guint len, i;
|
|
|
|
g_mutex_lock (&play->selection_lock);
|
|
if (play->is_playbin3) {
|
|
if (!play->collection) {
|
|
gst_print ("No stream-collection\n");
|
|
g_mutex_unlock (&play->selection_lock);
|
|
return;
|
|
}
|
|
|
|
/* Check the total number of streams of each type */
|
|
len = gst_stream_collection_get_size (play->collection);
|
|
for (i = 0; i < len; i++) {
|
|
GstStream *stream =
|
|
gst_stream_collection_get_stream (play->collection, i);
|
|
if (stream) {
|
|
GstStreamType type = gst_stream_get_stream_type (stream);
|
|
const gchar *sid = gst_stream_get_stream_id (stream);
|
|
|
|
if (type & GST_STREAM_TYPE_AUDIO) {
|
|
if (play->cur_audio_sid && !g_strcmp0 (play->cur_audio_sid, sid))
|
|
cur_audio_idx = nb_audio;
|
|
nb_audio++;
|
|
} else if (type & GST_STREAM_TYPE_VIDEO) {
|
|
if (play->cur_video_sid && !g_strcmp0 (play->cur_video_sid, sid))
|
|
cur_video_idx = nb_video;
|
|
nb_video++;
|
|
} else if (type & GST_STREAM_TYPE_TEXT) {
|
|
if (play->cur_text_sid && !g_strcmp0 (play->cur_text_sid, sid))
|
|
cur_text_idx = nb_text;
|
|
nb_text++;
|
|
} else {
|
|
gst_print ("Unknown stream type with stream-id %s", sid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (track_type) {
|
|
case GST_PLAY_TRACK_TYPE_AUDIO:
|
|
prop_get = "get-audio-tags";
|
|
prop_cur = "current-audio";
|
|
prop_n = "n-audio";
|
|
name = "audio";
|
|
flag = 0x2;
|
|
if (play->is_playbin3) {
|
|
n = nb_audio;
|
|
cur = cur_audio_idx;
|
|
if (play->cur_video_sid) {
|
|
selected_streams =
|
|
g_list_append (selected_streams, play->cur_video_sid);
|
|
}
|
|
if (play->cur_text_sid) {
|
|
selected_streams =
|
|
g_list_append (selected_streams, play->cur_text_sid);
|
|
}
|
|
}
|
|
break;
|
|
case GST_PLAY_TRACK_TYPE_VIDEO:
|
|
prop_get = "get-video-tags";
|
|
prop_cur = "current-video";
|
|
prop_n = "n-video";
|
|
name = "video";
|
|
flag = 0x1;
|
|
if (play->is_playbin3) {
|
|
n = nb_video;
|
|
cur = cur_video_idx;
|
|
if (play->cur_audio_sid) {
|
|
selected_streams =
|
|
g_list_append (selected_streams, play->cur_audio_sid);
|
|
}
|
|
if (play->cur_text_sid) {
|
|
selected_streams =
|
|
g_list_append (selected_streams, play->cur_text_sid);
|
|
}
|
|
}
|
|
break;
|
|
case GST_PLAY_TRACK_TYPE_SUBTITLE:
|
|
prop_get = "get-text-tags";
|
|
prop_cur = "current-text";
|
|
prop_n = "n-text";
|
|
name = "subtitle";
|
|
flag = 0x4;
|
|
if (play->is_playbin3) {
|
|
n = nb_text;
|
|
cur = cur_text_idx;
|
|
if (play->cur_audio_sid) {
|
|
selected_streams =
|
|
g_list_append (selected_streams, play->cur_audio_sid);
|
|
}
|
|
if (play->cur_video_sid) {
|
|
selected_streams =
|
|
g_list_append (selected_streams, play->cur_video_sid);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
if (play->is_playbin3) {
|
|
if (n > 0) {
|
|
if (forward) {
|
|
if (cur < 0)
|
|
cur = 0;
|
|
else
|
|
cur = (cur + 1) % (n + 1);
|
|
} else {
|
|
if (cur <= 0)
|
|
cur = n;
|
|
else
|
|
cur = (cur - 1) % (n + 1);
|
|
}
|
|
}
|
|
} else {
|
|
g_object_get (play->playbin, prop_cur, &cur, prop_n, &n, "flags",
|
|
&cur_flags, NULL);
|
|
|
|
if (forward) {
|
|
if (!(cur_flags & flag))
|
|
cur = 0;
|
|
else
|
|
cur = (cur + 1) % (n + 1);
|
|
|
|
} else {
|
|
if (cur <= 0)
|
|
cur = n;
|
|
else
|
|
cur = (cur - 1) % (n + 1);
|
|
}
|
|
}
|
|
|
|
if (n < 1) {
|
|
gst_print ("No %s tracks.\n", name);
|
|
g_mutex_unlock (&play->selection_lock);
|
|
} else {
|
|
gchar *lcode = NULL, *lname = NULL;
|
|
const gchar *lang = NULL;
|
|
GstTagList *tags = NULL;
|
|
|
|
if (cur >= n && track_type != GST_PLAY_TRACK_TYPE_VIDEO) {
|
|
cur = -1;
|
|
gst_print ("Disabling %s. \n", name);
|
|
if (play->is_playbin3) {
|
|
/* Just make it empty for the track type */
|
|
} else if (cur_flags & flag) {
|
|
cur_flags &= ~flag;
|
|
g_object_set (play->playbin, "flags", cur_flags, NULL);
|
|
}
|
|
} else {
|
|
/* For video we only want to switch between streams, not disable it altogether */
|
|
if (cur >= n)
|
|
cur = 0;
|
|
|
|
if (play->is_playbin3) {
|
|
GstStream *stream;
|
|
|
|
stream = play_get_nth_stream_in_collection (play, cur, track_type);
|
|
if (stream) {
|
|
selected_streams = g_list_append (selected_streams,
|
|
(gchar *) gst_stream_get_stream_id (stream));
|
|
tags = gst_stream_get_tags (stream);
|
|
} else {
|
|
gst_print ("Collection has no stream for track %d of %d.\n",
|
|
cur + 1, n);
|
|
}
|
|
} else {
|
|
if (!(cur_flags & flag) && track_type != GST_PLAY_TRACK_TYPE_VIDEO) {
|
|
cur_flags |= flag;
|
|
g_object_set (play->playbin, "flags", cur_flags, NULL);
|
|
}
|
|
g_signal_emit_by_name (play->playbin, prop_get, cur, &tags);
|
|
}
|
|
|
|
if (tags != NULL) {
|
|
if (gst_tag_list_get_string (tags, GST_TAG_LANGUAGE_CODE, &lcode))
|
|
lang = gst_tag_get_language_name (lcode);
|
|
else if (gst_tag_list_get_string (tags, GST_TAG_LANGUAGE_NAME, &lname))
|
|
lang = lname;
|
|
gst_tag_list_unref (tags);
|
|
}
|
|
if (lang != NULL)
|
|
gst_print ("Switching to %s track %d of %d (%s).\n", name, cur + 1, n,
|
|
lang);
|
|
else
|
|
gst_print ("Switching to %s track %d of %d.\n", name, cur + 1, n);
|
|
}
|
|
g_free (lcode);
|
|
g_free (lname);
|
|
g_mutex_unlock (&play->selection_lock);
|
|
|
|
if (play->is_playbin3) {
|
|
if (selected_streams)
|
|
gst_element_send_event (play->playbin,
|
|
gst_event_new_select_streams (selected_streams));
|
|
else
|
|
gst_print ("Can't disable all streams !\n");
|
|
} else {
|
|
g_object_set (play->playbin, prop_cur, cur, NULL);
|
|
}
|
|
}
|
|
|
|
if (selected_streams)
|
|
g_list_free (selected_streams);
|
|
}
|
|
|
|
static void
|
|
print_keyboard_help (void)
|
|
{
|
|
/* *INDENT-OFF* */
|
|
static struct
|
|
{
|
|
const gchar *key_desc;
|
|
const gchar *key_help;
|
|
} key_controls[] = {
|
|
{
|
|
N_("space"), N_("pause/unpause")}, {
|
|
N_("q or ESC"), N_("quit")}, {
|
|
N_("> or n"), N_("play next")}, {
|
|
N_("< or b"), N_("play previous")}, {
|
|
"\342\206\222", N_("seek forward")}, {
|
|
"\342\206\220", N_("seek backward")}, {
|
|
"\342\206\221", N_("volume up")}, {
|
|
"\342\206\223", N_("volume down")}, {
|
|
"m", N_("toggle audio mute on/off")}, {
|
|
"+", N_("increase playback rate")}, {
|
|
"-", N_("decrease playback rate")}, {
|
|
"d", N_("change playback direction")}, {
|
|
"t", N_("enable/disable trick modes")}, {
|
|
"A/a", N_("change to previous/next audio track")}, {
|
|
"V/v", N_("change to previous/next video track")}, {
|
|
"S/s", N_("change to previous/next subtitle track")}, {
|
|
"0", N_("seek to beginning")}, {
|
|
"k", N_("show keyboard shortcuts")},};
|
|
/* *INDENT-ON* */
|
|
guint i, chars_to_pad, desc_len, max_desc_len = 0;
|
|
|
|
gst_print ("\n\n%s\n\n", _("Interactive mode - keyboard controls:"));
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (key_controls); ++i) {
|
|
desc_len = g_utf8_strlen (key_controls[i].key_desc, -1);
|
|
max_desc_len = MAX (max_desc_len, desc_len);
|
|
}
|
|
++max_desc_len;
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (key_controls); ++i) {
|
|
chars_to_pad = max_desc_len - g_utf8_strlen (key_controls[i].key_desc, -1);
|
|
gst_print ("\t%s", key_controls[i].key_desc);
|
|
gst_print ("%-*s: ", chars_to_pad, "");
|
|
gst_print ("%s\n", key_controls[i].key_help);
|
|
}
|
|
gst_print ("\n");
|
|
}
|
|
|
|
static void
|
|
keyboard_cb (const gchar * key_input, gpointer user_data)
|
|
{
|
|
GstPlay *play = (GstPlay *) user_data;
|
|
gchar key = '\0';
|
|
|
|
/* Switch on the first char for single char inputs,
|
|
* otherwise leave key = '\0' to fall through to
|
|
* the default case below */
|
|
if (key_input[0] != '\0' && key_input[1] == '\0') {
|
|
key = key_input[0];
|
|
}
|
|
|
|
switch (key) {
|
|
case 'k':
|
|
print_keyboard_help ();
|
|
break;
|
|
case ' ':
|
|
toggle_paused (play);
|
|
break;
|
|
case 'q':
|
|
case 'Q':
|
|
g_main_loop_quit (play->loop);
|
|
break;
|
|
case 'n':
|
|
case '>':
|
|
if (!play_next (play)) {
|
|
gst_print ("\n%s\n", _("Reached end of play list."));
|
|
g_main_loop_quit (play->loop);
|
|
}
|
|
break;
|
|
case 'b':
|
|
case '<':
|
|
play_prev (play);
|
|
break;
|
|
case '+':
|
|
if (play->rate > -0.2 && play->rate < 0.0)
|
|
play_set_relative_playback_rate (play, 0.0, TRUE);
|
|
else if (ABS (play->rate) < 2.0)
|
|
play_set_relative_playback_rate (play, 0.1, FALSE);
|
|
else if (ABS (play->rate) < 4.0)
|
|
play_set_relative_playback_rate (play, 0.5, FALSE);
|
|
else
|
|
play_set_relative_playback_rate (play, 1.0, FALSE);
|
|
break;
|
|
case '-':
|
|
if (play->rate > 0.0 && play->rate < 0.20)
|
|
play_set_relative_playback_rate (play, 0.0, TRUE);
|
|
else if (ABS (play->rate) <= 2.0)
|
|
play_set_relative_playback_rate (play, -0.1, FALSE);
|
|
else if (ABS (play->rate) <= 4.0)
|
|
play_set_relative_playback_rate (play, -0.5, FALSE);
|
|
else
|
|
play_set_relative_playback_rate (play, -1.0, FALSE);
|
|
break;
|
|
case 'd':
|
|
play_set_relative_playback_rate (play, 0.0, TRUE);
|
|
break;
|
|
case 't':
|
|
play_switch_trick_mode (play);
|
|
break;
|
|
case 27: /* ESC */
|
|
if (key_input[1] == '\0') {
|
|
g_main_loop_quit (play->loop);
|
|
break;
|
|
}
|
|
case 'a':
|
|
case 'A':
|
|
play_cycle_track_selection (play, GST_PLAY_TRACK_TYPE_AUDIO, key == 'a');
|
|
break;
|
|
case 'v':
|
|
case 'V':
|
|
play_cycle_track_selection (play, GST_PLAY_TRACK_TYPE_VIDEO, key == 'v');
|
|
break;
|
|
case 's':
|
|
case 'S':
|
|
play_cycle_track_selection (play, GST_PLAY_TRACK_TYPE_SUBTITLE,
|
|
key == 's');
|
|
break;
|
|
case '0':
|
|
play_do_seek (play, 0, play->rate, play->trick_mode);
|
|
break;
|
|
case 'm':
|
|
play_toggle_audio_mute (play);
|
|
break;
|
|
default:
|
|
if (strcmp (key_input, GST_PLAY_KB_ARROW_RIGHT) == 0) {
|
|
relative_seek (play, +0.08);
|
|
} else if (strcmp (key_input, GST_PLAY_KB_ARROW_LEFT) == 0) {
|
|
relative_seek (play, -0.01);
|
|
} else if (strcmp (key_input, GST_PLAY_KB_ARROW_UP) == 0) {
|
|
play_set_relative_volume (play, +1.0 / VOLUME_STEPS);
|
|
} else if (strcmp (key_input, GST_PLAY_KB_ARROW_DOWN) == 0) {
|
|
play_set_relative_volume (play, -1.0 / VOLUME_STEPS);
|
|
} else {
|
|
GST_INFO ("keyboard input:");
|
|
for (; *key_input != '\0'; ++key_input)
|
|
GST_INFO (" code %3d", *key_input);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
#ifdef HAVE_WINMM
|
|
static guint
|
|
enable_winmm_timer_resolution (void)
|
|
{
|
|
TIMECAPS time_caps;
|
|
guint resolution = 0;
|
|
MMRESULT res;
|
|
|
|
res = timeGetDevCaps (&time_caps, sizeof (TIMECAPS));
|
|
if (res != TIMERR_NOERROR) {
|
|
g_warning ("timeGetDevCaps() returned non-zero code %d", res);
|
|
return 0;
|
|
}
|
|
|
|
resolution = MIN (MAX (time_caps.wPeriodMin, 1), time_caps.wPeriodMax);
|
|
res = timeBeginPeriod (resolution);
|
|
if (res != TIMERR_NOERROR) {
|
|
g_warning ("timeBeginPeriod() returned non-zero code %d", res);
|
|
return 0;
|
|
}
|
|
|
|
gst_println (_("Use Windows high-resolution clock, precision: %u ms\n"),
|
|
resolution);
|
|
|
|
return resolution;
|
|
}
|
|
|
|
static void
|
|
clear_winmm_timer_resolution (guint resolution)
|
|
{
|
|
if (resolution == 0)
|
|
return;
|
|
|
|
timeEndPeriod (resolution);
|
|
}
|
|
#endif
|
|
|
|
int
|
|
main (int argc, char **argv)
|
|
{
|
|
GstPlay *play;
|
|
GPtrArray *playlist;
|
|
gboolean verbose = FALSE;
|
|
gboolean print_version = FALSE;
|
|
gboolean interactive = TRUE;
|
|
gboolean gapless = FALSE;
|
|
gboolean shuffle = FALSE;
|
|
gdouble volume = -1;
|
|
gdouble start_position = 0;
|
|
gchar **filenames = NULL;
|
|
gchar *audio_sink = NULL;
|
|
gchar *video_sink = NULL;
|
|
gchar **uris;
|
|
gchar *flags = NULL;
|
|
guint num, i;
|
|
GError *err = NULL;
|
|
GOptionContext *ctx;
|
|
gchar *playlist_file = NULL;
|
|
gboolean use_playbin3 = FALSE;
|
|
#ifdef HAVE_WINMM
|
|
guint winmm_timer_resolution = 0;
|
|
#endif
|
|
GOptionEntry options[] = {
|
|
{"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
|
|
N_("Output status information and property notifications"), NULL},
|
|
{"flags", 0, 0, G_OPTION_ARG_STRING, &flags,
|
|
N_("Control playback behaviour setting playbin 'flags' property"),
|
|
NULL},
|
|
{"version", 0, 0, G_OPTION_ARG_NONE, &print_version,
|
|
N_("Print version information and exit"), NULL},
|
|
{"videosink", 0, 0, G_OPTION_ARG_STRING, &video_sink,
|
|
N_("Video sink to use (default is autovideosink)"), NULL},
|
|
{"audiosink", 0, 0, G_OPTION_ARG_STRING, &audio_sink,
|
|
N_("Audio sink to use (default is autoaudiosink)"), NULL},
|
|
{"gapless", 0, 0, G_OPTION_ARG_NONE, &gapless,
|
|
N_("Enable gapless playback"), NULL},
|
|
{"shuffle", 0, 0, G_OPTION_ARG_NONE, &shuffle,
|
|
N_("Shuffle playlist"), NULL},
|
|
{"no-interactive", 0, G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE,
|
|
&interactive,
|
|
N_("Disable interactive control via the keyboard"), NULL},
|
|
{"volume", 0, 0, G_OPTION_ARG_DOUBLE, &volume,
|
|
N_("Volume"), NULL},
|
|
{"start-position", 's', 0, G_OPTION_ARG_DOUBLE, &start_position,
|
|
N_("Start position in seconds."), NULL},
|
|
{"playlist", 0, 0, G_OPTION_ARG_FILENAME, &playlist_file,
|
|
N_("Playlist file containing input media files"), NULL},
|
|
{"instant-rate-changes", 'i', 0, G_OPTION_ARG_NONE, &instant_rate_changes,
|
|
N_
|
|
("Use the experimental instant-rate-change flag when changing rate"),
|
|
NULL},
|
|
{"quiet", 'q', 0, G_OPTION_ARG_NONE, &quiet,
|
|
N_("Do not print any output (apart from errors)"), NULL},
|
|
{"use-playbin3", 0, 0, G_OPTION_ARG_NONE, &use_playbin3,
|
|
N_("Use playbin3 pipeline")
|
|
N_("(default varies depending on 'USE_PLAYBIN' env variable)"),
|
|
NULL},
|
|
{"wait-on-eos", 0, 0, G_OPTION_ARG_NONE, &wait_on_eos,
|
|
N_
|
|
("Keep showing the last frame on EOS until quit or playlist change command "
|
|
"(gapless is ignored)"),
|
|
NULL},
|
|
{G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &filenames, NULL},
|
|
{NULL}
|
|
};
|
|
|
|
setlocale (LC_ALL, "");
|
|
|
|
#ifdef ENABLE_NLS
|
|
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
|
|
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
|
|
textdomain (GETTEXT_PACKAGE);
|
|
#endif
|
|
|
|
g_set_prgname ("gst-play-" GST_API_VERSION);
|
|
/* Ensure XInitThreads() is called if/when needed */
|
|
g_setenv ("GST_GL_XINITTHREADS", "1", TRUE);
|
|
|
|
ctx = g_option_context_new ("FILE1|URI1 [FILE2|URI2] [FILE3|URI3] ...");
|
|
g_option_context_add_main_entries (ctx, options, GETTEXT_PACKAGE);
|
|
g_option_context_add_group (ctx, gst_init_get_option_group ());
|
|
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
|
|
gst_print ("Error initializing: %s\n", GST_STR_NULL (err->message));
|
|
g_option_context_free (ctx);
|
|
g_clear_error (&err);
|
|
return 1;
|
|
}
|
|
g_option_context_free (ctx);
|
|
|
|
GST_DEBUG_CATEGORY_INIT (play_debug, "play", 0, "gst-play");
|
|
|
|
if (print_version) {
|
|
gchar *version_str;
|
|
|
|
version_str = gst_version_string ();
|
|
gst_print ("%s version %s\n", g_get_prgname (), PACKAGE_VERSION);
|
|
gst_print ("%s\n", version_str);
|
|
gst_print ("%s\n", GST_PACKAGE_ORIGIN);
|
|
g_free (version_str);
|
|
|
|
g_free (audio_sink);
|
|
g_free (video_sink);
|
|
g_free (playlist_file);
|
|
|
|
return 0;
|
|
}
|
|
|
|
if (wait_on_eos)
|
|
gapless = FALSE;
|
|
|
|
playlist = g_ptr_array_new ();
|
|
|
|
if (playlist_file != NULL) {
|
|
gchar *playlist_contents = NULL;
|
|
gchar **lines = NULL;
|
|
|
|
if (g_file_get_contents (playlist_file, &playlist_contents, NULL, &err)) {
|
|
lines = g_strsplit (playlist_contents, "\n", 0);
|
|
num = g_strv_length (lines);
|
|
|
|
for (i = 0; i < num; i++) {
|
|
if (lines[i][0] != '\0') {
|
|
GST_LOG ("Playlist[%d]: %s", i + 1, lines[i]);
|
|
add_to_playlist (playlist, lines[i]);
|
|
}
|
|
}
|
|
g_strfreev (lines);
|
|
g_free (playlist_contents);
|
|
} else {
|
|
gst_printerr ("Could not read playlist: %s\n", err->message);
|
|
g_clear_error (&err);
|
|
}
|
|
g_free (playlist_file);
|
|
playlist_file = NULL;
|
|
}
|
|
|
|
if (playlist->len == 0 && (filenames == NULL || *filenames == NULL)) {
|
|
gst_printerr (_("Usage: %s FILE1|URI1 [FILE2|URI2] [FILE3|URI3] ..."),
|
|
"gst-play-" GST_API_VERSION);
|
|
gst_printerr ("\n\n"),
|
|
gst_printerr ("%s\n\n",
|
|
_("You must provide at least one filename or URI to play."));
|
|
/* No input provided. Free array */
|
|
g_ptr_array_free (playlist, TRUE);
|
|
|
|
g_free (audio_sink);
|
|
g_free (video_sink);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* fill playlist */
|
|
if (filenames != NULL && *filenames != NULL) {
|
|
num = g_strv_length (filenames);
|
|
for (i = 0; i < num; ++i) {
|
|
GST_LOG ("command line argument: %s", filenames[i]);
|
|
add_to_playlist (playlist, filenames[i]);
|
|
}
|
|
g_strfreev (filenames);
|
|
}
|
|
|
|
num = playlist->len;
|
|
g_ptr_array_add (playlist, NULL);
|
|
|
|
uris = (gchar **) g_ptr_array_free (playlist, FALSE);
|
|
|
|
if (shuffle)
|
|
shuffle_uris (uris, num);
|
|
|
|
/* prepare */
|
|
play = play_new (uris, audio_sink, video_sink, gapless, volume, verbose,
|
|
flags, use_playbin3, start_position);
|
|
|
|
if (play == NULL) {
|
|
gst_printerr
|
|
("Failed to create 'playbin' element. Check your GStreamer installation.\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
#ifdef HAVE_WINMM
|
|
/* Enable high-precision clock which will improve accuracy of various
|
|
* Windows timer APIs (e.g., Sleep()), and it will increase the precision
|
|
* of GstSystemClock as well
|
|
*/
|
|
|
|
/* NOTE: Once timer resolution is updated via timeBeginPeriod(),
|
|
* application should undo it by calling timeEndPeriod()
|
|
*
|
|
* Prior to Windows 10, version 2004, timeBeginPeriod() affects global
|
|
* Windows setting (meaning that it will affect other processes),
|
|
* but starting with Windows 10, version 2004, this function no longer
|
|
* affects global timer resolution
|
|
*/
|
|
winmm_timer_resolution = enable_winmm_timer_resolution ();
|
|
#endif
|
|
|
|
if (interactive) {
|
|
if (gst_play_kb_set_key_handler (keyboard_cb, play)) {
|
|
gst_print (_("Press 'k' to see a list of keyboard shortcuts.\n"));
|
|
atexit (restore_terminal);
|
|
} else {
|
|
gst_print ("Interactive keyboard handling in terminal not available.\n");
|
|
}
|
|
}
|
|
|
|
/* play */
|
|
do_play (play);
|
|
|
|
#ifdef HAVE_WINMM
|
|
/* Undo timeBeginPeriod() if required */
|
|
clear_winmm_timer_resolution (winmm_timer_resolution);
|
|
#endif
|
|
|
|
/* clean up */
|
|
play_free (play);
|
|
|
|
g_free (audio_sink);
|
|
g_free (video_sink);
|
|
|
|
gst_print ("\n");
|
|
gst_deinit ();
|
|
return 0;
|
|
}
|