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

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

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

#include <string.h>

#include "gstplaybasebin.h"

#include "gststreamselector.h"

#include "gstplay-marshal.h"

#include <gst/pbutils/pbutils.h>

#ifdef __SYMBIAN32__

#include <glib_global.h>

#endif

GST_DEBUG_CATEGORY_STATIC (gst_play_base_bin_debug);

#define GST_CAT_DEFAULT gst_play_base_bin_debug

#define DEFAULT_QUEUE_SIZE          (3 * GST_SECOND)

#define DEFAULT_QUEUE_MIN_THRESHOLD ((DEFAULT_QUEUE_SIZE * 30) / 100)

#define DEFAULT_QUEUE_THRESHOLD     ((DEFAULT_QUEUE_SIZE * 95) / 100)

#define DEFAULT_CONNECTION_SPEED    0

#define GROUP_LOCK(pbb) g_mutex_lock (pbb->group_lock)

#define GROUP_UNLOCK(pbb) g_mutex_unlock (pbb->group_lock)

#define GROUP_WAIT(pbb) g_cond_wait (pbb->group_cond, pbb->group_lock)

#define GROUP_SIGNAL(pbb) g_cond_signal (pbb->group_cond)

/* props */

enum

{

  ARG_0,

  ARG_URI,

  ARG_SUBURI,

  ARG_QUEUE_SIZE,

  ARG_QUEUE_THRESHOLD,

  ARG_QUEUE_MIN_THRESHOLD,

  ARG_NSTREAMS,

  ARG_STREAMINFO,

  ARG_STREAMINFO_VALUES,

  ARG_SOURCE,

  ARG_VIDEO,

  ARG_AUDIO,

  ARG_TEXT,

  ARG_SUBTITLE_ENCODING,

  ARG_CONNECTION_SPEED

};

static void gst_play_base_bin_class_init (GstPlayBaseBinClass * klass);

static void gst_play_base_bin_init (GstPlayBaseBin * play_base_bin);

static void gst_play_base_bin_dispose (GObject * object);

static void gst_play_base_bin_finalize (GObject * object);

static void gst_play_base_bin_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * spec);

static void gst_play_base_bin_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * spec);

static void gst_play_base_bin_handle_message_func (GstBin * bin,

    GstMessage * msg);

static GstStateChangeReturn gst_play_base_bin_change_state (GstElement *

    element, GstStateChange transition);

static const GList *gst_play_base_bin_get_streaminfo (GstPlayBaseBin * bin);

static GValueArray *gst_play_base_bin_get_streaminfo_value_array (GstPlayBaseBin

    * play_base_bin);

static void preroll_remove_overrun (GstElement * element,

    GstPlayBaseBin * play_base_bin);

static void queue_remove_probe (GstElement * queue, GstPlayBaseBin

    * play_base_bin);

static GstElement *make_decoder (GstPlayBaseBin * play_base_bin);

static gboolean has_all_raw_caps (GstPad * pad, gboolean * all_raw);

static gboolean prepare_output (GstPlayBaseBin * play_base_bin);

static void set_active_source (GstPlayBaseBin * play_base_bin,

    GstStreamType type, gint source_num);

static gboolean probe_triggered (GstPad * pad, GstEvent * event,

    gpointer user_data);

static void setup_substreams (GstPlayBaseBin * play_base_bin);

static GstPipelineClass *parent_class;

/*

 * GObject playbasebin wrappers.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GType

gst_play_base_bin_get_type (void)

{

  static GType gst_play_base_bin_type = 0;

  if (!gst_play_base_bin_type) {

    static const GTypeInfo gst_play_base_bin_info = {

      sizeof (GstPlayBaseBinClass),

      NULL,

      NULL,

      (GClassInitFunc) gst_play_base_bin_class_init,

      NULL,

      NULL,

      sizeof (GstPlayBaseBin),

      0,

      (GInstanceInitFunc) gst_play_base_bin_init,

      NULL

    };

    gst_play_base_bin_type = g_type_register_static (GST_TYPE_PIPELINE,

        "GstPlayBaseBin", &gst_play_base_bin_info, 0);

  }

  return gst_play_base_bin_type;

}

static void

gst_play_base_bin_class_init (GstPlayBaseBinClass * klass)

{

  GObjectClass *gobject_klass;

  GstElementClass *gstelement_klass;

  GstBinClass *gstbin_klass;

  gobject_klass = (GObjectClass *) klass;

  gstelement_klass = (GstElementClass *) klass;

  gstbin_klass = (GstBinClass *) klass;

  parent_class = g_type_class_peek_parent (klass);

  gobject_klass->set_property = gst_play_base_bin_set_property;

  gobject_klass->get_property = gst_play_base_bin_get_property;

  g_object_class_install_property (gobject_klass, ARG_URI,

      g_param_spec_string ("uri", "URI", "URI of the media to play",

          NULL, G_PARAM_READWRITE));

  g_object_class_install_property (gobject_klass, ARG_SUBURI,

      g_param_spec_string ("suburi", ".sub-URI", "Optional URI of a subtitle",

          NULL, G_PARAM_READWRITE));

  g_object_class_install_property (gobject_klass, ARG_QUEUE_SIZE,

      g_param_spec_uint64 ("queue-size", "Queue size",

          "Size of internal queues in nanoseconds", 0, G_MAXINT64,

          DEFAULT_QUEUE_SIZE, G_PARAM_READWRITE));

  g_object_class_install_property (gobject_klass, ARG_QUEUE_THRESHOLD,

      g_param_spec_uint64 ("queue-threshold", "Queue threshold",

          "Buffering threshold of internal queues in nanoseconds", 0,

          G_MAXINT64, DEFAULT_QUEUE_THRESHOLD, G_PARAM_READWRITE));

  g_object_class_install_property (gobject_klass, ARG_QUEUE_MIN_THRESHOLD,

      g_param_spec_uint64 ("queue-min-threshold", "Queue min threshold",

          "Buffering low threshold of internal queues in nanoseconds", 0,

          G_MAXINT64, DEFAULT_QUEUE_MIN_THRESHOLD, G_PARAM_READWRITE));

  g_object_class_install_property (gobject_klass, ARG_NSTREAMS,

      g_param_spec_int ("nstreams", "NStreams", "number of streams",

          0, G_MAXINT, 0, G_PARAM_READABLE));

  g_object_class_install_property (gobject_klass, ARG_STREAMINFO,

      g_param_spec_pointer ("stream-info", "Stream info", "List of streaminfo",

          G_PARAM_READABLE));

  g_object_class_install_property (gobject_klass, ARG_STREAMINFO_VALUES,

      g_param_spec_value_array ("stream-info-value-array",

          "StreamInfo GValueArray", "value array of streaminfo",

          g_param_spec_object ("streaminfo", "StreamInfo", "Streaminfo object",

              GST_TYPE_STREAM_INFO, G_PARAM_READABLE), G_PARAM_READABLE));

  g_object_class_install_property (gobject_klass, ARG_SOURCE,

      g_param_spec_object ("source", "Source", "Source element",

          GST_TYPE_ELEMENT, G_PARAM_READABLE));

  g_object_class_install_property (gobject_klass, ARG_VIDEO,

      g_param_spec_int ("current-video", "Current video",

          "Currently playing video stream (-1 = none)",

          -1, G_MAXINT, -1, G_PARAM_READWRITE));

  g_object_class_install_property (gobject_klass, ARG_AUDIO,

      g_param_spec_int ("current-audio", "Current audio",

          "Currently playing audio stream (-1 = none)",

          -1, G_MAXINT, -1, G_PARAM_READWRITE));

  g_object_class_install_property (gobject_klass, ARG_TEXT,

      g_param_spec_int ("current-text", "Current text",

          "Currently playing text stream (-1 = none)",

          -1, G_MAXINT, -1, G_PARAM_READWRITE));

  g_object_class_install_property (gobject_klass, ARG_SUBTITLE_ENCODING,

      g_param_spec_string ("subtitle-encoding", "subtitle encoding",

          "Encoding to assume if input subtitles are not in UTF-8 encoding. "

          "If not set, the GST_SUBTITLE_ENCODING environment variable will "

          "be checked for an encoding to use. If that is not set either, "

          "ISO-8859-15 will be assumed.", NULL, G_PARAM_READWRITE));

  /**

   * GstPlayBin::connection-speed

   *

   * Network connection speed in kbps (0 = unknown)

   *

   * Since: 0.10.10 at gstplaybin.c, 0.10.15 moved to gstplaybasebin

   **/

  g_object_class_install_property (gobject_klass, ARG_CONNECTION_SPEED,

      g_param_spec_uint ("connection-speed", "Connection Speed",

          "Network connection speed in kbps (0 = unknown)",

          0, G_MAXUINT, DEFAULT_CONNECTION_SPEED, G_PARAM_READWRITE));

  GST_DEBUG_CATEGORY_INIT (gst_play_base_bin_debug, "playbasebin", 0,

      "playbasebin");

  gobject_klass->dispose = GST_DEBUG_FUNCPTR (gst_play_base_bin_dispose);

  gobject_klass->finalize = GST_DEBUG_FUNCPTR (gst_play_base_bin_finalize);

  gstbin_klass->handle_message =

      GST_DEBUG_FUNCPTR (gst_play_base_bin_handle_message_func);

  gstelement_klass->change_state =

      GST_DEBUG_FUNCPTR (gst_play_base_bin_change_state);

}

static void

gst_play_base_bin_init (GstPlayBaseBin * play_base_bin)

{

  play_base_bin->uri = NULL;

  play_base_bin->suburi = NULL;

  play_base_bin->need_rebuild = TRUE;

  play_base_bin->is_stream = FALSE;

  play_base_bin->source = NULL;

  play_base_bin->decoders = NULL;

  play_base_bin->subtitle = NULL;

  play_base_bin->subencoding = NULL;

  play_base_bin->subtitle_elements = NULL;

  play_base_bin->sub_lock = g_mutex_new ();

  play_base_bin->group_lock = g_mutex_new ();

  play_base_bin->group_cond = g_cond_new ();

  play_base_bin->building_group = NULL;

  play_base_bin->queued_groups = NULL;

  play_base_bin->queue_size = DEFAULT_QUEUE_SIZE;

  play_base_bin->queue_threshold = DEFAULT_QUEUE_THRESHOLD;

  play_base_bin->queue_min_threshold = DEFAULT_QUEUE_MIN_THRESHOLD;

  play_base_bin->connection_speed = DEFAULT_CONNECTION_SPEED;

}

static void

gst_play_base_bin_dispose (GObject * object)

{

  GstPlayBaseBin *play_base_bin;

  play_base_bin = GST_PLAY_BASE_BIN (object);

  g_free (play_base_bin->uri);

  play_base_bin->uri = NULL;

  g_free (play_base_bin->suburi);

  play_base_bin->suburi = NULL;

  g_free (play_base_bin->subencoding);

  play_base_bin->subencoding = NULL;

  if (play_base_bin->subtitle_elements) {

    g_slist_free (play_base_bin->subtitle_elements);

    play_base_bin->subtitle_elements = NULL;

  }

  G_OBJECT_CLASS (parent_class)->dispose (object);

}

static void

gst_play_base_bin_finalize (GObject * object)

{

  GstPlayBaseBin *play_base_bin = GST_PLAY_BASE_BIN (object);

  g_mutex_free (play_base_bin->group_lock);

  g_cond_free (play_base_bin->group_cond);

  g_mutex_free (play_base_bin->sub_lock);

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

/*

 * playbasebingroup stuff.

 */

static GstPlayBaseGroup *

group_create (GstPlayBaseBin * play_base_bin)

{

  GstPlayBaseGroup *group;

  group = g_new0 (GstPlayBaseGroup, 1);

  group->bin = play_base_bin;

  group->streaminfo_value_array = g_value_array_new (0);

  GST_DEBUG_OBJECT (play_base_bin, "created new group %p", group);

  return group;

}

/*

 * Gets the currently playing group.

 *

 * Callers must have group-lock held when calling this.

 */

static GstPlayBaseGroup *

get_active_group (GstPlayBaseBin * play_base_bin)

{

  GstPlayBaseGroup *group = NULL;

  if (play_base_bin->queued_groups)

    group = play_base_bin->queued_groups->data;

  return group;

}

/*

 * get the group used for discovering the different streams.

 * This function creates a group is there is none.

 *

 * Callers must have group-lock held when calling this.

 */

static GstPlayBaseGroup *

get_building_group (GstPlayBaseBin * play_base_bin)

{

  GstPlayBaseGroup *group;

  group = play_base_bin->building_group;

  if (group == NULL) {

    group = group_create (play_base_bin);

    play_base_bin->building_group = group;

  }

  return group;

}

/*

 * Callers must have lock held when calling this!

 */

static void

group_destroy (GstPlayBaseGroup * group)

{

  GstPlayBaseBin *play_base_bin = group->bin;

  gint n;

  GST_LOG ("removing group %p", group);

  /* remove the preroll queues */

  for (n = 0; n < NUM_TYPES; n++) {

    GstElement *element = group->type[n].preroll;

    GstElement *fakesrc;

    GstElement *sel;

    const GList *item;

    if (!element)

      continue;

    sel = group->type[n].selector;

    /* remove any fakesrc elements for this preroll element */

    for (item = sel->pads; item != NULL; item = item->next) {

      GstPad *pad = GST_PAD (item->data);

      guint sig_id;

      if (GST_PAD_DIRECTION (pad) != GST_PAD_SINK)

        continue;

      sig_id =

          GPOINTER_TO_INT (g_object_get_data (G_OBJECT (pad), "unlinked_id"));

      if (sig_id != 0) {

        GST_LOG ("removing unlink signal %s:%s", GST_DEBUG_PAD_NAME (pad));

        g_signal_handler_disconnect (G_OBJECT (pad), sig_id);

        g_object_set_data (G_OBJECT (pad), "unlinked_id", GINT_TO_POINTER (0));

      }

      fakesrc = (GstElement *) g_object_get_data (G_OBJECT (pad), "fakesrc");

      if (fakesrc != NULL) {

        GST_LOG ("removing fakesrc from %s:%s",

            GST_PAD_NAME (pad), GST_ELEMENT_NAME (GST_PAD_PARENT (pad)));

        gst_element_set_state (fakesrc, GST_STATE_NULL);

        gst_bin_remove (GST_BIN_CAST (play_base_bin), fakesrc);

      }

    }

    /* if the group is currently being played, we have to remove the element

     * from the thread */

    gst_element_set_state (element, GST_STATE_NULL);

    gst_element_set_state (group->type[n].selector, GST_STATE_NULL);

    GST_LOG ("removing preroll element %s", GST_ELEMENT_NAME (element));

    gst_bin_remove (group->type[n].bin, element);

    gst_bin_remove (group->type[n].bin, group->type[n].selector);

    group->type[n].preroll = NULL;

    group->type[n].selector = NULL;

    group->type[n].bin = NULL;

  }

  /* free the streaminfo too */

  g_list_foreach (group->streaminfo, (GFunc) g_object_unref, NULL);

  g_list_free (group->streaminfo);

  g_value_array_free (group->streaminfo_value_array);

  g_free (group);

}

/*

 * is called when the current building group is completely finished

 * and ready for playback

 *

 * This function grabs lock, so take care when calling.

 */

static void

group_commit (GstPlayBaseBin * play_base_bin, gboolean fatal, gboolean subtitle)

{

  GstPlayBaseGroup *group;

  gboolean had_active_group;

  gboolean res;

  GROUP_LOCK (play_base_bin);

  group = play_base_bin->building_group;

  had_active_group = (get_active_group (play_base_bin) != NULL);

  GST_DEBUG_OBJECT (play_base_bin, "commit group %p, had active %d",

      group, had_active_group);

  /* if an element signalled a no-more-pads after we stopped due

   * to preroll, the group is NULL. This is not an error */

  if (group == NULL) {

    if (!fatal) {

      GROUP_UNLOCK (play_base_bin);

      return;

    } else {

      GST_DEBUG_OBJECT (play_base_bin, "Group loading failed, bailing out");

    }

  } else {

    if (!subtitle) {

      gint n;

      GST_DEBUG_OBJECT (play_base_bin, "group %p done", group);

      play_base_bin->queued_groups =

          g_list_append (play_base_bin->queued_groups, group);

      play_base_bin->building_group = NULL;

      /* remove signals. We don't want anymore signals from the preroll

       * elements at this stage. */

      for (n = 0; n < NUM_TYPES; n++) {

        GstElement *element = group->type[n].preroll;

        if (!element)

          continue;

        preroll_remove_overrun (element, play_base_bin);

        /* if overrun is removed, probe alse has to be removed */

        queue_remove_probe (element, play_base_bin);

      }

    } else {

      /* this is a special subtitle bin, we don't commit the group but

       * mark the subtitles as detected before we signal. */

      GST_DEBUG_OBJECT (play_base_bin, "marking subtitle bin as complete");

      play_base_bin->subtitle_done = TRUE;

    }

  }

  GST_DEBUG_OBJECT (play_base_bin, "signal group done");

  GROUP_SIGNAL (play_base_bin);

  GST_DEBUG_OBJECT (play_base_bin, "signaled group done");

  if (!subtitle && !had_active_group) {

    if (!prepare_output (play_base_bin)) {

      GROUP_UNLOCK (play_base_bin);

      return;

    }

    setup_substreams (play_base_bin);

    GST_DEBUG_OBJECT (play_base_bin, "Emitting signal");

    res = GST_PLAY_BASE_BIN_GET_CLASS (play_base_bin)->

        setup_output_pads (play_base_bin, group);

    GST_DEBUG_OBJECT (play_base_bin, "done");

    GROUP_UNLOCK (play_base_bin);

    g_object_notify (G_OBJECT (play_base_bin), "stream-info");

  } else {

    GROUP_UNLOCK (play_base_bin);

  }

}

/*

 * check if there are streams in the group that are not muted

 *

 * Callers must have group-lock held when calling this.

 */

static gboolean

group_is_muted (GstPlayBaseGroup * group)

{

  gint n;

  for (n = 0; n < NUM_TYPES; n++) {

    if (group->type[n].preroll && !group->type[n].done)

      return FALSE;

  }

  return TRUE;

}

/*

 * Buffer/cache checking.

 */

static inline void

fill_buffer (GstPlayBaseBin * play_base_bin, gint percent)

{

  GST_DEBUG_OBJECT (play_base_bin, "buffering %d", percent);

  gst_element_post_message (GST_ELEMENT_CAST (play_base_bin),

      gst_message_new_buffering (GST_OBJECT_CAST (play_base_bin), percent));