flightgear/3rdparty/iaxclient-2/lib/iaxclient_lib.c

/*
 * iaxclient: a cross-platform IAX softphone library
 *
 * Copyrights:
 * Copyright (C) 2003-2006, Horizon Wimba, Inc.
 * Copyright (C) 2007, Wimba, Inc.
 *
 * Contributors:
 * Steve Kann <stevek@stevek.com>
 * Michael Van Donselaar <mvand@vandonselaar.org>
 * Shawn Lawrence <shawn.lawrence@terracecomm.com>
 * Frik Strecker <frik@gatherworks.com>
 * Mihai Balea <mihai AT hates DOT ms>
 * Peter Grayson <jpgrayson@gmail.com>
 * Bill Cholewka <bcholew@gmail.com>
 * Erik Bunce <kde@bunce.us>
 *
 * This program is free software, distributed under the terms of
 * the GNU Lesser (Library) General Public License.
 */

#include <assert.h>

#if defined(WIN32) || defined(_WIN32_WCE)
#include <stdlib.h>
#endif

/* Win32 has _vsnprintf instead of vsnprintf */
#if ! HAVE_VSNPRINTF
# if HAVE__VSNPRINTF
#  define vsnprintf _vsnprintf
# endif
#endif

#include "iaxclient_lib.h"
#include "audio_portaudio.h"
#include "audio_encode.h"
#ifdef USE_VIDEO
#include "video.h"
#endif
#include "iax-client.h"
#include "jitterbuf.h"

#include <stdarg.h>

#ifdef AUDIO_ALSA
#include "audio_alsa.h"
#endif

#define IAXC_ERROR  IAXC_TEXT_TYPE_ERROR
#define IAXC_STATUS IAXC_TEXT_TYPE_STATUS
#define IAXC_NOTICE IAXC_TEXT_TYPE_NOTICE

#define DEFAULT_CALLERID_NAME    "Not Available"
#define DEFAULT_CALLERID_NUMBER  "7005551212"

#undef JB_DEBUGGING

/* global test mode flag */
int test_mode = 0;

/* configurable jitterbuffer options */
static long jb_target_extra = -1;

struct iaxc_registration
{
	struct iax_session *session;
	struct timeval last;
	char host[256];
	char user[256];
	char pass[256];
	long refresh;
	int id;
	struct iaxc_registration *next;
};

static int next_registration_id = 0;
static struct iaxc_registration *registrations = NULL;

static struct iaxc_audio_driver audio_driver;

static int audio_format_capability;
static int audio_format_preferred;

// Audio callback behavior
// By default apps should let iaxclient handle audio
static unsigned int audio_prefs = 0;

void * post_event_handle = NULL;
int post_event_id = 0;

static int minimum_outgoing_framesize = 160; /* 20ms */

static MUTEX iaxc_lock;
static MUTEX event_queue_lock;

static int iaxci_bound_port = -1;

// default to use port 4569 unless set by iaxc_set_preferred_source_udp_port
static int source_udp_port = IAX_DEFAULT_PORTNO;

int iaxci_audio_output_mode = 0; // Normal

int selected_call; // XXX to be protected by mutex?
struct iaxc_call* calls;
int max_calls; // number of calls for this library session
static int radioNo = -1;

static void service_network();
static int service_audio();

/* external global networking replacements */
static iaxc_sendto_t iaxc_sendto = (iaxc_sendto_t)sendto;
static iaxc_recvfrom_t iaxc_recvfrom = (iaxc_recvfrom_t)recvfrom;


static THREAD main_proc_thread;
#if defined(WIN32) || defined(_WIN32_WCE)
static THREADID main_proc_thread_id;
#endif

/* 0 running, 1 should quit, -1 not running */
static int main_proc_thread_flag = -1;

static iaxc_event_callback_t iaxc_event_callback = NULL;

// Internal queue of events, waiting to be posted once the library
// lock is released.
static iaxc_event *event_queue = NULL;

// Lock the library
static void get_iaxc_lock()
{
	MUTEXLOCK(&iaxc_lock);
}

int try_iaxc_lock()
{
	return MUTEXTRYLOCK(&iaxc_lock);
}

// Unlock the library and post any events that were queued in the meantime
void put_iaxc_lock()
{
	iaxc_event *prev, *event;

	MUTEXLOCK(&event_queue_lock);
	event = event_queue;
	event_queue = NULL;
	MUTEXUNLOCK(&event_queue_lock);

	MUTEXUNLOCK(&iaxc_lock);

	while (event)
	{
		iaxci_post_event(*event);
		prev = event;
		event = event->next;
		free(prev);
	}
}

EXPORT void iaxc_set_audio_output(int mode)
{
	iaxci_audio_output_mode = mode;
}

long iaxci_usecdiff(struct timeval * t0, struct timeval * t1)
{
	return (t0->tv_sec - t1->tv_sec) * 1000000L + t0->tv_usec - t1->tv_usec;
}

long iaxci_msecdiff(struct timeval * t0, struct timeval * t1)
{
	return iaxci_usecdiff(t0, t1) / 1000L;
}

EXPORT void iaxc_set_event_callback(iaxc_event_callback_t func)
{
	iaxc_event_callback = func;
}

EXPORT int iaxc_set_event_callpost(void *handle, int id)
{
	post_event_handle = handle;
	post_event_id = id;
	iaxc_event_callback = iaxci_post_event_callback;
	return 0;
}

EXPORT void iaxc_free_event(iaxc_event *e)
{
	free(e);
}

EXPORT struct iaxc_ev_levels *iaxc_get_event_levels(iaxc_event *e)
{
	return &e->ev.levels;
}

EXPORT struct iaxc_ev_text *iaxc_get_event_text(iaxc_event *e)
{
	return &e->ev.text;
}

EXPORT struct iaxc_ev_call_state *iaxc_get_event_state(iaxc_event *e)
{
	return &e->ev.call;
}

// Messaging functions
static void default_message_callback(const char * message)
{
	//fprintf(stderr, "IAXCLIENT: %s\n", message);
}

// Post Events back to clients
void iaxci_post_event(iaxc_event e)
{
	if ( e.type == 0 )
	{
		iaxci_usermsg(IAXC_ERROR,
			"Error: something posted to us an invalid event");
		return;
	}

    e.radioNo = radioNo;

	if ( MUTEXTRYLOCK(&iaxc_lock) )
	{
		iaxc_event **tail;

		/* We could not obtain the lock. Queue the event. */
		MUTEXLOCK(&event_queue_lock);
		tail = &event_queue;
		e.next = NULL;
		while ( *tail )
			tail = &(*tail)->next;
		*tail = (iaxc_event *)malloc(sizeof(iaxc_event));
		memcpy(*tail, &e, sizeof(iaxc_event));
		MUTEXUNLOCK(&event_queue_lock);
		return;
	}

	/* TODO: This is not the best. Since we were able to get the
	 * lock, we decide that it is okay to go ahead and do the
	 * callback to the application. This is really nasty because
	 * it gives the appearance of serialized callbacks, but in
	 * reality, we could callback an application multiple times
	 * simultaneously. So, as things stand, an application must
	 * do some locking in their callback function to make it
	 * reentrant. Barf. More ideally, iaxclient would guarantee
	 * serialized callbacks to the application.
	 */
	MUTEXUNLOCK(&iaxc_lock);

	if ( iaxc_event_callback )
	{
		int rv;

		rv = iaxc_event_callback(e);

		if ( e.type == IAXC_EVENT_VIDEO )
		{
			/* We can free the frame data once it is off the
			 * event queue and has been processed by the client.
			 */
			free(e.ev.video.data);
		}
		else if ( e.type == IAXC_EVENT_AUDIO )
		{
			free(e.ev.audio.data);
		}

		if ( rv < 0 )
			default_message_callback(
				"IAXCLIENT: BIG PROBLEM, event callback returned failure!");
		// > 0 means processed
		if ( rv > 0 )
			return;

		// else, fall through to "defaults"
	}

	switch ( e.type )
	{
		case IAXC_EVENT_TEXT:
			default_message_callback(e.ev.text.message);
			// others we just ignore too
			return;
	}
}


void iaxci_usermsg(int type, const char *fmt, ...)
{
	va_list args;
	iaxc_event e;

	e.type = IAXC_EVENT_TEXT;
	e.ev.text.type = type;
	e.ev.text.callNo = -1;
	va_start(args, fmt);
	vsnprintf(e.ev.text.message, IAXC_EVENT_BUFSIZ, fmt, args);
	va_end(args);

	iaxci_post_event(e);
}


void iaxci_do_levels_callback(float input, float output)
{
	iaxc_event e;
	e.type = IAXC_EVENT_LEVELS;
	e.ev.levels.input = input;
	e.ev.levels.output = output;
	iaxci_post_event(e);
}

void iaxci_do_state_callback(int callNo)
{
	iaxc_event e;
	if ( callNo < 0 || callNo >= max_calls )
		return;
	e.type = IAXC_EVENT_STATE;
	e.ev.call.callNo = callNo;
	e.ev.call.state = calls[callNo].state;
	e.ev.call.format = calls[callNo].format;
	e.ev.call.vformat = calls[callNo].vformat;
	strncpy(e.ev.call.remote,        calls[callNo].remote,        IAXC_EVENT_BUFSIZ);
	strncpy(e.ev.call.remote_name,   calls[callNo].remote_name,   IAXC_EVENT_BUFSIZ);
	strncpy(e.ev.call.local,         calls[callNo].local,         IAXC_EVENT_BUFSIZ);
	strncpy(e.ev.call.local_context, calls[callNo].local_context, IAXC_EVENT_BUFSIZ);
	iaxci_post_event(e);
}

void iaxci_do_registration_callback(int id, int reply, int msgcount)
{
	iaxc_event e;
	e.type = IAXC_EVENT_REGISTRATION;
	e.ev.reg.id = id;
	e.ev.reg.reply = reply;
	e.ev.reg.msgcount = msgcount;
	iaxci_post_event(e);
}

void iaxci_do_audio_callback(int callNo, unsigned int ts, int source,
		int encoded, int format, int size, unsigned char *data)
{
	iaxc_event e;

	e.type = IAXC_EVENT_AUDIO;
	e.ev.audio.ts = ts;
	e.ev.audio.encoded = encoded;
	assert(source == IAXC_SOURCE_REMOTE || source == IAXC_SOURCE_LOCAL);
	e.ev.audio.source = source;
	e.ev.audio.size = size;
	e.ev.audio.callNo = callNo;
	e.ev.audio.format = format;

	e.ev.audio.data = (unsigned char *)malloc(size);

	if ( !e.ev.audio.data )
	{
		iaxci_usermsg(IAXC_ERROR,
				"failed to allocate memory for audio event");
		return;
	}

	memcpy(e.ev.audio.data, data, size);

	iaxci_post_event(e);
}

void iaxci_do_dtmf_callback(int callNo, char digit)
{
	iaxc_event e;
	e.type = IAXC_EVENT_DTMF;
	e.ev.dtmf.callNo = callNo;
	e.ev.dtmf.digit  = digit;
	iaxci_post_event(e);
}

static int iaxc_remove_registration_by_id(int id)
{
	struct iaxc_registration *curr, *prev;
	int count = 0;
	for ( prev = NULL, curr = registrations; curr != NULL;
			prev = curr, curr = curr->next )
	{
		if ( curr->id == id )
		{
			count++;
			if ( curr->session != NULL )
				iax_destroy( curr->session );
			if ( prev != NULL )
				prev->next = curr->next;
			else
				registrations = curr->next;
			free( curr );
			break;
		}
	}
	return count;
}

EXPORT int iaxc_first_free_call()
{
	int i;
	for ( i = 0; i < max_calls; i++ )
		if ( calls[i].state == IAXC_CALL_STATE_FREE )
			return i;

	return -1;
}


static void iaxc_clear_call(int toDump)
{
	// XXX libiax should handle cleanup, I think..
	calls[toDump].state = IAXC_CALL_STATE_FREE;
	calls[toDump].format = 0;
	calls[toDump].vformat = 0;
	calls[toDump].session = NULL;
	iaxci_do_state_callback(toDump);
}

/* select a call.  */
/* XXX Locking??  Start/stop audio?? */
EXPORT int iaxc_select_call(int callNo)
{
	// continue if already selected?
	//if ( callNo == selected_call ) return;

	if ( callNo >= max_calls )
	{
		iaxci_usermsg(IAXC_ERROR, "Error: tried to select out_of_range call %d", callNo);
		return -1;
	}

	// callNo < 0 means no call selected (i.e. all on hold)
	if ( callNo < 0 )
	{
		if ( selected_call >= 0 )
		{
			calls[selected_call].state &= ~IAXC_CALL_STATE_SELECTED;
		}
		selected_call = callNo;
		return 0;
	}

	// de-select and notify the old call if not also the new call
	if ( callNo != selected_call )
	{
		if ( selected_call >= 0 )
		{
			calls[selected_call].state &= ~IAXC_CALL_STATE_SELECTED;
			iaxci_do_state_callback(selected_call);
		}
		selected_call = callNo;
		calls[selected_call].state |= IAXC_CALL_STATE_SELECTED;
	}

	// if it's an incoming call, and ringing, answer it.
	if ( !(calls[selected_call].state & IAXC_CALL_STATE_OUTGOING) &&
	      (calls[selected_call].state & IAXC_CALL_STATE_RINGING) )
	{
		iaxc_answer_call(selected_call);
	} else
	{
		// otherwise just update state (answer does this for us)
		iaxci_do_state_callback(selected_call);
	}

	return 0;
}

/* external API accessor */
EXPORT int iaxc_selected_call()
{
	return selected_call;
}

EXPORT void iaxc_set_networking(iaxc_sendto_t st, iaxc_recvfrom_t rf)
{
	iaxc_sendto = st;
	iaxc_recvfrom = rf;
}

EXPORT void iaxc_set_jb_target_extra( long value )
{
	/* store in jb_target_extra, a static global */
	jb_target_extra = value;
}

static void jb_errf(const char *fmt, ...)
{
	va_list args;
	char buf[1024];

	va_start(args, fmt);
	vsnprintf(buf, 1024, fmt, args);
	va_end(args);

	iaxci_usermsg(IAXC_ERROR, buf);
}

static void jb_warnf(const char *fmt, ...)
{
	va_list args;
	char buf[1024];

	va_start(args, fmt);
	vsnprintf(buf, 1024, fmt, args);
	va_end(args);

	iaxci_usermsg(IAXC_NOTICE, buf);
}

#ifdef JB_DEBUGGING
static void jb_dbgf(const char *fmt, ...)
{
	va_list args;

	va_start(args, fmt);
	vfprintf(stderr, fmt, args);
	va_end(args);
}
#endif

static void setup_jb_output()
{
#ifdef JB_DEBUGGING
	jb_setoutput(jb_errf, jb_warnf, jb_dbgf);
#else
	jb_setoutput(jb_errf, jb_warnf, NULL);
#endif
}

// Note: Must be called before iaxc_initialize()
EXPORT void iaxc_set_preferred_source_udp_port(int port)
{
	source_udp_port = port;
}

/* For "slow" systems. See iax.c code */
EXPORT int iaxc_video_bypass_jitter(int mode)
{
	/* TODO:
	 * 1. When switching from jitter to no-jitter the buffer must be
	 *    flushed of queued video packet and must be sent a key-frame
	 *    to redraw the screen (partially done).
	 * 2. When switching from no-jitter to jitter we must drop all
	 *    enqueued events prior the mode change (must be touched
	 *    iax_sched_del and iax_get_event).
	 */
	return iax_video_bypass_jitter(calls[selected_call].session,mode);
}

EXPORT int iaxc_get_bind_port()
{
	return iaxci_bound_port;
}

EXPORT int iaxc_initialize(int num_calls)
{
    printf("ESTOY IAXC 0\n");
	int i;
	int port;

	os_init();

	setup_jb_output();

	MUTEXINIT(&iaxc_lock);
	MUTEXINIT(&event_queue_lock);

	iaxc_set_audio_prefs(0);

	if ( iaxc_recvfrom != (iaxc_recvfrom_t)recvfrom )
		iax_set_networking(iaxc_sendto, iaxc_recvfrom);

	/* Note that iax_init() only sets up the receive port when the
	 * sendto/recvfrom functions have not been replaced. We need
	 * to call iaxc_init in either case because there is other
	 * initialization beyond the socket setup that needs to be done.
	 */
	if ( (port = iax_init(source_udp_port)) < 0 )
	{
		iaxci_usermsg(IAXC_ERROR,
				"Fatal error: failed to initialize iax with port %d",
				port);
		return -1;
	}

	if ( iaxc_recvfrom == (iaxc_recvfrom_t)recvfrom )
		iaxci_bound_port = port;
	else
		iaxci_bound_port = -1;

	/* tweak the jitterbuffer settings */
	iax_set_jb_target_extra( jb_target_extra );

	max_calls = num_calls;
	/* initialize calls */
	if ( max_calls <= 0 )
		max_calls = 1; /* 0 == Default? */

	/* calloc zeroes for us */
	calls = (struct iaxc_call *)calloc(sizeof(struct iaxc_call), max_calls);
	if ( !calls )
	{
		iaxci_usermsg(IAXC_ERROR, "Fatal error: can't allocate memory");
		return -1;
	}

	selected_call = -1;

	for ( i = 0; i < max_calls; i++ )
	{
		strncpy(calls[i].callerid_name,   DEFAULT_CALLERID_NAME,   IAXC_EVENT_BUFSIZ);
		strncpy(calls[i].callerid_number, DEFAULT_CALLERID_NUMBER, IAXC_EVENT_BUFSIZ);
	}
    printf("ESTOY IAXC\n");

    if ( alsa_initialize(&audio_driver, 8000) )
    {
        iaxci_usermsg(IAXC_ERROR, "failed alsa_initialize");
        return -1;
    }
#ifdef USE_VIDEO
	if ( video_initialize() )
		iaxci_usermsg(IAXC_ERROR,
				"iaxc_initialize: cannot initialize video!\n");
#endif

	/* Default audio format capabilities */
	audio_format_capability =
	    IAXC_FORMAT_ULAW |
	    IAXC_FORMAT_ALAW |
#ifdef CODEC_GSM
	    IAXC_FORMAT_GSM |
#endif
	    IAXC_FORMAT_SPEEX;
	audio_format_preferred = IAXC_FORMAT_SPEEX;

	return 0;
}

EXPORT void iaxc_shutdown()
{
	iaxc_dump_all_calls();

	get_iaxc_lock();

	if ( !test_mode )
	{
		audio_driver.destroy(&audio_driver);
#ifdef USE_VIDEO
		video_destroy();
#endif
	}

	/* destroy enocders and decoders for all existing calls */
	if ( calls )
	{
                int i;
		for ( i=0 ; i<max_calls ; i++ )
		{
			if ( calls[i].encoder )
				calls[i].encoder->destroy(calls[i].encoder);
			if ( calls[i].decoder )
				calls[i].decoder->destroy(calls[i].decoder);
			if ( calls[i].vencoder )
				calls[i].vencoder->destroy(calls[i].vencoder);
			if ( calls[i].vdecoder )
				calls[i].vdecoder->destroy(calls[i].vdecoder);
                }
		free(calls);
		calls = NULL;
	}
	put_iaxc_lock();
#ifdef WIN32
	//closesocket(iax_get_fd()); //fd:
#endif

	free(calls);

	MUTEXDESTROY(&event_queue_lock);
	MUTEXDESTROY(&iaxc_lock);
}


EXPORT void iaxc_set_formats(int preferred, int allowed)
{
	audio_format_capability = allowed;
	audio_format_preferred = preferred;
}

EXPORT void iaxc_set_min_outgoing_framesize(int samples)
{
	minimum_outgoing_framesize = samples;
}

EXPORT void iaxc_set_callerid(const char * name, const char * number)
{
	int i;

	for ( i = 0; i < max_calls; i++ )
	{
		strncpy(calls[i].callerid_name,   name,   IAXC_EVENT_BUFSIZ);
		strncpy(calls[i].callerid_number, number, IAXC_EVENT_BUFSIZ);
	}
}

static void iaxc_note_activity(int callNo)
{
	if ( callNo < 0 )
		return;
	calls[callNo].last_activity = iax_tvnow();
}

static void iaxc_refresh_registrations()
{
	struct iaxc_registration *cur;
	struct timeval now;

	now = iax_tvnow();

	for ( cur = registrations; cur != NULL; cur = cur->next )
	{
		// If there is less than three seconds before the registration is about
		// to expire, renew it.
		if ( iaxci_usecdiff(&now, &cur->last) > (cur->refresh - 3) * 1000 *1000 )
		{
			if ( cur->session != NULL )
			{
				iax_destroy( cur->session );
			}
			cur->session = iax_session_new();
			if ( !cur->session )
			{
				iaxci_usermsg(IAXC_ERROR, "Can't make new registration session");
				return;
			}
			iax_register(cur->session, cur->host, cur->user, cur->pass, cur->refresh);
			cur->last = now;
		}
	}
}

#define LOOP_SLEEP 5 // In ms
static THREADFUNCDECL(main_proc_thread_func)
{
	static int refresh_registration_count = 0;

	THREADFUNCRET(ret);

	/* Increase Priority */
	iaxci_prioboostbegin();

	while ( !main_proc_thread_flag )
	{
		get_iaxc_lock();

		service_network();
		if ( !test_mode )
			service_audio();

		// Check registration refresh once a second
		if ( refresh_registration_count++ > 1000/LOOP_SLEEP )
		{
			iaxc_refresh_registrations();
			refresh_registration_count = 0;
		}

		put_iaxc_lock();

		iaxc_millisleep(LOOP_SLEEP);
	}

	/* Decrease priority */
	iaxci_prioboostend();

	main_proc_thread_flag = -1;

	return ret;
}

EXPORT int iaxc_start_processing_thread()
{
	main_proc_thread_flag = 0;

	if ( THREADCREATE(main_proc_thread_func, NULL, main_proc_thread,
				main_proc_thread_id) == THREADCREATE_ERROR)
		return -1;

	return 0;
}

EXPORT int iaxc_stop_processing_thread()
{
	if ( main_proc_thread_flag >= 0 )
	{
		main_proc_thread_flag = 1;
		THREADJOIN(main_proc_thread);
	}

	return 0;
}

static int service_audio()
{
	/* TODO: maybe we shouldn't allocate 8kB on the stack here. */
	short buf [4096];

	int want_send_audio =
		selected_call >= 0 &&
		((calls[selected_call].state & IAXC_CALL_STATE_OUTGOING) ||
		 (calls[selected_call].state & IAXC_CALL_STATE_COMPLETE))
		&& !(audio_prefs & IAXC_AUDIO_PREF_SEND_DISABLE);

	int want_local_audio =
		(audio_prefs & IAXC_AUDIO_PREF_RECV_LOCAL_RAW) ||
		(audio_prefs & IAXC_AUDIO_PREF_RECV_LOCAL_ENCODED);

	if ( want_local_audio || want_send_audio )
	{
		for ( ;; )
		{
			int to_read;
			int cmin;

			audio_driver.start(&audio_driver);

			/* use codec minimum if higher */
			cmin = want_send_audio && calls[selected_call].encoder ?
				calls[selected_call].encoder->minimum_frame_size :
				1;

			to_read = cmin > minimum_outgoing_framesize ?
				cmin : minimum_outgoing_framesize;

			/* Round up to the next multiple */
			if ( to_read % cmin )
				to_read += cmin - (to_read % cmin);

			if ( to_read > (int)(sizeof(buf) / sizeof(short)) )
			{
				fprintf(stderr,
					"internal error: to_read > sizeof(buf)\n");
				exit(1);
			}

			/* Currently pa gives us either all the bits we ask for or none */
			if ( audio_driver.input(&audio_driver, buf, &to_read) )
			{
				iaxci_usermsg(IAXC_ERROR, "ERROR reading audio\n");
				break;
			}

			/* Frame was not available */
			if ( !to_read )
				break;

			if ( audio_prefs & IAXC_AUDIO_PREF_RECV_LOCAL_RAW )
				iaxci_do_audio_callback(selected_call, 0,
						IAXC_SOURCE_LOCAL, 0, 0,
						to_read * 2, (unsigned char *)buf);

			if ( want_send_audio )
				audio_send_encoded_audio(&calls[selected_call],
						selected_call, buf,
						calls[selected_call].format &
							IAXC_AUDIO_FORMAT_MASK,
						to_read);
		}
	}
	else
	{
		static int i = 0;

		audio_driver.stop(&audio_driver);

		/*!
			\deprecated
			Q: Why do we continuously send IAXC_EVENT_LEVELS events
		   when there is no selected call?

		 A: So that certain users of iaxclient do not have to
		   reset their vu meters when a call ends -- they can just
		   count on getting level callbacks. This is a bit of a hack
		   so any applications relying on this behavior should maybe
		   be changed.
		 */
		if ( i++ % 50 == 0 )
			iaxci_do_levels_callback(AUDIO_ENCODE_SILENCE_DB,
					AUDIO_ENCODE_SILENCE_DB);
	}

	return 0;
}

/* handle IAX text events */
static void handle_text_event(struct iax_event *e, int callNo)
{
	iaxc_event ev;
	int        len;

	if ( callNo < 0 )
		return;

	memset(&ev, 0, sizeof(iaxc_event));
	ev.type = IAXC_EVENT_TEXT;
	ev.ev.text.type = IAXC_TEXT_TYPE_IAX;
	ev.ev.text.callNo = callNo;

	len = e->datalen <= IAXC_EVENT_BUFSIZ - 1 ? e->datalen : IAXC_EVENT_BUFSIZ - 1;
	strncpy(ev.ev.text.message, (char *) e->data, len);
	iaxci_post_event(ev);
}

/* handle IAX URL events */
void handle_url_event( struct iax_event *e, int callNo )
{
	iaxc_event ev;

	if ( callNo < 0 )
		return;

	ev.ev.url.callNo = callNo;
	ev.type = IAXC_EVENT_URL;
	strcpy( ev.ev.url.url, "" );

	switch ( e->subclass )
	{
		case AST_HTML_URL:
			ev.ev.url.type = IAXC_URL_URL;
			if ( e->datalen )
			{
				if ( e->datalen > IAXC_EVENT_BUFSIZ )
				{
					fprintf( stderr, "ERROR: URL too long %d > %d\n",
							e->datalen, IAXC_EVENT_BUFSIZ );
				} else
				{
					strncpy( ev.ev.url.url, (char *) e->data, e->datalen );
				}
			}
			/* fprintf( stderr, "URL:%s\n", ev.ev.url.url ); */
			break;
		case AST_HTML_LINKURL:
			ev.ev.url.type = IAXC_URL_LINKURL;
			/* fprintf( stderr, "LINKURL event\n" ); */
			break;
		case AST_HTML_LDCOMPLETE:
			ev.ev.url.type = IAXC_URL_LDCOMPLETE;
			/* fprintf( stderr, "LDCOMPLETE event\n" ); */
			break;
		case AST_HTML_UNLINK:
			ev.ev.url.type = IAXC_URL_UNLINK;
			/* fprintf( stderr, "UNLINK event\n" ); */
			break;
		case AST_HTML_LINKREJECT:
			ev.ev.url.type = IAXC_URL_LINKREJECT;
			/* fprintf( stderr, "LINKREJECT event\n" ); */
			break;
		default:
			fprintf( stderr, "Unknown URL event %d\n", e->subclass );
			break;
	}
	iaxci_post_event( ev );
}

/* DANGER: bad things can happen if iaxc_netstat != iax_netstat.. */
EXPORT int iaxc_get_netstats(int call, int *rtt, struct iaxc_netstat *local,
		struct iaxc_netstat *remote)
{
	return iax_get_netstats(calls[call].session, rtt,
			(struct iax_netstat *)local,
			(struct iax_netstat *)remote);
}

/* handle IAX text events */
static void generate_netstat_event(int callNo)
{
	iaxc_event ev;

	if ( callNo < 0 )
		return;

	ev.type = IAXC_EVENT_NETSTAT;
	ev.ev.netstats.callNo = callNo;

	/* only post the event if the session is valid, etc */
	if ( !iaxc_get_netstats(callNo, &ev.ev.netstats.rtt,
				&ev.ev.netstats.local, &ev.ev.netstats.remote))
		iaxci_post_event(ev);
}

static void handle_audio_event(struct iax_event *e, int callNo)
{
	int total_consumed = 0;
	short fr[4096];
	const int fr_samples = sizeof(fr) / sizeof(short);
	int samples, format;
#ifdef WIN32
	int cycles_max = 100; //fd:
#endif
	struct iaxc_call *call;

	if ( callNo < 0 )
		return;

	call = &calls[callNo];

	if ( callNo != selected_call )
	{
	    /* drop audio for unselected call? */
	    return;
	}

	samples = fr_samples;
	format = call->format & IAXC_AUDIO_FORMAT_MASK;

	do
	{
		int bytes_decoded;

		int mainbuf_delta = fr_samples - samples;

		bytes_decoded = audio_decode_audio(call,
				fr,
				e->data + total_consumed,
				e->datalen - total_consumed,
				format,
				&samples);

		if ( bytes_decoded < 0 )
		{
			iaxci_usermsg(IAXC_STATUS,
				"Bad or incomplete voice packet. Unable to decode. dropping");
			return;
		}

		/* Pass encoded audio back to the app if required */
		if ( audio_prefs & IAXC_AUDIO_PREF_RECV_REMOTE_ENCODED )
			iaxci_do_audio_callback(callNo, e->ts, IAXC_SOURCE_REMOTE,
					1, format & IAXC_AUDIO_FORMAT_MASK,
					e->datalen - total_consumed,
					e->data + total_consumed);

#ifdef WIN32
		//fd: start: for some reason it loops here. Try to avoid it
		cycles_max--;
		if ( cycles_max < 0 )
		{
			iaxc_millisleep(0);
		}
		//fd: end
#endif
		total_consumed += bytes_decoded;
		if ( audio_prefs & IAXC_AUDIO_PREF_RECV_REMOTE_RAW )
		{
			// audio_decode_audio returns the number of samples.
			// We are using 16 bit samples, so we need to double
			// the number to obtain the size in bytes.
			// format will also be 0 since this is raw audio
			int size = (fr_samples - samples - mainbuf_delta) * 2;
			iaxci_do_audio_callback(callNo, e->ts, IAXC_SOURCE_REMOTE,
					0, 0, size, (unsigned char *)fr);
		}

		if ( iaxci_audio_output_mode )
			continue;

		if ( !test_mode )
			audio_driver.output(&audio_driver, fr,
			    fr_samples - samples - mainbuf_delta);

	} while ( total_consumed < e->datalen );
}

#ifdef USE_VIDEO
static void handle_video_event(struct iax_event *e, int callNo)
{
	struct iaxc_call *call;

	if ( callNo < 0 )
		return;

	if ( e->datalen == 0 )
	{
		iaxci_usermsg(IAXC_STATUS, "Received 0-size packet. Unable to decode.");
		return;
	}

	call = &calls[callNo];

	if ( callNo != selected_call )
	{
		/* drop video for unselected call? */
		return;
	}

	if ( call->vformat )
	{
		if ( video_recv_video(call, selected_call, e->data,
					e->datalen, e->ts, call->vformat) < 0 )
		{
			iaxci_usermsg(IAXC_STATUS,
				"Bad or incomplete video packet. Unable to decode.");
			return;
		}
	}
}
#endif	/* USE_VIDEO */

static void iaxc_handle_network_event(struct iax_event *e, int callNo)
{
	if ( callNo < 0 )
		return;

	iaxc_note_activity(callNo);

	switch ( e->etype )
	{
	case IAX_EVENT_NULL:
		break;
	case IAX_EVENT_HANGUP:
		iaxci_usermsg(IAXC_STATUS, "Call disconnected by remote");
		// XXX does the session go away now?
		iaxc_clear_call(callNo);
		break;
	case IAX_EVENT_REJECT:
		iaxci_usermsg(IAXC_STATUS, "Call rejected by remote");
		iaxc_clear_call(callNo);
		break;
	case IAX_EVENT_ACCEPT:
		calls[callNo].format = e->ies.format & IAXC_AUDIO_FORMAT_MASK;
		calls[callNo].vformat = e->ies.format & IAXC_VIDEO_FORMAT_MASK;
#ifdef USE_VIDEO
		if ( !(e->ies.format & IAXC_VIDEO_FORMAT_MASK) )
		{
			iaxci_usermsg(IAXC_NOTICE,
					"Failed video codec negotiation.");
		}
#endif
		iaxci_usermsg(IAXC_STATUS,"Call %d accepted", callNo);
		break;
	case IAX_EVENT_ANSWER:
		calls[callNo].state &= ~IAXC_CALL_STATE_RINGING;
		calls[callNo].state |= IAXC_CALL_STATE_COMPLETE;
		iaxci_do_state_callback(callNo);
		iaxci_usermsg(IAXC_STATUS,"Call %d answered", callNo);
		//iaxc_answer_call(callNo);
		// notify the user?
		break;
	case IAX_EVENT_BUSY:
		calls[callNo].state &= ~IAXC_CALL_STATE_RINGING;
		calls[callNo].state |= IAXC_CALL_STATE_BUSY;
		iaxci_do_state_callback(callNo);
		iaxci_usermsg(IAXC_STATUS, "Call %d busy", callNo);
		break;
	case IAX_EVENT_VOICE:
		handle_audio_event(e, callNo);
		if ( (calls[callNo].state & IAXC_CALL_STATE_OUTGOING) &&
		     (calls[callNo].state & IAXC_CALL_STATE_RINGING) )
		{
			calls[callNo].state &= ~IAXC_CALL_STATE_RINGING;
			calls[callNo].state |= IAXC_CALL_STATE_COMPLETE;
			iaxci_do_state_callback(callNo);
			iaxci_usermsg(IAXC_STATUS,"Call %d progress",
				     callNo);
		}
		break;
#ifdef USE_VIDEO
	case IAX_EVENT_VIDEO:
		handle_video_event(e, callNo);
		break;
#endif
	case IAX_EVENT_TEXT:
		handle_text_event(e, callNo);
		break;
	case IAX_EVENT_RINGA:
		calls[callNo].state |= IAXC_CALL_STATE_RINGING;
		iaxci_do_state_callback(callNo);
		iaxci_usermsg(IAXC_STATUS,"Call %d ringing", callNo);
		break;
	case IAX_EVENT_PONG:
		generate_netstat_event(callNo);
		break;
	case IAX_EVENT_URL:
		handle_url_event(e, callNo);
		break;
	case IAX_EVENT_CNG:
		/* ignore? */
		break;
	case IAX_EVENT_TIMEOUT:
		iax_hangup(e->session, "Call timed out");
		iaxci_usermsg(IAXC_STATUS, "Call %d timed out.", callNo);
		iaxc_clear_call(callNo);
		break;
	case IAX_EVENT_TRANSFER:
		calls[callNo].state |= IAXC_CALL_STATE_TRANSFER;
		iaxci_do_state_callback(callNo);
		iaxci_usermsg(IAXC_STATUS,"Call %d transfer released", callNo);
		break;
	case IAX_EVENT_DTMF:
		iaxci_do_dtmf_callback(callNo,e->subclass);
		iaxci_usermsg(IAXC_STATUS, "DTMF digit %c received", e->subclass);
        	break;
	default:
		iaxci_usermsg(IAXC_STATUS, "Unknown event: %d for call %d", e->etype, callNo);
		break;
	}
}

EXPORT int iaxc_unregister( int id )
{
	int count = 0;
	get_iaxc_lock();
	count = iaxc_remove_registration_by_id(id);
	put_iaxc_lock();
	return count;
}

EXPORT int iaxc_register(const char * user, const char * pass, const char * host)
{
	return iaxc_register_ex(user, pass, host, 60);
}

EXPORT int iaxc_register_ex(const char * user, const char * pass, const char * host, int refresh)
{
	struct iaxc_registration *newreg;

	newreg = (struct iaxc_registration *)malloc(sizeof (struct iaxc_registration));
	if ( !newreg )
	{
		iaxci_usermsg(IAXC_ERROR, "Can't make new registration");
		return -1;
	}

	get_iaxc_lock();
	newreg->session = iax_session_new();
	if ( !newreg->session )
	{
		iaxci_usermsg(IAXC_ERROR, "Can't make new registration session");
		put_iaxc_lock();
		return -1;
	}

	newreg->last = iax_tvnow();
	newreg->refresh = refresh;

	strncpy(newreg->host, host, 256);
	strncpy(newreg->user, user, 256);
	strncpy(newreg->pass, pass, 256);

	/* send out the initial registration with refresh seconds */
	iax_register(newreg->session, host, user, pass, refresh);

	/* add it to the list; */
	newreg->id = ++next_registration_id;
	newreg->next = registrations;
	registrations = newreg;

	put_iaxc_lock();
	return newreg->id;
}

static void codec_destroy( int callNo )
{
	if ( calls[callNo].encoder )
	{
		calls[callNo].encoder->destroy( calls[callNo].encoder );
		calls[callNo].encoder = NULL;
	}
	if ( calls[callNo].decoder )
	{
		calls[callNo].decoder->destroy( calls[callNo].decoder );
		calls[callNo].decoder = NULL;
	}
	if ( calls[callNo].vdecoder )
	{
		calls[callNo].vdecoder->destroy(calls[callNo].vdecoder);
		calls[callNo].vdecoder = NULL;
	}
	if ( calls[callNo].vencoder )
	{
		calls[callNo].vencoder->destroy(calls[callNo].vencoder);
		calls[callNo].vencoder = NULL;
	}
}

EXPORT int iaxc_call(const char * num)
{
	return iaxc_call_ex(num, NULL, NULL, 1);
}

EXPORT int iaxc_call_ex(const char *num, const char* callerid_name, const char* callerid_number, int video)
{
	int video_format_capability = 0;
	int video_format_preferred = 0;
	int callNo = -1;
	struct iax_session *newsession;
	char *ext = strstr(num, "/");

	get_iaxc_lock();

	// if no call is selected, get a new appearance
	if ( selected_call < 0 )
	{
		callNo = iaxc_first_free_call();
	} else
	{
		// use selected call if not active, otherwise, get a new appearance
		if ( calls[selected_call].state  & IAXC_CALL_STATE_ACTIVE )
		{
			callNo = iaxc_first_free_call();
		} else
		{
			callNo = selected_call;
		}
	}

	if ( callNo < 0 )
	{
		iaxci_usermsg(IAXC_STATUS, "No free call appearances");
		goto iaxc_call_bail;
	}

	newsession = iax_session_new();
	if ( !newsession )
	{
		iaxci_usermsg(IAXC_ERROR, "Can't make new session");
		goto iaxc_call_bail;
	}

	calls[callNo].session = newsession;

	codec_destroy( callNo );

	if ( ext )
	{
		strncpy(calls[callNo].remote_name, num, IAXC_EVENT_BUFSIZ);
		strncpy(calls[callNo].remote,    ++ext, IAXC_EVENT_BUFSIZ);
	} else
	{
		strncpy(calls[callNo].remote_name, num, IAXC_EVENT_BUFSIZ);
		strncpy(calls[callNo].remote,      "" , IAXC_EVENT_BUFSIZ);
	}

	if ( callerid_number != NULL )
		strncpy(calls[callNo].callerid_number, callerid_number, IAXC_EVENT_BUFSIZ);

	if ( callerid_name != NULL )
		strncpy(calls[callNo].callerid_name, callerid_name, IAXC_EVENT_BUFSIZ);

	strncpy(calls[callNo].local        , calls[callNo].callerid_name, IAXC_EVENT_BUFSIZ);
	strncpy(calls[callNo].local_context, "default", IAXC_EVENT_BUFSIZ);

	calls[callNo].state = IAXC_CALL_STATE_ACTIVE | IAXC_CALL_STATE_OUTGOING;

	/* reset activity and ping "timers" */
	iaxc_note_activity(callNo);
	calls[callNo].last_ping = calls[callNo].last_activity;

#ifdef USE_VIDEO
	if ( video )
		iaxc_video_format_get_cap(&video_format_preferred, &video_format_capability);
#endif

	iaxci_usermsg(IAXC_NOTICE, "Originating an %s call",
			video_format_preferred ? "audio+video" : "audio only");
	iax_call(calls[callNo].session, calls[callNo].callerid_number,
			calls[callNo].callerid_name, num, NULL, 0,
			audio_format_preferred | video_format_preferred,
			audio_format_capability | video_format_capability);

	// does state stuff also
	iaxc_select_call(callNo);

iaxc_call_bail:
	put_iaxc_lock();

	return callNo;
}

EXPORT void iaxc_send_busy_on_incoming_call(int callNo)
{
	if ( callNo < 0 )
		return;

	iax_busy(calls[callNo].session);
}

EXPORT void iaxc_answer_call(int callNo)
{
	if ( callNo < 0 )
		return;

	calls[callNo].state |= IAXC_CALL_STATE_COMPLETE;
	calls[callNo].state &= ~IAXC_CALL_STATE_RINGING;
	iax_answer(calls[callNo].session);
	iaxci_do_state_callback(callNo);
}

EXPORT void iaxc_blind_transfer_call(int callNo, const char * dest_extension)
{
	if ( callNo < 0 || !(calls[callNo].state & IAXC_CALL_STATE_ACTIVE) )
		return;

	iax_transfer(calls[callNo].session, dest_extension);
}

EXPORT void iaxc_setup_call_transfer(int sourceCallNo, int targetCallNo)
{
	if ( sourceCallNo < 0 || targetCallNo < 0 ||
			!(calls[sourceCallNo].state & IAXC_CALL_STATE_ACTIVE) ||
			!(calls[targetCallNo].state & IAXC_CALL_STATE_ACTIVE) )
		return;

	iax_setup_transfer(calls[sourceCallNo].session, calls[targetCallNo].session);
}

static void iaxc_dump_one_call(int callNo)
{
	if ( callNo < 0 )
		return;
	if ( calls[callNo].state == IAXC_CALL_STATE_FREE )
		return;

	iax_hangup(calls[callNo].session,"Dumped Call");
	iaxci_usermsg(IAXC_STATUS, "Hanging up call %d", callNo);
	iaxc_clear_call(callNo);
}

EXPORT void iaxc_dump_all_calls(void)
{
	int callNo;
	get_iaxc_lock();
	for ( callNo = 0; callNo < max_calls; callNo++ )
		iaxc_dump_one_call(callNo);
	put_iaxc_lock();
}


EXPORT void iaxc_dump_call_number( int callNo )
{
	if ( ( callNo >= 0 ) && ( callNo < max_calls ) )
	{
		get_iaxc_lock();
		iaxc_dump_one_call(callNo);
		put_iaxc_lock();
	}
}

EXPORT void iaxc_dump_call(void)
{
	if ( selected_call >= 0 )
	{
		get_iaxc_lock();
		iaxc_dump_one_call(selected_call);
		put_iaxc_lock();
	}
}

EXPORT void iaxc_reject_call(void)
{
	if ( selected_call >= 0 )
	{
		iaxc_reject_call_number(selected_call);
	}
}

EXPORT void iaxc_reject_call_number( int callNo )
{
	if ( ( callNo >= 0 ) && ( callNo < max_calls ) )
	{
		get_iaxc_lock();
		iax_reject(calls[callNo].session, "Call rejected manually.");
		iaxc_clear_call(callNo);
		put_iaxc_lock();
	}
}

EXPORT void iaxc_send_dtmf(char digit)
{
	if ( selected_call >= 0 )
	{
		get_iaxc_lock();
		if ( calls[selected_call].state & IAXC_CALL_STATE_ACTIVE )
			iax_send_dtmf(calls[selected_call].session,digit);
		put_iaxc_lock();
	}
}

EXPORT void iaxc_send_text(const char * text)
{
	if ( selected_call >= 0 )
	{
		get_iaxc_lock();
		if ( calls[selected_call].state & IAXC_CALL_STATE_ACTIVE )
			iax_send_text(calls[selected_call].session, text);
		put_iaxc_lock();
	}
}

EXPORT void iaxc_send_text_call(int callNo, const char * text)
{
	if ( callNo < 0 || !(calls[callNo].state & IAXC_CALL_STATE_ACTIVE) )
		return;

	get_iaxc_lock();
	if ( calls[callNo].state & IAXC_CALL_STATE_ACTIVE )
		iax_send_text(calls[callNo].session, text);
	put_iaxc_lock();
}

EXPORT void iaxc_send_url(const char * url, int link)
{
	if ( selected_call >= 0 )
	{
		get_iaxc_lock();
		if ( calls[selected_call].state & IAXC_CALL_STATE_ACTIVE )
			iax_send_url(calls[selected_call].session, url, link);
		put_iaxc_lock();
	}
}

static int iaxc_find_call_by_session(struct iax_session *session)
{
	int i;
	for ( i = 0; i < max_calls; i++ )
		if ( calls[i].session == session )
			return i;
	return -1;
}

static struct iaxc_registration *iaxc_find_registration_by_session(
		struct iax_session *session)
{
	struct iaxc_registration *reg;
	for (reg = registrations; reg != NULL; reg = reg->next)
		if ( reg->session == session )
			break;
	return reg;
}

static void iaxc_handle_regreply(struct iax_event *e, struct iaxc_registration *reg)
{
	iaxci_do_registration_callback(reg->id, e->etype, e->ies.msgcount);

	// XXX I think the session is no longer valid.. at least, that's
	// what miniphone does, and re-using the session doesn't seem to
	// work!
	iax_destroy(reg->session);
	reg->session = NULL;

	if ( e->etype == IAX_EVENT_REGREJ )
	{
		// we were rejected, so end the registration
		iaxc_remove_registration_by_id(reg->id);
	}
}

/* this is what asterisk does */
static int iaxc_choose_codec(int formats)
{
	int i;
	static int codecs[] =
	{
		IAXC_FORMAT_ULAW,
		IAXC_FORMAT_ALAW,
		IAXC_FORMAT_SLINEAR,
		IAXC_FORMAT_G726,
		IAXC_FORMAT_ADPCM,
		IAXC_FORMAT_GSM,
		IAXC_FORMAT_ILBC,
		IAXC_FORMAT_SPEEX,
		IAXC_FORMAT_LPC10,
		IAXC_FORMAT_G729A,
		IAXC_FORMAT_G723_1,

		/* To negotiate video codec */
		IAXC_FORMAT_JPEG,
		IAXC_FORMAT_PNG,
		IAXC_FORMAT_H261,
		IAXC_FORMAT_H263,
		IAXC_FORMAT_H263_PLUS,
		IAXC_FORMAT_MPEG4,
		IAXC_FORMAT_H264,
		IAXC_FORMAT_THEORA,
	};
	for ( i = 0; i < (int)(sizeof(codecs) / sizeof(int)); i++ )
		if ( codecs[i] & formats )
			return codecs[i];
	return 0;
}

static void iaxc_handle_connect(struct iax_event * e)
{
#ifdef USE_VIDEO
	int video_format_capability;
	int video_format_preferred;
#endif
	int video_format = 0;
	int format = 0;
	int callno;

	callno = iaxc_first_free_call();

	if ( callno < 0 )
	{
		iaxci_usermsg(IAXC_STATUS,
				"%i \n Incoming Call, but no appearances",
				callno);
		// XXX Reject this call!, or just ignore?
		//iax_reject(e->session, "Too many calls, we're busy!");
		iax_accept(e->session, audio_format_preferred & e->ies.capability);
		iax_busy(e->session);
		return;
	}

	/* negotiate codec */
	/* first, try _their_ preferred format */
	format = audio_format_capability & e->ies.format;
	if ( !format )
	{
		/* then, try our preferred format */
		format = audio_format_preferred & e->ies.capability;
	}

	if ( !format )
	{
		/* finally, see if we have one in common */
		format = audio_format_capability & e->ies.capability;

		/* now choose amongst these, if we got one */
		if ( format )
		{
			format = iaxc_choose_codec(format);
		}
	}

	if ( !format )
	{
		iax_reject(e->session, "Could not negotiate common codec");
		return;
	}

#ifdef USE_VIDEO
	iaxc_video_format_get_cap(&video_format_preferred,
			&video_format_capability);

	/* first, see if they even want video */
	video_format = (e->ies.format & IAXC_VIDEO_FORMAT_MASK);

	if ( video_format )
	{
		/* next, try _their_ preferred format */
		video_format &= video_format_capability;

		if ( !video_format )
		{
			/* then, try our preferred format */
			video_format = video_format_preferred &
				(e->ies.capability & IAXC_VIDEO_FORMAT_MASK);
		}

		if ( !video_format )
		{
			/* finally, see if we have one in common */
			video_format = video_format_capability &
				(e->ies.capability & IAXC_VIDEO_FORMAT_MASK);

			/* now choose amongst these, if we got one */
			if ( video_format )
			{
				video_format = iaxc_choose_codec(video_format);
			}
		}

		/* All video negotiations failed, then warn */
		if ( !video_format )
		{
			iaxci_usermsg(IAXC_NOTICE,
					"Notice: could not negotiate common video codec");
			iaxci_usermsg(IAXC_NOTICE,
					"Notice: switching to audio-only call");
		}
	}
#endif	/* USE_VIDEO */

	calls[callno].vformat = video_format;
	calls[callno].format = format;

	if ( e->ies.called_number )
		strncpy(calls[callno].local, e->ies.called_number,
				IAXC_EVENT_BUFSIZ);
	else
		strncpy(calls[callno].local, "unknown",
				IAXC_EVENT_BUFSIZ);

	if ( e->ies.called_context )
		strncpy(calls[callno].local_context, e->ies.called_context,
				IAXC_EVENT_BUFSIZ);
	else
		strncpy(calls[callno].local_context, "",
				IAXC_EVENT_BUFSIZ);

	if ( e->ies.calling_number )
		strncpy(calls[callno].remote, e->ies.calling_number,
				IAXC_EVENT_BUFSIZ);
	else
		strncpy(calls[callno].remote, "unknown",
				IAXC_EVENT_BUFSIZ);

	if ( e->ies.calling_name )
		strncpy(calls[callno].remote_name, e->ies.calling_name,
				IAXC_EVENT_BUFSIZ);
	else
		strncpy(calls[callno].remote_name, "unknown",
				IAXC_EVENT_BUFSIZ);

	iaxc_note_activity(callno);
	iaxci_usermsg(IAXC_STATUS, "Call from (%s)", calls[callno].remote);

	codec_destroy( callno );

	calls[callno].session = e->session;
	calls[callno].state = IAXC_CALL_STATE_ACTIVE|IAXC_CALL_STATE_RINGING;

	iax_accept(calls[callno].session, format | video_format);
	iax_ring_announce(calls[callno].session);

	iaxci_do_state_callback(callno);

	iaxci_usermsg(IAXC_STATUS, "Incoming call on line %d", callno);
}

static void service_network()
{
	struct iax_event *e = 0;
	int callNo;
	struct iaxc_registration *reg;

	while ( (e = iax_get_event(0)) )
	{
#ifdef WIN32
		iaxc_millisleep(0); //fd:
#endif
		// first, see if this is an event for one of our calls.
		callNo = iaxc_find_call_by_session(e->session);
		if ( e->etype == IAX_EVENT_NULL )
		{
			// Should we do something here?
			// Right now we do nothing, just go with the flow
			// and let the event be deallocated.
		} else if ( callNo >= 0 )
		{
			iaxc_handle_network_event(e, callNo);
		} else if ( (reg = iaxc_find_registration_by_session(e->session)) != NULL )
		{
			iaxc_handle_regreply(e,reg);
		} else if ( e->etype == IAX_EVENT_REGACK || e->etype == IAX_EVENT_REGREJ )
		{
			iaxci_usermsg(IAXC_ERROR, "Unexpected registration reply");
		} else if ( e->etype == IAX_EVENT_REGREQ )
		{
			iaxci_usermsg(IAXC_ERROR,
					"Registration requested by someone, but we don't understand!");
		} else if ( e->etype == IAX_EVENT_CONNECT )
		{
			iaxc_handle_connect(e);
		} else if ( e->etype == IAX_EVENT_TIMEOUT )
		{
			iaxci_usermsg(IAXC_STATUS,
					"Timeout for a non-existant session. Dropping",
					e->etype);
		} else
		{
			iaxci_usermsg(IAXC_ERROR,
					"Event (type %d) for a non-existant session. Dropping",
					e->etype);
		}
		iax_event_free(e);
	}
}

EXPORT int iaxc_audio_devices_get(struct iaxc_audio_device **devs, int *nDevs,
		int *input, int *output, int *ring)
{
	if ( test_mode )
		return 0;

	*devs = audio_driver.devices;
	*nDevs = audio_driver.nDevices;
	audio_driver.selected_devices(&audio_driver, input, output, ring);
	return 0;
}

EXPORT int iaxc_audio_devices_set(int input, int output, int ring)
{
	int ret;

	if ( test_mode )
		return 0;

	get_iaxc_lock();
	ret = audio_driver.select_devices(&audio_driver, input, output, ring);
	put_iaxc_lock();
	return ret;
}

EXPORT float iaxc_input_level_get()
{
	if ( test_mode )
		return 0;

	return audio_driver.input_level_get(&audio_driver);
}

EXPORT float iaxc_output_level_get()
{
	if ( test_mode )
		return 0;

	return audio_driver.output_level_get(&audio_driver);
}

EXPORT int iaxc_input_level_set(float level)
{
	if ( test_mode )
		return 0;

	return audio_driver.input_level_set(&audio_driver, level);
}

EXPORT int iaxc_output_level_set(float level)
{
	if ( test_mode )
		return 0;

	return audio_driver.output_level_set(&audio_driver, level);
}

EXPORT int iaxc_play_sound(struct iaxc_sound *s, int ring)
{
	int ret;

	if ( test_mode )
		return 0;

	get_iaxc_lock();
	ret = audio_driver.play_sound(s,ring);
	put_iaxc_lock();
	return ret;
}

EXPORT int iaxc_stop_sound(int id)
{
	int ret;

	if ( test_mode )
		return 0;

	get_iaxc_lock();
	ret = audio_driver.stop_sound(id);
	put_iaxc_lock();
	return ret;
}

EXPORT int iaxc_quelch(int callNo, int MOH)
{
	struct iax_session *session = calls[callNo].session;
	if ( !session )
		return -1;

	return iax_quelch_moh(session, MOH);
}

EXPORT int iaxc_unquelch(int call)
{
	return iax_unquelch(calls[call].session);
}

EXPORT int iaxc_mic_boost_get( void )
{
	return audio_driver.mic_boost_get( &audio_driver ) ;
}

EXPORT int iaxc_mic_boost_set( int enable )
{
	return audio_driver.mic_boost_set( &audio_driver, enable ) ;
}

EXPORT char* iaxc_version(char * ver)
{
#ifndef LIBVER
#define LIBVER ""
#endif
	strncpy(ver, LIBVER, IAXC_EVENT_BUFSIZ);
	return ver;
}

EXPORT unsigned int iaxc_get_audio_prefs(void)
{
	return audio_prefs;
}

EXPORT int iaxc_set_audio_prefs(unsigned int prefs)
{
	unsigned int prefs_mask =
		IAXC_AUDIO_PREF_RECV_LOCAL_RAW      |
		IAXC_AUDIO_PREF_RECV_LOCAL_ENCODED  |
		IAXC_AUDIO_PREF_RECV_REMOTE_RAW     |
		IAXC_AUDIO_PREF_RECV_REMOTE_ENCODED |
		IAXC_AUDIO_PREF_SEND_DISABLE;

	if ( prefs & ~prefs_mask )
		return -1;

	audio_prefs = prefs;
	return 0;
}

EXPORT void iaxc_set_test_mode(int tm)
{
	test_mode = tm;
}

EXPORT int iaxc_push_audio(void *data, unsigned int size, unsigned int samples)
{
	struct iaxc_call *call;

	if ( selected_call < 0 )
		return -1;

	call = &calls[selected_call];

	if ( audio_prefs & IAXC_AUDIO_PREF_SEND_DISABLE )
		return 0;

	//fprintf(stderr, "iaxc_push_audio: sending audio size %d\n", size);

	if ( iax_send_voice(call->session, call->format, data, size, samples) == -1 )
	{
		fprintf(stderr, "iaxc_push_audio: failed to send audio frame of size %d on call %d\n", size, selected_call);
		return -1;
	}

	return 0;
}

EXPORT void iaxc_key_radio(int callNo)
{
	if ( callNo < 0 )
		return;

	iax_key_radio(calls[callNo].session);
}

EXPORT void iaxc_unkey_radio(int callNo)
{
	if ( callNo < 0 )
		return;

	iax_unkey_radio(calls[callNo].session);
}

EXPORT void iaxc_set_radiono(int r)
{
    radioNo = r;
}

void iaxc_debug_iax_set(int enable)
{
#ifdef DEBUG_SUPPORT
	if (enable)
		iax_enable_debug();
	else
		iax_disable_debug();
#endif
}