tools/gst-play.c

   1 /* GStreamer command line playback testing utility
   2  *
   3  * Copyright (C) 2013-2014 Tim-Philipp Müller <tim centricular net>
   4  * Copyright (C) 2013 Collabora Ltd.
   5  * Copyright (C) 2015 Centricular Ltd
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  20  * Boston, MA 02110-1301, USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <locale.h>
  28
  29 #include <gst/gst.h>
  30 #include <gst/gst-i18n-app.h>
  31 #include <gst/audio/audio.h>
  32 #include <gst/video/video.h>
  33 #include <gst/pbutils/pbutils.h>
  34 #include <gst/tag/tag.h>
  35 #include <gst/math-compat.h>
  36 #include <stdlib.h>
  37 #include <stdio.h>
  38 #include <string.h>
  39
  40 #include <glib/gprintf.h>
  41
  42 #include "gst-play-kb.h"
  43
  44 #define VOLUME_STEPS 20
  45
  46 GST_DEBUG_CATEGORY (play_debug);
  47 #define GST_CAT_DEFAULT play_debug
  48
  49 typedef enum
  50 {
  51   GST_PLAY_TRICK_MODE_NONE = 0,
  52   GST_PLAY_TRICK_MODE_DEFAULT,
  53   GST_PLAY_TRICK_MODE_DEFAULT_NO_AUDIO,
  54   GST_PLAY_TRICK_MODE_KEY_UNITS,
  55   GST_PLAY_TRICK_MODE_KEY_UNITS_NO_AUDIO,
  56   GST_PLAY_TRICK_MODE_LAST
  57 } GstPlayTrickMode;
  58
  59 typedef enum
  60 {
  61   GST_PLAY_TRACK_TYPE_INVALID = 0,
  62   GST_PLAY_TRACK_TYPE_AUDIO,
  63   GST_PLAY_TRACK_TYPE_VIDEO,
  64   GST_PLAY_TRACK_TYPE_SUBTITLE
  65 } GstPlayTrackType;
  66
  67 typedef struct
  68 {
  69   gchar **uris;
  70   guint num_uris;
  71   gint cur_idx;
  72
  73   GstElement *playbin;
  74
  75   GMainLoop *loop;
  76   guint bus_watch;
  77   guint timeout;
  78
  79   /* missing plugin messages */
  80   GList *missing;
  81
  82   gboolean buffering;
  83   gboolean is_live;
  84
  85   GstState desired_state;       /* as per user interaction, PAUSED or PLAYING */
  86
  87   gulong deep_notify_id;
  88
  89   /* configuration */
  90   gboolean gapless;
  91
  92   GstPlayTrickMode trick_mode;
  93   gdouble rate;
  94 } GstPlay;
  95
  96 static gboolean quiet = FALSE;
  97
  98 static gboolean play_bus_msg (GstBus * bus, GstMessage * msg, gpointer data);
  99 static gboolean play_next (GstPlay * play);
 100 static gboolean play_prev (GstPlay * play);
 101 static gboolean play_timeout (gpointer user_data);
 102 static void play_about_to_finish (GstElement * playbin, gpointer user_data);
 103 static void play_reset (GstPlay * play);
 104 static void play_set_relative_volume (GstPlay * play, gdouble volume_step);
 105 static gboolean play_do_seek (GstPlay * play, gint64 pos, gdouble rate,
 106     GstPlayTrickMode mode);
 107
 108 /* *INDENT-OFF* */
 109 static void gst_play_printf (const gchar * format, ...) G_GNUC_PRINTF (1, 2);
 110 /* *INDENT-ON* */
 111
 112 static void keyboard_cb (const gchar * key_input, gpointer user_data);
 113 static void relative_seek (GstPlay * play, gdouble percent);
 114
 115 static void
 116 gst_play_printf (const gchar * format, ...)
 117 {
 118   gchar *str = NULL;
 119   va_list args;
 120   int len;
 121
 122   if (quiet)
 123     return;
 124
 125   va_start (args, format);
 126
 127   len = g_vasprintf (&str, format, args);
 128
 129   va_end (args);
 130
 131   if (len > 0 && str != NULL)
 132     g_print ("%s", str);
 133
 134   g_free (str);
 135 }
 136
 137 #define g_print gst_play_printf
 138
 139 static GstPlay *
 140 play_new (gchar ** uris, const gchar * audio_sink, const gchar * video_sink,
 141     gboolean gapless, gdouble initial_volume, gboolean verbose,
 142     const gchar * flags_string)
 143 {
 144   GstElement *sink, *playbin;
 145   GstPlay *play;
 146
 147   playbin = gst_element_factory_make ("playbin", "playbin");
 148   if (playbin == NULL)
 149     return NULL;
 150
 151   play = g_new0 (GstPlay, 1);
 152
 153   play->uris = uris;
 154   play->num_uris = g_strv_length (uris);
 155   play->cur_idx = -1;
 156
 157   play->playbin = playbin;
 158
 159   if (audio_sink != NULL) {
 160     if (strchr (audio_sink, ' ') != NULL)
 161       sink = gst_parse_bin_from_description (audio_sink, TRUE, NULL);
 162     else
 163       sink = gst_element_factory_make (audio_sink, NULL);
 164
 165     if (sink != NULL)
 166       g_object_set (play->playbin, "audio-sink", sink, NULL);
 167     else
 168       g_warning ("Couldn't create specified audio sink '%s'", audio_sink);
 169   }
 170   if (video_sink != NULL) {
 171     if (strchr (video_sink, ' ') != NULL)
 172       sink = gst_parse_bin_from_description (video_sink, TRUE, NULL);
 173     else
 174       sink = gst_element_factory_make (video_sink, NULL);
 175
 176     if (sink != NULL)
 177       g_object_set (play->playbin, "video-sink", sink, NULL);
 178     else
 179       g_warning ("Couldn't create specified video sink '%s'", video_sink);
 180   }
 181
 182   if (flags_string != NULL) {
 183     GParamSpec *pspec;
 184     GValue val = { 0, };
 185
 186     pspec =
 187         g_object_class_find_property (G_OBJECT_GET_CLASS (playbin), "flags");
 188     g_value_init (&val, pspec->value_type);
 189     if (gst_value_deserialize (&val, flags_string))
 190       g_object_set_property (G_OBJECT (play->playbin), "flags", &val);
 191     else
 192       g_printerr ("Couldn't convert '%s' to playbin flags!\n", flags_string);
 193     g_value_unset (&val);
 194   }
 195
 196   if (verbose) {
 197     play->deep_notify_id = g_signal_connect (play->playbin, "deep-notify",
 198         G_CALLBACK (gst_object_default_deep_notify), NULL);
 199   }
 200
 201   play->loop = g_main_loop_new (NULL, FALSE);
 202
 203   play->bus_watch = gst_bus_add_watch (GST_ELEMENT_BUS (play->playbin),
 204       play_bus_msg, play);
 205
 206   /* FIXME: make configurable incl. 0 for disable */
 207   play->timeout = g_timeout_add (100, play_timeout, play);
 208
 209   play->missing = NULL;
 210   play->buffering = FALSE;
 211   play->is_live = FALSE;
 212
 213   play->desired_state = GST_STATE_PLAYING;
 214
 215   play->gapless = gapless;
 216   if (gapless) {
 217     g_signal_connect (play->playbin, "about-to-finish",
 218         G_CALLBACK (play_about_to_finish), play);
 219   }
 220
 221   if (initial_volume != -1)
 222     play_set_relative_volume (play, initial_volume - 1.0);
 223
 224   play->rate = 1.0;
 225   play->trick_mode = GST_PLAY_TRICK_MODE_NONE;
 226
 227   return play;
 228 }
 229
 230 static void
 231 play_free (GstPlay * play)
 232 {
 233   /* No need to see all those pad caps going to NULL etc., it's just noise */
 234   if (play->deep_notify_id != 0)
 235     g_signal_handler_disconnect (play->playbin, play->deep_notify_id);
 236
 237   play_reset (play);
 238
 239   gst_element_set_state (play->playbin, GST_STATE_NULL);
 240   gst_object_unref (play->playbin);
 241
 242   g_source_remove (play->bus_watch);
 243   g_source_remove (play->timeout);
 244   g_main_loop_unref (play->loop);
 245
 246   g_strfreev (play->uris);
 247   g_free (play);
 248 }
 249
 250 /* reset for new file/stream */
 251 static void
 252 play_reset (GstPlay * play)
 253 {
 254   g_list_foreach (play->missing, (GFunc) gst_message_unref, NULL);
 255   play->missing = NULL;
 256
 257   play->buffering = FALSE;
 258   play->is_live = FALSE;
 259 }
 260
 261 static void
 262 play_set_relative_volume (GstPlay * play, gdouble volume_step)
 263 {
 264   gdouble volume;
 265
 266   volume = gst_stream_volume_get_volume (GST_STREAM_VOLUME (play->playbin),
 267       GST_STREAM_VOLUME_FORMAT_CUBIC);
 268
 269   volume = round ((volume + volume_step) * VOLUME_STEPS) / VOLUME_STEPS;
 270   volume = CLAMP (volume, 0.0, 10.0);
 271
 272   gst_stream_volume_set_volume (GST_STREAM_VOLUME (play->playbin),
 273       GST_STREAM_VOLUME_FORMAT_CUBIC, volume);
 274
 275   g_print (_("Volume: %.0f%%"), volume * 100);
 276   g_print ("                  \n");
 277 }
 278
 279 /* returns TRUE if something was installed and we should restart playback */
 280 static gboolean
 281 play_install_missing_plugins (GstPlay * play)
 282 {
 283   /* FIXME: implement: try to install any missing plugins we haven't
 284    * tried to install before */
 285   return FALSE;
 286 }
 287
 288 static gboolean
 289 play_bus_msg (GstBus * bus, GstMessage * msg, gpointer user_data)
 290 {
 291   GstPlay *play = user_data;
 292
 293   switch (GST_MESSAGE_TYPE (msg)) {
 294     case GST_MESSAGE_ASYNC_DONE:
 295
 296       /* dump graph on preroll */
 297       GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (play->playbin),
 298           GST_DEBUG_GRAPH_SHOW_ALL, "gst-play.async-done");
 299
 300       g_print ("Prerolled.\r");
 301       if (play->missing != NULL && play_install_missing_plugins (play)) {
 302         g_print ("New plugins installed, trying again...\n");
 303         --play->cur_idx;
 304         play_next (play);
 305       }
 306       break;
 307     case GST_MESSAGE_BUFFERING:{
 308       gint percent;
 309
 310       if (!play->buffering)
 311         g_print ("\n");
 312
 313       gst_message_parse_buffering (msg, &percent);
 314       g_print ("%s %d%%  \r", _("Buffering..."), percent);
 315
 316       if (percent == 100) {
 317         /* a 100% message means buffering is done */
 318         if (play->buffering) {
 319           play->buffering = FALSE;
 320           /* no state management needed for live pipelines */
 321           if (!play->is_live)
 322             gst_element_set_state (play->playbin, play->desired_state);
 323         }
 324       } else {
 325         /* buffering... */
 326         if (!play->buffering) {
 327           if (!play->is_live)
 328             gst_element_set_state (play->playbin, GST_STATE_PAUSED);
 329           play->buffering = TRUE;
 330         }
 331       }
 332       break;
 333     }
 334     case GST_MESSAGE_CLOCK_LOST:{
 335       g_print (_("Clock lost, selecting a new one\n"));
 336       gst_element_set_state (play->playbin, GST_STATE_PAUSED);
 337       gst_element_set_state (play->playbin, GST_STATE_PLAYING);
 338       break;
 339     }
 340     case GST_MESSAGE_LATENCY:
 341       g_print ("Redistribute latency...\n");
 342       gst_bin_recalculate_latency (GST_BIN (play->playbin));
 343       break;
 344     case GST_MESSAGE_REQUEST_STATE:{
 345       GstState state;
 346       gchar *name;
 347
 348       name = gst_object_get_path_string (GST_MESSAGE_SRC (msg));
 349
 350       gst_message_parse_request_state (msg, &state);
 351
 352       g_print ("Setting state to %s as requested by %s...\n",
 353           gst_element_state_get_name (state), name);
 354
 355       gst_element_set_state (play->playbin, state);
 356       g_free (name);
 357       break;
 358     }
 359     case GST_MESSAGE_EOS:
 360       /* print final position at end */
 361       play_timeout (play);
 362       g_print ("\n");
 363       /* and switch to next item in list */
 364       if (!play_next (play)) {
 365         g_print ("%s\n", _("Reached end of play list."));
 366         g_main_loop_quit (play->loop);
 367       }
 368       break;
 369     case GST_MESSAGE_WARNING:{
 370       GError *err;
 371       gchar *dbg = NULL;
 372
 373       /* dump graph on warning */
 374       GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (play->playbin),
 375           GST_DEBUG_GRAPH_SHOW_ALL, "gst-play.warning");
 376
 377       gst_message_parse_warning (msg, &err, &dbg);
 378       g_printerr ("WARNING %s\n", err->message);
 379       if (dbg != NULL)
 380         g_printerr ("WARNING debug information: %s\n", dbg);
 381       g_clear_error (&err);
 382       g_free (dbg);
 383       break;
 384     }
 385     case GST_MESSAGE_ERROR:{
 386       GError *err;
 387       gchar *dbg;
 388
 389       /* dump graph on error */
 390       GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (play->playbin),
 391           GST_DEBUG_GRAPH_SHOW_ALL, "gst-play.error");
 392
 393       gst_message_parse_error (msg, &err, &dbg);
 394       g_printerr ("ERROR %s for %s\n", err->message, play->uris[play->cur_idx]);
 395       if (dbg != NULL)
 396         g_printerr ("ERROR debug information: %s\n", dbg);
 397       g_clear_error (&err);
 398       g_free (dbg);
 399
 400       /* flush any other error messages from the bus and clean up */
 401       gst_element_set_state (play->playbin, GST_STATE_NULL);
 402
 403       if (play->missing != NULL && play_install_missing_plugins (play)) {
 404         g_print ("New plugins installed, trying again...\n");
 405         --play->cur_idx;
 406         play_next (play);
 407         break;
 408       }
 409       /* try next item in list then */
 410       if (!play_next (play)) {
 411         g_print ("%s\n", _("Reached end of play list."));
 412         g_main_loop_quit (play->loop);
 413       }
 414       break;
 415     }
 416     case GST_MESSAGE_ELEMENT:
 417     {
 418       GstNavigationMessageType mtype = gst_navigation_message_get_type (msg);
 419       if (mtype == GST_NAVIGATION_MESSAGE_EVENT) {
 420         GstEvent *ev = NULL;
 421
 422         if (gst_navigation_message_parse_event (msg, &ev)) {
 423           GstNavigationEventType e_type = gst_navigation_event_get_type (ev);
 424           switch (e_type) {
 425             case GST_NAVIGATION_EVENT_KEY_PRESS:
 426             {
 427               const gchar *key;
 428
 429               if (gst_navigation_event_parse_key_event (ev, &key)) {
 430                 GST_INFO ("Key press: %s", key);
 431
 432                 if (strcmp (key, "Left") == 0)
 433                   key = GST_PLAY_KB_ARROW_LEFT;
 434                 else if (strcmp (key, "Right") == 0)
 435                   key = GST_PLAY_KB_ARROW_RIGHT;
 436                 else if (strcmp (key, "Up") == 0)
 437                   key = GST_PLAY_KB_ARROW_UP;
 438                 else if (strcmp (key, "Down") == 0)
 439                   key = GST_PLAY_KB_ARROW_DOWN;
 440                 else if (strcmp (key, "space") == 0)
 441                   key = " ";
 442                 else if (strlen (key) > 1)
 443                   break;
 444
 445                 keyboard_cb (key, user_data);
 446               }
 447               break;
 448             }
 449             case GST_NAVIGATION_EVENT_MOUSE_BUTTON_PRESS:
 450             {
 451               gint button;
 452               if (gst_navigation_event_parse_mouse_button_event (ev, &button,
 453                       NULL, NULL)) {
 454                 if (button == 4) {
 455                   /* wheel up */
 456                   relative_seek (play, +0.08);
 457                 } else if (button == 5) {
 458                   /* wheel down */
 459                   relative_seek (play, -0.01);
 460                 }
 461               }
 462               break;
 463             }
 464             default:
 465               break;
 466           }
 467         }
 468         if (ev)
 469           gst_event_unref (ev);
 470       }
 471       break;
 472     }
 473     default:
 474       if (gst_is_missing_plugin_message (msg)) {
 475         gchar *desc;
 476
 477         desc = gst_missing_plugin_message_get_description (msg);
 478         g_print ("Missing plugin: %s\n", desc);
 479         g_free (desc);
 480         play->missing = g_list_append (play->missing, gst_message_ref (msg));
 481       }
 482       break;
 483   }
 484
 485   return TRUE;
 486 }
 487
 488 static gboolean
 489 play_timeout (gpointer user_data)
 490 {
 491   GstPlay *play = user_data;
 492   gint64 pos = -1, dur = -1;
 493   const gchar *paused = _("Paused");
 494   gchar *status;
 495
 496   if (play->buffering)
 497     return TRUE;
 498
 499   gst_element_query_position (play->playbin, GST_FORMAT_TIME, &pos);
 500   gst_element_query_duration (play->playbin, GST_FORMAT_TIME, &dur);
 501
 502   if (play->desired_state == GST_STATE_PAUSED) {
 503     status = (gchar *) paused;
 504   } else {
 505     gint len = g_utf8_strlen (paused, -1);
 506     status = g_newa (gchar, len + 1);
 507     memset (status, ' ', len);
 508     status[len] = '\0';
 509   }
 510
 511   if (pos >= 0 && dur > 0) {
 512     gchar dstr[32], pstr[32];
 513
 514     /* FIXME: pretty print in nicer format */
 515     g_snprintf (pstr, 32, "%" GST_TIME_FORMAT, GST_TIME_ARGS (pos));
 516     pstr[9] = '\0';
 517     g_snprintf (dstr, 32, "%" GST_TIME_FORMAT, GST_TIME_ARGS (dur));
 518     dstr[9] = '\0';
 519     g_print ("%s / %s %s\r", pstr, dstr, status);
 520   }
 521
 522   return TRUE;
 523 }
 524
 525 static gchar *
 526 play_uri_get_display_name (GstPlay * play, const gchar * uri)
 527 {
 528   gchar *loc;
 529
 530   if (gst_uri_has_protocol (uri, "file")) {
 531     loc = g_filename_from_uri (uri, NULL, NULL);
 532   } else if (gst_uri_has_protocol (uri, "pushfile")) {
 533     loc = g_filename_from_uri (uri + 4, NULL, NULL);
 534   } else {
 535     loc = g_strdup (uri);
 536   }
 537
 538   /* Maybe additionally use glib's filename to display name function */
 539   return loc;
 540 }
 541
 542 static void
 543 play_uri (GstPlay * play, const gchar * next_uri)
 544 {
 545   gchar *loc;
 546
 547   gst_element_set_state (play->playbin, GST_STATE_READY);
 548   play_reset (play);
 549
 550   loc = play_uri_get_display_name (play, next_uri);
 551   g_print (_("Now playing %s\n"), loc);
 552   g_free (loc);
 553
 554   g_object_set (play->playbin, "uri", next_uri, NULL);
 555
 556   switch (gst_element_set_state (play->playbin, GST_STATE_PAUSED)) {
 557     case GST_STATE_CHANGE_FAILURE:
 558       /* ignore, we should get an error message posted on the bus */
 559       break;
 560     case GST_STATE_CHANGE_NO_PREROLL:
 561       g_print ("Pipeline is live.\n");
 562       play->is_live = TRUE;
 563       break;
 564     case GST_STATE_CHANGE_ASYNC:
 565       g_print ("Prerolling...\r");
 566       break;
 567     default:
 568       break;
 569   }
 570
 571   if (play->desired_state != GST_STATE_PAUSED)
 572     gst_element_set_state (play->playbin, play->desired_state);
 573 }
 574
 575 /* returns FALSE if we have reached the end of the playlist */
 576 static gboolean
 577 play_next (GstPlay * play)
 578 {
 579   if ((play->cur_idx + 1) >= play->num_uris)
 580     return FALSE;
 581
 582   play_uri (play, play->uris[++play->cur_idx]);
 583   return TRUE;
 584 }
 585
 586 /* returns FALSE if we have reached the beginning of the playlist */
 587 static gboolean
 588 play_prev (GstPlay * play)
 589 {
 590   if (play->cur_idx == 0 || play->num_uris <= 1)
 591     return FALSE;
 592
 593   play_uri (play, play->uris[--play->cur_idx]);
 594   return TRUE;
 595 }
 596
 597 static void
 598 play_about_to_finish (GstElement * playbin, gpointer user_data)
 599 {
 600   GstPlay *play = user_data;
 601   const gchar *next_uri;
 602   gchar *loc;
 603   guint next_idx;
 604
 605   if (!play->gapless)
 606     return;
 607
 608   next_idx = play->cur_idx + 1;
 609   if (next_idx >= play->num_uris)
 610     return;
 611
 612   next_uri = play->uris[next_idx];
 613   loc = play_uri_get_display_name (play, next_uri);
 614   g_print (_("About to finish, preparing next title: %s"), loc);
 615   g_print ("\n");
 616   g_free (loc);
 617
 618   g_object_set (play->playbin, "uri", next_uri, NULL);
 619   play->cur_idx = next_idx;
 620 }
 621
 622 static void
 623 do_play (GstPlay * play)
 624 {
 625   gint i;
 626
 627   /* dump playlist */
 628   for (i = 0; i < play->num_uris; ++i)
 629     GST_INFO ("%4u : %s", i, play->uris[i]);
 630
 631   if (!play_next (play))
 632     return;
 633
 634   g_main_loop_run (play->loop);
 635 }
 636
 637 static gint
 638 compare (gconstpointer a, gconstpointer b)
 639 {
 640   gchar *a1, *b1;
 641   gint ret;
 642
 643   a1 = g_utf8_collate_key_for_filename ((gchar *) a, -1);
 644   b1 = g_utf8_collate_key_for_filename ((gchar *) b, -1);
 645   ret = strcmp (a1, b1);
 646   g_free (a1);
 647   g_free (b1);
 648
 649   return ret;
 650 }
 651
 652 static void
 653 add_to_playlist (GPtrArray * playlist, const gchar * filename)
 654 {
 655   GDir *dir;
 656   gchar *uri;
 657
 658   if (gst_uri_is_valid (filename)) {
 659     g_ptr_array_add (playlist, g_strdup (filename));
 660     return;
 661   }
 662
 663   if ((dir = g_dir_open (filename, 0, NULL))) {
 664     const gchar *entry;
 665     GList *l, *files = NULL;
 666
 667     while ((entry = g_dir_read_name (dir))) {
 668       gchar *path;
 669
 670       path = g_build_filename (filename, entry, NULL);
 671       files = g_list_insert_sorted (files, path, compare);
 672     }
 673
 674     g_dir_close (dir);
 675
 676     for (l = files; l != NULL; l = l->next) {
 677       gchar *path = (gchar *) l->data;
 678
 679       add_to_playlist (playlist, path);
 680       g_free (path);
 681     }
 682     g_list_free (files);
 683     return;
 684   }
 685
 686   uri = gst_filename_to_uri (filename, NULL);
 687   if (uri != NULL)
 688     g_ptr_array_add (playlist, uri);
 689   else
 690     g_warning ("Could not make URI out of filename '%s'", filename);
 691 }
 692
 693 static void
 694 shuffle_uris (gchar ** uris, guint num)
 695 {
 696   gchar *tmp;
 697   guint i, j;
 698
 699   if (num < 2)
 700     return;
 701
 702   for (i = 0; i < num; i++) {
 703     /* gets equally distributed random number in 0..num-1 [0;num[ */
 704     j = g_random_int_range (0, num);
 705     tmp = uris[j];
 706     uris[j] = uris[i];
 707     uris[i] = tmp;
 708   }
 709 }
 710
 711 static void
 712 restore_terminal (void)
 713 {
 714   gst_play_kb_set_key_handler (NULL, NULL);
 715 }
 716
 717 static void
 718 toggle_paused (GstPlay * play)
 719 {
 720   if (play->desired_state == GST_STATE_PLAYING)
 721     play->desired_state = GST_STATE_PAUSED;
 722   else
 723     play->desired_state = GST_STATE_PLAYING;
 724
 725   if (!play->buffering) {
 726     gst_element_set_state (play->playbin, play->desired_state);
 727   } else if (play->desired_state == GST_STATE_PLAYING) {
 728     g_print ("\nWill play as soon as buffering finishes)\n");
 729   }
 730 }
 731
 732 static void
 733 relative_seek (GstPlay * play, gdouble percent)
 734 {
 735   GstQuery *query;
 736   gboolean seekable = FALSE;
 737   gint64 dur = -1, pos = -1, step;
 738
 739   g_return_if_fail (percent >= -1.0 && percent <= 1.0);
 740
 741   if (!gst_element_query_position (play->playbin, GST_FORMAT_TIME, &pos))
 742     goto seek_failed;
 743
 744   query = gst_query_new_seeking (GST_FORMAT_TIME);
 745   if (!gst_element_query (play->playbin, query)) {
 746     gst_query_unref (query);
 747     goto seek_failed;
 748   }
 749
 750   gst_query_parse_seeking (query, NULL, &seekable, NULL, &dur);
 751   gst_query_unref (query);
 752
 753   if (!seekable || dur <= 0)
 754     goto seek_failed;
 755
 756   step = dur * percent;
 757   if (ABS (step) < GST_SECOND)
 758     step = (percent < 0) ? -GST_SECOND : GST_SECOND;
 759
 760   pos = pos + step;
 761   if (pos > dur) {
 762     if (!play_next (play)) {
 763       g_print ("\n%s\n", _("Reached end of play list."));
 764       g_main_loop_quit (play->loop);
 765     }
 766   } else {
 767     if (pos < 0)
 768       pos = 0;
 769
 770     play_do_seek (play, pos, play->rate, play->trick_mode);
 771   }
 772
 773   return;
 774
 775 seek_failed:
 776   {
 777     g_print ("\nCould not seek.\n");
 778   }
 779 }
 780
 781 static gboolean
 782 play_set_rate_and_trick_mode (GstPlay * play, gdouble rate,
 783     GstPlayTrickMode mode)
 784 {
 785   gint64 pos = -1;
 786
 787   g_return_val_if_fail (rate != 0, FALSE);
 788
 789   if (!gst_element_query_position (play->playbin, GST_FORMAT_TIME, &pos))
 790     return FALSE;
 791
 792   return play_do_seek (play, pos, rate, mode);
 793 }
 794
 795 static gboolean
 796 play_do_seek (GstPlay * play, gint64 pos, gdouble rate, GstPlayTrickMode mode)
 797 {
 798   GstSeekFlags seek_flags;
 799   GstQuery *query;
 800   GstEvent *seek;
 801   gboolean seekable = FALSE;
 802
 803   query = gst_query_new_seeking (GST_FORMAT_TIME);
 804   if (!gst_element_query (play->playbin, query)) {
 805     gst_query_unref (query);
 806     return FALSE;
 807   }
 808
 809   gst_query_parse_seeking (query, NULL, &seekable, NULL, NULL);
 810   gst_query_unref (query);
 811
 812   if (!seekable)
 813     return FALSE;
 814
 815   seek_flags = GST_SEEK_FLAG_FLUSH;
 816
 817   switch (mode) {
 818     case GST_PLAY_TRICK_MODE_DEFAULT:
 819       seek_flags |= GST_SEEK_FLAG_TRICKMODE;
 820       break;
 821     case GST_PLAY_TRICK_MODE_DEFAULT_NO_AUDIO:
 822       seek_flags |= GST_SEEK_FLAG_TRICKMODE | GST_SEEK_FLAG_TRICKMODE_NO_AUDIO;
 823       break;
 824     case GST_PLAY_TRICK_MODE_KEY_UNITS:
 825       seek_flags |= GST_SEEK_FLAG_TRICKMODE_KEY_UNITS;
 826       break;
 827     case GST_PLAY_TRICK_MODE_KEY_UNITS_NO_AUDIO:
 828       seek_flags |=
 829           GST_SEEK_FLAG_TRICKMODE_KEY_UNITS | GST_SEEK_FLAG_TRICKMODE_NO_AUDIO;
 830       break;
 831     case GST_PLAY_TRICK_MODE_NONE:
 832     default:
 833       break;
 834   }
 835
 836   if (rate >= 0)
 837     seek = gst_event_new_seek (rate, GST_FORMAT_TIME,
 838         seek_flags | GST_SEEK_FLAG_ACCURATE,
 839         /* start */ GST_SEEK_TYPE_SET, pos,
 840         /* stop */ GST_SEEK_TYPE_SET, GST_CLOCK_TIME_NONE);
 841   else
 842     seek = gst_event_new_seek (rate, GST_FORMAT_TIME,
 843         seek_flags | GST_SEEK_FLAG_ACCURATE,
 844         /* start */ GST_SEEK_TYPE_SET, 0,
 845         /* stop */ GST_SEEK_TYPE_SET, pos);
 846
 847   if (!gst_element_send_event (play->playbin, seek))
 848     return FALSE;
 849
 850   play->rate = rate;
 851   play->trick_mode = mode;
 852   return TRUE;
 853 }
 854
 855 static void
 856 play_set_playback_rate (GstPlay * play, gdouble rate)
 857 {
 858   if (play_set_rate_and_trick_mode (play, rate, play->trick_mode)) {
 859     g_print (_("Playback rate: %.2f"), rate);
 860     g_print ("                               \n");
 861   } else {
 862     g_print ("\n");
 863     g_print (_("Could not change playback rate to %.2f"), rate);
 864     g_print (".\n");
 865   }
 866 }
 867
 868 static void
 869 play_set_relative_playback_rate (GstPlay * play, gdouble rate_step,
 870     gboolean reverse_direction)
 871 {
 872   gdouble new_rate = play->rate + rate_step;
 873
 874   if (reverse_direction)
 875     new_rate *= -1.0;
 876
 877   play_set_playback_rate (play, new_rate);
 878 }
 879
 880 static const gchar *
 881 trick_mode_get_description (GstPlayTrickMode mode)
 882 {
 883   switch (mode) {
 884     case GST_PLAY_TRICK_MODE_NONE:
 885       return "normal playback, trick modes disabled";
 886     case GST_PLAY_TRICK_MODE_DEFAULT:
 887       return "trick mode: default";
 888     case GST_PLAY_TRICK_MODE_DEFAULT_NO_AUDIO:
 889       return "trick mode: default, no audio";
 890     case GST_PLAY_TRICK_MODE_KEY_UNITS:
 891       return "trick mode: key frames only";
 892     case GST_PLAY_TRICK_MODE_KEY_UNITS_NO_AUDIO:
 893       return "trick mode: key frames only, no audio";
 894     default:
 895       break;
 896   }
 897   return "unknown trick mode";
 898 }
 899
 900 static void
 901 play_switch_trick_mode (GstPlay * play)
 902 {
 903   GstPlayTrickMode new_mode = ++play->trick_mode;
 904   const gchar *mode_desc;
 905
 906   if (new_mode == GST_PLAY_TRICK_MODE_LAST)
 907     new_mode = GST_PLAY_TRICK_MODE_NONE;
 908
 909   mode_desc = trick_mode_get_description (new_mode);
 910
 911   if (play_set_rate_and_trick_mode (play, play->rate, new_mode)) {
 912     g_print ("Rate: %.2f (%s)                      \n", play->rate, mode_desc);
 913   } else {
 914     g_print ("\nCould not change trick mode to %s.\n", mode_desc);
 915   }
 916 }
 917
 918 static void
 919 play_cycle_track_selection (GstPlay * play, GstPlayTrackType track_type)
 920 {
 921   const gchar *prop_cur, *prop_n, *prop_get, *name;
 922   gint cur = -1, n = -1;
 923   guint flag, cur_flags;
 924
 925   switch (track_type) {
 926     case GST_PLAY_TRACK_TYPE_AUDIO:
 927       prop_get = "get-audio-tags";
 928       prop_cur = "current-audio";
 929       prop_n = "n-audio";
 930       name = "audio";
 931       flag = 0x2;
 932       break;
 933     case GST_PLAY_TRACK_TYPE_VIDEO:
 934       prop_get = "get-video-tags";
 935       prop_cur = "current-video";
 936       prop_n = "n-video";
 937       name = "video";
 938       flag = 0x1;
 939       break;
 940     case GST_PLAY_TRACK_TYPE_SUBTITLE:
 941       prop_get = "get-text-tags";
 942       prop_cur = "current-text";
 943       prop_n = "n-text";
 944       name = "subtitle";
 945       flag = 0x4;
 946       break;
 947     default:
 948       return;
 949   }
 950
 951   g_object_get (play->playbin, prop_cur, &cur, prop_n, &n, "flags", &cur_flags,
 952       NULL);
 953
 954   if (n < 1) {
 955     g_print ("No %s tracks.\n", name);
 956   } else {
 957     gchar *lcode = NULL, *lname = NULL;
 958     const gchar *lang = NULL;
 959     GstTagList *tags = NULL;
 960
 961     if (!(cur_flags & flag))
 962       cur = 0;
 963     else
 964       cur = (cur + 1) % (n + 1);
 965
 966     if (cur >= n && track_type != GST_PLAY_TRACK_TYPE_VIDEO) {
 967       cur = -1;
 968       g_print ("Disabling %s.           \n", name);
 969       if (cur_flags & flag) {
 970         cur_flags &= ~flag;
 971         g_object_set (play->playbin, "flags", cur_flags, NULL);
 972       }
 973     } else {
 974       /* For video we only want to switch between streams, not disable it altogether */
 975       if (cur >= n)
 976         cur = 0;
 977       if (!(cur_flags & flag) && track_type != GST_PLAY_TRACK_TYPE_VIDEO) {
 978         cur_flags |= flag;
 979         g_object_set (play->playbin, "flags", cur_flags, NULL);
 980       }
 981       g_signal_emit_by_name (play->playbin, prop_get, cur, &tags);
 982       if (tags != NULL) {
 983         if (gst_tag_list_get_string (tags, GST_TAG_LANGUAGE_CODE, &lcode))
 984           lang = gst_tag_get_language_name (lcode);
 985         else if (gst_tag_list_get_string (tags, GST_TAG_LANGUAGE_NAME, &lname))
 986           lang = lname;
 987         gst_tag_list_unref (tags);
 988       }
 989       if (lang != NULL)
 990         g_print ("Switching to %s track %d of %d (%s).\n", name, cur + 1, n,
 991             lang);
 992       else
 993         g_print ("Switching to %s track %d of %d.\n", name, cur + 1, n);
 994     }
 995     g_object_set (play->playbin, prop_cur, cur, NULL);
 996     g_free (lcode);
 997     g_free (lname);
 998   }
 999 }
1000
1001 static void
1002 print_keyboard_help (void)
1003 {
1004   static struct
1005   {
1006     const gchar *key_desc;
1007     const gchar *key_help;
1008   } key_controls[] = {
1009     {
1010     N_("space"), N_("pause/unpause")}, {
1011     N_("q or ESC"), N_("quit")}, {
1012     N_("> or n"), N_("play next")}, {
1013     N_("< or b"), N_("play previous")}, {
1014     "\342\206\222", N_("seek forward")}, {
1015     "\342\206\220", N_("seek backward")}, {
1016     "\342\206\221", N_("volume up")}, {
1017     "\342\206\223", N_("volume down")}, {
1018     "+", N_("increase playback rate")}, {
1019     "-", N_("decrease playback rate")}, {
1020     "d", N_("change playback direction")}, {
1021     "t", N_("enable/disable trick modes")}, {
1022     "a", N_("change audio track")}, {
1023     "v", N_("change video track")}, {
1024     "s", N_("change subtitle track")}, {
1025     "0", N_("seek to beginning")}, {
1026   "k", N_("show keyboard shortcuts")},};
1027   guint i, chars_to_pad, desc_len, max_desc_len = 0;
1028
1029   g_print ("\n\n%s\n\n", _("Interactive mode - keyboard controls:"));
1030
1031   for (i = 0; i < G_N_ELEMENTS (key_controls); ++i) {
1032     desc_len = g_utf8_strlen (key_controls[i].key_desc, -1);
1033     max_desc_len = MAX (max_desc_len, desc_len);
1034   }
1035   ++max_desc_len;
1036
1037   for (i = 0; i < G_N_ELEMENTS (key_controls); ++i) {
1038     chars_to_pad = max_desc_len - g_utf8_strlen (key_controls[i].key_desc, -1);
1039     g_print ("\t%s", key_controls[i].key_desc);
1040     g_print ("%-*s: ", chars_to_pad, "");
1041     g_print ("%s\n", key_controls[i].key_help);
1042   }
1043   g_print ("\n");
1044 }
1045
1046 static void
1047 keyboard_cb (const gchar * key_input, gpointer user_data)
1048 {
1049   GstPlay *play = (GstPlay *) user_data;
1050   gchar key = '\0';
1051
1052   /* only want to switch/case on single char, not first char of string */
1053   if (key_input[0] != '\0' && key_input[1] == '\0')
1054     key = g_ascii_tolower (key_input[0]);
1055
1056   switch (key) {
1057     case 'k':
1058       print_keyboard_help ();
1059       break;
1060     case ' ':
1061       toggle_paused (play);
1062       break;
1063     case 'q':
1064     case 'Q':
1065       g_main_loop_quit (play->loop);
1066       break;
1067     case 'n':
1068     case '>':
1069       if (!play_next (play)) {
1070         g_print ("\n%s\n", _("Reached end of play list."));
1071         g_main_loop_quit (play->loop);
1072       }
1073       break;
1074     case 'b':
1075     case '<':
1076       play_prev (play);
1077       break;
1078     case '+':
1079       if (play->rate > -0.2 && play->rate < 0.0)
1080         play_set_relative_playback_rate (play, 0.0, TRUE);
1081       else if (ABS (play->rate) < 2.0)
1082         play_set_relative_playback_rate (play, 0.1, FALSE);
1083       else if (ABS (play->rate) < 4.0)
1084         play_set_relative_playback_rate (play, 0.5, FALSE);
1085       else
1086         play_set_relative_playback_rate (play, 1.0, FALSE);
1087       break;
1088     case '-':
1089       if (play->rate > 0.0 && play->rate < 0.20)
1090         play_set_relative_playback_rate (play, 0.0, TRUE);
1091       else if (ABS (play->rate) <= 2.0)
1092         play_set_relative_playback_rate (play, -0.1, FALSE);
1093       else if (ABS (play->rate) <= 4.0)
1094         play_set_relative_playback_rate (play, -0.5, FALSE);
1095       else
1096         play_set_relative_playback_rate (play, -1.0, FALSE);
1097       break;
1098     case 'd':
1099       play_set_relative_playback_rate (play, 0.0, TRUE);
1100       break;
1101     case 't':
1102       play_switch_trick_mode (play);
1103       break;
1104     case 27:                   /* ESC */
1105       if (key_input[1] == '\0') {
1106         g_main_loop_quit (play->loop);
1107         break;
1108       }
1109     case 'a':
1110       play_cycle_track_selection (play, GST_PLAY_TRACK_TYPE_AUDIO);
1111       break;
1112     case 'v':
1113       play_cycle_track_selection (play, GST_PLAY_TRACK_TYPE_VIDEO);
1114       break;
1115     case 's':
1116       play_cycle_track_selection (play, GST_PLAY_TRACK_TYPE_SUBTITLE);
1117       break;
1118     case '0':
1119       play_do_seek (play, 0, play->rate, play->trick_mode);
1120       break;
1121     default:
1122       if (strcmp (key_input, GST_PLAY_KB_ARROW_RIGHT) == 0) {
1123         relative_seek (play, +0.08);
1124       } else if (strcmp (key_input, GST_PLAY_KB_ARROW_LEFT) == 0) {
1125         relative_seek (play, -0.01);
1126       } else if (strcmp (key_input, GST_PLAY_KB_ARROW_UP) == 0) {
1127         play_set_relative_volume (play, +1.0 / VOLUME_STEPS);
1128       } else if (strcmp (key_input, GST_PLAY_KB_ARROW_DOWN) == 0) {
1129         play_set_relative_volume (play, -1.0 / VOLUME_STEPS);
1130       } else {
1131         GST_INFO ("keyboard input:");
1132         for (; *key_input != '\0'; ++key_input)
1133           GST_INFO ("  code %3d", *key_input);
1134       }
1135       break;
1136   }
1137 }
1138
1139 int
1140 main (int argc, char **argv)
1141 {
1142   GstPlay *play;
1143   GPtrArray *playlist;
1144   gboolean verbose = FALSE;
1145   gboolean print_version = FALSE;
1146   gboolean interactive = TRUE;
1147   gboolean gapless = FALSE;
1148   gboolean shuffle = FALSE;
1149   gdouble volume = -1;
1150   gchar **filenames = NULL;
1151   gchar *audio_sink = NULL;
1152   gchar *video_sink = NULL;
1153   gchar **uris;
1154   gchar *flags = NULL;
1155   guint num, i;
1156   GError *err = NULL;
1157   GOptionContext *ctx;
1158   gchar *playlist_file = NULL;
1159   GOptionEntry options[] = {
1160     {"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
1161         N_("Output status information and property notifications"), NULL},
1162     {"flags", 0, 0, G_OPTION_ARG_STRING, &flags,
1163           N_("Control playback behaviour setting playbin 'flags' property"),
1164         NULL},
1165     {"version", 0, 0, G_OPTION_ARG_NONE, &print_version,
1166         N_("Print version information and exit"), NULL},
1167     {"videosink", 0, 0, G_OPTION_ARG_STRING, &video_sink,
1168         N_("Video sink to use (default is autovideosink)"), NULL},
1169     {"audiosink", 0, 0, G_OPTION_ARG_STRING, &audio_sink,
1170         N_("Audio sink to use (default is autoaudiosink)"), NULL},
1171     {"gapless", 0, 0, G_OPTION_ARG_NONE, &gapless,
1172         N_("Enable gapless playback"), NULL},
1173     {"shuffle", 0, 0, G_OPTION_ARG_NONE, &shuffle,
1174         N_("Shuffle playlist"), NULL},
1175     {"no-interactive", 0, G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE,
1176           &interactive,
1177         N_("Disable interactive control via the keyboard"), NULL},
1178     {"volume", 0, 0, G_OPTION_ARG_DOUBLE, &volume,
1179         N_("Volume"), NULL},
1180     {"playlist", 0, 0, G_OPTION_ARG_FILENAME, &playlist_file,
1181         N_("Playlist file containing input media files"), NULL},
1182     {"quiet", 'q', 0, G_OPTION_ARG_NONE, &quiet,
1183         N_("Do not print any output (apart from errors)"), NULL},
1184     {G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &filenames, NULL},
1185     {NULL}
1186   };
1187
1188   setlocale (LC_ALL, "");
1189
1190 #ifdef ENABLE_NLS
1191   bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
1192   bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
1193   textdomain (GETTEXT_PACKAGE);
1194 #endif
1195
1196   g_set_prgname ("gst-play-" GST_API_VERSION);
1197
1198   ctx = g_option_context_new ("FILE1|URI1 [FILE2|URI2] [FILE3|URI3] ...");
1199   g_option_context_add_main_entries (ctx, options, GETTEXT_PACKAGE);
1200   g_option_context_add_group (ctx, gst_init_get_option_group ());
1201   if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
1202     g_print ("Error initializing: %s\n", GST_STR_NULL (err->message));
1203     g_option_context_free (ctx);
1204     g_clear_error (&err);
1205     return 1;
1206   }
1207   g_option_context_free (ctx);
1208
1209   GST_DEBUG_CATEGORY_INIT (play_debug, "play", 0, "gst-play");
1210
1211   if (print_version) {
1212     gchar *version_str;
1213
1214     version_str = gst_version_string ();
1215     g_print ("%s version %s\n", g_get_prgname (), PACKAGE_VERSION);
1216     g_print ("%s\n", version_str);
1217     g_print ("%s\n", GST_PACKAGE_ORIGIN);
1218     g_free (version_str);
1219
1220     g_free (audio_sink);
1221     g_free (video_sink);
1222     g_free (playlist_file);
1223
1224     return 0;
1225   }
1226
1227   playlist = g_ptr_array_new ();
1228
1229   if (playlist_file != NULL) {
1230     gchar *playlist_contents = NULL;
1231     gchar **lines = NULL;
1232
1233     if (g_file_get_contents (playlist_file, &playlist_contents, NULL, &err)) {
1234       lines = g_strsplit (playlist_contents, "\n", 0);
1235       num = g_strv_length (lines);
1236
1237       for (i = 0; i < num; i++) {
1238         if (lines[i][0] != '\0') {
1239           GST_LOG ("Playlist[%d]: %s", i + 1, lines[i]);
1240           add_to_playlist (playlist, lines[i]);
1241         }
1242       }
1243       g_strfreev (lines);
1244       g_free (playlist_contents);
1245     } else {
1246       g_printerr ("Could not read playlist: %s\n", err->message);
1247       g_clear_error (&err);
1248     }
1249     g_free (playlist_file);
1250     playlist_file = NULL;
1251   }
1252
1253   if (playlist->len == 0 && (filenames == NULL || *filenames == NULL)) {
1254     g_printerr (_("Usage: %s FILE1|URI1 [FILE2|URI2] [FILE3|URI3] ..."),
1255         "gst-play-" GST_API_VERSION);
1256     g_printerr ("\n\n"),
1257         g_printerr ("%s\n\n",
1258         _("You must provide at least one filename or URI to play."));
1259     /* No input provided. Free array */
1260     g_ptr_array_free (playlist, TRUE);
1261
1262     g_free (audio_sink);
1263     g_free (video_sink);
1264
1265     return 1;
1266   }
1267
1268   /* fill playlist */
1269   if (filenames != NULL && *filenames != NULL) {
1270     num = g_strv_length (filenames);
1271     for (i = 0; i < num; ++i) {
1272       GST_LOG ("command line argument: %s", filenames[i]);
1273       add_to_playlist (playlist, filenames[i]);
1274     }
1275     g_strfreev (filenames);
1276   }
1277
1278   num = playlist->len;
1279   g_ptr_array_add (playlist, NULL);
1280
1281   uris = (gchar **) g_ptr_array_free (playlist, FALSE);
1282
1283   if (shuffle)
1284     shuffle_uris (uris, num);
1285
1286   /* prepare */
1287   play =
1288       play_new (uris, audio_sink, video_sink, gapless, volume, verbose, flags);
1289
1290   if (play == NULL) {
1291     g_printerr
1292         ("Failed to create 'playbin' element. Check your GStreamer installation.\n");
1293     return EXIT_FAILURE;
1294   }
1295
1296   if (interactive) {
1297     if (gst_play_kb_set_key_handler (keyboard_cb, play)) {
1298       g_print (_("Press 'k' to see a list of keyboard shortcuts.\n"));
1299       atexit (restore_terminal);
1300     } else {
1301       g_print ("Interactive keyboard handling in terminal not available.\n");
1302     }
1303   }
1304
1305   /* play */
1306   do_play (play);
1307
1308   /* clean up */
1309   play_free (play);
1310
1311   g_free (audio_sink);
1312   g_free (video_sink);
1313
1314   g_print ("\n");
1315   gst_deinit ();
1316   return 0;
1317 }