/*

 * gabble-media-stream.c - Source for GabbleMediaStream

 * Copyright (C) 2006 Collabora Ltd.

 * 

 *   @author Ole Andre Vadla Ravnaas <ole.andre.ravnaas@collabora.co.uk>

 *

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

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

 * License as published by the Free Software Foundation; either

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

 * Lesser General Public License for more details.

 *

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

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

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#include <dbus/dbus-glib.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "ansi.h"

#include "debug.h"

#include "handles.h"

#include "namespaces.h"

#include "gabble-connection.h"

#include "gabble-media-channel.h"

#include "gabble-media-session.h"

#include "gabble-media-session-enumtypes.h"

#include "telepathy-helpers.h"

#include "telepathy-constants.h"

#include "gabble-media-stream.h"

#include "gabble-media-stream-signals-marshal.h"

#include "gabble-media-stream-glue.h"

#include "gabble_enums.h"

#ifndef EMULATOR

G_DEFINE_TYPE(GabbleMediaStream, gabble_media_stream, G_TYPE_OBJECT)

#endif

#define DEBUG_FLAG GABBLE_DEBUG_MEDIA

#ifdef DEBUG_FLAG

//#define DEBUG(format, ...)

#define DEBUGGING 0

//#define NODE_DEBUG(n, s) ;

#endif /* DEBUG_FLAG */

/* signal enum */

enum

{

    DESTROY,

    ADD_REMOTE_CANDIDATE,

    CLOSE,

    REMOVE_REMOTE_CANDIDATE,

    SET_ACTIVE_CANDIDATE_PAIR,

    SET_REMOTE_CANDIDATE_LIST,

    SET_REMOTE_CODECS,

    SET_STREAM_PLAYING,

    SET_STREAM_SENDING,

    NEW_ACTIVE_CANDIDATE_PAIR,

    NEW_NATIVE_CANDIDATE,

    SUPPORTED_CODECS,

    ERROR,

    LAST_SIGNAL 

#ifdef EMULATOR    

    = LAST_SIGNAL_MED_STREAM

#endif

};

#ifdef EMULATOR

#include "libgabble_wsd_solution.h"

	GET_STATIC_ARRAY_FROM_TLS(signals,gabble_med_stream,guint)

	#define signals (GET_WSD_VAR_NAME(signals,gabble_med_stream, s)())	

	GET_STATIC_VAR_FROM_TLS(gabble_media_stream_parent_class,gabble_med_stream,gpointer)

	#define gabble_media_stream_parent_class (*GET_WSD_VAR_NAME(gabble_media_stream_parent_class,gabble_med_stream,s)())

	GET_STATIC_VAR_FROM_TLS(g_define_type_id,gabble_med_stream,GType)

	#define g_define_type_id (*GET_WSD_VAR_NAME(g_define_type_id,gabble_med_stream,s)())

	/*gchar** _s_gabble_med_stream_video_codec_params() { return (gchar**)((libgabble_ImpurePtr()->_s_gabble_med_stream_video_codec_params)); }

	#define video_codec_params (GET_WSD_VAR_NAME(video_codec_params,gabble_med_stream, s)())*/	

static void gabble_media_stream_init (GabbleMediaStream *self); 

static void gabble_media_stream_class_init (GabbleMediaStreamClass *klass); 

static void gabble_media_stream_class_intern_init (gpointer klass) 

{ 

gabble_media_stream_parent_class = g_type_class_peek_parent (klass);

 gabble_media_stream_class_init ((GabbleMediaStreamClass*) klass);

}

 EXPORT_C GType gabble_media_stream_get_type (void) 

 {

  if ((g_define_type_id == 0)) 

  {

   static const GTypeInfo g_define_type_info = { sizeof (GabbleMediaStreamClass), (GBaseInitFunc) ((void *)0), (GBaseFinalizeFunc) ((void *)0), (GClassInitFunc) gabble_media_stream_class_intern_init, (GClassFinalizeFunc) ((void *)0), ((void *)0), sizeof (GabbleMediaStream), 0, (GInstanceInitFunc) gabble_media_stream_init, ((void *)0) }; g_define_type_id = g_type_register_static ( ((GType) ((20) << (2))), g_intern_static_string ("GabbleMediaStream"), &g_define_type_info, (GTypeFlags) 0); { {} ; } } return g_define_type_id; 

  };

#else

	static guint signals[LAST_SIGNAL] = {0};

#endif

/* properties */

enum

{

  PROP_CONNECTION = 1,

  PROP_MEDIA_SESSION,

  PROP_OBJECT_PATH,

  PROP_MODE,

  PROP_NAME,

  PROP_ID,

  PROP_INITIATOR,

  PROP_MEDIA_TYPE,

  PROP_CONNECTION_STATE,

  PROP_READY,

  PROP_GOT_LOCAL_CODECS,

  PROP_SIGNALLING_STATE,

  PROP_PLAYING,

  PROP_COMBINED_DIRECTION,

  LAST_PROPERTY

};

/* private structure */

typedef struct _GabbleMediaStreamPrivate GabbleMediaStreamPrivate;

struct _GabbleMediaStreamPrivate

{

  GabbleConnection *conn;

  GabbleMediaSession *session;

  GabbleMediaSessionMode mode;

  gchar *object_path;

  guint id;

  guint media_type;

  gboolean ready;

  gboolean sending;

  GValue native_codecs;     /* intersected codec list */

  GValue native_candidates;

  GValue remote_codecs;

  GValue remote_candidates;

  guint remote_candidate_count;

  gboolean closed;

  gboolean dispose_has_run;

};

#define GABBLE_MEDIA_STREAM_GET_PRIVATE(obj) \

    ((GabbleMediaStreamPrivate *)obj->priv)

//Vinod: add below definition

#define ENABLE_DEBUG

#ifdef ENABLE_DEBUG

#if _GMS_DEBUG_LEVEL > 1

static const char *tp_protocols[] = {

  "TP_MEDIA_STREAM_PROTO_UDP (0)",

  "TP_MEDIA_STREAM_PROTO_TCP (1)"

};

static const char *tp_transports[] = {

  "TP_MEDIA_STREAM_TRANSPORT_TYPE_LOCAL (0)",

  "TP_MEDIA_STREAM_TRANSPORT_TYPE_DERIVED (1)",

  "TP_MEDIA_STREAM_TRANSPORT_TYPE_RELAY (2)"

};

#endif

#endif

static void push_native_candidates (GabbleMediaStream *stream);

static void push_remote_codecs (GabbleMediaStream *stream);

static void push_remote_candidates (GabbleMediaStream *stream);

static void push_playing (GabbleMediaStream *stream);

static void push_sending (GabbleMediaStream *stream);

static void

gabble_media_stream_init (GabbleMediaStream *self)

{

  GabbleMediaStreamPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,

      GABBLE_TYPE_MEDIA_STREAM, GabbleMediaStreamPrivate);

  self->priv = priv;

  g_value_init (&priv->native_codecs, TP_TYPE_CODEC_LIST);

  g_value_take_boxed (&priv->native_codecs,

      dbus_g_type_specialized_construct (TP_TYPE_CODEC_LIST));

  g_value_init (&priv->native_candidates, TP_TYPE_CANDIDATE_LIST);

  g_value_take_boxed (&priv->native_candidates,

      dbus_g_type_specialized_construct (TP_TYPE_CANDIDATE_LIST));

  g_value_init (&priv->remote_codecs, TP_TYPE_CODEC_LIST);

  g_value_take_boxed (&priv->remote_codecs,

      dbus_g_type_specialized_construct (TP_TYPE_CODEC_LIST));

  g_value_init (&priv->remote_candidates, TP_TYPE_CANDIDATE_LIST);

  g_value_take_boxed (&priv->remote_candidates,

      dbus_g_type_specialized_construct (TP_TYPE_CANDIDATE_LIST));

}

static GObject *

gabble_media_stream_constructor (GType type, guint n_props,

                                 GObjectConstructParam *props)

{

  GObject *obj;

  GabbleMediaStreamPrivate *priv;

  DBusGConnection *bus;

  /* call base class constructor */

  obj = G_OBJECT_CLASS (gabble_media_stream_parent_class)->

           constructor (type, n_props, props);

  priv = GABBLE_MEDIA_STREAM_GET_PRIVATE (GABBLE_MEDIA_STREAM (obj));

  /* go for the bus */

  bus = tp_get_bus ();

  dbus_g_connection_register_g_object (bus, priv->object_path, obj);

  return obj;

}

static void

gabble_media_stream_get_property (GObject    *object,

                                  guint       property_id,

                                  GValue     *value,

                                  GParamSpec *pspec)

{

  GabbleMediaStream *stream = GABBLE_MEDIA_STREAM (object);

  GabbleMediaStreamPrivate *priv = GABBLE_MEDIA_STREAM_GET_PRIVATE (stream);

  switch (property_id) {

    case PROP_CONNECTION:

      g_value_set_object (value, priv->conn);

      break;

    case PROP_MEDIA_SESSION:

      g_value_set_object (value, priv->session);

      break;

    case PROP_OBJECT_PATH:

      g_value_set_string (value, priv->object_path);

      break;

    case PROP_MODE:

      g_value_set_enum (value, priv->mode);

      break;

    case PROP_NAME:

      g_value_set_string (value, stream->name);

      break;

    case PROP_ID:

      g_value_set_uint (value, priv->id);

      break;

    case PROP_INITIATOR:

      g_value_set_uint (value, stream->initiator);

      break;

    case PROP_MEDIA_TYPE:

      g_value_set_uint (value, priv->media_type);

      break;

    case PROP_CONNECTION_STATE:

      g_value_set_uint (value, stream->connection_state);

      break;

    case PROP_READY:

      g_value_set_boolean (value, priv->ready);

      break;

    case PROP_GOT_LOCAL_CODECS:

      g_value_set_boolean (value, stream->got_local_codecs);

      break;

    case PROP_SIGNALLING_STATE:

      g_value_set_uint (value, stream->signalling_state);

      break;

    case PROP_PLAYING:

      g_value_set_boolean (value, stream->playing);

      break;

    case PROP_COMBINED_DIRECTION:

      g_value_set_uint (value, stream->combined_direction);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

  }

}

static void

gabble_media_stream_set_property (GObject      *object,

                                  guint         property_id,

                                  const GValue *value,

                                  GParamSpec   *pspec)

{

  GabbleMediaStream *stream = GABBLE_MEDIA_STREAM (object);

  GabbleMediaStreamPrivate *priv = GABBLE_MEDIA_STREAM_GET_PRIVATE (stream);

  switch (property_id) {

    case PROP_CONNECTION:

      priv->conn = g_value_get_object (value);

      break;

    case PROP_MEDIA_SESSION:

      priv->session = g_value_get_object (value);

      break;

    case PROP_OBJECT_PATH:

      g_free (priv->object_path);

      priv->object_path = g_value_dup_string (value);

      break;

    case PROP_MODE:

      priv->mode = g_value_get_enum (value);

      break;

    case PROP_NAME:

      g_free (stream->name);

      stream->name = g_value_dup_string (value);

      break;

    case PROP_ID:

      priv->id = g_value_get_uint (value);

      break;

    case PROP_INITIATOR:

      stream->initiator = g_value_get_uint (value);

      break;

    case PROP_MEDIA_TYPE:

      priv->media_type = g_value_get_uint (value);

      break;

    case PROP_CONNECTION_STATE:

      _gabble_media_session_debug (priv->session, DEBUG_MSG_INFO, DEBUG_MSG_INFO, "stream %s connection state %d",

          stream->name, stream->connection_state);

      stream->connection_state = g_value_get_uint (value);

      break;

    case PROP_READY:

      priv->ready = g_value_get_boolean (value);

      break;

    case PROP_GOT_LOCAL_CODECS:

      stream->got_local_codecs = g_value_get_boolean (value);

      break;

    case PROP_SIGNALLING_STATE:

        {

          StreamSignallingState old = stream->signalling_state;

          stream->signalling_state = g_value_get_uint (value);

          _gabble_media_session_debug (priv->session, DEBUG_MSG_INFO, DEBUG_MSG_INFO, "stream %s sig_state %d->%d",

              stream->name, old, stream->signalling_state);

          if (stream->signalling_state != old)

            push_native_candidates (stream);

        }

      break;

    case PROP_PLAYING:

        {

          gboolean old = stream->playing;

          stream->playing = g_value_get_boolean (value);

          if (stream->playing != old)

            push_playing (stream);

        }

      break;

    case PROP_COMBINED_DIRECTION:

      stream->combined_direction = g_value_get_uint (value);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

  }

}

static void gabble_media_stream_dispose (GObject *object);

static void gabble_media_stream_finalize (GObject *object);

static void

gabble_media_stream_class_init (GabbleMediaStreamClass *gabble_media_stream_class)

{

  GObjectClass *object_class = G_OBJECT_CLASS (gabble_media_stream_class);

  GParamSpec *param_spec;

  g_type_class_add_private (gabble_media_stream_class, sizeof (GabbleMediaStreamPrivate));

  object_class->constructor = gabble_media_stream_constructor;

  object_class->get_property = gabble_media_stream_get_property;

  object_class->set_property = gabble_media_stream_set_property;

  object_class->dispose = gabble_media_stream_dispose;

  object_class->finalize = gabble_media_stream_finalize;

  param_spec = g_param_spec_object ("connection", "GabbleConnection object",

                                    "Gabble connection object that owns this "

                                    "media stream's channel.",

                                    GABBLE_TYPE_CONNECTION,

                                    G_PARAM_CONSTRUCT_ONLY |

                                    G_PARAM_READWRITE |

                                    G_PARAM_STATIC_NICK |

                                    G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_CONNECTION, param_spec);

  param_spec = g_param_spec_object ("media-session", "GabbleMediaSession object",

                                    "Gabble media session object that owns this "

                                    "media stream object.",

                                    GABBLE_TYPE_MEDIA_SESSION,

                                    G_PARAM_CONSTRUCT_ONLY |

                                    G_PARAM_READWRITE |

                                    G_PARAM_STATIC_NICK |

                                    G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_MEDIA_SESSION, param_spec);

  param_spec = g_param_spec_string ("object-path", "D-Bus object path",

                                    "The D-Bus object path used for this "

                                    "object on the bus.",

                                    NULL,

                                    G_PARAM_CONSTRUCT_ONLY |

                                    G_PARAM_READWRITE |

                                    G_PARAM_STATIC_NAME |

                                    G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_OBJECT_PATH, param_spec);

  param_spec = g_param_spec_enum ("mode", "Signalling mode",

                                  "Which signalling mode used to control the "

                                  "stream.",

                                  gabble_media_session_mode_get_type(),

                                  MODE_JINGLE,

                                  G_PARAM_CONSTRUCT_ONLY |

                                  G_PARAM_READWRITE |

                                  G_PARAM_STATIC_NAME |

                                  G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_MODE, param_spec);

  param_spec = g_param_spec_string ("name", "Stream name",

                                    "An opaque name for the stream used in the "

                                    "signalling.",

                                    NULL,

                                    G_PARAM_CONSTRUCT_ONLY |

                                    G_PARAM_READWRITE |

                                    G_PARAM_STATIC_NAME |

                                    G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_NAME, param_spec);

  param_spec = g_param_spec_uint ("id", "Stream ID",

                                  "A stream number for the stream used in the "

                                  "D-Bus API.",

                                  0, G_MAXUINT, 0,

                                  G_PARAM_CONSTRUCT_ONLY |

                                  G_PARAM_READWRITE |

                                  G_PARAM_STATIC_NAME |

                                  G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_ID, param_spec);

  param_spec = g_param_spec_uint ("initiator", "Stream initiator",

                                  "An enum signifying which end initiated "

                                  "the stream.",

                                  INITIATOR_LOCAL,

                                  INITIATOR_REMOTE,

                                  INITIATOR_LOCAL,

                                  G_PARAM_CONSTRUCT_ONLY |

                                  G_PARAM_READWRITE |

                                  G_PARAM_STATIC_NAME |

                                  G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_INITIATOR, param_spec);

  param_spec = g_param_spec_uint ("media-type", "Stream media type",

                                  "A constant indicating which media type the "

                                  "stream carries.",

                                  TP_MEDIA_STREAM_TYPE_AUDIO,

                                  TP_MEDIA_STREAM_TYPE_VIDEO,

                                  TP_MEDIA_STREAM_TYPE_AUDIO,

                                  G_PARAM_CONSTRUCT_ONLY |

                                  G_PARAM_READWRITE |

                                  G_PARAM_STATIC_NAME |

                                  G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_MEDIA_TYPE, param_spec);

  param_spec = g_param_spec_uint ("connection-state", "Stream connection state",

                                  "An integer indicating the state of the"

                                  "stream's connection.",

                                  TP_MEDIA_STREAM_STATE_DISCONNECTED,

                                  TP_MEDIA_STREAM_STATE_CONNECTED,

                                  TP_MEDIA_STREAM_STATE_DISCONNECTED,

                                  G_PARAM_CONSTRUCT |

                                  G_PARAM_READWRITE |

                                  G_PARAM_STATIC_NAME |

                                  G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_CONNECTION_STATE, param_spec);

  param_spec = g_param_spec_boolean ("ready", "Ready?",

                                     "A boolean signifying whether the user "

                                     "is ready to handle signals from this "

                                     "object.",

                                     FALSE,

                                     G_PARAM_CONSTRUCT |

                                     G_PARAM_READWRITE |

                                     G_PARAM_STATIC_NAME |

                                     G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_READY, param_spec);

  param_spec = g_param_spec_boolean ("got-local-codecs", "Got local codecs?",

                                     "A boolean signifying whether we've got "

                                     "the locally supported codecs from the user.",

                                     FALSE,

                                     G_PARAM_CONSTRUCT |

                                     G_PARAM_READWRITE |

                                     G_PARAM_STATIC_NAME |

                                     G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_GOT_LOCAL_CODECS, param_spec);

  param_spec = g_param_spec_uint ("signalling-state", "Signalling state",

                                  "Whether the stream is newly created, "

                                  "sent to the peer, or acknowledged.",

                                  STREAM_SIG_STATE_NEW,

                                  STREAM_SIG_STATE_REMOVING,

                                  STREAM_SIG_STATE_NEW,

                                  G_PARAM_CONSTRUCT |

                                  G_PARAM_READWRITE |

                                  G_PARAM_STATIC_NAME |

                                  G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_SIGNALLING_STATE, param_spec);

  param_spec = g_param_spec_boolean ("playing", "Set playing",

                                     "A boolean signifying whether the stream "

                                     "has been set playing yet.",

                                     FALSE,

                                     G_PARAM_CONSTRUCT |

                                     G_PARAM_READWRITE |