emacs-jabber-commit Mailing List for jabber.el (Page 16)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/emacs-jabber/tox
In directory sc8-pr-cvs17.sourceforge.net:/tmp/cvs-serv15060

Added Files:
	Makefile README main.c tox-marshal.list tox-object.xml 
	tox-session.c tox-session.h tox-session.xml tox.c tox.h 
Log Message:
Initial import of tox sources

--- NEW FILE: tox.c ---
#include <dbus/dbus-glib.h>
#include <glib/gprintf.h>
#include "tox.h"
#include "tox-session.h"

typedef struct _ToxObjectPrivate {
  guint session_counter;
  DBusGConnection *connection;
} ToxObjectPrivate;

G_DEFINE_TYPE(ToxObject, tox_object, G_TYPE_OBJECT)

gboolean tox_create_session(ToxObject *obj, guint8 dir, char **ret, GError **error);

/* properties */
enum {
  TOX_DBUS_CONNECTION = 1,
};

static void tox_set_property(GObject *obj, guint property_id, const GValue *value, GParamSpec *pspec);
static void tox_get_property(GObject *obj, guint property_id, GValue *value, GParamSpec *pspec);

#include "tox-object-glue.h"

void
tox_object_init(ToxObject *obj)
{
  obj->priv = g_new0(ToxObjectPrivate, 1);
}

void
tox_object_class_init(ToxObjectClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
  GParamSpec *connection_param_spec;

  gobject_class->set_property = tox_set_property;
  gobject_class->get_property = tox_get_property;

  connection_param_spec = g_param_spec_boxed("dbus-connection",
					     "D-Bus connection",
					     "Connection where new sessions are registered",
					     DBUS_TYPE_G_CONNECTION,
					     G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
  g_object_class_install_property(gobject_class,
				  TOX_DBUS_CONNECTION,
				  connection_param_spec);

  dbus_g_object_type_install_info(TOX_TYPE_OBJECT, &dbus_glib_tox_object_info);

}

static void
tox_set_property(GObject *obj, guint property_id, const GValue *value, GParamSpec *pspec)
{
  ToxObject *self = (ToxObject *)obj;

  switch(property_id) {
  case TOX_DBUS_CONNECTION:
    /* XXX: this should be a weak ref */
    /* hm? */
/*     if (self->priv->connection) */
/*       dbus_g_connection_unref(self->priv->connection); */
    self->priv->connection = (DBusGConnection *)g_value_get_boxed(value);
/*     dbus_g_connection_ref(self->priv->connection); */
    break;
  default:
    G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, property_id, pspec);
  }
}

static void
tox_get_property(GObject *obj, guint property_id, GValue *value, GParamSpec *pspec)
{
  ToxObject *self = (ToxObject *)obj;

  switch(property_id) {
  case TOX_DBUS_CONNECTION:
    g_value_set_boxed(value, self->priv->connection);
    break;
  default:
    G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, property_id, pspec);
  }
}

gboolean
tox_create_session(ToxObject *obj, guint8 dir, char **ret, GError **error)
{
  guint session_number = ++obj->priv->session_counter;
  DBusGConnection *connection = obj->priv->connection;
  ToxSession *session;

  if (dir < 1 || dir > 3) {
    /* XXX: how to set the D-Bus error name? */
    g_set_error(error, DBUS_GERROR,
		DBUS_GERROR_REMOTE_EXCEPTION,
		"Direction out of range (was %u, should be 1 <= dir <= 3)",
		dir);
    return FALSE;
  }

  session = g_object_new(TOX_TYPE_SESSION, "direction", dir, NULL);

  *ret = g_strdup_printf("/net/sourceforge/emacs_jabber/Tox/%u", session_number);
  dbus_g_connection_register_g_object(connection, *ret, G_OBJECT(session));

  g_printf("CreateSession called, returning %s\n", *ret);

  return TRUE;
}

--- NEW FILE: tox-object.xml ---
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
          "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
<node name='/net/sourceforce/emacs_jabber/Tox'>

  <interface name='net.sourceforge.emacs_jabber.Tox'>
    <method name='CreateSession'>
      <!-- 1: send only.
           2: receive only.
	   3: send and receive.
      -->
      <arg name='direction' direction='in' type='y'/>
      <arg name='session' type='o' direction='out'/>
    </method>
  </interface>
</node>

--- NEW FILE: main.c ---
#include <farsight/farsight.h>
#include <dbus/dbus-glib.h>
#include <glib/gprintf.h>
#include <string.h>
#include "tox.h"

int
main(int argc, char *argv[])
{
  GMainLoop *loop;
  DBusGConnection *connection;
  DBusGProxy *bus_proxy;
  GError *error = NULL;
  ToxObject *obj;
  guint32 x;

  g_type_init();
  gst_init(&argc, &argv);

  {
    GLogLevelFlags fatal_mask;

    fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
    /* not aborting on warnings because of:
       farsight-rtp-WARNING **: Not enough information in rtp caps
    */
    fatal_mask |= /*G_LOG_LEVEL_WARNING | */ G_LOG_LEVEL_CRITICAL;
    g_log_set_always_fatal (fatal_mask);
  }

  connection = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
  if (connection == NULL) {
    g_printerr("Failed to open connection to bus: %s\n",
	       error->message);
    exit(1);
  }

  bus_proxy = dbus_g_proxy_new_for_name(connection, "org.freedesktop.DBus",
					"/org/freedesktop/DBus",
					"org.freedesktop.DBus");

  if (!dbus_g_proxy_call(bus_proxy, "RequestName", &error,
			 G_TYPE_STRING, "net.sourceforge.emacs-jabber.Tox",
			 G_TYPE_UINT, 
			 /* these settings are good for debugging.  we
			    should listen for the NameLost signal, though. */
			 DBUS_NAME_FLAG_ALLOW_REPLACEMENT
			 | DBUS_NAME_FLAG_REPLACE_EXISTING
			 | DBUS_NAME_FLAG_DO_NOT_QUEUE,
			 G_TYPE_INVALID,
			 G_TYPE_UINT, &x,
			 G_TYPE_INVALID)) {
    g_printerr("Couldn't acquire name: %s\n", error->message);
    exit(1);
  }
  else if (x != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
    g_printerr("Couldn't acquire name: RequestName returned %u\n", x);
    exit(1);
  }

  obj = g_object_new(TOX_TYPE_OBJECT, "dbus-connection", connection, NULL);
  dbus_g_connection_register_g_object(connection, "/net/sourceforge/emacs_jabber/Tox", G_OBJECT(obj));

  loop = g_main_loop_new(NULL, FALSE);

  g_main_loop_run(loop);
  return 0;
}

--- NEW FILE: tox.h ---
#ifndef __TOX_H__
#define __TOX_H__

typedef struct ToxObject
{
  GObject parent;

  struct _ToxObjectPrivate *priv;
} ToxObject;

typedef struct ToxObjectClass
{
  GObjectClass parent;
} ToxObjectClass;

GType tox_object_get_type(void);
#define TOX_TYPE_OBJECT         (tox_object_get_type())
#define TOX_OBJECT(object)      (G_TYPE_CHECK_INSTANCE_CAST((object), TOX_TYPE_OBJECT, ToxObject))
#define TOX_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), TOX_TYPE_OBJECT, ToxObjectClass))
#define TOX_IS_OBJECT(object)   (G_TYPE_CHECK_INSTANCE_TYPE((object), TOX_TYPE_OBJECT))
#define TOX_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), TOX_TYPE_OBJECT))
#define TOX_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), TOX_TYPE_OBJECT, ToxObjectClass))

#endif /* __TOX_H__ */

--- NEW FILE: Makefile ---
CFLAGS=-g -Wall `pkg-config --cflags farsight-0.1 dbus-glib-1`
LDFLAGS=`pkg-config --libs farsight-0.1 dbus-glib-1`
OBJS=main.o tox.o tox-session.o tox-marshal.o

tox : $(OBJS)
	gcc -o tox $(OBJS) $(LDFLAGS)

main.o : tox.h

tox.o : tox.h tox-object-glue.h tox-session.h

tox-object-glue.h : tox-object.xml
	dbus-binding-tool --mode=glib-server --output=tox-object-glue.h --prefix=tox tox-object.xml 

tox-session.o : tox-session.h tox-session-glue.h tox-marshal.h

tox-session-glue.h : tox-session.xml
	dbus-binding-tool --mode=glib-server --output=tox-session-glue.h --prefix=tox_session tox-session.xml

tox-marshal.c : tox-marshal.list
	glib-genmarshal --prefix=tox_marshal tox-marshal.list --header --body > tox-marshal.c

tox-marshal.h : tox-marshal.list
	glib-genmarshal --prefix=tox_marshal tox-marshal.list --header > tox-marshal.h

--- NEW FILE: tox-session.h ---
#ifndef __TOX_SESSION_H__
#define __TOX_SESSION_H__

typedef struct ToxSession
{
  GObject parent;

  struct _ToxSessionPrivate *priv;
} ToxSession;

typedef struct ToxSessionClass
{
  GObjectClass parent;
} ToxSessionClass;

GType tox_session_get_type(void);
#define TOX_TYPE_SESSION         (tox_session_get_type())
#define TOX_SESSION(object)      (G_TYPE_CHECK_INSTANCE_CAST((object), TOX_TYPE_SESSION, ToxSession))
#define TOX_SESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), TOX_TYPE_SESSION, ToxSessionClass))
#define TOX_IS_SESSION(object)   (G_TYPE_CHECK_INSTANCE_TYPE((object), TOX_TYPE_SESSION))
#define TOX_IS_SESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), TOX_TYPE_SESSION))
#define TOX_SESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), TOX_TYPE_SESSION, ToxSessionClass))

#endif /* __TOX_SESSION_H__ */

--- NEW FILE: tox-marshal.list ---
VOID:BOXED

--- NEW FILE: README ---
Tox (Talk Over XMPP, or something) is a utility for adding Jingle
functionality to a Jabber client, primarily voice communication.  It
interfaces to the Jabber client using DBus.

The DBus interface is described below.  From this you should be able
to piece together a Jingle client.  Good luck!

Tox registers the well-known name net.sourceforge.emacs-jabber.Tox
(NB: hyphen, not underscore) on the session bus.
/net/sourceforge/emacs_jabber/Tox (NB: underscore, not hyphen) is the
path to the main object.

This object has one method in the interface
net.sourceforge.emacs_jabber.Tox (NB: underscore, not hyphen):

object_path CreateSession(byte direction)

  Creates an audio session.  direction is 1 for "send only", 2 for
  "receive only", and 3 for "send and receive".  The path to the new
  session is returned.

The session object in turn has methods in the interface
net.sourceforge.emacs_jabber.ToxSession (NB: underscore, not hyphen):

void Destroy()

  Destroys the session.

void SetDefaultAudioSink()

  Create an "autoaudiosink" GStreamer element and connect it to the
  session.  This usually means that you will hear things in your
  speakers.

void SetOggVorbisAudioSource(string filename)

  Set the named Ogg Vorbis file as audio source, i.e. what to send
  over the session.

void AddRemoteCandidate(array components)

  Add a transport candidate of the remote party, consisting of the
  given components.  "components" is an array of structs with
  signature "(susqsssyyss)" and meaning:

	   - Candidate ID
	   - Component (starting from 1)
	   - IP number (as a string)
	   - Port number
	   - Protocol ("tcp" or "udp")
	   - Protocol subtype (only "RTP" supported)
	   - Protocol profile (only "AVP" supported)
	   - Preference, between 0 and 100
	   - Type.  0 means local, 1 means derived (e.g. through
	     STUN), 2 means relay
	   - Username (may be empty)
	   - Password (may be empty)

signal NativeCandidatesPrepared(array components)

  Signalled when the local candidates have been determined, and are
  ready to send to the other party.  The argument is the same as to
  AddRemoteCandidate.

void SetRemoteCodecs(array codecs)

  Set the codecs that the remote party claims to support.  codecs is
  an array of structs with signature "(isyuua{ss})" and meaning:

           - numeric identifier
	   - codec name
	   - media type: 0 is audio, 1 is video
	   - clock rate
	   - number of channels
	   - optional parameters

array GetLocalCodecs()

  Get the codecs supported by this implementation.  The return value
  is of the same type as the argument to SetRemoteCodecs.

array GetCodecIntersection()

  Get the intersection of supported codecs of remote and local
  parties.  The return value is like the argument to SetRemoteCodecs.

--- NEW FILE: tox-session.xml ---
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
          "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
<node>

  <interface name='net.sourceforge.emacs_jabber.ToxSession'>
    <method name='Destroy'/>

    <method name='SetDefaultAudioSink'/>

    <method name='SetOggVorbisAudioSource'>
      <arg name='filename' direction='in' type='s'/>
    </method>

    <method name='AddRemoteCandidate'>
      <arg name='transport' direction='in' type='a(susqsssyyss)'/>
      <!-- Each element is a candidate component.  (Usually each
	   candidate has only one component)

           Struct members are:
	   - Candidate ID
	   - Component (starting from 1)
	   - IP number (as a string)
	   - Port number
	   - Protocol ("tcp" or "udp")
	   - Protocol subtype (only "RTP" supported)
	   - Protocol profile (only "AVP" supported)
	   - Preference, between 0 and 100
	   - Type.  0 means local, 1 means derived (e.g. through
	     STUN), 2 means relay
	   - Username (may be empty)
	   - Password (may be empty)
      -->
    </method>

    <signal name="NativeCandidatesPrepared">
      <arg name="candidates" type="a(susqsssyyss)"/>
      <!-- Argument as to AddRemoteCandidate -->
    </signal>

    <method name='SetRemoteCodecs'>
      <arg name='codec-list' direction='in' type='a(isyuua{ss})'/>
      <!-- Each element is a codec.  Struct members are:

           - numeric identifier
	   - codec name
	   - media type: 0 is audio, 1 is video
	   - clock rate
	   - number of channels
	   - optional parameters
      -->
    </method>

    <method name='GetLocalCodecs'>
      <arg name='codec-list' direction='out' type='a(isyuua{ss})'/>
      <!-- Argument as to SetRemoteCodecs -->
    </method>

    <method name='GetCodecIntersection'>
      <arg name='codec-list' direction='out' type='a(isyuua{ss})'/>
      <!-- Argument layout: see SetRemoteCodecs -->
    </method>

  </interface>
</node>

--- NEW FILE: tox-session.c ---
#include <glib.h>
#include <farsight/farsight.h>
#include <farsight/farsight-transport.h>
#include <dbus/dbus-glib.h>
#include <glib/gprintf.h>
#include <string.h>
#include "tox-session.h"
#include "tox-marshal.h"

G_DEFINE_TYPE(ToxSession, tox_session, G_TYPE_OBJECT)

typedef struct _ToxSessionPrivate {
  FarsightSession *session;
  /* for now, one stream is enough */
  FarsightStream *stream;

  int have_source, have_sink;

  gboolean dispose_has_run;
} ToxSessionPrivate;

gboolean tox_session_destroy(ToxSession *obj, GError **error);
gboolean tox_session_set_default_audio_sink(ToxSession *obj, GError **error);
gboolean tox_session_set_ogg_vorbis_audio_source(ToxSession *obj, char *filename, GError **error);
gboolean tox_session_add_remote_candidate(ToxSession *obj, GPtrArray *candidate, GError **error);
gboolean tox_session_set_remote_codecs(ToxSession *obj, GPtrArray *codecs, GError **error);
gboolean tox_session_get_local_codecs(ToxSession *obj, GPtrArray **codecs, GError **error);
gboolean tox_session_get_codec_intersection(ToxSession *obj, GPtrArray **codecs, GError **error);

/* properties */
enum {
  DIRECTION = 1
};
static void tox_session_set_property(GObject *obj, guint property_id, const GValue *value, GParamSpec *pspec);

/* signals */
enum {
  NATIVE_CANDIDATES_PREPARED,
  LAST_SIGNAL
};

static guint signals[LAST_SIGNAL];

#include "tox-session-glue.h"

static GstElement *prepare_source(const char *filename);
static void new_pad(GstElement *, GstPad *, gpointer);
static GstElement *prepare_sink(void);
static void stream_done(ToxSession *);

static void tox_session_native_candidates_prepared(FarsightStream *stream, gpointer user_data);
static void tox_session_new_native_candidate(FarsightStream *stream, gchar *candidate_id, ToxSession *self);

void
tox_session_init(ToxSession *obj)
{
  ToxSessionPrivate *priv;
  priv = g_new0(ToxSessionPrivate, 1);
  obj->priv = priv;

  priv->session = farsight_session_factory_make("rtp");
  g_assert(priv->session);

  /* we need to know the direction to create a stream,
     so we do that when that property is set.
  */

}

static GObjectClass *parent_class = NULL;

static void
tox_session_dispose(GObject *obj)
{
  ToxSession *self = (ToxSession *)obj;

  if (self->priv->dispose_has_run) {
    return;
  }
  g_printf("in tox_session_dispose\n");
  self->priv->dispose_has_run = TRUE;

  if (self->priv->stream)
    g_object_unref(self->priv->stream);
  if (self->priv->session)
    g_object_unref(self->priv->session);

  self->priv->stream = NULL;
  self->priv->session = NULL;

  G_OBJECT_CLASS(parent_class)->dispose(obj);
}

static void
tox_session_finalize(GObject *obj)
{
  ToxSession *self = (ToxSession *)obj;

  g_printf("in tox_session_finalize\n");
  g_free(self->priv);

  G_OBJECT_CLASS(parent_class)->finalize(obj);
}

void
tox_session_class_init(ToxSessionClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
  GParamSpec *direction_param_spec;

  gobject_class->dispose = tox_session_dispose;
  gobject_class->finalize = tox_session_finalize;

  gobject_class->set_property = tox_session_set_property;

  direction_param_spec = g_param_spec_uint("direction",
					   "stream direction",
					   "1 means send-only, 2 means receive-only, 3 means both",
					   1,
					   3,
					   1,
					   G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE);
  g_object_class_install_property(gobject_class,
				  DIRECTION,
				  direction_param_spec);

  signals[NATIVE_CANDIDATES_PREPARED] =
    g_signal_new("native-candidates-prepared",
		 G_OBJECT_CLASS_TYPE(klass),
		 G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
		 0,
		 NULL, NULL,
		 tox_marshal_VOID__BOXED,
		 G_TYPE_NONE,
		 1,
		 G_TYPE_POINTER);

  dbus_g_object_type_install_info(TOX_TYPE_SESSION, &dbus_glib_tox_session_object_info);

  parent_class = g_type_class_peek_parent (klass);
}

static void
tox_session_set_property(GObject *obj, guint property_id, const GValue *value, GParamSpec *pspec)
{
  ToxSession *self = (ToxSession *)obj;
  guint dir;

  switch(property_id) {
  case DIRECTION:
    if (self->priv->stream)
      g_object_unref(self->priv->stream);
    /* Now we know the direction, so we create a stream. */
    dir = g_value_get_uint(value);
    self->priv->stream = farsight_session_create_stream(self->priv->session,
							FARSIGHT_MEDIA_TYPE_AUDIO,
							dir);
    g_assert(self->priv->stream);

    g_object_set(G_OBJECT(self->priv->stream), "transmitter", "libjingle", NULL);

    /* XXX: should we set null source/sink here? */
    switch (dir) {
    case 1:
      /* send-only, we need no sink */
      self->priv->have_sink = 1;
      break;
    case 2:
      /* receive-only, we need no source */
      self->priv->have_source = 1;
      break;
    }

    /* start preparing native candidates */
    g_print("About to prepare native candidates...\n");
    g_signal_connect(self->priv->stream, "new-native-candidate",
		     (GCallback)tox_session_new_native_candidate, (gpointer)self);
    g_signal_connect(self->priv->stream, "native-candidates-prepared",
		     (GCallback)tox_session_native_candidates_prepared, (gpointer)self);
    /* but we can't actually do it until we have a pipeline.
       so, we'll call stream_done when we do. */
    break;
  default:
    G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, property_id, pspec);
  }
}

gboolean
tox_session_destroy(ToxSession *obj, GError **error)
{
  g_object_unref(obj);
  return TRUE;
}

gboolean 
tox_session_set_default_audio_sink(ToxSession *obj, GError **error)
{
  GstElement *sink = prepare_sink();
  farsight_stream_set_sink(obj->priv->stream, sink);
  obj->priv->have_sink = 1;

  if (obj->priv->have_sink && obj->priv->have_source)
    stream_done(obj);

  return TRUE;
}

gboolean
tox_session_set_ogg_vorbis_audio_source(ToxSession *obj, char *filename, GError **error)
{
    GstElement *source = prepare_source(filename);
    farsight_stream_set_source(obj->priv->stream, source);
    obj->priv->have_source = 1;

    if (obj->priv->have_sink && obj->priv->have_source)
      stream_done(obj);

    return TRUE;
}

static GstElement *
prepare_source(const char *filename)
{
  GstElement *bin, *filesrc, *demux, *decode;

  bin = gst_bin_new("mysource");
  filesrc = gst_element_factory_make("filesrc", "file-source");
  g_object_set(G_OBJECT(filesrc), "location", filename, NULL);

  demux = gst_element_factory_make("oggdemux", "ogg-parser");
  decode = gst_element_factory_make("vorbisdec", "vorbis-decoder");

  gst_element_link(filesrc, demux);
  g_signal_connect(demux, "pad-added", G_CALLBACK(new_pad), decode);

  gst_bin_add_many(GST_BIN(bin), filesrc, demux, decode, NULL);

  return bin;
}

static void
new_pad(GstElement *demux, GstPad *pad, gpointer data)
{
  GstElement *decode = (GstElement*)data;
  GstPad *decoder_pad;

  decoder_pad = gst_element_get_pad(decode, "sink");
  gst_pad_link(pad, decoder_pad);

  gst_object_unref(decoder_pad);
}

static GstElement *
prepare_sink(void)
{
  GstElement *bin, *converter, *audiosink;

  bin = gst_bin_new("mysink");
  converter = gst_element_factory_make("audioconvert", "converter");
  audiosink = gst_element_factory_make("autoaudiosink", "audiosink");
  gst_element_link(converter, audiosink);

  gst_bin_add_many(GST_BIN(bin), converter, audiosink, NULL);

  return bin;
}

static void
stream_done(ToxSession *self)
{
  farsight_stream_prepare_transports(self->priv->stream);
}

gboolean
tox_session_add_remote_candidate(ToxSession *self, GPtrArray *candidate, GError **error)
{
  int i;
  guint n;
  GList *candidate_list;

  candidate_list = NULL;

  /* Here we convert the array of structs into a GList of
     FarsightTransportInfo.  The argument list is described in
     tox-session.xml. */
  for (i = 0; i < candidate->len; i++) {
    GValueArray *component;
    FarsightTransportInfo *info;
    gchar *s;

    component = g_ptr_array_index(candidate, i);
    info = g_new0(FarsightTransportInfo, 1);

    info->candidate_id = 
      g_value_dup_string(
			 g_value_array_get_nth(component, 0));
    info->component = 
      g_value_get_uint(
		       g_value_array_get_nth(component, 1));
    info->ip =
      g_value_dup_string(
			 g_value_array_get_nth(component, 2));
    info->port =
      g_value_get_uint(
		       g_value_array_get_nth(component, 3));

    s = g_value_dup_string(g_value_array_get_nth(component, 4));
    if (strcmp(s, "tcp") == 0)
      info->proto = FARSIGHT_NETWORK_PROTOCOL_TCP;
    else if (strcmp(s, "udp") == 0)
      info->proto = FARSIGHT_NETWORK_PROTOCOL_UDP;
    else {
      g_set_error(error, DBUS_GERROR,
		  DBUS_GERROR_REMOTE_EXCEPTION,
		  "Unexpected protocol '%s'",
		  s);
      g_free(s);
      g_free(info);
      goto fail;
    }
    g_free(s);

    /* this should be "RTP" */
    info->proto_subtype =
      g_value_dup_string(
			 g_value_array_get_nth(component, 5));
    /* this should be "AVP" */
    info->proto_profile =
      g_value_dup_string(
			 g_value_array_get_nth(component, 6));

    info->preference =
      g_value_get_uint(
		       g_value_array_get_nth(component, 7))
      * 0.01;

    n = g_value_get_uint(g_value_array_get_nth(component, 8));
    switch (n) {
    case 0:
      info->type = FARSIGHT_CANDIDATE_TYPE_LOCAL;
      break;
    case 1:
      info->type = FARSIGHT_CANDIDATE_TYPE_DERIVED;
      break;
    case 2:
      info->type = FARSIGHT_CANDIDATE_TYPE_RELAY;
      break;
    default:
      g_set_error(error, DBUS_GERROR,
		  DBUS_GERROR_REMOTE_EXCEPTION,
		  "Unexpected type %u",
		  n);
      g_free(info);
      goto fail;
    }

    info->username = g_value_dup_string(
					g_value_array_get_nth(component, 9));
    info->password = g_value_dup_string(
					g_value_array_get_nth(component, 10));

    candidate_list = g_list_append(candidate_list, info);
  }

  farsight_stream_add_remote_candidate(self->priv->stream, candidate_list);
  return TRUE;

 fail:
  farsight_transport_list_destroy(candidate_list);
  return FALSE;
}

gboolean
tox_session_set_remote_codecs(ToxSession *obj, GPtrArray *codecs, GError **error)
{
  GList *codec_list;
  int i;
  /* GList *j; */

  codec_list = NULL;

  for (i = 0; i < codecs->len; i++) {
    GValueArray *codec_in;
    FarsightCodec *codec_out;

    codec_in = g_ptr_array_index(codecs, i);
    codec_out = g_new0(FarsightCodec, 1);

    codec_out->id = g_value_get_int(g_value_array_get_nth(codec_in, 0));
    codec_out->encoding_name = g_value_dup_string(g_value_array_get_nth(codec_in, 1));
    /* maybe check range of media_type... */
    codec_out->media_type = g_value_get_int(g_value_array_get_nth(codec_in, 2));
    codec_out->clock_rate = g_value_get_uint(g_value_array_get_nth(codec_in, 3));
    codec_out->channels = g_value_get_uint(g_value_array_get_nth(codec_in, 4));

    codec_list = g_list_append(codec_list, codec_out);
  }

  farsight_stream_set_remote_candidate_list(obj->priv->stream, codec_list);

  /* should the elements be freed, or just the list itself? */
  /*for (j = codec_list; j; j = g_list_next(j)) {
    g_free(j->data);
    }*/
  g_list_free(codec_list);

  return TRUE;
}

gboolean
tox_session_get_local_codecs(ToxSession *obj, GPtrArray **codecs, GError **error)
{
  FarsightStream *stream;
  const GList *codec_list;

  GType hash_string_string;

  stream = obj->priv->stream;
  codec_list = farsight_stream_get_local_codecs(stream);

  hash_string_string = dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_STRING);

  *codecs = g_ptr_array_sized_new(g_list_length(codec_list));
  for (; codec_list; codec_list = g_list_next(codec_list)) {
    GValueArray *codec_struct;
    const FarsightCodec *codec;
    GValue value;
    GHashTable *parameters;
    GList *p;

    memset(&value, 0, sizeof value);

    codec = (const FarsightCodec*)codec_list->data;
    codec_struct = g_value_array_new(2);

    g_value_init(&value, G_TYPE_INT);
    g_value_set_int(&value, codec->id);
    g_value_array_append(codec_struct, &value);
    g_value_unset(&value);

    g_value_init(&value, G_TYPE_STRING);
    g_value_set_string(&value, codec->encoding_name);
    g_value_array_append(codec_struct, &value);
    g_value_unset(&value);

    g_value_init(&value, G_TYPE_UCHAR);
    g_value_set_uchar(&value, codec->media_type);
    g_value_array_append(codec_struct, &value);
    g_value_unset(&value);

    g_value_init(&value, G_TYPE_UINT);
    g_value_set_uint(&value, codec->clock_rate);
    g_value_array_append(codec_struct, &value);
    g_value_unset(&value);

    g_value_init(&value, G_TYPE_UINT);
    g_value_set_uint(&value, codec->channels);
    g_value_array_append(codec_struct, &value);
    g_value_unset(&value);

    /* optional parameters - this should be a hash table, I think */
    /* parameters = g_hash_table_new(g_str_hash, g_str_equal); */
    parameters = dbus_g_type_specialized_construct(hash_string_string);
    for (p = codec->optional_params; p; p = g_list_next(p)) {
      FarsightCodecParameter *param = p->data;

      g_hash_table_insert(parameters, param->name, param->value);
    }
    g_value_init(&value, hash_string_string);
    g_value_set_boxed(&value, parameters);
    g_value_array_append(codec_struct, &value);
    g_value_unset(&value);
    g_hash_table_unref(parameters);

    g_assert(codec_struct->n_values == 6);

    g_ptr_array_add(*codecs, codec_struct);
  }

  return TRUE;
}

gboolean
tox_session_get_codec_intersection(ToxSession *obj, GPtrArray **codecs, GError **error)
{
  FarsightStream *stream;
  GList *codec_list;

  stream = obj->priv->stream;
  codec_list = farsight_stream_get_codec_intersection(stream);

  *codecs = g_ptr_array_sized_new(g_list_length(codec_list));
  for (; codec_list; codec_list = g_list_next(codec_list)) {
    GValueArray *codec_struct;
    FarsightCodec *codec;
    GValue *value;

    codec = (FarsightCodec*)codec_list->data;
    codec_struct = g_value_array_new(6);

    value = g_new(GValue, 1);
    g_value_init(value, G_TYPE_INT);
    g_value_set_int(value, codec->id);
    g_value_array_append(codec_struct, value);

    value = g_new(GValue, 1);
    g_value_init(value, G_TYPE_STRING);
    g_value_set_string(value, codec->encoding_name);
    g_value_array_append(codec_struct, value);

    value = g_new(GValue, 1);
    g_value_init(value, G_TYPE_UCHAR);
    g_value_set_uchar(value, codec->media_type);
    g_value_array_append(codec_struct, value);

    value = g_new(GValue, 1);
    g_value_init(value, G_TYPE_UINT);
    g_value_set_uint(value, codec->clock_rate);
    g_value_array_append(codec_struct, value);

    value = g_new(GValue, 1);
    g_value_init(value, G_TYPE_UINT);
    g_value_set_uint(value, codec->channels);
    g_value_array_append(codec_struct, value);

    /* XXX: do something about optional parameters */
    value = g_new(GValue, 1);
    g_value_init(value, G_TYPE_HASH_TABLE);
    g_value_set_boxed(value, g_hash_table_new(g_str_hash, g_str_equal));
    g_value_array_append(codec_struct, value);

    g_assert(codec_struct->n_values == 6);

    g_ptr_array_add(*codecs, codec_struct);
  }

  return TRUE;
}

static void
tox_session_native_candidates_prepared(FarsightStream *stream, gpointer user_data)
{
  ToxSession *self = (ToxSession *)user_data;
  const GList *candidates;
  GPtrArray *array;

  candidates = farsight_stream_get_native_candidate_list(stream);
  array = g_ptr_array_new();

  for (; candidates; candidates = g_list_next(candidates)) {
    GValueArray *candidate;
    FarsightTransportInfo *info;
    GValue *value;

    info = (FarsightTransportInfo*)candidates->data;
    candidate = g_value_array_new(10);

    value = g_new(GValue, 1);
    g_value_init(value, G_TYPE_STRING);
    g_value_set_string(value, info->candidate_id);
    g_value_array_append(candidate, value);

    value = g_new(GValue, 1);
    g_value_init(value, G_TYPE_UINT);
    g_value_set_uint(value, info->component);
    g_value_array_append(candidate, value);

    value = g_new(GValue, 1);
    g_value_init(value, G_TYPE_STRING);
    g_value_set_string(value, info->ip);
    g_value_array_append(candidate, value);

    value = g_new(GValue, 1);
    g_value_init(value, G_TYPE_UINT);
    g_value_set_uint(value, info->port);
    g_value_array_append(candidate, value);

    value = g_new(GValue, 1);
    g_value_init(value, G_TYPE_STRING);
    switch(info->proto) {
    case FARSIGHT_NETWORK_PROTOCOL_UDP:
      g_value_set_static_string(value, "udp");
      break;
    case FARSIGHT_NETWORK_PROTOCOL_TCP:
      g_value_set_static_string(value, "tcp");
      break;
    default:
      g_error("Unknown protocol value %u\n", info->proto);
    }
    g_value_array_append(candidate, value);

    value = g_new(GValue, 1);
    g_value_init(value, G_TYPE_STRING);
    g_value_set_string(value, info->proto_subtype);
    g_value_array_append(candidate, value);

    value = g_new(GValue, 1);
    g_value_init(value, G_TYPE_STRING);
    g_value_set_string(value, info->proto_profile);
    g_value_array_append(candidate, value);

    value = g_new(GValue, 1);
    g_value_init(value, G_TYPE_UINT);
    g_value_set_uint(value, (guint)(info->preference * 100));
    g_value_array_append(candidate, value);

    value = g_new(GValue, 1);
    g_value_init(value, G_TYPE_UINT);
    switch(info->type) {
    case FARSIGHT_CANDIDATE_TYPE_LOCAL:
      g_value_set_uint(value, 0);
      break;
    case FARSIGHT_CANDIDATE_TYPE_DERIVED:
      g_value_set_uint(value, 1);
      break;
    case FARSIGHT_CANDIDATE_TYPE_RELAY:
      g_value_set_uint(value, 2);
      break;
    default:
      g_error("Unknown candidate type %u\n", info->proto);
    }
    g_value_array_append(candidate, value);

    value = g_new(GValue, 1);
    g_value_init(value, G_TYPE_STRING);
    g_value_set_string(value, info->username);
    g_value_array_append(candidate, value);

    value = g_new(GValue, 1);
    g_value_init(value, G_TYPE_STRING);
    g_value_set_string(value, info->password);
    g_value_array_append(candidate, value);

    g_assert(candidate->n_values == 11);

    g_ptr_array_add(array, candidate);
  }

  g_print("Sending signal NativeCandidatesPrepared!\n");
  g_signal_emit(self, signals[NATIVE_CANDIDATES_PREPARED], 0, array);
}

static void
tox_session_new_native_candidate(FarsightStream *stream, gchar *candidate_id, ToxSession *self)
{
  GList *candidate =
      farsight_stream_get_native_candidate (stream, candidate_id);
  FarsightTransportInfo *trans = candidate->data;
  FarsightMediaType type;

  g_message ("tox_session_new_native_candidate: New native candidate: "
      "<id: %s, "
      "component: %d, "
      "ip: %s port: %d "
      "proto: %d, "
      "proto_subtype: %s, "
      "proto_profile: %s, "
      "preference: %f, "
      "type: %d "
      "username: %s password: %s>",
      trans->candidate_id, trans->component,
      trans->ip, trans->port, trans->proto, trans->proto_subtype,
      trans->proto_profile, trans->preference,
      trans->type, trans->username, trans->password);
}

2007	Jan	Feb	Mar	Apr (4)	May (13)	Jun (3)	Jul (4)	Aug (30)	Sep (17)	Oct (2)	Nov (6)	Dec (9)
2008	Jan (9)	Feb (30)	Mar (22)	Apr (23)	May (25)	Jun (25)	Jul (4)	Aug (21)	Sep (16)	Oct (44)	Nov (15)	Dec (3)
2009	Jan (9)	Feb (6)	Mar (2)	Apr (2)	May (1)	Jun	Jul	Aug	Sep (4)	Oct	Nov	Dec
2010	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug (1)	Sep (2)	Oct (3)	Nov	Dec
2011	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug (5)	Sep	Oct (3)	Nov	Dec (2)
2012	Jan	Feb (3)	Mar	Apr (3)	May (2)	Jun (2)	Jul (1)	Aug	Sep (2)	Oct	Nov	Dec (1)
2013	Jan (3)	Feb (4)	Mar	Apr (4)	May (2)	Jun (1)	Jul (3)	Aug (3)	Sep (1)	Oct (1)	Nov (10)	Dec
2014	Jan (6)	Feb (2)	Mar	Apr (3)	May (8)	Jun (5)	Jul (2)	Aug (6)	Sep (2)	Oct (1)	Nov	Dec (2)
2015	Jan (1)	Feb (2)	Mar (2)	Apr (6)	May	Jun (1)	Jul	Aug	Sep	Oct (4)	Nov	Dec
2016	Jan (2)	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec
2017	Jan (1)	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec
2018	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep (2)	Oct	Nov	Dec

emacs-jabber-commit Mailing List for jabber.el (Page 16)

emacs-jabber-commit — jabber.el commit messages