diff --git a/jni/pjproject-android/.svn/pristine/69/69282b11f74328fce376c2a8be8f160d51cd91f4.svn-base b/jni/pjproject-android/.svn/pristine/69/69282b11f74328fce376c2a8be8f160d51cd91f4.svn-base
new file mode 100644
index 0000000..efda319
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/69/69282b11f74328fce376c2a8be8f160d51cd91f4.svn-base
@@ -0,0 +1,980 @@
+/* $Id$ */
+/*
+ * Copyright (C) 2009-2011 Teluu Inc. (http://www.teluu.com)
+ * Copyright (C) 2007-2009 Keystream AB and Konftel AB, All rights reserved.
+ *                         Author: <dan.aberg@keystream.se>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include <pjmedia_audiodev.h>
+#include <pj/assert.h>
+#include <pj/log.h>
+#include <pj/os.h>
+#include <pj/pool.h>
+#include <pjmedia/errno.h>
+
+#if defined(PJMEDIA_AUDIO_DEV_HAS_ALSA) && PJMEDIA_AUDIO_DEV_HAS_ALSA
+
+#include <sys/syscall.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <sys/select.h>
+#include <pthread.h>
+#include <errno.h>
+#include <alsa/asoundlib.h>
+
+
+#define THIS_FILE 			"alsa_dev.c"
+#define ALSA_DEVICE_NAME 		"plughw:%d,%d"
+#define ALSASOUND_PLAYBACK 		1
+#define ALSASOUND_CAPTURE  		2
+#define MAX_SOUND_CARDS 		5
+#define MAX_SOUND_DEVICES_PER_CARD 	5
+#define MAX_DEVICES			16
+
+/* Set to 1 to enable tracing */
+#if 0
+#	define TRACE_(expr)		PJ_LOG(5,expr)
+#else
+#	define TRACE_(expr)
+#endif
+
+/*
+ * Factory prototypes
+ */
+static pj_status_t alsa_factory_init(pjmedia_aud_dev_factory *f);
+static pj_status_t alsa_factory_destroy(pjmedia_aud_dev_factory *f);
+static pj_status_t alsa_factory_refresh(pjmedia_aud_dev_factory *f);
+static unsigned    alsa_factory_get_dev_count(pjmedia_aud_dev_factory *f);
+static pj_status_t alsa_factory_get_dev_info(pjmedia_aud_dev_factory *f,
+					     unsigned index,
+					     pjmedia_aud_dev_info *info);
+static pj_status_t alsa_factory_default_param(pjmedia_aud_dev_factory *f,
+					      unsigned index,
+					      pjmedia_aud_param *param);
+static pj_status_t alsa_factory_create_stream(pjmedia_aud_dev_factory *f,
+					      const pjmedia_aud_param *param,
+					      pjmedia_aud_rec_cb rec_cb,
+					      pjmedia_aud_play_cb play_cb,
+					      void *user_data,
+					      pjmedia_aud_stream **p_strm);
+
+/*
+ * Stream prototypes
+ */
+static pj_status_t alsa_stream_get_param(pjmedia_aud_stream *strm,
+					 pjmedia_aud_param *param);
+static pj_status_t alsa_stream_get_cap(pjmedia_aud_stream *strm,
+				       pjmedia_aud_dev_cap cap,
+				       void *value);
+static pj_status_t alsa_stream_set_cap(pjmedia_aud_stream *strm,
+				       pjmedia_aud_dev_cap cap,
+				       const void *value);
+static pj_status_t alsa_stream_start(pjmedia_aud_stream *strm);
+static pj_status_t alsa_stream_stop(pjmedia_aud_stream *strm);
+static pj_status_t alsa_stream_destroy(pjmedia_aud_stream *strm);
+
+
+struct alsa_factory
+{
+    pjmedia_aud_dev_factory	 base;
+    pj_pool_factory		*pf;
+    pj_pool_t			*pool;
+    pj_pool_t			*base_pool;
+
+    unsigned			 dev_cnt;
+    pjmedia_aud_dev_info	 devs[MAX_DEVICES];
+};
+
+struct alsa_stream
+{
+    pjmedia_aud_stream	 base;
+
+    /* Common */
+    pj_pool_t		*pool;
+    struct alsa_factory *af;
+    void		*user_data;
+    pjmedia_aud_param	 param;		/* Running parameter 		*/
+    int                  rec_id;      	/* Capture device id		*/
+    int                  quit;
+
+    /* Playback */
+    snd_pcm_t		*pb_pcm;
+    snd_pcm_uframes_t    pb_frames; 	/* samples_per_frame		*/
+    pjmedia_aud_play_cb  pb_cb;
+    unsigned             pb_buf_size;
+    char		*pb_buf;
+    pj_thread_t		*pb_thread;
+
+    /* Capture */
+    snd_pcm_t		*ca_pcm;
+    snd_pcm_uframes_t    ca_frames; 	/* samples_per_frame		*/
+    pjmedia_aud_rec_cb   ca_cb;
+    unsigned             ca_buf_size;
+    char		*ca_buf;
+    pj_thread_t		*ca_thread;
+};
+
+static pjmedia_aud_dev_factory_op alsa_factory_op =
+{
+    &alsa_factory_init,
+    &alsa_factory_destroy,
+    &alsa_factory_get_dev_count,
+    &alsa_factory_get_dev_info,
+    &alsa_factory_default_param,
+    &alsa_factory_create_stream,
+    &alsa_factory_refresh
+};
+
+static pjmedia_aud_stream_op alsa_stream_op =
+{
+    &alsa_stream_get_param,
+    &alsa_stream_get_cap,
+    &alsa_stream_set_cap,
+    &alsa_stream_start,
+    &alsa_stream_stop,
+    &alsa_stream_destroy
+};
+
+static void null_alsa_error_handler (const char *file,
+				int line,
+				const char *function,
+				int err,
+				const char *fmt,
+				...)
+{
+    PJ_UNUSED_ARG(file);
+    PJ_UNUSED_ARG(line);
+    PJ_UNUSED_ARG(function);
+    PJ_UNUSED_ARG(err);
+    PJ_UNUSED_ARG(fmt);
+}
+
+static void alsa_error_handler (const char *file,
+				int line,
+				const char *function,
+				int err,
+				const char *fmt,
+				...)
+{
+    char err_msg[128];
+    int index;
+    va_list arg;
+
+#ifndef NDEBUG
+    index = snprintf (err_msg, sizeof(err_msg), "ALSA lib %s:%i:(%s) ",
+		      file, line, function);
+#else
+    index = snprintf (err_msg, sizeof(err_msg), "ALSA lib: ");
+#endif
+    va_start (arg, fmt);
+    if (index < sizeof(err_msg)-1)
+	index += vsnprintf (err_msg+index, sizeof(err_msg)-index, fmt, arg);
+    va_end(arg);
+    if (err && index < sizeof(err_msg)-1)
+	index += snprintf (err_msg+index, sizeof(err_msg)-index, ": %s",
+			   snd_strerror(err));
+    PJ_LOG (4,(THIS_FILE, "%s", err_msg));
+}
+
+
+static pj_status_t add_dev (struct alsa_factory *af, const char *dev_name)
+{
+    pjmedia_aud_dev_info *adi;
+    snd_pcm_t* pcm;
+    int pb_result, ca_result;
+
+    if (af->dev_cnt >= PJ_ARRAY_SIZE(af->devs))
+	return PJ_ETOOMANY;
+
+    adi = &af->devs[af->dev_cnt];
+
+    TRACE_((THIS_FILE, "add_dev (%s): Enter", dev_name));
+
+    /* Try to open the device in playback mode */
+    pb_result = snd_pcm_open (&pcm, dev_name, SND_PCM_STREAM_PLAYBACK, 0);
+    if (pb_result >= 0) {
+	TRACE_((THIS_FILE, "Try to open the device for playback - success"));
+	snd_pcm_close (pcm);
+    } else {
+	TRACE_((THIS_FILE, "Try to open the device for playback - failure"));
+    }
+
+    /* Try to open the device in capture mode */
+    ca_result = snd_pcm_open (&pcm, dev_name, SND_PCM_STREAM_CAPTURE, 0);
+    if (ca_result >= 0) {
+	TRACE_((THIS_FILE, "Try to open the device for capture - success"));
+	snd_pcm_close (pcm);
+    } else {
+	TRACE_((THIS_FILE, "Try to open the device for capture - failure"));
+    }
+
+    /* Check if the device could be opened in playback or capture mode */
+    if (pb_result<0 && ca_result<0) {
+	TRACE_((THIS_FILE, "Unable to open sound device %s", dev_name));
+	return PJMEDIA_EAUD_NODEV;
+    }
+
+    /* Reset device info */
+    pj_bzero(adi, sizeof(*adi));
+
+    /* Set device name */
+    strncpy(adi->name, dev_name, sizeof(adi->name));
+
+    /* Check the number of playback channels */
+    adi->output_count = (pb_result>=0) ? 1 : 0;
+
+    /* Check the number of capture channels */
+    adi->input_count = (ca_result>=0) ? 1 : 0;
+
+    /* Set the default sample rate */
+    adi->default_samples_per_sec = 8000;
+
+    /* Driver name */
+    strcpy(adi->driver, "ALSA");
+
+    ++af->dev_cnt;
+
+    PJ_LOG (5,(THIS_FILE, "Added sound device %s", adi->name));
+
+    return PJ_SUCCESS;
+}
+
+
+/* Create ALSA audio driver. */
+pjmedia_aud_dev_factory* pjmedia_alsa_factory(pj_pool_factory *pf)
+{
+    struct alsa_factory *af;
+    pj_pool_t *pool;
+
+    pool = pj_pool_create(pf, "alsa_aud_base", 256, 256, NULL);
+    af = PJ_POOL_ZALLOC_T(pool, struct alsa_factory);
+    af->pf = pf;
+    af->base_pool = pool;
+    af->base.op = &alsa_factory_op;
+
+    return &af->base;
+}
+
+
+/* API: init factory */
+static pj_status_t alsa_factory_init(pjmedia_aud_dev_factory *f)
+{
+    pj_status_t status = alsa_factory_refresh(f);
+    if (PJ_SUCCESS != status)
+	return status;
+
+    PJ_LOG(4,(THIS_FILE, "ALSA initialized"));
+    return PJ_SUCCESS;
+}
+
+
+/* API: destroy factory */
+static pj_status_t alsa_factory_destroy(pjmedia_aud_dev_factory *f)
+{
+    struct alsa_factory *af = (struct alsa_factory*)f;
+
+    if (af->pool)
+	pj_pool_release(af->pool);
+
+    if (af->base_pool) {
+	pj_pool_t *pool = af->base_pool;
+	af->base_pool = NULL;
+	pj_pool_release(pool);
+    }
+
+    /* Restore handler */
+    snd_lib_error_set_handler(NULL);
+
+    return PJ_SUCCESS;
+}
+
+
+/* API: refresh the device list */
+static pj_status_t alsa_factory_refresh(pjmedia_aud_dev_factory *f)
+{
+    struct alsa_factory *af = (struct alsa_factory*)f;
+    char **hints, **n;
+    int err;
+
+    TRACE_((THIS_FILE, "pjmedia_snd_init: Enumerate sound devices"));
+
+    if (af->pool != NULL) {
+	pj_pool_release(af->pool);
+	af->pool = NULL;
+    }
+
+    af->pool = pj_pool_create(af->pf, "alsa_aud", 256, 256, NULL);
+    af->dev_cnt = 0;
+
+    /* Enumerate sound devices */
+    err = snd_device_name_hint(-1, "pcm", (void***)&hints);
+    if (err != 0)
+	return PJMEDIA_EAUD_SYSERR;
+
+    /* Set a null error handler prior to enumeration to suppress errors */
+    snd_lib_error_set_handler(null_alsa_error_handler);
+
+    n = hints;
+    while (*n != NULL) {
+	char *name = snd_device_name_get_hint(*n, "NAME");
+	if (name != NULL && 0 != strcmp("null", name)) {
+	    add_dev(af, name);
+	    free(name);
+	}
+	n++;
+    }
+
+    /* Install error handler after enumeration, otherwise we'll get many
+     * error messages about invalid card/device ID.
+     */
+    snd_lib_error_set_handler(alsa_error_handler);
+
+    err = snd_device_name_free_hint((void**)hints);
+
+    PJ_LOG(4,(THIS_FILE, "ALSA driver found %d devices", af->dev_cnt));
+
+    return PJ_SUCCESS;
+}
+
+
+/* API: get device count */
+static unsigned  alsa_factory_get_dev_count(pjmedia_aud_dev_factory *f)
+{
+    struct alsa_factory *af = (struct alsa_factory*)f;
+    return af->dev_cnt;
+}
+
+
+/* API: get device info */
+static pj_status_t alsa_factory_get_dev_info(pjmedia_aud_dev_factory *f,
+					     unsigned index,
+					     pjmedia_aud_dev_info *info)
+{
+    struct alsa_factory *af = (struct alsa_factory*)f;
+
+    PJ_ASSERT_RETURN(index>=0 && index<af->dev_cnt, PJ_EINVAL);
+
+    pj_memcpy(info, &af->devs[index], sizeof(*info));
+    info->caps = PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY |
+		 PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY;
+    return PJ_SUCCESS;
+}
+
+/* API: create default parameter */
+static pj_status_t alsa_factory_default_param(pjmedia_aud_dev_factory *f,
+					      unsigned index,
+					      pjmedia_aud_param *param)
+{
+    struct alsa_factory *af = (struct alsa_factory*)f;
+    pjmedia_aud_dev_info *adi;
+
+    PJ_ASSERT_RETURN(index>=0 && index<af->dev_cnt, PJ_EINVAL);
+
+    adi = &af->devs[index];
+
+    pj_bzero(param, sizeof(*param));
+    if (adi->input_count && adi->output_count) {
+	param->dir = PJMEDIA_DIR_CAPTURE_PLAYBACK;
+	param->rec_id = index;
+	param->play_id = index;
+    } else if (adi->input_count) {
+	param->dir = PJMEDIA_DIR_CAPTURE;
+	param->rec_id = index;
+	param->play_id = PJMEDIA_AUD_INVALID_DEV;
+    } else if (adi->output_count) {
+	param->dir = PJMEDIA_DIR_PLAYBACK;
+	param->play_id = index;
+	param->rec_id = PJMEDIA_AUD_INVALID_DEV;
+    } else {
+	return PJMEDIA_EAUD_INVDEV;
+    }
+
+    param->clock_rate = adi->default_samples_per_sec;
+    param->channel_count = 1;
+    param->samples_per_frame = adi->default_samples_per_sec * 20 / 1000;
+    param->bits_per_sample = 16;
+    param->flags = adi->caps;
+    param->input_latency_ms = PJMEDIA_SND_DEFAULT_REC_LATENCY;
+    param->output_latency_ms = PJMEDIA_SND_DEFAULT_PLAY_LATENCY;
+
+    return PJ_SUCCESS;
+}
+
+
+static int pb_thread_func (void *arg)
+{
+    struct alsa_stream* stream = (struct alsa_stream*) arg;
+    snd_pcm_t* pcm             = stream->pb_pcm;
+    int size                   = stream->pb_buf_size;
+    snd_pcm_uframes_t nframes  = stream->pb_frames;
+    void* user_data            = stream->user_data;
+    char* buf 		       = stream->pb_buf;
+    pj_timestamp tstamp;
+    int result;
+
+    pj_bzero (buf, size);
+    tstamp.u64 = 0;
+
+    TRACE_((THIS_FILE, "pb_thread_func(%u): Started",
+	    (unsigned)syscall(SYS_gettid)));
+
+    snd_pcm_prepare (pcm);
+
+    while (!stream->quit) {
+	pjmedia_frame frame;
+
+	frame.type = PJMEDIA_FRAME_TYPE_AUDIO;
+	frame.buf = buf;
+	frame.size = size;
+	frame.timestamp.u64 = tstamp.u64;
+	frame.bit_info = 0;
+
+	result = stream->pb_cb (user_data, &frame);
+	if (result != PJ_SUCCESS || stream->quit)
+	    break;
+
+	if (frame.type != PJMEDIA_FRAME_TYPE_AUDIO)
+	    pj_bzero (buf, size);
+
+	result = snd_pcm_writei (pcm, buf, nframes);
+	if (result == -EPIPE) {
+	    PJ_LOG (4,(THIS_FILE, "pb_thread_func: underrun!"));
+	    snd_pcm_prepare (pcm);
+	} else if (result < 0) {
+	    PJ_LOG (4,(THIS_FILE, "pb_thread_func: error writing data!"));
+	}
+
+	tstamp.u64 += nframes;
+    }
+
+    snd_pcm_drain (pcm);
+    TRACE_((THIS_FILE, "pb_thread_func: Stopped"));
+    return PJ_SUCCESS;
+}
+
+
+
+static int ca_thread_func (void *arg)
+{
+    struct alsa_stream* stream = (struct alsa_stream*) arg;
+    snd_pcm_t* pcm             = stream->ca_pcm;
+    int size                   = stream->ca_buf_size;
+    snd_pcm_uframes_t nframes  = stream->ca_frames;
+    void* user_data            = stream->user_data;
+    char* buf 		       = stream->ca_buf;
+    pj_timestamp tstamp;
+    int result;
+    struct sched_param param;
+    pthread_t* thid;
+
+    thid = (pthread_t*) pj_thread_get_os_handle (pj_thread_this());
+    param.sched_priority = sched_get_priority_max (SCHED_RR);
+    PJ_LOG (5,(THIS_FILE, "ca_thread_func(%u): Set thread priority "
+		          "for audio capture thread.",
+		          (unsigned)syscall(SYS_gettid)));
+    result = pthread_setschedparam (*thid, SCHED_RR, &param);
+    if (result) {
+	if (result == EPERM)
+	    PJ_LOG (5,(THIS_FILE, "Unable to increase thread priority, "
+				  "root access needed."));
+	else
+	    PJ_LOG (5,(THIS_FILE, "Unable to increase thread priority, "
+				  "error: %d",
+				  result));
+    }
+
+    pj_bzero (buf, size);
+    tstamp.u64 = 0;
+
+    TRACE_((THIS_FILE, "ca_thread_func(%u): Started",
+	    (unsigned)syscall(SYS_gettid)));
+
+    snd_pcm_prepare (pcm);
+
+    while (!stream->quit) {
+	pjmedia_frame frame;
+
+	pj_bzero (buf, size);
+	result = snd_pcm_readi (pcm, buf, nframes);
+	if (result == -EPIPE) {
+	    PJ_LOG (4,(THIS_FILE, "ca_thread_func: overrun!"));
+	    snd_pcm_prepare (pcm);
+	    continue;
+	} else if (result < 0) {
+	    PJ_LOG (4,(THIS_FILE, "ca_thread_func: error reading data!"));
+	}
+	if (stream->quit)
+	    break;
+
+	frame.type = PJMEDIA_FRAME_TYPE_AUDIO;
+	frame.buf = (void*) buf;
+	frame.size = size;
+	frame.timestamp.u64 = tstamp.u64;
+	frame.bit_info = 0;
+
+	result = stream->ca_cb (user_data, &frame);
+	if (result != PJ_SUCCESS || stream->quit)
+	    break;
+
+	tstamp.u64 += nframes;
+    }
+    snd_pcm_drain (pcm);
+    TRACE_((THIS_FILE, "ca_thread_func: Stopped"));
+
+    return PJ_SUCCESS;
+}
+
+
+static pj_status_t open_playback (struct alsa_stream* stream,
+			          const pjmedia_aud_param *param)
+{
+    snd_pcm_hw_params_t* params;
+    snd_pcm_format_t format;
+    int result;
+    unsigned int rate;
+    snd_pcm_uframes_t tmp_buf_size;
+    snd_pcm_uframes_t tmp_period_size;
+
+    if (param->play_id < 0 || param->play_id >= stream->af->dev_cnt)
+	return PJMEDIA_EAUD_INVDEV;
+
+    /* Open PCM for playback */
+    PJ_LOG (5,(THIS_FILE, "open_playback: Open playback device '%s'",
+	       stream->af->devs[param->play_id].name));
+    result = snd_pcm_open (&stream->pb_pcm,
+			   stream->af->devs[param->play_id].name,
+			   SND_PCM_STREAM_PLAYBACK,
+			   0);
+    if (result < 0)
+	return PJMEDIA_EAUD_SYSERR;
+
+    /* Allocate a hardware parameters object. */
+    snd_pcm_hw_params_alloca (&params);
+
+    /* Fill it in with default values. */
+    snd_pcm_hw_params_any (stream->pb_pcm, params);
+
+    /* Set interleaved mode */
+    snd_pcm_hw_params_set_access (stream->pb_pcm, params,
+				  SND_PCM_ACCESS_RW_INTERLEAVED);
+
+    /* Set format */
+    switch (param->bits_per_sample) {
+    case 8:
+	TRACE_((THIS_FILE, "open_playback: set format SND_PCM_FORMAT_S8"));
+	format = SND_PCM_FORMAT_S8;
+	break;
+    case 16:
+	TRACE_((THIS_FILE, "open_playback: set format SND_PCM_FORMAT_S16_LE"));
+	format = SND_PCM_FORMAT_S16_LE;
+	break;
+    case 24:
+	TRACE_((THIS_FILE, "open_playback: set format SND_PCM_FORMAT_S24_LE"));
+	format = SND_PCM_FORMAT_S24_LE;
+	break;
+    case 32:
+	TRACE_((THIS_FILE, "open_playback: set format SND_PCM_FORMAT_S32_LE"));
+	format = SND_PCM_FORMAT_S32_LE;
+	break;
+    default:
+	TRACE_((THIS_FILE, "open_playback: set format SND_PCM_FORMAT_S16_LE"));
+	format = SND_PCM_FORMAT_S16_LE;
+	break;
+    }
+    snd_pcm_hw_params_set_format (stream->pb_pcm, params, format);
+
+    /* Set number of channels */
+    TRACE_((THIS_FILE, "open_playback: set channels: %d",
+		       param->channel_count));
+    snd_pcm_hw_params_set_channels (stream->pb_pcm, params,
+				    param->channel_count);
+
+    /* Set clock rate */
+    rate = param->clock_rate;
+    TRACE_((THIS_FILE, "open_playback: set clock rate: %d", rate));
+    snd_pcm_hw_params_set_rate_near (stream->pb_pcm, params, &rate, NULL);
+    TRACE_((THIS_FILE, "open_playback: clock rate set to: %d", rate));
+
+    /* Set period size to samples_per_frame frames. */
+    stream->pb_frames = (snd_pcm_uframes_t) param->samples_per_frame /
+					    param->channel_count;
+    TRACE_((THIS_FILE, "open_playback: set period size: %d",
+	    stream->pb_frames));
+    tmp_period_size = stream->pb_frames;
+    snd_pcm_hw_params_set_period_size_near (stream->pb_pcm, params,
+					    &tmp_period_size, NULL);
+    TRACE_((THIS_FILE, "open_playback: period size set to: %d",
+	    tmp_period_size));
+
+    /* Set the sound device buffer size and latency */
+    if (param->flags & PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY)
+	tmp_buf_size = (rate / 1000) * param->output_latency_ms;
+    else
+	tmp_buf_size = (rate / 1000) * PJMEDIA_SND_DEFAULT_PLAY_LATENCY;
+    snd_pcm_hw_params_set_buffer_size_near (stream->pb_pcm, params,
+					    &tmp_buf_size);
+    stream->param.output_latency_ms = tmp_buf_size / (rate / 1000);
+
+    /* Set our buffer */
+    stream->pb_buf_size = stream->pb_frames * param->channel_count *
+			  (param->bits_per_sample/8);
+    stream->pb_buf = (char*) pj_pool_alloc(stream->pool, stream->pb_buf_size);
+
+    TRACE_((THIS_FILE, "open_playback: buffer size set to: %d",
+	    (int)tmp_buf_size));
+    TRACE_((THIS_FILE, "open_playback: playback_latency set to: %d ms",
+	    (int)stream->param.output_latency_ms));
+
+    /* Activate the parameters */
+    result = snd_pcm_hw_params (stream->pb_pcm, params);
+    if (result < 0) {
+	snd_pcm_close (stream->pb_pcm);
+	return PJMEDIA_EAUD_SYSERR;
+    }
+
+    PJ_LOG (5,(THIS_FILE, "Opened device alsa(%s) for playing, sample rate=%d"
+	       ", ch=%d, bits=%d, period size=%d frames, latency=%d ms",
+	       stream->af->devs[param->play_id].name,
+	       rate, param->channel_count,
+	       param->bits_per_sample, stream->pb_frames,
+	       (int)stream->param.output_latency_ms));
+
+    return PJ_SUCCESS;
+}
+
+
+static pj_status_t open_capture (struct alsa_stream* stream,
+			         const pjmedia_aud_param *param)
+{
+    snd_pcm_hw_params_t* params;
+    snd_pcm_format_t format;
+    int result;
+    unsigned int rate;
+    snd_pcm_uframes_t tmp_buf_size;
+    snd_pcm_uframes_t tmp_period_size;
+
+    if (param->rec_id < 0 || param->rec_id >= stream->af->dev_cnt)
+	return PJMEDIA_EAUD_INVDEV;
+
+    /* Open PCM for capture */
+    PJ_LOG (5,(THIS_FILE, "open_capture: Open capture device '%s'",
+	       stream->af->devs[param->rec_id].name));
+    result = snd_pcm_open (&stream->ca_pcm,
+		            stream->af->devs[param->rec_id].name,
+			   SND_PCM_STREAM_CAPTURE,
+			   0);
+    if (result < 0)
+	return PJMEDIA_EAUD_SYSERR;
+
+    /* Allocate a hardware parameters object. */
+    snd_pcm_hw_params_alloca (&params);
+
+    /* Fill it in with default values. */
+    snd_pcm_hw_params_any (stream->ca_pcm, params);
+
+    /* Set interleaved mode */
+    snd_pcm_hw_params_set_access (stream->ca_pcm, params,
+				  SND_PCM_ACCESS_RW_INTERLEAVED);
+
+    /* Set format */
+    switch (param->bits_per_sample) {
+    case 8:
+	TRACE_((THIS_FILE, "open_capture: set format SND_PCM_FORMAT_S8"));
+	format = SND_PCM_FORMAT_S8;
+	break;
+    case 16:
+	TRACE_((THIS_FILE, "open_capture: set format SND_PCM_FORMAT_S16_LE"));
+	format = SND_PCM_FORMAT_S16_LE;
+	break;
+    case 24:
+	TRACE_((THIS_FILE, "open_capture: set format SND_PCM_FORMAT_S24_LE"));
+	format = SND_PCM_FORMAT_S24_LE;
+	break;
+    case 32:
+	TRACE_((THIS_FILE, "open_capture: set format SND_PCM_FORMAT_S32_LE"));
+	format = SND_PCM_FORMAT_S32_LE;
+	break;
+    default:
+	TRACE_((THIS_FILE, "open_capture: set format SND_PCM_FORMAT_S16_LE"));
+	format = SND_PCM_FORMAT_S16_LE;
+	break;
+    }
+    snd_pcm_hw_params_set_format (stream->ca_pcm, params, format);
+
+    /* Set number of channels */
+    TRACE_((THIS_FILE, "open_capture: set channels: %d",
+	    param->channel_count));
+    snd_pcm_hw_params_set_channels (stream->ca_pcm, params,
+				    param->channel_count);
+
+    /* Set clock rate */
+    rate = param->clock_rate;
+    TRACE_((THIS_FILE, "open_capture: set clock rate: %d", rate));
+    snd_pcm_hw_params_set_rate_near (stream->ca_pcm, params, &rate, NULL);
+    TRACE_((THIS_FILE, "open_capture: clock rate set to: %d", rate));
+
+    /* Set period size to samples_per_frame frames. */
+    stream->ca_frames = (snd_pcm_uframes_t) param->samples_per_frame /
+					    param->channel_count;
+    TRACE_((THIS_FILE, "open_capture: set period size: %d",
+	    stream->ca_frames));
+    tmp_period_size = stream->ca_frames;
+    snd_pcm_hw_params_set_period_size_near (stream->ca_pcm, params,
+					    &tmp_period_size, NULL);
+    TRACE_((THIS_FILE, "open_capture: period size set to: %d",
+	    tmp_period_size));
+
+    /* Set the sound device buffer size and latency */
+    if (param->flags & PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY)
+	tmp_buf_size = (rate / 1000) * param->input_latency_ms;
+    else
+	tmp_buf_size = (rate / 1000) * PJMEDIA_SND_DEFAULT_REC_LATENCY;
+    snd_pcm_hw_params_set_buffer_size_near (stream->ca_pcm, params,
+					    &tmp_buf_size);
+    stream->param.input_latency_ms = tmp_buf_size / (rate / 1000);
+
+    /* Set our buffer */
+    stream->ca_buf_size = stream->ca_frames * param->channel_count *
+			  (param->bits_per_sample/8);
+    stream->ca_buf = (char*) pj_pool_alloc (stream->pool, stream->ca_buf_size);
+
+    TRACE_((THIS_FILE, "open_capture: buffer size set to: %d",
+	    (int)tmp_buf_size));
+    TRACE_((THIS_FILE, "open_capture: capture_latency set to: %d ms",
+	    (int)stream->param.input_latency_ms));
+
+    /* Activate the parameters */
+    result = snd_pcm_hw_params (stream->ca_pcm, params);
+    if (result < 0) {
+	snd_pcm_close (stream->ca_pcm);
+	return PJMEDIA_EAUD_SYSERR;
+    }
+
+    PJ_LOG (5,(THIS_FILE, "Opened device alsa(%s) for capture, sample rate=%d"
+	       ", ch=%d, bits=%d, period size=%d frames, latency=%d ms",
+	       stream->af->devs[param->rec_id].name,
+	       rate, param->channel_count,
+	       param->bits_per_sample, stream->ca_frames,
+	       (int)stream->param.input_latency_ms));
+
+    return PJ_SUCCESS;
+}
+
+
+/* API: create stream */
+static pj_status_t alsa_factory_create_stream(pjmedia_aud_dev_factory *f,
+					      const pjmedia_aud_param *param,
+					      pjmedia_aud_rec_cb rec_cb,
+					      pjmedia_aud_play_cb play_cb,
+					      void *user_data,
+					      pjmedia_aud_stream **p_strm)
+{
+    struct alsa_factory *af = (struct alsa_factory*)f;
+    pj_status_t status;
+    pj_pool_t* pool;
+    struct alsa_stream* stream;
+
+    pool = pj_pool_create (af->pf, "alsa%p", 1024, 1024, NULL);
+    if (!pool)
+	return PJ_ENOMEM;
+
+    /* Allocate and initialize comon stream data */
+    stream = PJ_POOL_ZALLOC_T (pool, struct alsa_stream);
+    stream->base.op = &alsa_stream_op;
+    stream->pool      = pool;
+    stream->af 	      = af;
+    stream->user_data = user_data;
+    stream->pb_cb     = play_cb;
+    stream->ca_cb     = rec_cb;
+    stream->quit      = 0;
+    pj_memcpy(&stream->param, param, sizeof(*param));
+
+    /* Init playback */
+    if (param->dir & PJMEDIA_DIR_PLAYBACK) {
+	status = open_playback (stream, param);
+	if (status != PJ_SUCCESS) {
+	    pj_pool_release (pool);
+	    return status;
+	}
+    }
+
+    /* Init capture */
+    if (param->dir & PJMEDIA_DIR_CAPTURE) {
+	status = open_capture (stream, param);
+	if (status != PJ_SUCCESS) {
+	    if (param->dir & PJMEDIA_DIR_PLAYBACK)
+		snd_pcm_close (stream->pb_pcm);
+	    pj_pool_release (pool);
+	    return status;
+	}
+    }
+
+    *p_strm = &stream->base;
+    return PJ_SUCCESS;
+}
+
+
+/* API: get running parameter */
+static pj_status_t alsa_stream_get_param(pjmedia_aud_stream *s,
+					 pjmedia_aud_param *pi)
+{
+    struct alsa_stream *stream = (struct alsa_stream*)s;
+
+    PJ_ASSERT_RETURN(s && pi, PJ_EINVAL);
+
+    pj_memcpy(pi, &stream->param, sizeof(*pi));
+
+    return PJ_SUCCESS;
+}
+
+
+/* API: get capability */
+static pj_status_t alsa_stream_get_cap(pjmedia_aud_stream *s,
+				       pjmedia_aud_dev_cap cap,
+				       void *pval)
+{
+    struct alsa_stream *stream = (struct alsa_stream*)s;
+
+    PJ_ASSERT_RETURN(s && pval, PJ_EINVAL);
+
+    if (cap==PJMEDIA_AUD_DEV_CAP_INPUT_LATENCY &&
+	(stream->param.dir & PJMEDIA_DIR_CAPTURE))
+    {
+	/* Recording latency */
+	*(unsigned*)pval = stream->param.input_latency_ms;
+	return PJ_SUCCESS;
+    } else if (cap==PJMEDIA_AUD_DEV_CAP_OUTPUT_LATENCY &&
+	       (stream->param.dir & PJMEDIA_DIR_PLAYBACK))
+    {
+	/* Playback latency */
+	*(unsigned*)pval = stream->param.output_latency_ms;
+	return PJ_SUCCESS;
+    } else {
+	return PJMEDIA_EAUD_INVCAP;
+    }
+}
+
+
+/* API: set capability */
+static pj_status_t alsa_stream_set_cap(pjmedia_aud_stream *strm,
+				       pjmedia_aud_dev_cap cap,
+				       const void *value)
+{
+    PJ_UNUSED_ARG(strm);
+    PJ_UNUSED_ARG(cap);
+    PJ_UNUSED_ARG(value);
+
+    return PJMEDIA_EAUD_INVCAP;
+}
+
+
+/* API: start stream */
+static pj_status_t alsa_stream_start (pjmedia_aud_stream *s)
+{
+    struct alsa_stream *stream = (struct alsa_stream*)s;
+    pj_status_t status = PJ_SUCCESS;
+
+    stream->quit = 0;
+    if (stream->param.dir & PJMEDIA_DIR_PLAYBACK) {
+	status = pj_thread_create (stream->pool,
+				   "alsasound_playback",
+				   pb_thread_func,
+				   stream,
+				   0, //ZERO,
+				   0,
+				   &stream->pb_thread);
+	if (status != PJ_SUCCESS)
+	    return status;
+    }
+
+    if (stream->param.dir & PJMEDIA_DIR_CAPTURE) {
+	status = pj_thread_create (stream->pool,
+				   "alsasound_playback",
+				   ca_thread_func,
+				   stream,
+				   0, //ZERO,
+				   0,
+				   &stream->ca_thread);
+	if (status != PJ_SUCCESS) {
+	    stream->quit = PJ_TRUE;
+	    pj_thread_join(stream->pb_thread);
+	    pj_thread_destroy(stream->pb_thread);
+	    stream->pb_thread = NULL;
+	}
+    }
+
+    return status;
+}
+
+
+/* API: stop stream */
+static pj_status_t alsa_stream_stop (pjmedia_aud_stream *s)
+{
+    struct alsa_stream *stream = (struct alsa_stream*)s;
+
+    stream->quit = 1;
+
+    if (stream->pb_thread) {
+	TRACE_((THIS_FILE,
+		   "alsa_stream_stop(%u): Waiting for playback to stop.",
+		   (unsigned)syscall(SYS_gettid)));
+	pj_thread_join (stream->pb_thread);
+	TRACE_((THIS_FILE,
+		   "alsa_stream_stop(%u): playback stopped.",
+		   (unsigned)syscall(SYS_gettid)));
+	pj_thread_destroy(stream->pb_thread);
+	stream->pb_thread = NULL;
+    }
+
+    if (stream->ca_thread) {
+	TRACE_((THIS_FILE,
+		   "alsa_stream_stop(%u): Waiting for capture to stop.",
+		   (unsigned)syscall(SYS_gettid)));
+	pj_thread_join (stream->ca_thread);
+	TRACE_((THIS_FILE,
+		   "alsa_stream_stop(%u): capture stopped.",
+		   (unsigned)syscall(SYS_gettid)));
+	pj_thread_destroy(stream->ca_thread);
+	stream->ca_thread = NULL;
+    }
+
+    return PJ_SUCCESS;
+}
+
+
+
+static pj_status_t alsa_stream_destroy (pjmedia_aud_stream *s)
+{
+    struct alsa_stream *stream = (struct alsa_stream*)s;
+
+    alsa_stream_stop (s);
+
+    if (stream->param.dir & PJMEDIA_DIR_PLAYBACK) {
+	snd_pcm_close (stream->pb_pcm);
+	stream->pb_pcm = NULL;
+    }
+    if (stream->param.dir & PJMEDIA_DIR_CAPTURE) {
+	snd_pcm_close (stream->ca_pcm);
+	stream->ca_pcm = NULL;
+    }
+
+    pj_pool_release (stream->pool);
+
+    return PJ_SUCCESS;
+}
+
+#endif	/* PJMEDIA_AUDIO_DEV_HAS_ALSA */
diff --git a/jni/pjproject-android/.svn/pristine/69/693681842dbb1125017d7780e1e6a1c5f405fe32.svn-base b/jni/pjproject-android/.svn/pristine/69/693681842dbb1125017d7780e1e6a1c5f405fe32.svn-base
new file mode 100644
index 0000000..1b892756
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/69/693681842dbb1125017d7780e1e6a1c5f405fe32.svn-base
@@ -0,0 +1,15 @@
+//
+//  ipjsuaViewController.h
+//  ipjsua
+//
+//  Created by Liong Sauw Ming on 13/3/13.
+//  Copyright (c) 2013 Teluu. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@interface ipjsuaViewController : UIViewController
+
+@property (nonatomic, retain) IBOutlet UILabel *textLabel;
+
+@end
diff --git a/jni/pjproject-android/.svn/pristine/69/6945e474834e50dbe6df418f16f335e5dfb585bd.svn-base b/jni/pjproject-android/.svn/pristine/69/6945e474834e50dbe6df418f16f335e5dfb585bd.svn-base
new file mode 100644
index 0000000..a928485
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/69/6945e474834e50dbe6df418f16f335e5dfb585bd.svn-base
@@ -0,0 +1,220 @@
+/* $Id$ */
+/* 
+ * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
+ */
+#include <pjmedia-audiodev/errno.h>
+#include <pj/string.h>
+#include <pj/unicode.h>
+#if PJMEDIA_AUDIO_DEV_HAS_PORTAUDIO
+#   include <portaudio.h>
+#endif
+#if PJMEDIA_AUDIO_DEV_HAS_WMME
+#   ifdef _MSC_VER
+#	pragma warning(push, 3)
+#   endif
+#   include <windows.h>
+#   include <mmsystem.h>
+#   ifdef _MSC_VER
+#	pragma warning(pop)
+#   endif
+#endif
+
+/* PJMEDIA-Audiodev's own error codes/messages 
+ * MUST KEEP THIS ARRAY SORTED!!
+ * Message must be limited to 64 chars!
+ */
+
+#if defined(PJ_HAS_ERROR_STRING) && (PJ_HAS_ERROR_STRING != 0)
+
+static const struct 
+{
+    int code;
+    const char *msg;
+} err_str[] = 
+{
+    PJ_BUILD_ERR( PJMEDIA_EAUD_ERR,	    "Unspecified audio device error" ),
+    PJ_BUILD_ERR( PJMEDIA_EAUD_SYSERR,	    "Unknown error from audio driver" ),
+    PJ_BUILD_ERR( PJMEDIA_EAUD_INIT,	    "Audio subsystem not initialized" ),
+    PJ_BUILD_ERR( PJMEDIA_EAUD_INVDEV,	    "Invalid audio device" ),
+    PJ_BUILD_ERR( PJMEDIA_EAUD_NODEV,	    "Found no audio devices" ),
+    PJ_BUILD_ERR( PJMEDIA_EAUD_NODEFDEV,    "Unable to find default audio device" ),
+    PJ_BUILD_ERR( PJMEDIA_EAUD_NOTREADY,    "Audio device not ready" ),
+    PJ_BUILD_ERR( PJMEDIA_EAUD_INVCAP,	    "Invalid or unsupported audio capability" ),
+    PJ_BUILD_ERR( PJMEDIA_EAUD_INVOP,	    "Invalid or unsupported audio device operation" ),
+    PJ_BUILD_ERR( PJMEDIA_EAUD_BADFORMAT,   "Bad or invalid audio device format" ),
+    PJ_BUILD_ERR( PJMEDIA_EAUD_SAMPFORMAT,  "Invalid audio device sample format"),
+    PJ_BUILD_ERR( PJMEDIA_EAUD_BADLATENCY,  "Bad audio latency setting")
+
+};
+
+#endif	/* PJ_HAS_ERROR_STRING */
+
+
+
+/*
+ * pjmedia_audiodev_strerror()
+ */
+PJ_DEF(pj_str_t) pjmedia_audiodev_strerror(pj_status_t statcode, 
+					   char *buf, pj_size_t bufsize )
+{
+    pj_str_t errstr;
+
+#if defined(PJ_HAS_ERROR_STRING) && (PJ_HAS_ERROR_STRING != 0)
+
+
+    /* See if the error comes from Core Audio. */
+#if PJMEDIA_AUDIO_DEV_HAS_COREAUDIO
+    if (statcode >= PJMEDIA_AUDIODEV_COREAUDIO_ERRNO_START &&
+	statcode <= PJMEDIA_AUDIODEV_COREAUDIO_ERRNO_END)
+    {
+	int ca_err = PJMEDIA_AUDIODEV_COREAUDIO_ERRNO_START - statcode;
+
+	PJ_UNUSED_ARG(ca_err);
+	// TODO: create more helpful error messages
+	errstr.ptr = buf;
+	pj_strcpy2(&errstr, "Core audio error");
+	return errstr;
+    } else
+#endif
+
+    /* See if the error comes from PortAudio. */
+#if PJMEDIA_AUDIO_DEV_HAS_PORTAUDIO
+    if (statcode >= PJMEDIA_AUDIODEV_PORTAUDIO_ERRNO_START &&
+	statcode <= PJMEDIA_AUDIODEV_PORTAUDIO_ERRNO_END)
+    {
+
+	//int pa_err = statcode - PJMEDIA_ERRNO_FROM_PORTAUDIO(0);
+	int pa_err = PJMEDIA_AUDIODEV_PORTAUDIO_ERRNO_START - statcode;
+	pj_str_t msg;
+	
+	msg.ptr = (char*)Pa_GetErrorText(pa_err);
+	msg.slen = pj_ansi_strlen(msg.ptr);
+
+	errstr.ptr = buf;
+	pj_strncpy_with_null(&errstr, &msg, bufsize);
+	return errstr;
+
+    } else 
+#endif	/* PJMEDIA_SOUND_IMPLEMENTATION */
+
+    /* See if the error comes from WMME */
+#if PJMEDIA_AUDIO_DEV_HAS_WMME
+    if ((statcode >= PJMEDIA_AUDIODEV_WMME_IN_ERROR_START &&
+	 statcode < PJMEDIA_AUDIODEV_WMME_IN_ERROR_END) ||
+	(statcode >= PJMEDIA_AUDIODEV_WMME_OUT_ERROR_START &&
+	 statcode < PJMEDIA_AUDIODEV_WMME_OUT_ERROR_END))
+    {
+	MMRESULT native_err, mr;
+	MMRESULT (WINAPI *waveGetErrText)(UINT mmrError, LPTSTR pszText, UINT cchText);
+	PJ_DECL_UNICODE_TEMP_BUF(wbuf, 80)
+
+	if (statcode >= PJMEDIA_AUDIODEV_WMME_IN_ERROR_START &&
+	    statcode <= PJMEDIA_AUDIODEV_WMME_IN_ERROR_END)
+	{
+	    native_err = statcode - PJMEDIA_AUDIODEV_WMME_IN_ERROR_START;
+	    waveGetErrText = &waveInGetErrorText;
+	} else {
+	    native_err = statcode - PJMEDIA_AUDIODEV_WMME_OUT_ERROR_START;
+	    waveGetErrText = &waveOutGetErrorText;
+	}
+
+#if PJ_NATIVE_STRING_IS_UNICODE
+	mr = (*waveGetErrText)(native_err, wbuf, PJ_ARRAY_SIZE(wbuf));
+	if (mr == MMSYSERR_NOERROR) {
+	    int len = wcslen(wbuf);
+	    pj_unicode_to_ansi(wbuf, len, buf, bufsize);
+	}
+#else
+	mr = (*waveGetErrText)(native_err, buf, (UINT)bufsize);
+#endif
+
+	if (mr==MMSYSERR_NOERROR) {
+	    errstr.ptr = buf;
+	    errstr.slen = pj_ansi_strlen(buf);
+	    return errstr;
+	} else {
+	    pj_ansi_snprintf(buf, bufsize, "MMSYSTEM native error %d", 
+			     native_err);
+	    return pj_str(buf);
+	}
+
+    } else
+#endif
+
+/* See if the error comes from BDIMAD */
+#if PJMEDIA_AUDIO_DEV_HAS_BDIMAD
+	
+	if (statcode >= PJMEDIA_AUDIODEV_BDIMAD_ERROR_START &&
+	    statcode <  PJMEDIA_AUDIODEV_BDIMAD_ERROR_END)
+	{
+	    pj_status_t native_err;
+	    native_err = statcode - PJMEDIA_AUDIODEV_BDIMAD_ERROR_START;
+
+	    pj_ansi_snprintf(buf, bufsize, "BDIMAD native error %d", native_err);
+	    return pj_str(buf);
+	} else
+#endif
+
+    /* Audiodev error */
+    if (statcode >= PJMEDIA_AUDIODEV_ERRNO_START && 
+	statcode < PJMEDIA_AUDIODEV_ERRNO_END)
+    {
+	/* Find the error in the table.
+	 * Use binary search!
+	 */
+	int first = 0;
+	int n = PJ_ARRAY_SIZE(err_str);
+
+	while (n > 0) {
+	    int half = n/2;
+	    int mid = first + half;
+
+	    if (err_str[mid].code < statcode) {
+		first = mid+1;
+		n -= (half+1);
+	    } else if (err_str[mid].code > statcode) {
+		n = half;
+	    } else {
+		first = mid;
+		break;
+	    }
+	}
+
+
+	if (PJ_ARRAY_SIZE(err_str) && err_str[first].code == statcode) {
+	    pj_str_t msg;
+	    
+	    msg.ptr = (char*)err_str[first].msg;
+	    msg.slen = pj_ansi_strlen(err_str[first].msg);
+
+	    errstr.ptr = buf;
+	    pj_strncpy_with_null(&errstr, &msg, bufsize);
+	    return errstr;
+
+	} 
+    } 
+#endif	/* PJ_HAS_ERROR_STRING */
+
+    /* Error not found. */
+    errstr.ptr = buf;
+    errstr.slen = pj_ansi_snprintf(buf, bufsize, 
+				   "Unknown pjmedia-audiodev error %d",
+				   statcode);
+
+    return errstr;
+}
+
diff --git a/jni/pjproject-android/.svn/pristine/69/695b7aa536ef4aa9f87017799427d44fa4dfcd3f.svn-base b/jni/pjproject-android/.svn/pristine/69/695b7aa536ef4aa9f87017799427d44fa4dfcd3f.svn-base
new file mode 100644
index 0000000..949c389
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/69/695b7aa536ef4aa9f87017799427d44fa4dfcd3f.svn-base
@@ -0,0 +1,223 @@
+Changelog
+
+1.3.20
+
+  Lots of changes.  Thanks to Jeff Chan for catching a memory leak and
+  helping track down the endian issues with the SSRCs.
+
+1.3.8
+
+  This is an interim release.  Several little-endian bugs were identified
+  and fixed; this means that we can use intel/linux for development again.
+
+  Cleaned up sha1 and hmac code significantly, got rid of some excess
+  functions and properly documented the fuctions in the .h files.
+
+  Eliminated some vestigial files.
+
+  There is a SIGBUS error in the AES encrypt function on sparc
+  (observed on both solaris and openbsd) with gcc 2.95.  Was unable to
+  find bad pointer anywhere, so I'm wondering if it isn't a compiler
+  problem (there's a known problem whose profile it fits).  It doesn't
+  appear on any other platform, even in the cipher_driver stress
+  tests.
+
+  Planned changes
+
+  Change interface to nonces (xtd_seq_num_t) so that it uses
+  network byte ordering, and is consistent with other arguments.
+
+
+1.3.6 
+
+  Changed /dev/random (in configure.in and crypto/rng/rand_source.c) to
+  /dev/urandom; the latter is non-blocking on all known platforms (which 
+  corrects some programs that seem to hang) and is actually present on 
+  Open BSD (unlike /dev/random, which only works in the presence of 
+  hardware supported random number generation).
+
+  Added machine/types.h case in include/integers.h.
+
+1.3.5
+
+  Removing srtp_t::template and stream_clone().
+
+  Adding a new policy structure, which will reflect a complete SRTP
+  policy (including SRTCP).
+
+  This version is *incomplete* and will undergo more changes.  It is
+  provided only as a basis for discussion.
+
+1.3.4
+
+   Removed tmmh.c and tmmh.h, which implemented version one of TMMH.
+
+   Changed srtp_get_trailer_length() to act on streams rather than
+   sessions, and documented the macro SRTP_MAX_TRAILER_LEN, which should
+   usually be used rather than that function.
+
+   Removed 'salt' from cipher input. 
+
+   Changed rdbx to use err.h error codes.
+
+   Changed malloc() and free() to xalloc() and xfree; these functions
+   are defined in crypto/kernel/alloc.c and declared in 
+   include/alloc.h.
+
+   Added 'output' functions to cipher, in addition to 'encrypt'
+   functions.  It is no longer necessary to zeroize a buffer before
+   encrypting in order to get keystream.
+
+   Changed octet_string_hex_string() so that "times two" isn't needed
+   in its input.
+
+   Added crypto_kernel_init() prior to command-line parsing, so that
+   kernel can be passed command-line arguments, such as "-d
+   debug_module".  This was done to for the applications
+   test/srtp-driver, test/kernel-driver, and test/ust-driver.
+
+   Improved srtp_init_aes_128_prf - wrote key derivation function
+   (srtp_kdf_t).
+
+   Add the tag_len as an argument to the auth_compute() function, but
+   not the corresponding macro.  This change allows the tag length for
+   a given auth func to be set to different values at initialization
+   time.  Previously, the structure auth_t contained the
+   output_length, but that value was inaccessible from hmac_compute()
+   and other functions.
+
+   Re-named files from a-b.c to a_b.c. in order to help portability.
+
+   Re-named rijndael to aes (or aes_128 as appropriate).
+
+
+1.2.1 
+
+  Changes so that 1.2.0 compiles on cygwin-win2k.
+
+  Added better error reporting system.  If syslog is present on the
+  OS, then it is used.
+
+
+1.2.0 Many improvements and additions, and a fex fixes
+
+   Fixed endian issues in RTP header construction in the function
+   rtp_sendto() in srtp/rtp.c.
+
+   Implemented RIJNDAEL decryption operation, adding the functions
+   rijndael_decrypt() and rijndael_expand_decryption_key().  Also
+   re-named rijndael_expand_key() to rijndael_expand_encryption_key()
+   for consistency.
+
+   Implemented random number source using /dev/random, in the files
+   crypto/rng/rand_source.c and include/rand_source.h.
+
+   Added index check to SEAL cipher (only values less than 2^32 are
+   allowed)
+
+   Added test case for null_auth authentication function.
+
+   Added a timing test which tests the effect of CPU cache thrash on
+   cipher throughput.  The test is done by the function
+   cipher_test_throughput_array(); the function
+   cipher_array_alloc_init() creates an array of ciphers for use in
+   this test.  This test can be accessed by using the -a flag to
+   the application cipher-driver in the test subdirectory.
+ 
+   Added argument processing to ust-driver.c, and added that app to
+   the 'runtest' target in Makefile.in.
+
+   A minor auth_t API change: last argument of auth_init() eliminated.
+
+
+1.0.6 A small but important fix
+
+   Fixed srtp_init_aes_128_prf() by adding octet_string_set_to_zero()
+   after buffer allocation.
+
+   Eliminated references to no-longer-existing variables in debugging
+   code in srtp/srtp.c.  This fixes the compilation failure that
+   occured when using PRINT_DEBUG in that file.
+
+   Corrected spelling of Richard Priestley's name in credits.  Sorry
+   Richard!
+
+
+1.0.5 Many little fixes
+
+   Fixed octet_string_set_to_zero(), which was writing one
+   more zero octet than it should.  This bug caused srtp_protect()
+   and srtp_unprotect() to overwrite the byte that followed the
+   srtp packet.
+
+   Changed sizeof(uint32_t) to srtp_get_trailer_length() in
+   srtp-driver.c.  This is just defensive coding.
+
+   Added NULL check to malloc in srtp_alloc().
+
+
+1.0.4 Many minor fixes and two big ones (thanks for the bug reports!)
+
+   Removed 'ssrc' from the srtp_init_aes_128_prf() function argument
+   list.  This is so that applications which do not a priori know the
+   ssrc which they will be receiving can still use libsrtp.  Now the
+   SSRC value is gleaned from the rtp header and exored into the
+   counter mode offset in the srtp_protect() and srtp_unprotect()
+   functions, if that cipher is used.  This change cascaed through
+   many other functions, including srtp_init_from_hex(),
+   srtp_sender_init() and srtp_receiver_init() in rtp.c, and also
+   changing the CLI to test/rtpw.  In the future, another function
+   call will be added to the library that enables multiple ssrc/key
+   pairs to be installed into the same srtp session, so that libsrtp
+   works with multiple srtp senders.  For now, this functionality is
+   lacking.
+
+   Removed the GDOI interface to the rtpw demo program.  This will be
+   added again at a later date, after the SRTP and GDOI distributions
+   stabilize.  For now, I've left in the GDOI #defines and autoconf
+   definitions so that they'll be in place when needed.
+
+   Updated tmmhv2_compute() so that it didn't assume any particular
+   alginment of the output tag.
+
+   Changed bit field variables in srtp.h to unsigned char from
+   unsigned int in order to avoid a potential endianness issue.
+
+   Fixed rdbx_estimate_index() to handle all input cases.  This solves
+   the now notorious "abaft" bug in the rtpw demo app on linux/intel,
+   in which spurious replay protection failures happen after that word
+   is received.
+
+   Added ntohs(hdr->seq) to srtp_protect and srtp_unprotect, removed
+   from rijndael_icm_set_segment().
+
+   Added error checking and handling to srtp_sender_init() and
+   srtp_receiver_init().
+
+   Changed srtp_alloc() so that it does what you'd expect: allocate an
+   srtp_ctx_t structure.  This hides the library internals.
+
+
+1.0.1   Many minor fixes
+
+   Added cipher_driver_buffer_test(...) to test/cipher-driver.c.  This
+   function checks that the byte-buffering functions used by a cipher
+   are correct.
+
+   Fixed SunOS/Solaris build problems: added HAVE_SYS_INT_TYPES_H and
+   changed index_t to xtd_seq_num_t (see include/rdbx.h).
+
+   Fixed SEAL3.0 output byte buffering, added byte-buffering test to
+   cipher/cipher-driver.c.
+
+   Fixed roc-driver so that the non-sequential insertion test
+   automatically recovers from bad estimates.  This was required to
+   prevent spurious failures.
+
+   Made rdbx_estimate_index(...) function smarter, so that initial RTP
+   sequence numbers greater than 32,768 don't cause it to estimate the
+   rollover counter of 0xffffffff.
+
+
+1.0.0   Initial release
+
diff --git a/jni/pjproject-android/.svn/pristine/69/6984e1f817da0d43aa30f8489f6538c0820ae656.svn-base b/jni/pjproject-android/.svn/pristine/69/6984e1f817da0d43aa30f8489f6538c0820ae656.svn-base
new file mode 100644
index 0000000..a0397c5
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/69/6984e1f817da0d43aa30f8489f6538c0820ae656.svn-base
@@ -0,0 +1,28 @@
+# $Id$
+import inc_sip as sip
+import inc_sdp as sdp
+
+# Multiple m=audio, one of them has dynamic PT codec that we don't support
+sdp = \
+"""
+v=0
+o=- 0 0 IN IP4 127.0.0.1
+s=-
+c=IN IP4 127.0.0.1
+t=0 0
+m=audio 5000 RTP/AVP 100
+a=rtpmap:100 someunknowncodec/8000
+m=audio 4000 RTP/AVP 0
+"""
+
+pjsua_args = "--null-audio --auto-answer 200"
+extra_headers = ""
+include = ["Content-Type: application/sdp",	# response must include SDP
+	   "m=audio 0 RTP/AVP[\s\S]+m=audio [1-9]+[0-9]* RTP/AVP"
+	   ]
+exclude = []
+
+sendto_cfg = sip.SendtoCfg("Multiple audio lines", pjsua_args, sdp, 200,
+			   extra_headers=extra_headers,
+			   resp_inc=include, resp_exc=exclude) 
+
diff --git a/jni/pjproject-android/.svn/pristine/69/698e68916a362ffbf8f2b23f3b4e843fb6696439.svn-base b/jni/pjproject-android/.svn/pristine/69/698e68916a362ffbf8f2b23f3b4e843fb6696439.svn-base
new file mode 100644
index 0000000..c2685bb
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/69/698e68916a362ffbf8f2b23f3b4e843fb6696439.svn-base
@@ -0,0 +1,478 @@
+//------------------------------------------------------------------------------
+// File: RenBase.h
+//
+// Desc: DirectShow base classes - defines a generic ActiveX base renderer
+//       class.
+//
+// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------------------------
+
+
+#ifndef __RENBASE__
+#define __RENBASE__
+
+// Forward class declarations
+
+class CBaseRenderer;
+class CBaseVideoRenderer;
+class CRendererInputPin;
+
+// This is our input pin class that channels calls to the renderer
+
+class CRendererInputPin : public CBaseInputPin
+{
+protected:
+
+    CBaseRenderer *m_pRenderer;
+
+public:
+
+    CRendererInputPin(__inout CBaseRenderer *pRenderer,
+                      __inout HRESULT *phr,
+                      __in_opt LPCWSTR Name);
+
+    // Overriden from the base pin classes
+
+    HRESULT BreakConnect();
+    HRESULT CompleteConnect(IPin *pReceivePin);
+    HRESULT SetMediaType(const CMediaType *pmt);
+    HRESULT CheckMediaType(const CMediaType *pmt);
+    HRESULT Active();
+    HRESULT Inactive();
+
+    // Add rendering behaviour to interface functions
+
+    STDMETHODIMP QueryId(__deref_out LPWSTR *Id);
+    STDMETHODIMP EndOfStream();
+    STDMETHODIMP BeginFlush();
+    STDMETHODIMP EndFlush();
+    STDMETHODIMP Receive(IMediaSample *pMediaSample);
+
+    // Helper
+    IMemAllocator inline *Allocator() const
+    {
+        return m_pAllocator;
+    }
+};
+
+// Main renderer class that handles synchronisation and state changes
+
+class CBaseRenderer : public CBaseFilter
+{
+protected:
+
+    friend class CRendererInputPin;
+
+    friend void CALLBACK EndOfStreamTimer(UINT uID,      // Timer identifier
+                                          UINT uMsg,     // Not currently used
+                                          DWORD_PTR dwUser,  // User information
+                                          DWORD_PTR dw1,     // Windows reserved
+                                          DWORD_PTR dw2);    // Is also reserved
+
+    CRendererPosPassThru *m_pPosition;  // Media seeking pass by object
+    CAMEvent m_RenderEvent;             // Used to signal timer events
+    CAMEvent m_ThreadSignal;            // Signalled to release worker thread
+    CAMEvent m_evComplete;              // Signalled when state complete
+    BOOL m_bAbort;                      // Stop us from rendering more data
+    BOOL m_bStreaming;                  // Are we currently streaming
+    DWORD_PTR m_dwAdvise;                   // Timer advise cookie
+    IMediaSample *m_pMediaSample;       // Current image media sample
+    BOOL m_bEOS;                        // Any more samples in the stream
+    BOOL m_bEOSDelivered;               // Have we delivered an EC_COMPLETE
+    CRendererInputPin *m_pInputPin;     // Our renderer input pin object
+    CCritSec m_InterfaceLock;           // Critical section for interfaces
+    CCritSec m_RendererLock;            // Controls access to internals
+    IQualityControl * m_pQSink;         // QualityControl sink
+    BOOL m_bRepaintStatus;              // Can we signal an EC_REPAINT
+    //  Avoid some deadlocks by tracking filter during stop
+    volatile BOOL  m_bInReceive;        // Inside Receive between PrepareReceive
+                                        // And actually processing the sample
+    REFERENCE_TIME m_SignalTime;        // Time when we signal EC_COMPLETE
+    UINT m_EndOfStreamTimer;            // Used to signal end of stream
+    CCritSec m_ObjectCreationLock;      // This lock protects the creation and
+                                        // of m_pPosition and m_pInputPin.  It
+                                        // ensures that two threads cannot create
+                                        // either object simultaneously.
+
+public:
+
+    CBaseRenderer(REFCLSID RenderClass, // CLSID for this renderer
+                  __in_opt LPCTSTR pName,         // Debug ONLY description
+                  __inout_opt LPUNKNOWN pUnk,       // Aggregated owner object
+                  __inout HRESULT *phr);        // General OLE return code
+
+    ~CBaseRenderer();
+
+    // Overriden to say what interfaces we support and where
+
+    virtual HRESULT GetMediaPositionInterface(REFIID riid, __deref_out void **ppv);
+    STDMETHODIMP NonDelegatingQueryInterface(REFIID, __deref_out void **);
+
+    virtual HRESULT SourceThreadCanWait(BOOL bCanWait);
+
+#ifdef DEBUG
+    // Debug only dump of the renderer state
+    void DisplayRendererState();
+#endif
+    virtual HRESULT WaitForRenderTime();
+    virtual HRESULT CompleteStateChange(FILTER_STATE OldState);
+
+    // Return internal information about this filter
+
+    BOOL IsEndOfStream() { return m_bEOS; };
+    BOOL IsEndOfStreamDelivered() { return m_bEOSDelivered; };
+    BOOL IsStreaming() { return m_bStreaming; };
+    void SetAbortSignal(BOOL bAbort) { m_bAbort = bAbort; };
+    virtual void OnReceiveFirstSample(IMediaSample *pMediaSample) { };
+    CAMEvent *GetRenderEvent() { return &m_RenderEvent; };
+
+    // Permit access to the transition state
+
+    void Ready() { m_evComplete.Set(); };
+    void NotReady() { m_evComplete.Reset(); };
+    BOOL CheckReady() { return m_evComplete.Check(); };
+
+    virtual int GetPinCount();
+    virtual CBasePin *GetPin(int n);
+    FILTER_STATE GetRealState();
+    void SendRepaint();
+    void SendNotifyWindow(IPin *pPin,HWND hwnd);
+    BOOL OnDisplayChange();
+    void SetRepaintStatus(BOOL bRepaint);
+
+    // Override the filter and pin interface functions
+
+    STDMETHODIMP Stop();
+    STDMETHODIMP Pause();
+    STDMETHODIMP Run(REFERENCE_TIME StartTime);
+    STDMETHODIMP GetState(DWORD dwMSecs, __out FILTER_STATE *State);
+    STDMETHODIMP FindPin(LPCWSTR Id, __deref_out IPin **ppPin);
+
+    // These are available for a quality management implementation
+
+    virtual void OnRenderStart(IMediaSample *pMediaSample);
+    virtual void OnRenderEnd(IMediaSample *pMediaSample);
+    virtual HRESULT OnStartStreaming() { return NOERROR; };
+    virtual HRESULT OnStopStreaming() { return NOERROR; };
+    virtual void OnWaitStart() { };
+    virtual void OnWaitEnd() { };
+    virtual void PrepareRender() { };
+
+#ifdef PERF
+    REFERENCE_TIME m_trRenderStart; // Just before we started drawing
+                                    // Set in OnRenderStart, Used in OnRenderEnd
+    int m_idBaseStamp;              // MSR_id for frame time stamp
+    int m_idBaseRenderTime;         // MSR_id for true wait time
+    int m_idBaseAccuracy;           // MSR_id for time frame is late (int)
+#endif
+
+    // Quality management implementation for scheduling rendering
+
+    virtual BOOL ScheduleSample(IMediaSample *pMediaSample);
+    virtual HRESULT GetSampleTimes(IMediaSample *pMediaSample,
+                                   __out REFERENCE_TIME *pStartTime,
+                                   __out REFERENCE_TIME *pEndTime);
+
+    virtual HRESULT ShouldDrawSampleNow(IMediaSample *pMediaSample,
+                                        __out REFERENCE_TIME *ptrStart,
+                                        __out REFERENCE_TIME *ptrEnd);
+
+    // Lots of end of stream complexities
+
+    void TimerCallback();
+    void ResetEndOfStreamTimer();
+    HRESULT NotifyEndOfStream();
+    virtual HRESULT SendEndOfStream();
+    virtual HRESULT ResetEndOfStream();
+    virtual HRESULT EndOfStream();
+
+    // Rendering is based around the clock
+
+    void SignalTimerFired();
+    virtual HRESULT CancelNotification();
+    virtual HRESULT ClearPendingSample();
+
+    // Called when the filter changes state
+
+    virtual HRESULT Active();
+    virtual HRESULT Inactive();
+    virtual HRESULT StartStreaming();
+    virtual HRESULT StopStreaming();
+    virtual HRESULT BeginFlush();
+    virtual HRESULT EndFlush();
+
+    // Deal with connections and type changes
+
+    virtual HRESULT BreakConnect();
+    virtual HRESULT SetMediaType(const CMediaType *pmt);
+    virtual HRESULT CompleteConnect(IPin *pReceivePin);
+
+    // These look after the handling of data samples
+
+    virtual HRESULT PrepareReceive(IMediaSample *pMediaSample);
+    virtual HRESULT Receive(IMediaSample *pMediaSample);
+    virtual BOOL HaveCurrentSample();
+    virtual IMediaSample *GetCurrentSample();
+    virtual HRESULT Render(IMediaSample *pMediaSample);
+
+    // Derived classes MUST override these
+    virtual HRESULT DoRenderSample(IMediaSample *pMediaSample) PURE;
+    virtual HRESULT CheckMediaType(const CMediaType *) PURE;
+
+    // Helper
+    void WaitForReceiveToComplete();
+};
+
+
+// CBaseVideoRenderer is a renderer class (see its ancestor class) and
+// it handles scheduling of media samples so that they are drawn at the
+// correct time by the reference clock.  It implements a degradation
+// strategy.  Possible degradation modes are:
+//    Drop frames here (only useful if the drawing takes significant time)
+//    Signal supplier (upstream) to drop some frame(s) - i.e. one-off skip.
+//    Signal supplier to change the frame rate - i.e. ongoing skipping.
+//    Or any combination of the above.
+// In order to determine what's useful to try we need to know what's going
+// on.  This is done by timing various operations (including the supplier).
+// This timing is done by using timeGetTime as it is accurate enough and
+// usually cheaper than calling the reference clock.  It also tells the
+// truth if there is an audio break and the reference clock stops.
+// We provide a number of public entry points (named OnXxxStart, OnXxxEnd)
+// which the rest of the renderer calls at significant moments.  These do
+// the timing.
+
+// the number of frames that the sliding averages are averaged over.
+// the rule is (1024*NewObservation + (AVGPERIOD-1) * PreviousAverage)/AVGPERIOD
+#define AVGPERIOD 4
+#define DO_MOVING_AVG(avg,obs) (avg = (1024*obs + (AVGPERIOD-1)*avg)/AVGPERIOD)
+// Spot the bug in this macro - I can't. but it doesn't work!
+
+class CBaseVideoRenderer : public CBaseRenderer,    // Base renderer class
+                           public IQualProp,        // Property page guff
+                           public IQualityControl   // Allow throttling
+{
+protected:
+
+    // Hungarian:
+    //     tFoo is the time Foo in mSec (beware m_tStart from filter.h)
+    //     trBar is the time Bar by the reference clock
+
+    //******************************************************************
+    // State variables to control synchronisation
+    //******************************************************************
+
+    // Control of sending Quality messages.  We need to know whether
+    // we are in trouble (e.g. frames being dropped) and where the time
+    // is being spent.
+
+    // When we drop a frame we play the next one early.
+    // The frame after that is likely to wait before drawing and counting this
+    // wait as spare time is unfair, so we count it as a zero wait.
+    // We therefore need to know whether we are playing frames early or not.
+
+    int m_nNormal;                  // The number of consecutive frames
+                                    // drawn at their normal time (not early)
+                                    // -1 means we just dropped a frame.
+
+#ifdef PERF
+    BOOL m_bDrawLateFrames;         // Don't drop any frames (debug and I'm
+                                    // not keen on people using it!)
+#endif
+
+    BOOL m_bSupplierHandlingQuality;// The response to Quality messages says
+                                    // our supplier is handling things.
+                                    // We will allow things to go extra late
+                                    // before dropping frames.  We will play
+                                    // very early after he has dropped one.
+
+    // Control of scheduling, frame dropping etc.
+    // We need to know where the time is being spent so as to tell whether
+    // we should be taking action here, signalling supplier or what.
+    // The variables are initialised to a mode of NOT dropping frames.
+    // They will tell the truth after a few frames.
+    // We typically record a start time for an event, later we get the time
+    // again and subtract to get the elapsed time, and we average this over
+    // a few frames.  The average is used to tell what mode we are in.
+
+    // Although these are reference times (64 bit) they are all DIFFERENCES
+    // between times which are small.  An int will go up to 214 secs before
+    // overflow.  Avoiding 64 bit multiplications and divisions seems
+    // worth while.
+
+
+
+    // Audio-video throttling.  If the user has turned up audio quality
+    // very high (in principle it could be any other stream, not just audio)
+    // then we can receive cries for help via the graph manager.  In this case
+    // we put in a wait for some time after rendering each frame.
+    int m_trThrottle;
+
+    // The time taken to render (i.e. BitBlt) frames controls which component
+    // needs to degrade.  If the blt is expensive, the renderer degrades.
+    // If the blt is cheap it's done anyway and the supplier degrades.
+    int m_trRenderAvg;              // Time frames are taking to blt
+    int m_trRenderLast;             // Time for last frame blt
+    int m_tRenderStart;             // Just before we started drawing (mSec)
+                                    // derived from timeGetTime.
+
+    // When frames are dropped we will play the next frame as early as we can.
+    // If it was a false alarm and the machine is fast we slide gently back to
+    // normal timing.  To do this, we record the offset showing just how early
+    // we really are.  This will normally be negative meaning early or zero.
+    int m_trEarliness;
+
+    // Target provides slow long-term feedback to try to reduce the
+    // average sync offset to zero.  Whenever a frame is actually rendered
+    // early we add a msec or two, whenever late we take off a few.
+    // We add or take off 1/32 of the error time.
+    // Eventually we should be hovering around zero.  For a really bad case
+    // where we were (say) 300mSec off, it might take 100 odd frames to
+    // settle down.  The rate of change of this is intended to be slower
+    // than any other mechanism in Quartz, thereby avoiding hunting.
+    int m_trTarget;
+
+    // The proportion of time spent waiting for the right moment to blt
+    // controls whether we bother to drop a frame or whether we reckon that
+    // we're doing well enough that we can stand a one-frame glitch.
+    int m_trWaitAvg;                // Average of last few wait times
+                                    // (actually we just average how early
+                                    // we were).  Negative here means LATE.
+
+    // The average inter-frame time.
+    // This is used to calculate the proportion of the time used by the
+    // three operations (supplying us, waiting, rendering)
+    int m_trFrameAvg;               // Average inter-frame time
+    int m_trDuration;               // duration of last frame.
+
+#ifdef PERF
+    // Performance logging identifiers
+    int m_idTimeStamp;              // MSR_id for frame time stamp
+    int m_idEarliness;              // MSR_id for earliness fudge
+    int m_idTarget;                 // MSR_id for Target fudge
+    int m_idWaitReal;               // MSR_id for true wait time
+    int m_idWait;                   // MSR_id for wait time recorded
+    int m_idFrameAccuracy;          // MSR_id for time frame is late (int)
+    int m_idRenderAvg;              // MSR_id for Render time recorded (int)
+    int m_idSchLateTime;            // MSR_id for lateness at scheduler
+    int m_idQualityRate;            // MSR_id for Quality rate requested
+    int m_idQualityTime;            // MSR_id for Quality time requested
+    int m_idDecision;               // MSR_id for decision code
+    int m_idDuration;               // MSR_id for duration of a frame
+    int m_idThrottle;               // MSR_id for audio-video throttling
+    //int m_idDebug;                  // MSR_id for trace style debugging
+    //int m_idSendQuality;          // MSR_id for timing the notifications per se
+#endif // PERF
+    REFERENCE_TIME m_trRememberStampForPerf;  // original time stamp of frame
+                                              // with no earliness fudges etc.
+#ifdef PERF
+    REFERENCE_TIME m_trRememberFrameForPerf;  // time when previous frame rendered
+
+    // debug...
+    int m_idFrameAvg;
+    int m_idWaitAvg;
+#endif
+
+    // PROPERTY PAGE
+    // This has edit fields that show the user what's happening
+    // These member variables hold these counts.
+
+    int m_cFramesDropped;           // cumulative frames dropped IN THE RENDERER
+    int m_cFramesDrawn;             // Frames since streaming started seen BY THE
+                                    // RENDERER (some may be dropped upstream)
+
+    // Next two support average sync offset and standard deviation of sync offset.
+    LONGLONG m_iTotAcc;                  // Sum of accuracies in mSec
+    LONGLONG m_iSumSqAcc;           // Sum of squares of (accuracies in mSec)
+
+    // Next two allow jitter calculation.  Jitter is std deviation of frame time.
+    REFERENCE_TIME m_trLastDraw;    // Time of prev frame (for inter-frame times)
+    LONGLONG m_iSumSqFrameTime;     // Sum of squares of (inter-frame time in mSec)
+    LONGLONG m_iSumFrameTime;            // Sum of inter-frame times in mSec
+
+    // To get performance statistics on frame rate, jitter etc, we need
+    // to record the lateness and inter-frame time.  What we actually need are the
+    // data above (sum, sum of squares and number of entries for each) but the data
+    // is generated just ahead of time and only later do we discover whether the
+    // frame was actually drawn or not.  So we have to hang on to the data
+    int m_trLate;                   // hold onto frame lateness
+    int m_trFrame;                  // hold onto inter-frame time
+
+    int m_tStreamingStart;          // if streaming then time streaming started
+                                    // else time of last streaming session
+                                    // used for property page statistics
+#ifdef PERF
+    LONGLONG m_llTimeOffset;        // timeGetTime()*10000+m_llTimeOffset==ref time
+#endif
+
+public:
+
+
+    CBaseVideoRenderer(REFCLSID RenderClass, // CLSID for this renderer
+                       __in_opt LPCTSTR pName,         // Debug ONLY description
+                       __inout_opt LPUNKNOWN pUnk,       // Aggregated owner object
+                       __inout HRESULT *phr);        // General OLE return code
+
+    ~CBaseVideoRenderer();
+
+    // IQualityControl methods - Notify allows audio-video throttling
+
+    STDMETHODIMP SetSink( IQualityControl * piqc);
+    STDMETHODIMP Notify( IBaseFilter * pSelf, Quality q);
+
+    // These provide a full video quality management implementation
+
+    void OnRenderStart(IMediaSample *pMediaSample);
+    void OnRenderEnd(IMediaSample *pMediaSample);
+    void OnWaitStart();
+    void OnWaitEnd();
+    HRESULT OnStartStreaming();
+    HRESULT OnStopStreaming();
+    void ThrottleWait();
+
+    // Handle the statistics gathering for our quality management
+
+    void PreparePerformanceData(int trLate, int trFrame);
+    virtual void RecordFrameLateness(int trLate, int trFrame);
+    virtual void OnDirectRender(IMediaSample *pMediaSample);
+    virtual HRESULT ResetStreamingTimes();
+    BOOL ScheduleSample(IMediaSample *pMediaSample);
+    HRESULT ShouldDrawSampleNow(IMediaSample *pMediaSample,
+                                __inout REFERENCE_TIME *ptrStart,
+                                __inout REFERENCE_TIME *ptrEnd);
+
+    virtual HRESULT SendQuality(REFERENCE_TIME trLate, REFERENCE_TIME trRealStream);
+    STDMETHODIMP JoinFilterGraph(__inout_opt IFilterGraph * pGraph, __in_opt LPCWSTR pName);
+
+    //
+    //  Do estimates for standard deviations for per-frame
+    //  statistics
+    //
+    //  *piResult = (llSumSq - iTot * iTot / m_cFramesDrawn - 1) /
+    //                            (m_cFramesDrawn - 2)
+    //  or 0 if m_cFramesDrawn <= 3
+    //
+    HRESULT GetStdDev(
+        int nSamples,
+        __out int *piResult,
+        LONGLONG llSumSq,
+        LONGLONG iTot
+    );
+public:
+
+    // IQualProp property page support
+
+    STDMETHODIMP get_FramesDroppedInRenderer(__out int *cFramesDropped);
+    STDMETHODIMP get_FramesDrawn(__out int *pcFramesDrawn);
+    STDMETHODIMP get_AvgFrameRate(__out int *piAvgFrameRate);
+    STDMETHODIMP get_Jitter(__out int *piJitter);
+    STDMETHODIMP get_AvgSyncOffset(__out int *piAvg);
+    STDMETHODIMP get_DevSyncOffset(__out int *piDev);
+
+    // Implement an IUnknown interface and expose IQualProp
+
+    DECLARE_IUNKNOWN
+    STDMETHODIMP NonDelegatingQueryInterface(REFIID riid,__deref_out VOID **ppv);
+};
+
+#endif // __RENBASE__
+
diff --git a/jni/pjproject-android/.svn/pristine/69/69a788a132e0fc16210836a59f56bc2551deac2f.svn-base b/jni/pjproject-android/.svn/pristine/69/69a788a132e0fc16210836a59f56bc2551deac2f.svn-base
new file mode 100644
index 0000000..4e126a7
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/69/69a788a132e0fc16210836a59f56bc2551deac2f.svn-base
@@ -0,0 +1,46 @@
+/* $Id$ */
+/* 
+ * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
+ * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
+ */
+
+/*
+ * THIS FILE IS INCLUDED BY scanner.c.
+ * DO NOT COMPILE THIS FILE ALONE!
+ */
+
+
+PJ_DEF(void) pj_cis_buf_init( pj_cis_buf_t *cis_buf)
+{
+    /* Do nothing. */
+    PJ_UNUSED_ARG(cis_buf);
+}
+
+PJ_DEF(pj_status_t) pj_cis_init(pj_cis_buf_t *cis_buf, pj_cis_t *cis)
+{
+    PJ_UNUSED_ARG(cis_buf);
+    pj_bzero(cis->cis_buf, sizeof(cis->cis_buf));
+    return PJ_SUCCESS;
+}
+
+PJ_DEF(pj_status_t) pj_cis_dup( pj_cis_t *new_cis, pj_cis_t *existing)
+{
+    pj_memcpy(new_cis, existing, sizeof(pj_cis_t));
+    return PJ_SUCCESS;
+}
+
+