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

#include <gst/gst.h>

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

#include <gst/pbutils/pbutils.h>

#include "gstplaysink.h"

GST_DEBUG_CATEGORY_STATIC (gst_play_sink_debug);

#define GST_CAT_DEFAULT gst_play_sink_debug

#define VOLUME_MAX_DOUBLE 10.0

#define GST_PLAY_CHAIN(c) ((GstPlayChain *)(c))

/* holds the common data fields for the audio and video pipelines. We keep them

 * in a structure to more easily have all the info available. */

typedef struct

{

  GstPlaySink *playsink;

  GstElement *bin;

  gboolean added;

  gboolean activated;

  gboolean raw;

} GstPlayChain;

typedef struct

{

  GstPlayChain chain;

  GstPad *sinkpad;

  GstElement *queue;

  GstElement *conv;

  GstElement *resample;

  GstElement *volume;           /* element with the volume property */

  gboolean sink_volume;         /* if the volume was provided by the sink */

  GstElement *mute;             /* element with the mute property */

  GstElement *sink;

} GstPlayAudioChain;

typedef struct

{

  GstPlayChain chain;

  GstPad *sinkpad;

  GstElement *queue;

  GstElement *conv;

  GstElement *scale;

  GstElement *sink;

  gboolean async;

} GstPlayVideoChain;

typedef struct

{

  GstPlayChain chain;

  GstPad *sinkpad;

  GstElement *queue;

  GstElement *conv;

  GstElement *resample;

  GstPad *blockpad;             /* srcpad of resample, used for switching the vis */

  GstPad *vissinkpad;           /* visualisation sinkpad, */

  GstElement *vis;

  GstPad *vissrcpad;            /* visualisation srcpad, */

  GstPad *srcpad;               /* outgoing srcpad, used to connect to the next

                                 * chain */

} GstPlayVisChain;

typedef struct

{

  GstPlayChain chain;

  GstPad *sinkpad;

  GstElement *conv;

  GstElement *overlay;

  GstPad *videosinkpad;

  GstPad *textsinkpad;

  GstPad *srcpad;               /* outgoing srcpad, used to connect to the next

                                 * chain */

  GstElement *sink;             /* custom sink to receive subtitle buffers */

} GstPlayTextChain;

typedef struct

{

  GstPlayChain chain;

  GstPad *sinkpad;

  GstElement *queue;

  GstElement *conv;

  GstElement *overlay;

  GstPad *videosinkpad;

  GstPad *subpsinkpad;

  GstPad *srcpad;               /* outgoing srcpad, used to connect to the next

                                 * chain */

  GstElement *sink;             /* custom sink to receive subpicture buffers */

} GstPlaySubpChain;

#define GST_PLAY_SINK_GET_LOCK(playsink) (((GstPlaySink *)playsink)->lock)

#define GST_PLAY_SINK_LOCK(playsink)     g_mutex_lock (GST_PLAY_SINK_GET_LOCK (playsink))

#define GST_PLAY_SINK_UNLOCK(playsink)   g_mutex_unlock (GST_PLAY_SINK_GET_LOCK (playsink))

struct _GstPlaySink

{

  GstBin bin;

  GMutex *lock;

  gboolean async_pending;

  gboolean need_async_start;

  GstPlayFlags flags;

  /* chains */

  GstPlayAudioChain *audiochain;

  GstPlayVideoChain *videochain;

  GstPlayVisChain *vischain;

  GstPlayTextChain *textchain;

  GstPlaySubpChain *subpchain;

  /* audio */

  GstPad *audio_pad;

  gboolean audio_pad_raw;

  /* audio tee */

  GstElement *audio_tee;

  GstPad *audio_tee_sink;

  GstPad *audio_tee_asrc;

  GstPad *audio_tee_vissrc;

  /* video */

  GstPad *video_pad;

  gboolean video_pad_raw;

  /* text */

  GstPad *text_pad;

  /* subpictures */

  GstPad *subp_pad;

  /* properties */

  GstElement *audio_sink;

  GstElement *video_sink;

  GstElement *visualisation;

  GstElement *text_sink;

  GstElement *subp_sink;

  gfloat volume;

  gboolean mute;

  gchar *font_desc;             /* font description */

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

  gint count;

  gboolean volume_changed;      /* volume/mute changed while no audiochain */

  gboolean mute_changed;        /* ... has been reated yet */

};

struct _GstPlaySinkClass

{

  GstBinClass parent_class;

};

/* props */

enum

{

  PROP_0,

  PROP_LAST

};

/* signals */

enum

{

  LAST_SIGNAL

};

static void gst_play_sink_class_init (GstPlaySinkClass * klass);

static void gst_play_sink_init (GstPlaySink * playsink);

static void gst_play_sink_dispose (GObject * object);

static void gst_play_sink_finalize (GObject * object);

static gboolean gst_play_sink_send_event (GstElement * element,

    GstEvent * event);

static GstStateChangeReturn gst_play_sink_change_state (GstElement * element,

    GstStateChange transition);

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

/* static guint gst_play_sink_signals[LAST_SIGNAL] = { 0 }; */

static const GstElementDetails gst_play_sink_details =

GST_ELEMENT_DETAILS ("Player Sink",

    "Generic/Bin/Player",

    "Autoplug and play media from an uri",

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

G_DEFINE_TYPE (GstPlaySink, gst_play_sink, GST_TYPE_BIN);

static void

gst_play_sink_class_init (GstPlaySinkClass * klass)

{

  GObjectClass *gobject_klass;

  GstElementClass *gstelement_klass;

  GstBinClass *gstbin_klass;

  gobject_klass = (GObjectClass *) klass;

  gstelement_klass = (GstElementClass *) klass;

  gstbin_klass = (GstBinClass *) klass;

  gobject_klass->dispose = GST_DEBUG_FUNCPTR (gst_play_sink_dispose);

  gobject_klass->finalize = GST_DEBUG_FUNCPTR (gst_play_sink_finalize);

  gst_element_class_set_details (gstelement_klass, &gst_play_sink_details);

  gstelement_klass->change_state =

      GST_DEBUG_FUNCPTR (gst_play_sink_change_state);

  gstelement_klass->send_event = GST_DEBUG_FUNCPTR (gst_play_sink_send_event);

  gstbin_klass->handle_message =

      GST_DEBUG_FUNCPTR (gst_play_sink_handle_message);

  GST_DEBUG_CATEGORY_INIT (gst_play_sink_debug, "playsink", 0, "play bin");

}

static void

gst_play_sink_init (GstPlaySink * playsink)

{

  /* init groups */

  playsink->video_sink = NULL;

  playsink->audio_sink = NULL;

  playsink->visualisation = NULL;

  playsink->text_sink = NULL;

  playsink->volume = 1.0;

  playsink->font_desc = NULL;

  playsink->flags = GST_PLAY_FLAG_SOFT_VOLUME;

  playsink->lock = g_mutex_new ();

  playsink->need_async_start = TRUE;

  GST_OBJECT_FLAG_SET (playsink, GST_ELEMENT_IS_SINK);

}

static void

free_chain (GstPlayChain * chain)

{

  if (chain) {

    if (chain->bin)

      gst_object_unref (chain->bin);

    g_free (chain);

  }

}

static void

gst_play_sink_dispose (GObject * object)

{

  GstPlaySink *playsink;

  playsink = GST_PLAY_SINK (object);

  if (playsink->audio_sink != NULL) {

    gst_element_set_state (playsink->audio_sink, GST_STATE_NULL);

    gst_object_unref (playsink->audio_sink);

    playsink->audio_sink = NULL;

  }

  if (playsink->video_sink != NULL) {

    gst_element_set_state (playsink->video_sink, GST_STATE_NULL);

    gst_object_unref (playsink->video_sink);

    playsink->video_sink = NULL;

  }

  if (playsink->visualisation != NULL) {

    gst_element_set_state (playsink->visualisation, GST_STATE_NULL);

    gst_object_unref (playsink->visualisation);

    playsink->visualisation = NULL;

  }

  if (playsink->text_sink != NULL) {

    gst_element_set_state (playsink->text_sink, GST_STATE_NULL);

    gst_object_unref (playsink->text_sink);

    playsink->text_sink = NULL;

  }

  free_chain ((GstPlayChain *) playsink->videochain);

  playsink->videochain = NULL;

  free_chain ((GstPlayChain *) playsink->audiochain);

  playsink->audiochain = NULL;

  free_chain ((GstPlayChain *) playsink->vischain);

  playsink->vischain = NULL;

  free_chain ((GstPlayChain *) playsink->textchain);

  playsink->textchain = NULL;

  if (playsink->audio_tee_sink) {

    gst_object_unref (playsink->audio_tee_sink);

    playsink->audio_tee_sink = NULL;

  }

  if (playsink->audio_tee_vissrc) {

    gst_element_release_request_pad (playsink->audio_tee,

        playsink->audio_tee_vissrc);

    gst_object_unref (playsink->audio_tee_vissrc);

    playsink->audio_tee_vissrc = NULL;

  }

  if (playsink->audio_tee_asrc) {

    gst_element_release_request_pad (playsink->audio_tee,

        playsink->audio_tee_asrc);

    gst_object_unref (playsink->audio_tee_asrc);

    playsink->audio_tee_asrc = NULL;

  }

  g_free (playsink->font_desc);

  playsink->font_desc = NULL;

  G_OBJECT_CLASS (gst_play_sink_parent_class)->dispose (object);

}

static void

gst_play_sink_finalize (GObject * object)

{

  GstPlaySink *playsink;

  playsink = GST_PLAY_SINK (object);

  g_mutex_free (playsink->lock);

  G_OBJECT_CLASS (gst_play_sink_parent_class)->finalize (object);

}

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_play_sink_set_sink (GstPlaySink * playsink, GstPlaySinkType type,

    GstElement * sink)

{

  GstElement **elem = NULL, *old = NULL;

  GST_LOG ("Setting sink %" GST_PTR_FORMAT " as sink type %d", sink, type);

  GST_PLAY_SINK_LOCK (playsink);

  switch (type) {

    case GST_PLAY_SINK_TYPE_AUDIO:

    case GST_PLAY_SINK_TYPE_AUDIO_RAW:

      elem = &playsink->audio_sink;

      break;

    case GST_PLAY_SINK_TYPE_VIDEO:

    case GST_PLAY_SINK_TYPE_VIDEO_RAW:

      elem = &playsink->video_sink;

      break;

    case GST_PLAY_SINK_TYPE_TEXT:

      elem = &playsink->text_sink;

      break;

    case GST_PLAY_SINK_TYPE_SUBPIC:

      elem = &playsink->subp_sink;

      break;

    default:

      break;

  }

  if (elem) {

    old = *elem;

    if (sink)

      gst_object_ref (sink);

    *elem = sink;

  }

  GST_PLAY_SINK_UNLOCK (playsink);

  if (old)

    gst_object_unref (old);

}

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GstElement *

gst_play_sink_get_sink (GstPlaySink * playsink, GstPlaySinkType type)

{

  GstElement *result = NULL;

  GstElement *elem = NULL, *chainp = NULL;

  GST_PLAY_SINK_LOCK (playsink);

  switch (type) {

    case GST_PLAY_SINK_TYPE_AUDIO:

    {

      GstPlayAudioChain *chain;

      if ((chain = (GstPlayAudioChain *) playsink->audiochain))

        chainp = chain->sink;

      elem = playsink->audio_sink;

      break;

    }

    case GST_PLAY_SINK_TYPE_VIDEO:

    {

      GstPlayVideoChain *chain;

      if ((chain = (GstPlayVideoChain *) playsink->videochain))

        chainp = chain->sink;

      elem = playsink->video_sink;

      break;

    }

    case GST_PLAY_SINK_TYPE_TEXT:

    {

      GstPlayTextChain *chain;

      if ((chain = (GstPlayTextChain *) playsink->textchain))

        chainp = chain->sink;

      elem = playsink->text_sink;

      break;

    }

    case GST_PLAY_SINK_TYPE_SUBPIC:

    {

      GstPlaySubpChain *chain;

      if ((chain = (GstPlaySubpChain *) playsink->subpchain))

        chainp = chain->sink;

      elem = playsink->subp_sink;

      break;

    }

    default:

      break;

  }

  if (chainp) {

    /* we have an active chain with a sink, get the sink */

    result = gst_object_ref (chainp);

  }

  /* nothing found, return last configured sink */

  if (result == NULL && elem)

    result = gst_object_ref (elem);

  GST_PLAY_SINK_UNLOCK (playsink);

  return result;

}

static void

gst_play_sink_vis_unblocked (GstPad * tee_pad, gboolean blocked,

    gpointer user_data)

{

  GstPlaySink *playsink;

  playsink = GST_PLAY_SINK (user_data);

  /* nothing to do here, we need a dummy callback here to make the async call

   * non-blocking. */

  GST_DEBUG_OBJECT (playsink, "vis pad unblocked");

}

static void

gst_play_sink_vis_blocked (GstPad * tee_pad, gboolean blocked,

    gpointer user_data)

{

  GstPlaySink *playsink;

  GstPlayVisChain *chain;

  playsink = GST_PLAY_SINK (user_data);

  GST_PLAY_SINK_LOCK (playsink);

  GST_DEBUG_OBJECT (playsink, "vis pad blocked");

  /* now try to change the plugin in the running vis chain */

  if (!(chain = (GstPlayVisChain *) playsink->vischain))

    goto done;

  /* unlink the old plugin and unghost the pad */

  gst_pad_unlink (chain->blockpad, chain->vissinkpad);

  gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (chain->srcpad), NULL);

  /* set the old plugin to NULL and remove */

  gst_element_set_state (chain->vis, GST_STATE_NULL);

  gst_bin_remove (GST_BIN_CAST (chain->chain.bin), chain->vis);

  /* add new plugin and set state to playing */

  chain->vis = playsink->visualisation;

  gst_bin_add (GST_BIN_CAST (chain->chain.bin), chain->vis);

  gst_element_set_state (chain->vis, GST_STATE_PLAYING);

  /* get pads */

  chain->vissinkpad = gst_element_get_static_pad (chain->vis, "sink");

  chain->vissrcpad = gst_element_get_static_pad (chain->vis, "src");

  /* link pads */

  gst_pad_link (chain->blockpad, chain->vissinkpad);

  gst_ghost_pad_set_target (GST_GHOST_PAD_CAST (chain->srcpad),

      chain->vissrcpad);

done:

  /* Unblock the pad */

  gst_pad_set_blocked_async (tee_pad, FALSE, gst_play_sink_vis_unblocked,

      playsink);

  GST_PLAY_SINK_UNLOCK (playsink);

}

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_play_sink_set_vis_plugin (GstPlaySink * playsink, GstElement * vis)

{

  GstPlayVisChain *chain;

  /* setting NULL means creating the default vis plugin */

  if (vis == NULL)

    vis = gst_element_factory_make ("goom", "vis");

  /* simply return if we don't have a vis plugin here */

  if (vis == NULL)

    return;