[asterisk-commits] branch oej/test-this-branch r10708 - /team/oej/test-this-branch/

asterisk-commits at lists.digium.com asterisk-commits at lists.digium.com
Wed Feb 22 08:15:53 MST 2006


Author: oej
Date: Wed Feb 22 09:15:27 2006
New Revision: 10708

URL: http://svn.digium.com/view/asterisk?rev=10708&view=rev
Log:
Adding missing files :-)

Added:
    team/oej/test-this-branch/abstract_jb.c   (with props)
    team/oej/test-this-branch/abstract_jb.h   (with props)

Added: team/oej/test-this-branch/abstract_jb.c
URL: http://svn.digium.com/view/asterisk/team/oej/test-this-branch/abstract_jb.c?rev=10708&view=auto
==============================================================================
--- team/oej/test-this-branch/abstract_jb.c (added)
+++ team/oej/test-this-branch/abstract_jb.c Wed Feb 22 09:15:27 2006
@@ -1,0 +1,878 @@
+/*
+ * abstract_jb: common implementation-independent jitterbuffer stuff
+ *
+ * Copyright (C) 2005, Attractel OOD
+ *
+ * Contributors:
+ * Slav Klenov <slav at securax.org>
+ *
+ * Copyright on this file is disclaimed to Digium for inclusion in Asterisk
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ *
+ * \brief Common implementation-independent jitterbuffer stuff.
+ * 
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include "asterisk/frame.h"
+#include "asterisk/channel.h"
+#include "asterisk/logger.h"
+#include "asterisk/term.h"
+#include "asterisk/options.h"
+#include "asterisk/utils.h"
+
+#ifdef AST_JB
+
+#include "asterisk/abstract_jb.h"
+#include "scx_jitterbuf.h"
+#include "jitterbuf.h"
+
+
+/* Internal jb flags */
+#define JB_USE (1 << 0)
+#define JB_TIMEBASE_INITIALIZED (1 << 1)
+#define JB_CREATED (1 << 2)
+
+
+/* Hooks for the abstract jb implementation */
+
+/* Create */
+typedef void * (*jb_create_impl)(struct ast_jb_conf *general_config, long resynch_threshold);
+/* Destroy */
+typedef void (*jb_destroy_impl)(void *jb);
+/* Put first frame */
+typedef int (*jb_put_first_impl)(void *jb, struct ast_frame *fin, long now);
+/* Put frame */
+typedef int (*jb_put_impl)(void *jb, struct ast_frame *fin, long now);
+/* Get frame for now */
+typedef int (*jb_get_impl)(void *jb, struct ast_frame **fout, long now, long interpl);
+/* Get next */
+typedef long (*jb_next_impl)(void *jb);
+/* Remove first frame */
+typedef int (*jb_remove_impl)(void *jb, struct ast_frame **fout);
+/* Force resynch */
+typedef void (*jb_force_resynch_impl)(void *jb);
+
+
+/*!
+ * \brief Jitterbuffer implementation private struct.
+ */
+struct ast_jb_impl
+{
+	char name[AST_JB_IMPL_NAME_SIZE];
+	jb_create_impl create;
+	jb_destroy_impl destroy;
+	jb_put_first_impl put_first;
+	jb_put_impl put;
+	jb_get_impl get;
+	jb_next_impl next;
+	jb_remove_impl remove;
+	jb_force_resynch_impl force_resync;
+};
+
+/* Implementation functions */
+/* scx */
+static void * jb_create_scx(struct ast_jb_conf *general_config, long resynch_threshold);
+static void jb_destroy_scx(void *jb);
+static int jb_put_first_scx(void *jb, struct ast_frame *fin, long now);
+static int jb_put_scx(void *jb, struct ast_frame *fin, long now);
+static int jb_get_scx(void *jb, struct ast_frame **fout, long now, long interpl);
+static long jb_next_scx(void *jb);
+static int jb_remove_scx(void *jb, struct ast_frame **fout);
+static void jb_force_resynch_scx(void *jb);
+/* stevek */
+static void * jb_create_stevek(struct ast_jb_conf *general_config, long resynch_threshold);
+static void jb_destroy_stevek(void *jb);
+static int jb_put_first_stevek(void *jb, struct ast_frame *fin, long now);
+static int jb_put_stevek(void *jb, struct ast_frame *fin, long now);
+static int jb_get_stevek(void *jb, struct ast_frame **fout, long now, long interpl);
+static long jb_next_stevek(void *jb);
+static int jb_remove_stevek(void *jb, struct ast_frame **fout);
+static void jb_force_resynch_stevek(void *jb);
+
+/* Available jb implementations */
+static struct ast_jb_impl avail_impl[] = 
+{
+	{
+		.name = "fixed",
+		.create = jb_create_scx,
+		.destroy = jb_destroy_scx,
+		.put_first = jb_put_first_scx,
+		.put = jb_put_scx,
+		.get = jb_get_scx,
+		.next = jb_next_scx,
+		.remove = jb_remove_scx,
+		.force_resync = jb_force_resynch_scx
+	},
+	{
+		.name = "adaptive",
+		.create = jb_create_stevek,
+		.destroy = jb_destroy_stevek,
+		.put_first = jb_put_first_stevek,
+		.put = jb_put_stevek,
+		.get = jb_get_stevek,
+		.next = jb_next_stevek,
+		.remove = jb_remove_stevek,
+		.force_resync = jb_force_resynch_stevek
+	}
+};
+
+static int default_impl = 0;
+
+
+/* Abstract return codes */
+#define JB_IMPL_OK 0
+#define JB_IMPL_DROP 1
+#define JB_IMPL_INTERP 2
+#define JB_IMPL_NOFRAME 3
+
+/* Translations between impl and abstract return codes */
+static int scx_to_abstract_code[] =
+	{JB_IMPL_OK, JB_IMPL_DROP, JB_IMPL_INTERP, JB_IMPL_NOFRAME};
+static int stevek_to_abstract_code[] =
+	{JB_IMPL_OK, JB_IMPL_NOFRAME, JB_IMPL_NOFRAME, JB_IMPL_INTERP, JB_IMPL_DROP, JB_IMPL_OK};
+
+/* JB_GET actions (used only for the frames log) */
+static char *jb_get_actions[] = {"Delivered", "Dropped", "Interpolated", "No"};
+
+/* Macros for JB logs */
+/*#define jb_verbose(...) ast_verbose(VERBOSE_PREFIX_3 " ***[JB LOG]*** " __VA_ARGS__)*/
+#define jb_verbose(...) if(1){\
+	char tmp[192];\
+	char msg[128];\
+	snprintf(msg, sizeof(msg), VERBOSE_PREFIX_3 "***[JB LOG]*** " __VA_ARGS__);\
+	ast_verbose("%s\n", term_color(tmp, msg, COLOR_BRGREEN, 0, sizeof(tmp)));}
+
+/* Macros for the frame log files */
+#define jb_framelog(...) \
+if(jb->logfile) \
+{ \
+	fprintf(jb->logfile, __VA_ARGS__); \
+	fflush(jb->logfile); \
+} \
+
+
+/* Internal utility functions */
+static void jb_choose_impl(struct ast_channel *chan);
+static void jb_get_and_deliver(struct ast_channel *chan);
+static int create_jb(struct ast_channel *chan, struct ast_frame *first_frame);
+static long get_now(struct ast_jb *jb, struct timeval *tv);
+
+
+/* Interface ast jb functions impl */
+
+
+static void jb_choose_impl(struct ast_channel *chan)
+{
+	struct ast_jb *jb = &chan->jb;
+	struct ast_jb_conf *jbconf = &jb->conf;
+	struct ast_jb_impl *test_impl;
+	int i, avail_impl_count = sizeof(avail_impl) / sizeof(avail_impl[0]);
+	
+	jb->impl = &avail_impl[default_impl];
+	
+	if(*jbconf->impl == '\0')
+	{
+		return;
+	}
+		
+	for(i=0; i<avail_impl_count; i++)
+	{
+		test_impl = &avail_impl[i];
+		if(strcmp(jbconf->impl, test_impl->name) == 0)
+		{
+			jb->impl = test_impl;
+			return;
+		}
+	}
+}
+
+
+void ast_jb_do_usecheck(struct ast_channel *c0, struct ast_channel *c1)
+{
+	struct ast_jb *jb0 = &c0->jb;
+	struct ast_jb *jb1 = &c1->jb;
+	struct ast_jb_conf *conf0 = &jb0->conf;
+	struct ast_jb_conf *conf1 = &jb1->conf;
+	int c0_wants_jitter = c0->tech->properties & AST_CHAN_TP_WANTSJITTER;
+	int c0_creates_jitter = c0->tech->properties & AST_CHAN_TP_CREATESJITTER;
+	int c0_jb_enabled = ast_test_flag(conf0, AST_JB_ENABLED);
+	int c0_force_jb = ast_test_flag(conf0, AST_JB_FORCED);
+	int c0_jb_timebase_initialized = ast_test_flag(jb0, JB_TIMEBASE_INITIALIZED);
+	int c0_jb_created = ast_test_flag(jb0, JB_CREATED);
+	int c1_wants_jitter = c1->tech->properties & AST_CHAN_TP_WANTSJITTER;
+	int c1_creates_jitter = c1->tech->properties & AST_CHAN_TP_CREATESJITTER;
+	int c1_jb_enabled = ast_test_flag(conf1, AST_JB_ENABLED);
+	int c1_force_jb = ast_test_flag(conf1, AST_JB_FORCED);
+	int c1_jb_timebase_initialized = ast_test_flag(jb1, JB_TIMEBASE_INITIALIZED);
+	int c1_jb_created = ast_test_flag(jb1, JB_CREATED);
+	
+	if(((!c0_wants_jitter && c1_creates_jitter) || c0_force_jb) && c0_jb_enabled)
+	{
+		ast_set_flag(jb0, JB_USE);
+		if(!c0_jb_timebase_initialized)
+		{
+			if(c1_jb_timebase_initialized)
+			{
+				memcpy(&jb0->timebase, &jb1->timebase, sizeof(struct timeval));
+			}
+			else
+			{
+				gettimeofday(&jb0->timebase, NULL);
+			}
+			ast_set_flag(jb0, JB_TIMEBASE_INITIALIZED);
+		}
+		
+		if(!c0_jb_created)
+		{
+			jb_choose_impl(c0);
+		}
+	}
+	
+	if(((!c1_wants_jitter && c0_creates_jitter) || c1_force_jb) && c1_jb_enabled)
+	{
+		ast_set_flag(jb1, JB_USE);
+		if(!c1_jb_timebase_initialized)
+		{
+			if(c0_jb_timebase_initialized)
+			{
+				memcpy(&jb1->timebase, &jb0->timebase, sizeof(struct timeval));
+			}
+			else
+			{
+				gettimeofday(&jb1->timebase, NULL);
+			}
+			ast_set_flag(jb1, JB_TIMEBASE_INITIALIZED);
+		}
+		
+		if(!c1_jb_created)
+		{
+			jb_choose_impl(c1);
+		}
+	}
+}
+
+
+int ast_jb_get_when_to_wakeup(struct ast_channel *c0, struct ast_channel *c1, int time_left)
+{
+	struct ast_jb *jb0 = &c0->jb;
+	struct ast_jb *jb1 = &c1->jb;
+	int c0_use_jb = ast_test_flag(jb0, JB_USE);
+	int c0_jb_is_created = ast_test_flag(jb0, JB_CREATED);
+	int c1_use_jb = ast_test_flag(jb1, JB_USE);
+	int c1_jb_is_created = ast_test_flag(jb1, JB_CREATED);
+	int wait, wait0, wait1;
+	struct timeval tv_now;
+	
+	if(time_left == 0)
+	{
+		/* No time left - the bridge will be retried */
+		/* TODO: Test disable this */
+		/*return 0;*/
+	}
+	
+	if(time_left < 0)
+	{
+		time_left = INT_MAX;
+	}
+	
+	gettimeofday(&tv_now, NULL);
+	
+	wait0 = (c0_use_jb && c0_jb_is_created) ? jb0->next - get_now(jb0, &tv_now) : time_left;
+	wait1 = (c1_use_jb && c1_jb_is_created) ? jb1->next - get_now(jb1, &tv_now) : time_left;
+	
+	wait = wait0 < wait1 ? wait0 : wait1;
+	wait = wait < time_left ? wait : time_left;
+	
+	if(wait == INT_MAX)
+	{
+		wait = -1;
+	}
+	else if(wait < 1)
+	{
+		/* don't let wait=0, because this can cause the pbx thread to loop without any sleeping at all */
+		wait = 1;
+	}
+	
+	return wait;
+}
+
+
+int ast_jb_put(struct ast_channel *chan, struct ast_frame *f)
+{
+	struct ast_jb *jb = &chan->jb;
+	struct ast_jb_impl *jbimpl = jb->impl;
+	void *jbobj = jb->jbobj;
+	struct ast_frame *frr;
+	long now = 0;
+	
+	if(!ast_test_flag(jb, JB_USE))
+	{
+		return -1;
+	}
+	
+	if(f->frametype != AST_FRAME_VOICE)
+	{
+		if(f->frametype == AST_FRAME_DTMF && ast_test_flag(jb, JB_CREATED))
+		{
+			jb_framelog("JB_PUT {now=%ld}: Received DTMF frame. Force resynching jb...\n", now);
+			jbimpl->force_resync(jbobj);
+		}
+		
+		return -1;
+	}
+	
+	if(!f->has_timing_info || f->len < 2)
+	{
+		/* TODO: Shouldn't we disable the jb here? Or we can produce timestamp and seqno? */
+		return -1;
+	}
+	
+	frr = ast_frisolate(f);
+	if(frr == NULL)
+	{
+		ast_log(LOG_ERROR, "Failed to isolate frame for the jitterbuffer on channel '%s'\n", chan->name);
+		return -1;
+	}
+	
+	if(!ast_test_flag(jb, JB_CREATED))
+	{
+		if(create_jb(chan, frr))
+		{
+			ast_frfree(frr);
+			/* Disable the jitterbuffer */
+			ast_clear_flag(jb, JB_USE);
+			return -1;
+		}
+		
+		ast_set_flag(jb, JB_CREATED);
+		return 0;
+	}
+	else
+	{
+		now = get_now(jb, NULL);
+		if(jbimpl->put(jbobj, frr, now) != JB_IMPL_OK)
+		{
+			jb_framelog("JB_PUT {now=%ld}: Dropped frame with ts=%ld and len=%ld\n", now, frr->ts, frr->len);
+			ast_frfree(frr);
+			/*return -1;*/
+			/* TODO: Check this fix - should return 0 here, because the dropped frame shouldn't 
+			   be delivered at all */
+			return 0;
+		}
+		
+		jb->next = jbimpl->next(jbobj);
+		
+		jb_framelog("JB_PUT {now=%ld}: Queued frame with ts=%ld and len=%ld\n", now, frr->ts, frr->len);
+		
+		return 0;
+	}
+}
+
+
+void ast_jb_get_and_deliver(struct ast_channel *c0, struct ast_channel *c1)
+{
+	struct ast_jb *jb0 = &c0->jb;
+	struct ast_jb *jb1 = &c1->jb;
+	int c0_use_jb = ast_test_flag(jb0, JB_USE);
+	int c0_jb_is_created = ast_test_flag(jb0, JB_CREATED);
+	int c1_use_jb = ast_test_flag(jb1, JB_USE);
+	int c1_jb_is_created = ast_test_flag(jb1, JB_CREATED);
+	
+	if(c0_use_jb && c0_jb_is_created)
+	{
+		jb_get_and_deliver(c0);
+	}
+	
+	if(c1_use_jb && c1_jb_is_created)
+	{
+		jb_get_and_deliver(c1);
+	}
+}
+
+
+static void jb_get_and_deliver(struct ast_channel *chan)
+{
+	struct ast_jb *jb = &chan->jb;
+	struct ast_jb_impl *jbimpl = jb->impl;
+	void *jbobj = jb->jbobj;
+	struct ast_frame *f, finterp;
+	long now;
+	int interpolation_len, res;
+	
+	now = get_now(jb, NULL);
+	jb->next = jbimpl->next(jbobj);
+	if(now < jb->next)
+	{
+		jb_framelog("\tJB_GET {now=%ld}: now < next=%ld\n", now, jb->next);
+		return;
+	}
+	
+	while(now >= jb->next)
+	{
+		interpolation_len = ast_codec_interp_len(jb->last_format);
+		
+		res = jbimpl->get(jbobj, &f, now, interpolation_len);
+		
+		switch(res)
+		{
+		case JB_IMPL_OK:
+			/* deliver the frame */
+			ast_write(chan, f);
+		case JB_IMPL_DROP:
+			jb_framelog("\tJB_GET {now=%ld}: %s frame with ts=%ld and len=%ld\n",
+				now, jb_get_actions[res], f->ts, f->len);
+			jb->last_format = f->subclass;
+			ast_frfree(f);
+			break;
+		case JB_IMPL_INTERP:
+			/* interpolate a frame */
+			f = &finterp;
+			f->frametype = AST_FRAME_VOICE;
+			f->subclass = jb->last_format;
+			f->datalen  = 0;
+			f->samples  = interpolation_len * 8;
+			f->mallocd  = 0;
+			f->src  = "JB interpolation";
+			f->data  = NULL;
+			f->delivery = ast_tvadd(jb->timebase, ast_samp2tv(jb->next, 1000));
+			f->offset=AST_FRIENDLY_OFFSET;
+			/* deliver the interpolated frame */
+			ast_write(chan, f);
+			jb_framelog("\tJB_GET {now=%ld}: Interpolated frame with len=%d\n", now, interpolation_len);
+			break;
+		case JB_IMPL_NOFRAME:
+			ast_log(LOG_WARNING,
+				"JB_IMPL_NOFRAME is retuned from the %s jb when now=%ld >= next=%ld, jbnext=%ld!\n",
+				jbimpl->name, now, jb->next, jbimpl->next(jbobj));
+			jb_framelog("\tJB_GET {now=%ld}: No frame for now!?\n", now);
+			return;
+		default:
+			ast_log(LOG_ERROR, "This should never happen!\n");
+			CRASH;
+			break;
+		}
+		
+		jb->next = jbimpl->next(jbobj);
+	}
+}
+
+
+static int create_jb(struct ast_channel *chan, struct ast_frame *frr)
+{
+	struct ast_jb *jb = &chan->jb;
+	struct ast_jb_conf *jbconf = &jb->conf;
+	struct ast_jb_impl *jbimpl = jb->impl;
+	void *jbobj;
+	struct ast_channel *bridged;
+	long now;
+	char logfile_pathname[20 + AST_JB_IMPL_NAME_SIZE + 2*AST_CHANNEL_NAME + 1];
+	char name1[AST_CHANNEL_NAME], name2[AST_CHANNEL_NAME], *tmp;
+	int res;
+
+	jbobj = jb->jbobj = jbimpl->create(jbconf, jbconf->resync_threshold);
+	if(jbobj == NULL)
+	{
+		ast_log(LOG_WARNING, "Failed to create jitterbuffer on channel '%s'\n", chan->name);
+		return -1;
+	}
+	
+	now = get_now(jb, NULL);
+	res = jbimpl->put_first(jbobj, frr, now);
+	
+	/* The result of putting the first frame should not differ from OK. However, its possible
+	   some implementations (i.e. stevek's when resynch_threshold is specified) to drop it. */
+	if(res != JB_IMPL_OK)
+	{
+		ast_log(LOG_WARNING, "Failed to put first frame in the jitterbuffer on channel '%s'\n", chan->name);
+		/*
+		jbimpl->destroy(jbobj);
+		return -1;
+		*/
+	}
+	
+	/* Init next */
+	jb->next = jbimpl->next(jbobj);
+	
+	/* Init last format for a first time. */
+	jb->last_format = frr->subclass;
+	
+	/* Create a frame log file */
+	if(ast_test_flag(jbconf, AST_JB_LOG))
+	{
+		snprintf(name2, sizeof(name2), "%s", chan->name);
+		tmp = strchr(name2, '/');
+		if(tmp != NULL)
+		{
+			*tmp = '#';
+		}
+		bridged = ast_bridged_channel(chan);
+		if(bridged == NULL)
+		{
+			/* We should always have bridged chan if a jitterbuffer is in use */
+			CRASH;
+		}
+		snprintf(name1, sizeof(name1), "%s", bridged->name);
+		tmp = strchr(name1, '/');
+		if(tmp != NULL)
+		{
+			*tmp = '#';
+		}
+		snprintf(logfile_pathname, sizeof(logfile_pathname),
+			"/tmp/ast_%s_jb_%s--%s.log", jbimpl->name, name1, name2);
+		jb->logfile = fopen(logfile_pathname, "w+b");
+		
+		if(jb->logfile == NULL)
+		{
+			ast_log(LOG_WARNING, "Failed to create frame log file with pathname '%s'\n", logfile_pathname);
+		}
+		
+		if(res == JB_IMPL_OK)
+		{
+			jb_framelog("JB_PUT_FIRST {now=%ld}: Queued frame with ts=%ld and len=%ld\n",
+				now, frr->ts, frr->len);
+		}
+		else
+		{
+			jb_framelog("JB_PUT_FIRST {now=%ld}: Dropped frame with ts=%ld and len=%ld\n",
+				now, frr->ts, frr->len);
+		}
+	}
+	
+	jb_verbose("%s jitterbuffer created on channel %s", jbimpl->name, chan->name);
+	
+	/* Free the frame if it has not been queued in the jb */
+	if(res != JB_IMPL_OK)
+	{
+		ast_frfree(frr);
+	}
+	
+	return 0;
+}
+
+
+void ast_jb_destroy(struct ast_channel *chan)
+{
+	struct ast_jb *jb = &chan->jb;
+	struct ast_jb_impl *jbimpl = jb->impl;
+	void *jbobj = jb->jbobj;
+	struct ast_frame *f;
+
+	if(jb->logfile != NULL)
+	{
+		fclose(jb->logfile);
+		jb->logfile = NULL;
+	}
+	
+	if(ast_test_flag(jb, JB_CREATED))
+	{
+		/* Remove and free all frames still queued in jb */
+		while(jbimpl->remove(jbobj, &f) == JB_IMPL_OK)
+		{
+			ast_frfree(f);
+		}
+		
+		jbimpl->destroy(jbobj);
+		jb->jbobj = NULL;
+		
+		ast_clear_flag(jb, JB_CREATED);
+		
+		jb_verbose("%s jitterbuffer destroyed on channel %s", jbimpl->name, chan->name);
+	}
+}
+
+
+static long get_now(struct ast_jb *jb, struct timeval *tv)
+{
+	struct timeval now;
+	
+	if(tv == NULL)
+	{
+		tv = &now;
+		gettimeofday(tv, NULL);
+	}
+	
+	return (long) ((tv->tv_sec - jb->timebase.tv_sec) * 1000) +
+		(long) ((double) (tv->tv_usec - jb->timebase.tv_usec) / 1000.0);
+	
+	/* TODO: For asterisk complience, we should use: */
+	/* return ast_tvdiff_ms(*tv, jb->timebase); */
+}
+
+
+int ast_jb_read_conf(struct ast_jb_conf *conf, char *varname, char *value)
+{
+	int prefixlen = sizeof(AST_JB_CONF_PREFIX) - 1;
+	char *name;
+	int tmp;
+	
+	if(memcmp(AST_JB_CONF_PREFIX, varname, prefixlen) != 0)
+	{
+		return -1;
+	}
+	
+	name = varname + prefixlen;
+	
+	if(strcmp(name, AST_JB_CONF_ENABLE) == 0)
+	{
+		if(ast_true(value))
+		{
+			conf->flags |= AST_JB_ENABLED;
+		}
+	}
+	else if(strcmp(name, AST_JB_CONF_FORCE) == 0)
+	{
+		if(ast_true(value))
+		{
+			conf->flags |= AST_JB_FORCED;
+		}
+	}
+	else if(strcmp(name, AST_JB_CONF_MAX_SIZE) == 0)
+	{
+		if((tmp = atoi(value)) > 0)
+		{
+			conf->max_size = tmp;
+		}
+	}
+	else if(strcmp(name, AST_JB_CONF_RESYNCH_THRESHOLD) == 0)
+	{
+		if((tmp = atoi(value)) > 0)
+		{
+			conf->resync_threshold = tmp;
+		}
+	}
+	else if(strcmp(name, AST_JB_CONF_IMPL) == 0)
+	{
+		if(*value)
+		{
+			snprintf(conf->impl, sizeof(conf->impl), "%s", value);
+		}
+	}
+	else if(strcmp(name, AST_JB_CONF_LOG) == 0)
+	{
+		if(ast_true(value))
+		{
+			conf->flags |= AST_JB_LOG;
+		}
+	}
+	else
+	{
+		return -1;
+	}
+	
+	return 0;
+}
+
+
+void ast_jb_configure(struct ast_channel *chan, struct ast_jb_conf *conf)
+{
+	struct ast_jb *jb = &chan->jb;
+	struct ast_jb_conf *jbconf = &jb->conf;
+	
+	memcpy(jbconf, conf, sizeof(struct ast_jb_conf));
+}
+
+
+void ast_jb_get_config(struct ast_channel *chan, struct ast_jb_conf *conf)
+{
+	struct ast_jb *jb = &chan->jb;
+	struct ast_jb_conf *jbconf = &jb->conf;
+	
+	memcpy(conf, jbconf, sizeof(struct ast_jb_conf));
+}
+
+
+/* Implementation functions */
+
+/* scx */
+
+static void * jb_create_scx(struct ast_jb_conf *general_config, long resynch_threshold)
+{
+	struct scx_jb_conf conf;
+	
+	conf.jbsize = general_config->max_size;
+	conf.resync_threshold = resynch_threshold;
+	
+	return scx_jb_new(&conf);
+}
+
+
+static void jb_destroy_scx(void *jb)
+{
+	struct scx_jb *scxjb = (struct scx_jb *) jb;
+	
+	/* destroy the jb */
+	scx_jb_destroy(scxjb);
+}
+
+
+static int jb_put_first_scx(void *jb, struct ast_frame *fin, long now)
+{
+	struct scx_jb *scxjb = (struct scx_jb *) jb;
+	int res;
+	
+	res = scx_jb_put_first(scxjb, fin, fin->len, fin->ts, now);
+	
+	return scx_to_abstract_code[res];
+}
+
+
+static int jb_put_scx(void *jb, struct ast_frame *fin, long now)
+{
+	struct scx_jb *scxjb = (struct scx_jb *) jb;
+	int res;
+	
+	res = scx_jb_put(scxjb, fin, fin->len, fin->ts, now);
+	
+	return scx_to_abstract_code[res];
+}
+
+
+static int jb_get_scx(void *jb, struct ast_frame **fout, long now, long interpl)
+{
+	struct scx_jb *scxjb = (struct scx_jb *) jb;
+	struct scx_jb_frame frame;
+	int res;
+	
+	res = scx_jb_get(scxjb, &frame, now, interpl);
+	*fout = frame.data;
+	
+	return scx_to_abstract_code[res];
+}
+
+
+static long jb_next_scx(void *jb)
+{
+	struct scx_jb *scxjb = (struct scx_jb *) jb;
+	
+	return scx_jb_next(scxjb);
+}
+
+
+static int jb_remove_scx(void *jb, struct ast_frame **fout)
+{
+	struct scx_jb *scxjb = (struct scx_jb *) jb;
+	struct scx_jb_frame frame;
+	int res;
+	
+	res = scx_jb_remove(scxjb, &frame);
+	*fout = frame.data;
+	
+	return scx_to_abstract_code[res];
+}
+
+
+static void jb_force_resynch_scx(void *jb)
+{
+	struct scx_jb *scxjb = (struct scx_jb *) jb;
+	
+	scx_jb_set_force_resynch(scxjb);
+}
+
+
+/* stevek */
+
+static void * jb_create_stevek(struct ast_jb_conf *general_config, long resynch_threshold)
+{
+	jb_conf jbconf;
+	jitterbuf *stevekjb;
+
+	stevekjb = jb_new();
+	if(stevekjb != NULL)
+	{
+		jbconf.max_jitterbuf = general_config->max_size;
+		jbconf.resync_threshold = general_config->resync_threshold;
+		jbconf.max_contig_interp = 10;
+		jb_setconf(stevekjb, &jbconf);
+	}
+	
+	return stevekjb;
+}
+
+
+static void jb_destroy_stevek(void *jb)
+{
+	jitterbuf *stevekjb = (jitterbuf *) jb;
+	
+	jb_destroy(stevekjb);
+}
+
+
+static int jb_put_first_stevek(void *jb, struct ast_frame *fin, long now)
+{
+	return jb_put_stevek(jb, fin, now);
+}
+
+
+static int jb_put_stevek(void *jb, struct ast_frame *fin, long now)
+{
+	jitterbuf *stevekjb = (jitterbuf *) jb;
+	int res;
+	
+	res = jb_put(stevekjb, fin, JB_TYPE_VOICE, fin->len, fin->ts, now);
+	
+	return stevek_to_abstract_code[res];
+}
+
+
+static int jb_get_stevek(void *jb, struct ast_frame **fout, long now, long interpl)
+{
+	jitterbuf *stevekjb = (jitterbuf *) jb;
+	jb_frame frame;
+	int res;
+	
+	res = jb_get(stevekjb, &frame, now, interpl);
+	*fout = frame.data;
+	
+	return stevek_to_abstract_code[res];
+}
+
+
+static long jb_next_stevek(void *jb)
+{
+	jitterbuf *stevekjb = (jitterbuf *) jb;
+	
+	return jb_next(stevekjb);
+}
+
+
+static int jb_remove_stevek(void *jb, struct ast_frame **fout)
+{
+	jitterbuf *stevekjb = (jitterbuf *) jb;
+	jb_frame frame;
+	int res;
+	
+	res = jb_getall(stevekjb, &frame);
+	*fout = frame.data;
+	
+	return stevek_to_abstract_code[res];
+}
+
+
+static void jb_force_resynch_stevek(void *jb)
+{
+}
+
+
+#endif /* AST_JB */
+
+

Propchange: team/oej/test-this-branch/abstract_jb.c
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: team/oej/test-this-branch/abstract_jb.c
------------------------------------------------------------------------------
    svn:keywords = Author Date Id Revision

Propchange: team/oej/test-this-branch/abstract_jb.c
------------------------------------------------------------------------------
    svn:mime-type = text/plain

Added: team/oej/test-this-branch/abstract_jb.h
URL: http://svn.digium.com/view/asterisk/team/oej/test-this-branch/abstract_jb.h?rev=10708&view=auto
==============================================================================
--- team/oej/test-this-branch/abstract_jb.h (added)
+++ team/oej/test-this-branch/abstract_jb.h Wed Feb 22 09:15:27 2006
@@ -1,0 +1,215 @@
+/*
+ * abstract_jb: common implementation-independent jitterbuffer stuff
+ *
+ * Copyright (C) 2005, Attractel OOD
+ *
+ * Contributors:
+ * Slav Klenov <slav at securax.org>
+ *
+ * Copyright on this file is disclaimed to Digium for inclusion in Asterisk
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ *
+ * \brief Common implementation-independent jitterbuffer stuff.
+ * 
+ */
+
+#ifndef _ABSTRACT_JB_H_
+#define _ABSTRACT_JB_H_
+
+#include <stdio.h>
+#include <sys/time.h>
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+struct ast_channel;
+struct ast_frame;
+
+
+/* Configuration flags */
+#define AST_JB_ENABLED         (1 << 0)
+#define AST_JB_FORCED          (1 << 1)
+#define AST_JB_LOG             (1 << 2)
+
+#define AST_JB_IMPL_NAME_SIZE 12
+
+/*!
+ * \brief General jitterbuffer configuration.
+ */
+struct ast_jb_conf
+{
+	/*! \brief Combination of the AST_JB_ENABLED, AST_JB_FORCED and AST_JB_LOG flags. */
+	unsigned int flags;
+	/*! \brief Max size of the jitterbuffer implementation. */
+	long max_size;
+	/*! \brief Resynchronization threshold of the jitterbuffer implementation. */
+ 	long resync_threshold;
+	/*! \brief Name of the jitterbuffer implementation to be used. */
+ 	char impl[AST_JB_IMPL_NAME_SIZE];
+};
+
+
+/* Jitterbuffer configuration property names */
+#define AST_JB_CONF_PREFIX "jb-"
+#define AST_JB_CONF_ENABLE "enable"
+#define AST_JB_CONF_FORCE "force"
+#define AST_JB_CONF_MAX_SIZE "max-size"
+#define AST_JB_CONF_RESYNCH_THRESHOLD "resynch-threshold"
+#define AST_JB_CONF_IMPL "impl"
+#define AST_JB_CONF_LOG "log"
+
+
+struct ast_jb_impl;
+
+
+/*!
+ * \brief General jitterbuffer state.
+ */
+struct ast_jb
+{
+	/*! \brief Jitterbuffer configuration. */
+	struct ast_jb_conf conf;
+	/*! \brief Jitterbuffer implementation to be used. */
+	struct ast_jb_impl *impl;
+	/*! \brief Jitterbuffer object, passed to the implementation. */
+	void *jbobj;
+	/*! \brief The time the jitterbuffer was created. */
+	struct timeval timebase;
+	/*! \brief The time the next frame should be played. */
+	long next;
+	/*! \brief Voice format of the last frame in. */
+	int last_format;
+	/*! \brief File for frame timestamp tracing. */
+	FILE *logfile;
+	/*! \brief Jitterbuffer internal state flags. */
+	unsigned int flags;
+};
+
+
+/*!
+ * \brief Checks the need of a jb use in a generic bridge.
+ * \param c0 first bridged channel.
+ * \param c1 second bridged channel.
+ *
+ * Called from ast_generic_bridge() when two channels are entering in a bridge.
+ * The function checks the need of a jitterbuffer, depending on both channel's
+ * configuration and technology properties. As a result, this function sets
+ * appropriate internal jb flags to the channels, determining further behaviour
+ * of the bridged jitterbuffers.
+ */
+void ast_jb_do_usecheck(struct ast_channel *c0, struct ast_channel *c1);
+
+
+/*!
+ * \brief Calculates the time, left to the closest delivery moment in a bridge.
+ * \param c0 first bridged channel.
+ * \param c1 second bridged channel.
+ * \param time_left bridge time limit, or -1 if not set.
+ *
+ * Called from ast_generic_bridge() to determine the maximum time to wait for
+ * activity in ast_waitfor_n() call. If neihter of the channels is using jb,
+ * this function returns the time limit passed.
+ *
+ * \return maximum time to wait.
+ */
+int ast_jb_get_when_to_wakeup(struct ast_channel *c0, struct ast_channel *c1, int time_left);
+
+
+/*!
+ * \brief Puts a frame into a channel jitterbuffer.
+ * \param chan channel.
+ * \param frame frame.
+ *
+ * Called from ast_generic_bridge() to put a frame into a channel's jitterbuffer.
+ * The function will successfuly enqueue a frame if and only if:
+ * 1. the channel is using a jitterbuffer (as determined by ast_jb_do_usecheck()),
+ * 2. the frame's type is AST_FRAME_VOICE,
+ * 3. the frame has timing info set and has length >= 2 ms,
+ * 4. there is no some internal error happened (like failed memory allocation).
+ * Frames, successfuly queued, should be delivered by the channel's jitterbuffer,
+ * when their delivery time has came.
+ * Frames, not successfuly queued, should be delivered immediately.
+ * Dropped by the jb implementation frames are considered successfuly enqueued as
+ * far as they should not be delivered at all.
+ *
+ * \return zero if the frame was queued, -1 if not.
+ */
+int ast_jb_put(struct ast_channel *chan, struct ast_frame *f);
+
+
+/*!
+ * \brief Deliver the queued frames that should be delivered now for both channels.
+ * \param c0 first bridged channel.
+ * \param c1 second bridged channel.
+ *
+ * Called from ast_generic_bridge() to deliver any frames, that should be delivered
+ * for the moment of invocation. Does nothing if neihter of the channels is using jb
+ * or has any frames currently queued in. The function delivers frames usig ast_write()
+ * each of the channels.
+ */
+void ast_jb_get_and_deliver(struct ast_channel *c0, struct ast_channel *c1);
+
+
+/*!
+ * \brief Destroys jitterbuffer on a channel.
+ * \param chan channel.
+ *
+ * Called from ast_channel_free() when a channel is destroyed.
+ */
+void ast_jb_destroy(struct ast_channel *chan);
+
+
+/*!
+ * \brief Sets jitterbuffer configuration property.
+ * \param conf configuration to store the property in.
+ * \param varname property name.
+ * \param value property value.
+ *
+ * Called from a channel driver to build a jitterbuffer configuration tipically when
+ * reading a configuration file. It is not neccessary for a channel driver to know
+ * each of the jb configuration property names. The jitterbuffer itself knows them.
+ * The channel driver can pass each config var it reads through this function. It will
+ * return 0 if the variable was consumed from the jb conf.
+ *
+ * \return zero if the property was set to the configuration, -1 if not.
+ */
+int ast_jb_read_conf(struct ast_jb_conf *conf, char *varname, char *value);
+
+
+/*!
+ * \brief Configures a jitterbuffer on a channel.
+ * \param chan channel to configure.
+ * \param conf configuration to apply.
+ *
+ * Called from a channel driver when a channel is created and its jitterbuffer needs
+ * to be configured.
+ */
+void ast_jb_configure(struct ast_channel *chan, struct ast_jb_conf *conf);
+
+
+/*!
+ * \brief Copies a channel's jitterbuffer configuration.
+ * \param chan channel.
+ * \param conf destination.
+ */
+void ast_jb_get_config(struct ast_channel *chan, struct ast_jb_conf *conf);
+
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif /* _ABSTRACT_JB_H_ */

Propchange: team/oej/test-this-branch/abstract_jb.h
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: team/oej/test-this-branch/abstract_jb.h
------------------------------------------------------------------------------
    svn:keywords = Author Date Id Revision

Propchange: team/oej/test-this-branch/abstract_jb.h
------------------------------------------------------------------------------
    svn:mime-type = text/plain



More information about the asterisk-commits mailing list