/* GStreamer

 * Copyright (C) <2007> Wim Taymans <wim.taymans@gmail.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/**

 * SECTION:element-playbin2

 *

 * 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>

 * </listitem>

 * <listitem>

 * </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>

 * </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

 * and autovideosink elements to find the first-best available output method.

 * 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

 * 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

 * </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.

 * <para>

 * 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 "gstplay-enum.h"

#include "gstplay-marshal.h"

#include "gstplaysink.h"

#include "gstfactorylists.h"

#include "gstscreenshot.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;

typedef struct _GstSourceGroup GstSourceGroup;

typedef struct _GstSourceSelect GstSourceSelect;

/* has the info for a selector and provides the link to the sink */

struct _GstSourceSelect

{

  GstPlaySinkType type;         /* the sink pad type of the selector */

  GstElement *selector;         /* the selector */

  GPtrArray *channels;

  GstPad *srcpad;               /* the source pad of the selector */

  GstPad *sinkpad;              /* the sinkpad of the sink when the selector is linked */

};

/* a structure to hold the objects for decoding a uri and the subtitle uri

 */

struct _GstSourceGroup

{

  GstPlayBin *playbin;

  gboolean valid;               /* the group has valid info to start playback */

  gboolean active;              /* the group is active */

  /* properties */

  gchar *uri;

  gchar *suburi;

  GValueArray *streaminfo;

  GstElement *source;

  GPtrArray *video_channels;    /* links to selector pads */

  GPtrArray *audio_channels;    /* links to selector pads */

  GPtrArray *text_channels;     /* links to selector pads */

  /* uridecodebins for uri and subtitle uri */

  GstElement *uridecodebin;

  GstElement *suburidecodebin;

  /* selectors for different streams */

  GstSourceSelect selector[GST_PLAY_SINK_TYPE_LAST];

};

struct _GstPlayBin

{

  GstPipeline parent;

  /* the groups, we use a double buffer to switch between current and next */

  GstSourceGroup groups[2];     /* array with group info */

  GstSourceGroup *curr_group;   /* pointer to the currently playing group */

  GstSourceGroup *next_group;   /* pointer to the next group */

  /* properties */

  guint connection_speed;       /* connection speed in bits/sec (0 = unknown) */

  gint current_video;           /* the currently selected stream */

  gint current_audio;           /* the currently selected stream */

  gint current_text;            /* the currently selected stream */

  /* our play sink */

  GstPlaySink *playsink;

  GValueArray *elements;        /* factories we can use for selecting elements */

};

struct _GstPlayBinClass

{

  GstPipelineClass parent_class;

  /* notify app that the current uri finished decoding and it is possible to

   * queue a new one for gapless playback */

  void (*about_to_finish) (GstPlayBin * playbin);

  /* notify app that number of audio/video/text streams changed */

  void (*video_changed) (GstPlayBin * playbin);

  void (*audio_changed) (GstPlayBin * playbin);

  void (*text_changed) (GstPlayBin * playbin);

  /* get audio/video/text tags for a stream */

  GstTagList *(*get_video_tags) (GstPlayBin * playbin, gint stream);

  GstTagList *(*get_audio_tags) (GstPlayBin * playbin, gint stream);

  GstTagList *(*get_text_tags) (GstPlayBin * playbin, gint stream);

  /* get the last video frame and convert it to the given caps */

  GstBuffer *(*convert_frame) (GstPlayBin * playbin, GstCaps * caps);

};

/* props */

#define DEFAULT_URI               NULL

#define DEFAULT_SUBURI            NULL

#define DEFAULT_SOURCE            NULL

#define DEFAULT_FLAGS             GST_PLAY_FLAG_AUDIO | GST_PLAY_FLAG_VIDEO | GST_PLAY_FLAG_TEXT | \

	                          GST_PLAY_FLAG_SOFT_VOLUME

#define DEFAULT_N_VIDEO           0

#define DEFAULT_CURRENT_VIDEO     -1

#define DEFAULT_N_AUDIO           0

#define DEFAULT_CURRENT_AUDIO     -1

#define DEFAULT_N_TEXT            0

#define DEFAULT_CURRENT_TEXT      -1

#define DEFAULT_SUBTITLE_ENCODING NULL

#define DEFAULT_AUDIO_SINK        NULL

#define DEFAULT_VIDEO_SINK        NULL

#define DEFAULT_VIS_PLUGIN        NULL

#define DEFAULT_VOLUME            1.0

#define DEFAULT_MUTE              FALSE

#define DEFAULT_FRAME             NULL

#define DEFAULT_FONT_DESC         NULL

#define DEFAULT_CONNECTION_SPEED  0

enum

{

  PROP_0,

  PROP_URI,

  PROP_SUBURI,

  PROP_SOURCE,

  PROP_FLAGS,

  PROP_N_VIDEO,

  PROP_CURRENT_VIDEO,

  PROP_N_AUDIO,

  PROP_CURRENT_AUDIO,

  PROP_N_TEXT,

  PROP_CURRENT_TEXT,

  PROP_SUBTITLE_ENCODING,

  PROP_AUDIO_SINK,

  PROP_VIDEO_SINK,

  PROP_VIS_PLUGIN,

  PROP_VOLUME,

  PROP_MUTE,

  PROP_FRAME,

  PROP_FONT_DESC,

};

/* signals */

enum

{

  SIGNAL_ABOUT_TO_FINISH,

  SIGNAL_VIDEO_CHANGED,

  SIGNAL_AUDIO_CHANGED,

  SIGNAL_TEXT_CHANGED,

  SIGNAL_GET_VIDEO_TAGS,

  SIGNAL_GET_AUDIO_TAGS,

  SIGNAL_GET_TEXT_TAGS,

  LAST_SIGNAL

};

static void gst_play_bin_class_init (GstPlayBinClass * klass);

static void gst_play_bin_init (GstPlayBin * playbin);

static void gst_play_bin_finalize (GObject * object);

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 GstStateChangeReturn gst_play_bin_change_state (GstElement * element,

    GstStateChange transition);

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

static GstTagList *gst_play_bin_get_video_tags (GstPlayBin * playbin,

    gint stream);

static GstTagList *gst_play_bin_get_audio_tags (GstPlayBin * playbin,