/* GStreamer

 * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>

 *

 * 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., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/**

 * SECTION:element-playbin

 *

 * Playbin provides a stand-alone everything-in-one abstraction for an

 * audio and/or video player.

 * It can handle both audio and video files and features

 * <itemizedlist>

 * <listitem>

 * automatic file type recognition and based on that automatic

 * selection and usage of the right audio/video/subtitle demuxers/decoders

 * </listitem>

 * <listitem>

 * visualisations for audio files

 * </listitem>

 * <listitem>

 * subtitle support for video files

 * </listitem>

 * <listitem>

 * stream selection between different audio/subtitles streams

 * </listitem>

 * <listitem>

 * meta info (tag) extraction

 * </listitem>

 * <listitem>

 * easy access to the last video frame

 * </listitem>

 * <listitem>

 * buffering when playing streams over a network

 * </listitem>

 * <listitem>

 * volume control

 * </listitem>

 * </itemizedlist>

 * <title>Usage</title>

 * <para>

 * A playbin element can be created just like any other element using

 * property. This must be an absolute URI, relative file paths are not allowed.

 * Example URIs are file:///home/joe/movie.avi or http://www.joedoe.com/foo.ogg

 * Playbin is a #GstPipeline. It will notify the application of everything

 * that's happening (errors, end of stream, tags found, state changes, etc.)

 * by posting messages on its #GstBus. The application needs to watch the

 * bus.

 * Playback can be initiated by setting the element to PLAYING state using

 * gst_element_set_state(). Note that the state change will take place in

 * the background in a separate thread, when the function returns playback

 * is probably not happening yet and any errors might not have occured yet.

 * Applications using playbin should ideally be written to deal with things

 * completely asynchroneous.

 * When playback has finished (an EOS message has been received on the bus)

 * or an error has occured (an ERROR message has been received on the bus) or

 * the user wants to play a different track, playbin should be set back to

 * Seeking can be done using gst_element_seek_simple() or gst_element_seek()

 * on the playbin element. Again, the seek will not be executed

 * instantaneously, but will be done in a background thread. When the seek

 * call returns the seek will most likely still be in process. An application

 * may wait for the seek to finish (or fail) using gst_element_get_state() with

 * -1 as the timeout, but this will block the user interface and is not

 * recommended at all.

 * Applications may query the current position and duration of the stream

 * via gst_element_query_position() and gst_element_query_duration() and

 * setting the format passed to GST_FORMAT_TIME. If the query was successful,

 * the duration or position will have been returned in units of nanoseconds.

 * </para>

 * <title>Advanced Usage: specifying the audio and video sink</title>

 * <para>

 * By default, if no audio sink or video sink has been specified via the

 * This should work in most cases, but is not always desirable. Often either

 * the user or application might want to specify more explicitly what to use

 * for audio and video output.

 * If the application wants more control over how audio or video should be

 * output, it may create the audio/video sink elements itself (for example

 * using gst_element_factory_make()) and provide them to playbin using the

 * GNOME-based applications, for example, will usually want to create

 * gconfaudiosink and gconfvideosink elements and make playbin use those,

 * so that output happens to whatever the user has configured in the GNOME

 * Multimedia System Selector confinguration dialog.

 * The sink elements do not necessarily need to be ready-made sinks. It is

 * possible to create container elements that look like a sink to playbin,

 * but in reality contain a number of custom elements linked together. This

 * can be achieved by creating a #GstBin and putting elements in there and

 * linking them, and then creating a sink #GstGhostPad for the bin and pointing

 * it to the sink pad of the first element within the bin. This can be used

 * for a number of purposes, for example to force output to a particular

 * format or to modify or observe the data before it is output.

 * It is also possible to 'suppress' audio and/or video output by using

 * 'fakesink' elements (or capture it from there using the fakesink element's

 * "handoff" signal, which, nota bene, is fired from the streaming thread!).

 * </para>

 * <title>Retrieving Tags and Other Meta Data</title>

 * <para>

 * Most of the common meta data (artist, title, etc.) can be retrieved by

 * watching for TAG messages on the pipeline's bus (see above).

 * Other more specific meta information like width/height/framerate of video

 * streams or samplerate/number of channels of audio streams can be obtained

 * Each stream info object has the following properties:

 * <itemizedlist>

 * <listitem>"object" (GstObject) (the decoder source pad usually)</listitem>

 * <listitem>"type" (enum) (if this is an audio/video/subtitle stream)</listitem>

 * <listitem>"decoder" (string) (name of decoder used to decode this stream)</listitem>

 * <listitem>"mute" (boolean) (to mute or unmute this stream)</listitem>

 * <listitem>"caps" (GstCaps) (caps of the decoded stream)</listitem>

 * <listitem>"language-code" (string) (ISO-639 language code for this stream, mostly used for audio/subtitle streams)</listitem>

 * <listitem>"codec" (string) (format this stream was encoded in)</listitem>

 * </itemizedlist>

 * playbin has changed into PAUSED or PLAYING state (which can be detected

 * new_state=PAUSED), since before that the list might not be complete yet or

 * not contain all available information (like language-codes).

 * </para>

 * <title>Buffering</title>

 * Playbin handles buffering automatically for the most part, but applications

 * need to handle parts of the buffering process as well. Whenever playbin is

 * buffering, it will post BUFFERING messages on the bus with a percentage

 * value that shows the progress of the buffering process. Applications need

 * to set playbin to PLAYING or PAUSED state in response to these messages.

 * They may also want to convey the buffering progress to the user in some

 * way. Here is how to extract the percentage information from the message

 * (requires GStreamer >= 0.10.11):

 * switch (GST_MESSAGE_TYPE (msg)) {

 *   case GST_MESSAGE_BUFFERING: {

 *     gint percent = 0;

 *     gst_message_parse_buffering (msg, &percent);

 *     g_print ("Buffering (%%u percent done)", percent);

 *     break;

 *   }

 *   ...

 * }

 * Note that applications should keep/set the pipeline in the PAUSED state when

 * a BUFFERING message is received with a buffer percent value < 100 and set

 * the pipeline back to PLAYING state when a BUFFERING message with a value

 * of 100 percent is received (if PLAYING is the desired state, that is).

 * <title>Embedding the video window in your application</title>

 * By default, playbin (or rather the video sinks used) will create their own

 * window. Applications will usually want to force output to a window of their

 * video sinks implement. See the documentation there for more details.

 * <title>Specifying which CD/DVD device to use</title>

 * The device to use for CDs/DVDs needs to be set on the source element

 * playbin creates before it is opened. The only way to do this at the moment

 * is to connect to playbin's "notify::source" signal, which will be emitted

 * by playbin when it has created the source element for a particular URI.

 * In the signal callback you can check if the source element has a "device"

 * property and set it appropriately. In future ways might be added to specify

 * the device as part of the URI, but at the time of writing this is not

 * possible yet.

 * <title>Examples</title>

 * gst-launch -v playbin uri=file:///path/to/somefile.avi

 * audio decoders required to decode the content are installed. Since no

 * special audio sink or video sink is supplied (not possible via gst-launch),

 * playbin will try to find a suitable audio and video sink automatically

 * using the autoaudiosink and autovideosink elements.

 * gst-launch -v playbin uri=cdda://4

 * the drive is detected automatically by the plugin).

 * gst-launch -v playbin uri=dvd://1

 * the drive is detected automatically by the plugin).

 * </refsect2>

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include <gst/gst.h>

#include <gst/gst-i18n-plugin.h>

#include <gst/pbutils/pbutils.h>

#include "gstplaybasebin.h"

GST_DEBUG_CATEGORY_STATIC (gst_play_bin_debug);

#define GST_CAT_DEFAULT gst_play_bin_debug

#define GST_TYPE_PLAY_BIN               (gst_play_bin_get_type())

#define GST_PLAY_BIN(obj)               (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_PLAY_BIN,GstPlayBin))

#define GST_PLAY_BIN_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_PLAY_BIN,GstPlayBinClass))

#define GST_IS_PLAY_BIN(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_PLAY_BIN))

#define GST_IS_PLAY_BIN_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_PLAY_BIN))

#define VOLUME_MAX_DOUBLE 10.0

typedef struct _GstPlayBin GstPlayBin;

typedef struct _GstPlayBinClass GstPlayBinClass;

struct _GstPlayBin

{

  GstPlayBaseBin parent;

  /* the configurable elements */

  GstElement *fakesink;

  GstElement *audio_sink;

  GstElement *video_sink;

  GstElement *visualisation;

  GstElement *pending_visualisation;

  GstElement *volume_element;

  GstElement *textoverlay_element;

  gfloat volume;

  /* these are the currently active sinks */

  GList *sinks;

  /* the last captured frame for snapshots */

  GstBuffer *frame;

  /* our cache for the sinks */

  GHashTable *cache;

  /* font description */

  gchar *font_desc;

  /* indication if the pipeline is live */

  gboolean is_live;

};

struct _GstPlayBinClass

{

  GstPlayBaseBinClass parent_class;

};

/* props */

enum

{

  ARG_0,

  ARG_AUDIO_SINK,

  ARG_VIDEO_SINK,

  ARG_VIS_PLUGIN,

  ARG_VOLUME,

  ARG_FRAME,

  ARG_FONT_DESC

};

/* signals */

enum

{

  LAST_SIGNAL

};

static void gst_play_bin_class_init (GstPlayBinClass * klass);

static void gst_play_bin_init (GstPlayBin * play_bin);

static void gst_play_bin_dispose (GObject * object);

static gboolean setup_sinks (GstPlayBaseBin * play_base_bin,

    GstPlayBaseGroup * group);

static void remove_sinks (GstPlayBin * play_bin);

static void playbin_set_subtitles_visible (GstPlayBaseBin * play_base_bin,

    gboolean visible);

static void gst_play_bin_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * spec);

static void gst_play_bin_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * spec);

static gboolean gst_play_bin_send_event (GstElement * element,

    GstEvent * event);

static GstStateChangeReturn gst_play_bin_change_state (GstElement * element,

    GstStateChange transition);

static void gst_play_bin_handle_message (GstBin * bin, GstMessage * message);

static GstElementClass *parent_class;

//static guint gst_play_bin_signals[LAST_SIGNAL] = { 0 };

static const GstElementDetails gst_play_bin_details =

GST_ELEMENT_DETAILS ("Player Bin",

    "Generic/Bin/Player",

    "Autoplug and play media from an uri",

    "Wim Taymans <wim.taymans@gmail.com>");

static GType

gst_play_bin_get_type (void)

{

  static GType gst_play_bin_type = 0;

  if (!gst_play_bin_type) {

    static const GTypeInfo gst_play_bin_info = {

      sizeof (GstPlayBinClass),

      NULL,

      NULL,

      (GClassInitFunc) gst_play_bin_class_init,

      NULL,

      NULL,

      sizeof (GstPlayBin),

      0,

      (GInstanceInitFunc) gst_play_bin_init,

      NULL

    };

    gst_play_bin_type = g_type_register_static (GST_TYPE_PLAY_BASE_BIN,

        "GstPlayBin", &gst_play_bin_info, 0);

  }

  return gst_play_bin_type;

}

static void

gst_play_bin_class_init (GstPlayBinClass * klass)

{

  GObjectClass *gobject_klass;

  GstElementClass *gstelement_klass;

  GstBinClass *gstbin_klass;

  GstPlayBaseBinClass *playbasebin_klass;

  gobject_klass = (GObjectClass *) klass;

  gstelement_klass = (GstElementClass *) klass;

  gstbin_klass = (GstBinClass *) klass;

  playbasebin_klass = (GstPlayBaseBinClass *) klass;

  parent_class = g_type_class_peek_parent (klass);

  gobject_klass->set_property = gst_play_bin_set_property;

  gobject_klass->get_property = gst_play_bin_get_property;

  g_object_class_install_property (gobject_klass, ARG_VIDEO_SINK,

      g_param_spec_object ("video-sink", "Video Sink",

          "the video output element to use (NULL = default sink)",

  g_object_class_install_property (gobject_klass, ARG_AUDIO_SINK,

      g_param_spec_object ("audio-sink", "Audio Sink",

          "the audio output element to use (NULL = default sink)",

  g_object_class_install_property (gobject_klass, ARG_VIS_PLUGIN,

      g_param_spec_object ("vis-plugin", "Vis plugin",

          "the visualization element to use (NULL = none)",

  g_object_class_install_property (gobject_klass, ARG_VOLUME,

      g_param_spec_double ("volume", "volume", "volume",

  g_object_class_install_property (gobject_klass, ARG_FRAME,

      gst_param_spec_mini_object ("frame", "Frame",

  g_object_class_install_property (gobject_klass, ARG_FONT_DESC,

  gobject_klass->dispose = GST_DEBUG_FUNCPTR (gst_play_bin_dispose);

  gst_element_class_set_details (gstelement_klass, &gst_play_bin_details);

  gstelement_klass->change_state =

      GST_DEBUG_FUNCPTR (gst_play_bin_change_state);

  gstelement_klass->send_event = GST_DEBUG_FUNCPTR (gst_play_bin_send_event);

  gstbin_klass->handle_message =

      GST_DEBUG_FUNCPTR (gst_play_bin_handle_message);

  playbasebin_klass->setup_output_pads = setup_sinks;

  playbasebin_klass->set_subtitles_visible = playbin_set_subtitles_visible;

}

static void

gst_play_bin_init (GstPlayBin * play_bin)

{

  play_bin->video_sink = NULL;

  play_bin->audio_sink = NULL;

  play_bin->visualisation = NULL;

  play_bin->pending_visualisation = NULL;

  play_bin->volume_element = NULL;

  play_bin->textoverlay_element = NULL;

  play_bin->volume = 1.0;

  play_bin->sinks = NULL;

  play_bin->frame = NULL;

  play_bin->font_desc = NULL;

  play_bin->cache = g_hash_table_new_full (g_str_hash, g_str_equal,

      NULL, (GDestroyNotify) gst_object_unref);

}

static void

gst_play_bin_dispose (GObject * object)

{

  GstPlayBin *play_bin;

  play_bin = GST_PLAY_BIN (object);

  if (play_bin->cache != NULL) {

    remove_sinks (play_bin);

    g_hash_table_destroy (play_bin->cache);

    play_bin->cache = NULL;

  }

  if (play_bin->audio_sink != NULL) {

    gst_element_set_state (play_bin->audio_sink, GST_STATE_NULL);

    gst_object_unref (play_bin->audio_sink);

    play_bin->audio_sink = NULL;

  }

  if (play_bin->video_sink != NULL) {

    gst_element_set_state (play_bin->video_sink, GST_STATE_NULL);

    gst_object_unref (play_bin->video_sink);

    play_bin->video_sink = NULL;

  }

  if (play_bin->visualisation != NULL) {

    gst_element_set_state (play_bin->visualisation, GST_STATE_NULL);

    gst_object_unref (play_bin->visualisation);

    play_bin->visualisation = NULL;

  }

  if (play_bin->pending_visualisation != NULL) {

    gst_element_set_state (play_bin->pending_visualisation, GST_STATE_NULL);

    gst_object_unref (play_bin->pending_visualisation);

    play_bin->pending_visualisation = NULL;

  }

  if (play_bin->textoverlay_element != NULL) {

    gst_object_unref (play_bin->textoverlay_element);

    play_bin->textoverlay_element = NULL;

  }

  g_free (play_bin->font_desc);

  play_bin->font_desc = NULL;

  G_OBJECT_CLASS (parent_class)->dispose (object);

}

static void

gst_play_bin_vis_unblocked (GstPad * tee_pad, gboolean blocked,

    gpointer user_data)

{

  GstPlayBin *play_bin = GST_PLAY_BIN (user_data);

  if (play_bin->pending_visualisation)

    gst_pad_set_blocked_async (tee_pad, FALSE, gst_play_bin_vis_unblocked,

        play_bin);

}

static void

gst_play_bin_vis_blocked (GstPad * tee_pad, gboolean blocked,

    gpointer user_data)

{

  GstPlayBin *play_bin = GST_PLAY_BIN (user_data);

  GstBin *vis_bin = NULL;

  GstPad *vis_sink_pad = NULL, *vis_src_pad = NULL, *vqueue_pad = NULL;

  GstState bin_state;

  GstElement *pending_visualisation;

  GST_OBJECT_LOCK (play_bin);

  pending_visualisation = play_bin->pending_visualisation;

  play_bin->pending_visualisation = NULL;

  GST_OBJECT_UNLOCK (play_bin);

  /* We want to disable visualisation */

  if (!GST_IS_ELEMENT (pending_visualisation)) {