Ticket #925: New application to simulate network and system impairments to see how it affects the audio quality
git-svn-id: https://svn.pjsip.org/repos/pjproject/trunk@2846 74dad513-b988-da41-8d7b-12977e46ad98
diff --git a/pjsip-apps/src/samples/jbsim.c b/pjsip-apps/src/samples/jbsim.c
new file mode 100644
index 0000000..947289d
--- /dev/null
+++ b/pjsip-apps/src/samples/jbsim.c
@@ -0,0 +1,1154 @@
+/* $Id$ */
+/*
+ * Copyright (C) 2008-2009 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
+ */
+
+/* jbsim:
+
+ This program emulates various system and network impairment
+ conditions as well as application parameters and apply it to
+ an input WAV file. The output is another WAV file as well as
+ a detailed log file (in CSV format) for troubleshooting.
+ */
+
+
+/* Include PJMEDIA and PJLIB */
+#include <pjmedia.h>
+#include <pjmedia-codec.h>
+#include <pjlib.h>
+#include <pjlib-util.h>
+
+#define THIS_FILE "jbsim.c"
+
+/* Timer resolution in ms (must be NONZERO!) */
+#define WALL_CLOCK_TICK 1
+
+/* Defaults settings */
+#define CODEC "PCMU"
+#define LOG_FILE "jbsim.out"
+#define WAV_REF "../../tests/pjsua/wavs/input.8.wav"
+#define WAV_OUT "jbsim.wav"
+#define DURATION 20
+#define DTX PJ_TRUE
+#define PLC PJ_TRUE
+#define MIN_LOST_BURST 0
+#define MAX_LOST_BURST 20
+#define LOSS_CORR 0
+#define LOSS_EXTRA 2
+
+/*
+ Test setup:
+
+ Input WAV --> TX Stream --> Loop transport --> RX Stream --> Out WAV
+ */
+
+/* Stream settings */
+struct stream_cfg
+{
+ const char *name; /* for logging purposes */
+ pjmedia_dir dir; /* stream direction */
+ pj_str_t codec; /* codec name */
+ unsigned ptime; /* zero for default */
+ pj_bool_t dtx; /* DTX enabled? */
+ pj_bool_t plc; /* PLC enabled? */
+};
+
+/* Stream instance. We will instantiate two streams, TX and RX */
+struct stream
+{
+ pj_pool_t *pool;
+ pjmedia_stream *strm;
+ pjmedia_port *port;
+
+ /*
+ * Running states:
+ */
+ union {
+ /* TX stream state */
+ struct {
+ pj_time_val next_schedule; /* Time to send next packet */
+ unsigned total_tx; /* # of TX packets so far */
+ int total_lost; /* # of dropped pkts so far */
+ unsigned cur_lost_burst; /* current # of lost bursts */
+ unsigned drop_prob; /* drop probability value */
+
+ } tx;
+
+ /* RX stream state */
+ struct {
+ pj_time_val next_schedule; /* Time to fetch next pkt */
+ } rx;
+ } state;
+};
+
+/*
+ * Logging
+ */
+
+/* Events names */
+#define EVENT_LOG ""
+#define EVENT_TX "TX/PUT"
+#define EVENT_TX_DROP "*** LOSS ***"
+#define EVENT_GET_PRE "GET (pre)"
+#define EVENT_GET_POST "GET (post)"
+
+
+/* Logging entry */
+struct log_entry
+{
+ pj_time_val wall_clock; /* Wall clock time */
+ const char *event; /* Event name */
+ pjmedia_jb_state *jb_state; /* JB state, optional */
+ pjmedia_rtcp_stat *stat; /* Stream stat, optional */
+ const char *log; /* Log message, optional */
+};
+
+/* Test settings, taken from command line */
+struct test_cfg
+{
+ /* General options */
+ const char *log_file; /* The output log file */
+
+ /* Test settings */
+ pj_str_t codec; /* Codec to be used */
+ unsigned duration_msec; /* Test duration */
+
+ /* Transmitter setting */
+ const char *tx_wav_in; /* Input/reference WAV */
+ unsigned tx_ptime; /* TX stream ptime */
+ unsigned tx_min_jitter; /* Minimum jitter in ms */
+ unsigned tx_max_jitter; /* Max jitter in ms */
+ unsigned tx_dtx; /* DTX enabled? */
+ unsigned tx_pct_avg_lost; /* Average loss in percent */
+ unsigned tx_min_lost_burst; /* Min lost burst in #pkt */
+ unsigned tx_max_lost_burst; /* Max lost burst in #pkt */
+ unsigned tx_pct_loss_corr; /* Loss correlation in pct */
+
+ /* Receiver setting */
+ const char *rx_wav_out; /* Output WAV file */
+ unsigned rx_ptime; /* RX stream ptime */
+ unsigned rx_snd_burst; /* RX sound burst */
+ pj_bool_t rx_plc; /* RX PLC enabled? */
+ int rx_jb_init; /* if > 0 will enable prefetch (ms) */
+ int rx_jb_min_pre; /* JB minimum prefetch (ms) */
+ int rx_jb_max_pre; /* JB maximum prefetch (ms) */
+ int rx_jb_max; /* JB maximum size (ms) */
+};
+
+/*
+ * Global var
+ */
+struct global_app
+{
+ pj_caching_pool cp;
+ pj_pool_t *pool;
+ pj_int16_t *framebuf;
+ pjmedia_endpt *endpt;
+ pjmedia_transport *loop;
+
+ pj_oshandle_t log_fd;
+
+ struct test_cfg cfg;
+
+ struct stream *tx;
+ pjmedia_port *tx_wav;
+
+ struct stream *rx;
+ pjmedia_port *rx_wav;
+
+ pj_time_val wall_clock;
+};
+
+static struct global_app g_app;
+
+
+#ifndef MAX
+# define MAX(a,b) (a<b ? b : a)
+#endif
+
+#ifndef MIN
+# define MIN(a,b) (a<b ? a : b)
+#endif
+
+/*****************************************************************************
+ * Logging
+ */
+static void write_log(struct log_entry *entry)
+{
+ /* Format (CSV): */
+ const char *format = "TIME;EVENT;#RX packets;#packets lost;#JB prefetch;#JB size;#JBDISCARD;#JBEMPTY;Log Message";
+ static char log[2000];
+ enum { D = 20 };
+ char s_jbprefetch[D],
+ s_jbsize[D],
+ s_rxpkt[D],
+ s_losspkt[D],
+ s_jbdiscard[D],
+ s_jbempty[D];
+ static pj_bool_t header_written;
+
+ if (!header_written) {
+ pj_ansi_snprintf(log, sizeof(log),
+ "%s\n", format);
+ if (g_app.log_fd != NULL) {
+ pj_ssize_t size = strlen(log);
+ pj_file_write(g_app.log_fd, log, &size);
+ }
+ header_written = PJ_TRUE;
+ }
+
+ if (entry->jb_state) {
+ sprintf(s_jbprefetch, "%d", entry->jb_state->prefetch);
+ sprintf(s_jbsize, "%d", entry->jb_state->size);
+ sprintf(s_jbdiscard, "%d", entry->jb_state->discard);
+ sprintf(s_jbempty, "%d", entry->jb_state->empty);
+ } else {
+ strcpy(s_jbprefetch, "");
+ strcpy(s_jbsize, "");
+ strcpy(s_jbdiscard, "");
+ strcpy(s_jbempty, "");
+ }
+
+ if (entry->stat) {
+ sprintf(s_rxpkt, "%d", entry->stat->rx.pkt);
+ sprintf(s_losspkt, "%d", entry->stat->rx.loss);
+ } else {
+ strcpy(s_rxpkt, "");
+ strcpy(s_losspkt, "");
+ }
+
+ if (entry->log == NULL)
+ entry->log = "";
+
+ pj_ansi_snprintf(log, sizeof(log),
+ "'%d.%03d;" /* time */
+ "%s;" /* event */
+ "%s;" /* rxpkt */
+ "%s;" /* jb prefetch */
+ "%s;" /* jbsize */
+ "%s;" /* losspkt */
+ "%s;" /* jbdiscard */
+ "%s;" /* jbempty */
+ "%s\n" /* logmsg */,
+
+ (int)entry->wall_clock.sec, (int)entry->wall_clock.msec, /* time */
+ entry->event,
+ s_rxpkt,
+ s_losspkt,
+ s_jbprefetch,
+ s_jbsize,
+ s_jbdiscard,
+ s_jbempty,
+ entry->log
+ );
+ if (g_app.log_fd != NULL) {
+ pj_ssize_t size = strlen(log);
+ pj_file_write(g_app.log_fd, log, &size);
+ }
+}
+
+static void log_cb(int level, const char *data, int len)
+{
+ struct log_entry entry;
+
+ /* Write to stdout */
+ pj_log_write(level, data, len);
+ puts("");
+
+ /* Also add to CSV file */
+ pj_bzero(&entry, sizeof(entry));
+ entry.event = EVENT_LOG;
+ entry.log = data;
+ entry.wall_clock = g_app.wall_clock;
+ write_log(&entry);
+}
+
+static void jbsim_perror(const char *title, pj_status_t status)
+{
+ char errmsg[PJ_ERR_MSG_SIZE];
+
+ pj_strerror(status, errmsg, sizeof(errmsg));
+ PJ_LOG(1,(THIS_FILE, "%s: %s", title, errmsg));
+}
+
+/*****************************************************************************
+ * stream
+ */
+
+static void stream_destroy(struct stream *stream)
+{
+ if (stream->strm)
+ pjmedia_stream_destroy(stream->strm);
+ if (stream->pool)
+ pj_pool_release(stream->pool);
+}
+
+static pj_status_t stream_init(const struct stream_cfg *cfg, struct stream **p_stream)
+{
+ pj_pool_t *pool = NULL;
+ struct stream *stream = NULL;
+ pjmedia_codec_mgr *cm;
+ unsigned count;
+ pjmedia_codec_info *ci;
+ pjmedia_stream_info si;
+ pj_status_t status;
+
+ /* Create instance */
+ pool = pj_pool_create(&g_app.cp.factory, cfg->name, 512, 512, NULL);
+ stream = PJ_POOL_ZALLOC_T(pool, struct stream);
+ stream->pool = pool;
+
+ /* Create stream info */
+ pj_bzero(&si, sizeof(si));
+ si.type = PJMEDIA_TYPE_AUDIO;
+ si.proto = PJMEDIA_TP_PROTO_RTP_AVP;
+ si.dir = cfg->dir;
+ pj_sockaddr_in_init(&si.rem_addr.ipv4, NULL, 4000); /* dummy */
+ pj_sockaddr_in_init(&si.rem_rtcp.ipv4, NULL, 4001); /* dummy */
+
+ /* Apply JB settings if this is RX direction */
+ if (cfg->dir == PJMEDIA_DIR_DECODING) {
+ si.jb_init = g_app.cfg.rx_jb_init;
+ si.jb_min_pre = g_app.cfg.rx_jb_min_pre;
+ si.jb_max_pre = g_app.cfg.rx_jb_max_pre;
+ si.jb_max = g_app.cfg.rx_jb_max;
+ }
+
+ /* Get the codec info and param */
+ cm = pjmedia_endpt_get_codec_mgr(g_app.endpt);
+ count = 1;
+ status = pjmedia_codec_mgr_find_codecs_by_id(cm, &cfg->codec, &count, &ci, NULL);
+ if (status != PJ_SUCCESS) {
+ jbsim_perror("Unable to find codec", status);
+ goto on_error;
+ }
+
+ pj_memcpy(&si.fmt, ci, sizeof(*ci));
+
+ si.param = PJ_POOL_ALLOC_T(pool, struct pjmedia_codec_param);
+ status = pjmedia_codec_mgr_get_default_param(cm, &si.fmt, si.param);
+ if (status != PJ_SUCCESS) {
+ jbsim_perror("Unable to get codec defaults", status);
+ goto on_error;
+ }
+
+ si.tx_pt = si.fmt.pt;
+
+ /* Apply ptime setting */
+ if (cfg->ptime) {
+ si.param->setting.frm_per_pkt = (pj_uint8_t)
+ ((cfg->ptime + si.param->info.frm_ptime - 1) /
+ si.param->info.frm_ptime);
+ }
+ /* Apply DTX setting */
+ si.param->setting.vad = cfg->dtx;
+
+ /* Apply PLC setting */
+ si.param->setting.plc = cfg->plc;
+
+ /* Create stream */
+ status = pjmedia_stream_create(g_app.endpt, pool, &si, g_app.loop, NULL, &stream->strm);
+ if (status != PJ_SUCCESS) {
+ jbsim_perror("Error creating stream", status);
+ goto on_error;
+ }
+
+ status = pjmedia_stream_get_port(stream->strm, &stream->port);
+ if (status != PJ_SUCCESS) {
+ jbsim_perror("Error retrieving stream", status);
+ goto on_error;
+ }
+
+ /* Start stream */
+ status = pjmedia_stream_start(stream->strm);
+ if (status != PJ_SUCCESS) {
+ jbsim_perror("Error starting stream", status);
+ goto on_error;
+ }
+
+ /* Done */
+ *p_stream = stream;
+ return PJ_SUCCESS;
+
+on_error:
+ if (stream) {
+ stream_destroy(stream);
+ } else {
+ if (pool)
+ pj_pool_release(pool);
+ }
+ return status;
+}
+
+
+/*****************************************************************************
+ * The test session
+ */
+static void test_destroy(void)
+{
+ if (g_app.tx)
+ stream_destroy(g_app.tx);
+ if (g_app.tx_wav)
+ pjmedia_port_destroy(g_app.tx_wav);
+ if (g_app.rx)
+ stream_destroy(g_app.rx);
+ if (g_app.rx_wav)
+ pjmedia_port_destroy(g_app.rx_wav);
+ if (g_app.loop)
+ pjmedia_transport_close(g_app.loop);
+ if (g_app.endpt)
+ pjmedia_endpt_destroy( g_app.endpt );
+ if (g_app.log_fd) {
+ pj_log_set_log_func(&pj_log_write);
+ pj_log_set_decor(pj_log_get_decor() | PJ_LOG_HAS_NEWLINE);
+ pj_file_close(g_app.log_fd);
+ g_app.log_fd = NULL;
+ }
+ if (g_app.pool)
+ pj_pool_release(g_app.pool);
+ pj_caching_pool_destroy( &g_app.cp );
+ pj_shutdown();
+}
+
+
+static pj_status_t test_init(void)
+{
+ struct stream_cfg strm_cfg;
+ pj_status_t status;
+
+ /* Must init PJLIB first: */
+ status = pj_init();
+ PJ_ASSERT_RETURN(status == PJ_SUCCESS, status);
+
+ /* Must create a pool factory before we can allocate any memory. */
+ pj_caching_pool_init(&g_app.cp, &pj_pool_factory_default_policy, 0);
+
+ /* Pool */
+ g_app.pool = pj_pool_create(&g_app.cp.factory, "g_app", 512, 512, NULL);
+
+ /* Log file */
+ if (g_app.cfg.log_file) {
+ status = pj_file_open(g_app.pool, g_app.cfg.log_file,
+ PJ_O_WRONLY,
+ &g_app.log_fd);
+ if (status != PJ_SUCCESS) {
+ jbsim_perror("Error writing output file", status);
+ goto on_error;
+ }
+
+ pj_log_set_decor(PJ_LOG_HAS_SENDER | PJ_LOG_HAS_COLOR | PJ_LOG_HAS_LEVEL_TEXT);
+ pj_log_set_log_func(&log_cb);
+ }
+
+ /*
+ * Initialize media endpoint.
+ * This will implicitly initialize PJMEDIA too.
+ */
+ status = pjmedia_endpt_create(&g_app.cp.factory, NULL, 0, &g_app.endpt);
+ if (status != PJ_SUCCESS) {
+ jbsim_perror("Error creating media endpoint", status);
+ goto on_error;
+ }
+
+ /* Register codecs */
+#if defined(PJMEDIA_HAS_GSM_CODEC) && PJMEDIA_HAS_GSM_CODEC != 0
+ pjmedia_codec_gsm_init(g_app.endpt);
+#endif
+#if defined(PJMEDIA_HAS_G711_CODEC) && PJMEDIA_HAS_G711_CODEC!=0
+ pjmedia_codec_g711_init(g_app.endpt);
+#endif
+#if defined(PJMEDIA_HAS_SPEEX_CODEC) && PJMEDIA_HAS_SPEEX_CODEC!=0
+ pjmedia_codec_speex_init(g_app.endpt, 0, PJMEDIA_CODEC_SPEEX_DEFAULT_QUALITY,
+ PJMEDIA_CODEC_SPEEX_DEFAULT_COMPLEXITY);
+#endif
+#if defined(PJMEDIA_HAS_G722_CODEC) && (PJMEDIA_HAS_G722_CODEC != 0)
+ pjmedia_codec_g722_init(g_app.endpt);
+#endif
+#if defined(PJMEDIA_HAS_ILBC_CODEC) && PJMEDIA_HAS_ILBC_CODEC != 0
+ pjmedia_codec_ilbc_init(g_app.endpt, 30);
+#endif
+#if defined(PJMEDIA_HAS_INTEL_IPP) && PJMEDIA_HAS_INTEL_IPP != 0
+ pjmedia_codec_ipp_init(g_app.endpt);
+#endif
+#if defined(PJMEDIA_HAS_L16_CODEC) && PJMEDIA_HAS_L16_CODEC != 0
+ pjmedia_codec_l16_init(g_app.endpt, 0);
+#endif
+
+ /* Create the loop transport */
+ status = pjmedia_transport_loop_create(g_app.endpt, &g_app.loop);
+ if (status != PJ_SUCCESS) {
+ jbsim_perror("Error creating loop transport", status);
+ goto on_error;
+ }
+
+ /* Create transmitter stream */
+ pj_bzero(&strm_cfg, sizeof(strm_cfg));
+ strm_cfg.name = "tx";
+ strm_cfg.dir = PJMEDIA_DIR_ENCODING;
+ strm_cfg.codec = g_app.cfg.codec;
+ strm_cfg.ptime = g_app.cfg.tx_ptime;
+ strm_cfg.dtx = g_app.cfg.tx_dtx;
+ strm_cfg.plc = PJ_TRUE;
+ status = stream_init(&strm_cfg, &g_app.tx);
+ if (status != PJ_SUCCESS)
+ goto on_error;
+
+ /* Create transmitter WAV */
+ status = pjmedia_wav_player_port_create(g_app.pool,
+ g_app.cfg.tx_wav_in,
+ g_app.cfg.tx_ptime,
+ 0,
+ 0,
+ &g_app.tx_wav);
+ if (status != PJ_SUCCESS) {
+ jbsim_perror("Error reading input WAV file", status);
+ goto on_error;
+ }
+
+ /* Make sure stream and WAV parameters match */
+ if (g_app.tx_wav->info.clock_rate != g_app.tx->port->info.clock_rate ||
+ g_app.tx_wav->info.channel_count != g_app.tx->port->info.channel_count)
+ {
+ jbsim_perror("Error: Input WAV file has different clock rate "
+ "or number of channels than the codec", PJ_SUCCESS);
+ goto on_error;
+ }
+
+
+ /* Create receiver */
+ pj_bzero(&strm_cfg, sizeof(strm_cfg));
+ strm_cfg.name = "rx";
+ strm_cfg.dir = PJMEDIA_DIR_DECODING;
+ strm_cfg.codec = g_app.cfg.codec;
+ strm_cfg.ptime = g_app.cfg.rx_ptime;
+ strm_cfg.dtx = PJ_TRUE;
+ strm_cfg.plc = g_app.cfg.rx_plc;
+ status = stream_init(&strm_cfg, &g_app.rx);
+ if (status != PJ_SUCCESS)
+ goto on_error;
+
+ /* Create receiver WAV */
+ status = pjmedia_wav_writer_port_create(g_app.pool,
+ g_app.cfg.rx_wav_out,
+ g_app.rx->port->info.clock_rate,
+ g_app.rx->port->info.channel_count,
+ g_app.rx->port->info.samples_per_frame,
+ g_app.rx->port->info.bits_per_sample,
+ 0,
+ 0,
+ &g_app.rx_wav);
+ if (status != PJ_SUCCESS) {
+ jbsim_perror("Error creating output WAV file", status);
+ goto on_error;
+ }
+
+
+ /* Frame buffer */
+ g_app.framebuf = (pj_int16_t*)
+ pj_pool_alloc(g_app.pool,
+ MAX(g_app.rx->port->info.samples_per_frame,
+ g_app.tx->port->info.samples_per_frame) * sizeof(pj_int16_t));
+
+
+ /* Set the receiver in the loop transport */
+ pjmedia_transport_loop_disable_rx(g_app.loop, g_app.tx->strm, PJ_TRUE);
+
+ /* Done */
+ return PJ_SUCCESS;
+
+on_error:
+ test_destroy();
+ return status;
+}
+
+static void run_one_frame(pjmedia_port *src, pjmedia_port *dst,
+ pj_bool_t *has_frame)
+{
+ pjmedia_frame frame;
+ pj_status_t status;
+
+ pj_bzero(&frame, sizeof(frame));
+ frame.type = PJMEDIA_FRAME_TYPE_AUDIO;
+ frame.buf = g_app.framebuf;
+ frame.size = src->info.samples_per_frame * 2;
+
+ status = pjmedia_port_get_frame(src, &frame);
+ pj_assert(status == PJ_SUCCESS);
+
+ if (status!= PJ_SUCCESS || frame.type != PJMEDIA_FRAME_TYPE_AUDIO) {
+ frame.buf = g_app.framebuf;
+ pjmedia_zero_samples(g_app.framebuf, src->info.samples_per_frame);
+ frame.size = src->info.samples_per_frame * 2;
+ if (has_frame)
+ *has_frame = PJ_FALSE;
+ } else {
+ if (has_frame)
+ *has_frame = PJ_TRUE;
+ }
+
+
+ status = pjmedia_port_put_frame(dst, &frame);
+ pj_assert(status == PJ_SUCCESS);
+}
+
+
+/* This is the transmission "tick".
+ * This function is called periodically every "tick" milliseconds, and
+ * it will determine whether to transmit packet(s) (or to drop it).
+ */
+static void tx_tick(const pj_time_val *t)
+{
+ struct stream *strm = g_app.tx;
+ static char log_msg[120];
+ pjmedia_port *port = g_app.tx->port;
+ long pkt_interval;
+
+ /* packet interval, without jitter */
+ pkt_interval = port->info.samples_per_frame * 1000 /
+ port->info.clock_rate;
+
+ while (PJ_TIME_VAL_GTE(*t, strm->state.tx.next_schedule)) {
+ struct log_entry entry;
+ pj_bool_t drop_this_pkt = PJ_FALSE;
+ int jitter;
+
+ /* Init log entry */
+ pj_bzero(&entry, sizeof(entry));
+ entry.wall_clock = *t;
+
+ /*
+ * Determine whether to drop this packet
+ */
+ if (strm->state.tx.cur_lost_burst) {
+ /* We are currently dropping packet */
+
+ /* Make it comply to minimum lost burst */
+ if (strm->state.tx.cur_lost_burst < g_app.cfg.tx_min_lost_burst) {
+ drop_this_pkt = PJ_TRUE;
+ }
+
+ /* Correlate the next packet loss */
+ if (!drop_this_pkt &&
+ strm->state.tx.cur_lost_burst < g_app.cfg.tx_max_lost_burst &&
+ MAX(strm->state.tx.total_lost-LOSS_EXTRA,0) * 100 / MAX(strm->state.tx.total_tx,1) < g_app.cfg.tx_pct_avg_lost
+ )
+ {
+ strm->state.tx.drop_prob = ((g_app.cfg.tx_pct_loss_corr * strm->state.tx.drop_prob) +
+ ((100-g_app.cfg.tx_pct_loss_corr) * (pj_rand()%100))
+ ) / 100;
+ if (strm->state.tx.drop_prob >= 100)
+ strm->state.tx.drop_prob = 99;
+
+ if (strm->state.tx.drop_prob >= 100 - g_app.cfg.tx_pct_avg_lost)
+ drop_this_pkt = PJ_TRUE;
+ }
+ }
+
+ /* If we're not dropping packet then use randomly distributed loss */
+ if (!drop_this_pkt &&
+ MAX(strm->state.tx.total_lost-LOSS_EXTRA,0) * 100 / MAX(strm->state.tx.total_tx,1) < g_app.cfg.tx_pct_avg_lost)
+ {
+ strm->state.tx.drop_prob = pj_rand() % 100;
+
+ if (strm->state.tx.drop_prob >= 100 - g_app.cfg.tx_pct_avg_lost)
+ drop_this_pkt = PJ_TRUE;
+ }
+
+ if (drop_this_pkt) {
+ /* Drop the frame */
+ pjmedia_transport_simulate_lost(g_app.loop, PJMEDIA_DIR_ENCODING, 100);
+ run_one_frame(g_app.tx_wav, g_app.tx->port, NULL);
+ pjmedia_transport_simulate_lost(g_app.loop, PJMEDIA_DIR_ENCODING, 0);
+
+ entry.event = EVENT_TX_DROP;
+ entry.log = "** This packet was lost **";
+
+ ++strm->state.tx.total_lost;
+ ++strm->state.tx.cur_lost_burst;
+
+ } else {
+ pjmedia_rtcp_stat stat;
+ pjmedia_jb_state jstate;
+ unsigned last_discard;
+
+ pjmedia_stream_get_stat_jbuf(g_app.rx->strm, &jstate);
+ last_discard = jstate.discard;
+
+ run_one_frame(g_app.tx_wav, g_app.tx->port, NULL);
+
+ pjmedia_stream_get_stat(g_app.rx->strm, &stat);
+ pjmedia_stream_get_stat_jbuf(g_app.rx->strm, &jstate);
+
+ entry.event = EVENT_TX;
+ entry.jb_state = &jstate;
+ entry.stat = &stat;
+ entry.log = log_msg;
+
+ if (jstate.discard > last_discard)
+ strcat(log_msg, "** Note: packet was discarded by jitter buffer **");
+
+ strm->state.tx.cur_lost_burst = 0;
+ }
+
+ write_log(&entry);
+
+ ++strm->state.tx.total_tx;
+
+ /* Calculate next schedule */
+ strm->state.tx.next_schedule.sec = 0;
+ strm->state.tx.next_schedule.msec = (strm->state.tx.total_tx + 1) * pkt_interval;
+
+ /* Apply jitter */
+ if (g_app.cfg.tx_max_jitter || g_app.cfg.tx_min_jitter) {
+
+ if (g_app.cfg.tx_max_jitter == g_app.cfg.tx_min_jitter) {
+ /* Fixed jitter */
+ switch (pj_rand() % 3) {
+ case 0:
+ jitter = 0 - g_app.cfg.tx_min_jitter;
+ break;
+ case 2:
+ jitter = g_app.cfg.tx_min_jitter;
+ break;
+ default:
+ jitter = 0;
+ break;
+ }
+ } else {
+ int jitter_range;
+ jitter_range = (g_app.cfg.tx_max_jitter-g_app.cfg.tx_min_jitter)*2;
+ jitter = pj_rand() % jitter_range;
+ if (jitter < jitter_range/2) {
+ jitter = 0 - g_app.cfg.tx_min_jitter - (jitter/2);
+ } else {
+ jitter = g_app.cfg.tx_min_jitter + (jitter/2);
+ }
+ }
+
+ } else {
+ jitter = 0;
+ }
+
+ pj_time_val_normalize(&strm->state.tx.next_schedule);
+
+ sprintf(log_msg, "** Packet #%u tick is at %d.%03d, %d ms jitter applied **",
+ strm->state.tx.total_tx+1,
+ (int)strm->state.tx.next_schedule.sec, (int)strm->state.tx.next_schedule.msec,
+ jitter);
+
+ strm->state.tx.next_schedule.msec += jitter;
+ pj_time_val_normalize(&strm->state.tx.next_schedule);
+
+ } /* while */
+}
+
+
+/* This is the RX "tick".
+ * This function is called periodically every "tick" milliseconds, and
+ * it will determine whether to call get_frame() from the RX stream.
+ */
+static void rx_tick(const pj_time_val *t)
+{
+ struct stream *strm = g_app.rx;
+ pjmedia_port *port = g_app.rx->port;
+ long pkt_interval;
+
+ pkt_interval = port->info.samples_per_frame * 1000 /
+ port->info.clock_rate *
+ g_app.cfg.rx_snd_burst;
+
+ if (PJ_TIME_VAL_GTE(*t, strm->state.rx.next_schedule)) {
+ unsigned i;
+ for (i=0; i<g_app.cfg.rx_snd_burst; ++i) {
+ struct log_entry entry;
+ pjmedia_rtcp_stat stat;
+ pjmedia_jb_state jstate;
+ pj_bool_t has_frame;
+ char msg[120];
+ unsigned last_empty;
+
+ pjmedia_stream_get_stat(g_app.rx->strm, &stat);
+ pjmedia_stream_get_stat_jbuf(g_app.rx->strm, &jstate);
+ last_empty = jstate.empty;
+
+ /* Pre GET event */
+ pj_bzero(&entry, sizeof(entry));
+ entry.event = EVENT_GET_PRE;
+ entry.wall_clock = *t;
+ entry.stat = &stat;
+ entry.jb_state = &jstate;
+
+ write_log(&entry);
+
+ /* GET */
+ run_one_frame(g_app.rx->port, g_app.rx_wav, &has_frame);
+
+ /* Post GET event */
+ pjmedia_stream_get_stat(g_app.rx->strm, &stat);
+ pjmedia_stream_get_stat_jbuf(g_app.rx->strm, &jstate);
+
+ pj_bzero(&entry, sizeof(entry));
+ entry.event = EVENT_GET_POST;
+ entry.wall_clock = *t;
+ entry.stat = &stat;
+ entry.jb_state = &jstate;
+
+ msg[0] = '\0';
+ entry.log = msg;
+
+ if (jstate.empty > last_empty)
+ strcat(msg, "** JBUF was empty **");
+ if (!has_frame)
+ strcat(msg, "** NULL frame was returned **");
+
+ write_log(&entry);
+
+ }
+
+
+ strm->state.rx.next_schedule.msec += pkt_interval;
+ pj_time_val_normalize(&strm->state.rx.next_schedule);
+ }
+
+}
+
+static void test_loop(long duration)
+{
+ g_app.wall_clock.sec = 0;
+ g_app.wall_clock.msec = 0;
+
+ while (PJ_TIME_VAL_MSEC(g_app.wall_clock) <= duration) {
+
+ /* Run TX tick */
+ tx_tick(&g_app.wall_clock);
+
+ /* Run RX tick */
+ rx_tick(&g_app.wall_clock);
+
+ /* Increment tick */
+ g_app.wall_clock.msec += WALL_CLOCK_TICK;
+ pj_time_val_normalize(&g_app.wall_clock);
+ }
+}
+
+
+/*****************************************************************************
+ * usage()
+ */
+enum {
+ OPT_CODEC = 'c',
+ OPT_INPUT = 'i',
+ OPT_OUTPUT = 'o',
+ OPT_DURATION = 'd',
+ OPT_LOG_FILE = 'l',
+ OPT_LOSS = 'x',
+ OPT_MIN_JITTER = 'j',
+ OPT_MAX_JITTER = 'J',
+ OPT_SND_BURST = 'b',
+ OPT_TX_PTIME = 't',
+ OPT_RX_PTIME = 'r',
+ OPT_NO_VAD = 'U',
+ OPT_NO_PLC = 'p',
+ OPT_JB_PREFETCH = 'P',
+ OPT_JB_MIN_PRE = 'm',
+ OPT_JB_MAX_PRE = 'M',
+ OPT_JB_MAX = 'X',
+ OPT_HELP = 'h',
+ OPT_MIN_LOST_BURST = 1,
+ OPT_MAX_LOST_BURST,
+ OPT_LOSS_CORR,
+};
+
+
+static void usage(void)
+{
+ printf("jbsim - System and network impairments simulator\n");
+ printf("Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)\n");
+ printf("\n");
+ printf("This program emulates various system and network impairment\n");
+ printf("conditions as well as application parameters and apply it to\n");
+ printf("an input WAV file. The output is another WAV file as well as\n");
+ printf("a detailed log file (in CSV format) for troubleshooting.\n");
+ printf("\n");
+ printf("Usage:\n");
+ printf(" jbsim [OPTIONS]\n");
+ printf("\n");
+ printf("General OPTIONS:\n");
+ printf(" --codec, -%c NAME Set the audio codec\n", OPT_CODEC);
+ printf(" Default: %s\n", CODEC);
+ printf(" --input, -%c FILE Set WAV reference file to FILE\n", OPT_INPUT);
+ printf(" Default: " WAV_REF "\n");
+ printf(" --output, -%c FILE Set WAV output file to FILE\n", OPT_OUTPUT);
+ printf(" Default: " WAV_OUT "\n");
+ printf(" --duration, -%c SEC Set test duration to SEC seconds\n", OPT_DURATION);
+ printf(" Default: %d\n", DURATION);
+ printf(" --log-file, -%c FILE Save simulation log file to FILE\n", OPT_LOG_FILE);
+ printf(" Note: FILE will be in CSV format with semicolon separator\n");
+ printf(" Default: %s\n", LOG_FILE);
+ printf(" --help, -h Display this screen\n");
+ printf("\n");
+ printf("Simulation OPTIONS:\n");
+ printf(" --loss, -%c PCT Set packet average loss to PCT percent\n", OPT_LOSS);
+ printf(" Default: 0\n");
+ printf(" --loss-corr PCT Set the loss correlation to PCT percent. Default: 0\n");
+ printf(" --min-lost-burst N Set minimum packet lost burst (default:%d)\n", MIN_LOST_BURST);
+ printf(" --max-lost-burst N Set maximum packet lost burst (default:%d)\n", MAX_LOST_BURST);
+ printf(" --min-jitter, -%c MSEC Set minimum network jitter to MSEC\n", OPT_MIN_JITTER);
+ printf(" Default: 0\n");
+ printf(" --max-jitter, -%c MSEC Set maximum network jitter to MSEC\n", OPT_MAX_JITTER);
+ printf(" Default: 0\n");
+ printf(" --snd-burst, -%c VAL Set RX sound burst value to VAL frames.\n", OPT_SND_BURST);
+ printf(" Default: 1\n");
+ printf(" --tx-ptime, -%c MSEC Set transmitter ptime to MSEC\n", OPT_TX_PTIME);
+ printf(" Default: 0 (not set, use default)\n");
+ printf(" --rx-ptime, -%c MSEC Set receiver ptime to MSEC\n", OPT_RX_PTIME);
+ printf(" Default: 0 (not set, use default)\n");
+ printf(" --no-vad, -%c Disable VAD/DTX in transmitter\n", OPT_NO_VAD);
+ printf(" --no-plc, -%c Disable PLC in receiver\n", OPT_NO_PLC);
+ printf(" --jb-prefetch, -%c Enable prefetch bufferring in jitter buffer\n", OPT_JB_PREFETCH);
+ printf(" --jb-min-pre, -%c MSEC Jitter buffer minimum prefetch delay in msec\n", OPT_JB_MIN_PRE);
+ printf(" --jb-max-pre, -%c MSEC Jitter buffer maximum prefetch delay in msec\n", OPT_JB_MAX_PRE);
+ printf(" --jb-max, -%c MSEC Set maximum delay that can be accomodated by the\n", OPT_JB_MAX);
+ printf(" jitter buffer msec.\n");
+}
+
+
+static int init_options(int argc, char *argv[])
+{
+ struct pj_getopt_option long_options[] = {
+ { "codec", 1, 0, OPT_CODEC },
+ { "input", 1, 0, OPT_INPUT },
+ { "output", 1, 0, OPT_OUTPUT },
+ { "duration", 1, 0, OPT_DURATION },
+ { "log-file", 1, 0, OPT_LOG_FILE},
+ { "loss", 1, 0, OPT_LOSS },
+ { "min-lost-burst", 1, 0, OPT_MIN_LOST_BURST},
+ { "max-lost-burst", 1, 0, OPT_MAX_LOST_BURST},
+ { "loss-corr", 1, 0, OPT_LOSS_CORR},
+ { "min-jitter", 1, 0, OPT_MIN_JITTER },
+ { "max-jitter", 1, 0, OPT_MAX_JITTER },
+ { "snd-burst", 1, 0, OPT_SND_BURST },
+ { "tx-ptime", 1, 0, OPT_TX_PTIME },
+ { "rx-ptime", 1, 0, OPT_RX_PTIME },
+ { "no-vad", 0, 0, OPT_NO_VAD },
+ { "no-plc", 0, 0, OPT_NO_PLC },
+ { "jb-prefetch", 0, 0, OPT_JB_PREFETCH },
+ { "jb-min-pre", 1, 0, OPT_JB_MIN_PRE },
+ { "jb-max-pre", 1, 0, OPT_JB_MAX_PRE },
+ { "jb-max", 1, 0, OPT_JB_MAX },
+ { "help", 0, 0, OPT_HELP},
+ { NULL, 0, 0, 0 },
+ };
+ int c;
+ int option_index;
+ char format[128];
+
+ /* Init default config */
+ g_app.cfg.codec = pj_str(CODEC);
+ g_app.cfg.duration_msec = DURATION * 1000;
+ g_app.cfg.log_file = LOG_FILE;
+ g_app.cfg.tx_wav_in = WAV_REF;
+ g_app.cfg.tx_ptime = 0;
+ g_app.cfg.tx_min_jitter = 0;
+ g_app.cfg.tx_max_jitter = 0;
+ g_app.cfg.tx_dtx = DTX;
+ g_app.cfg.tx_pct_avg_lost = 0;
+ g_app.cfg.tx_min_lost_burst = MIN_LOST_BURST;
+ g_app.cfg.tx_max_lost_burst = MAX_LOST_BURST;
+ g_app.cfg.tx_pct_loss_corr = LOSS_CORR;
+
+ g_app.cfg.rx_wav_out = WAV_OUT;
+ g_app.cfg.rx_ptime = 0;
+ g_app.cfg.rx_plc = PLC;
+ g_app.cfg.rx_snd_burst = 1;
+ g_app.cfg.rx_jb_init = -1;
+ g_app.cfg.rx_jb_min_pre = -1;
+ g_app.cfg.rx_jb_max_pre = -1;
+ g_app.cfg.rx_jb_max = -1;
+
+ /* Build format */
+ format[0] = '\0';
+ for (c=0; c<PJ_ARRAY_SIZE(long_options)-1; ++c) {
+ if (long_options[c].has_arg) {
+ char cmd[10];
+ pj_ansi_snprintf(cmd, sizeof(cmd), "%c:", long_options[c].val);
+ pj_ansi_strcat(format, cmd);
+ }
+ }
+ for (c=0; c<PJ_ARRAY_SIZE(long_options)-1; ++c) {
+ if (long_options[c].has_arg == 0) {
+ char cmd[10];
+ pj_ansi_snprintf(cmd, sizeof(cmd), "%c", long_options[c].val);
+ pj_ansi_strcat(format, cmd);
+ }
+ }
+
+ /* Parse options */
+ pj_optind = 0;
+ while((c=pj_getopt_long(argc,argv, format,
+ long_options, &option_index))!=-1)
+ {
+ switch (c) {
+ case OPT_CODEC:
+ g_app.cfg.codec = pj_str(pj_optarg);
+ break;
+ case OPT_INPUT:
+ g_app.cfg.tx_wav_in = pj_optarg;
+ break;
+ case OPT_OUTPUT:
+ g_app.cfg.rx_wav_out = pj_optarg;
+ break;
+ case OPT_DURATION:
+ g_app.cfg.duration_msec = atoi(pj_optarg) * 1000;
+ break;
+ case OPT_LOG_FILE:
+ g_app.cfg.log_file = pj_optarg;
+ break;
+ case OPT_LOSS:
+ g_app.cfg.tx_pct_avg_lost = atoi(pj_optarg);
+ if (g_app.cfg.tx_pct_avg_lost > 100) {
+ puts("Error: Invalid loss value?");
+ return 1;
+ }
+ break;
+ case OPT_MIN_LOST_BURST:
+ g_app.cfg.tx_min_lost_burst = atoi(pj_optarg);
+ break;
+ case OPT_MAX_LOST_BURST:
+ g_app.cfg.tx_max_lost_burst = atoi(pj_optarg);
+ break;
+ case OPT_LOSS_CORR:
+ g_app.cfg.tx_pct_loss_corr = atoi(pj_optarg);
+ if (g_app.cfg.tx_pct_avg_lost > 100) {
+ puts("Error: Loss correlation is in percentage, value is not valid?");
+ return 1;
+ }
+ break;
+ case OPT_MIN_JITTER:
+ g_app.cfg.tx_min_jitter = atoi(pj_optarg);
+ break;
+ case OPT_MAX_JITTER:
+ g_app.cfg.tx_max_jitter = atoi(pj_optarg);
+ break;
+ case OPT_SND_BURST:
+ g_app.cfg.rx_snd_burst = atoi(pj_optarg);
+ break;
+ case OPT_TX_PTIME:
+ g_app.cfg.tx_ptime = atoi(pj_optarg);
+ break;
+ case OPT_RX_PTIME:
+ g_app.cfg.rx_ptime = atoi(pj_optarg);
+ break;
+ case OPT_NO_VAD:
+ g_app.cfg.tx_dtx = PJ_FALSE;
+ break;
+ case OPT_NO_PLC:
+ g_app.cfg.rx_plc = PJ_FALSE;
+ break;
+ case OPT_JB_PREFETCH:
+ g_app.cfg.rx_jb_init = 1;
+ break;
+ case OPT_JB_MIN_PRE:
+ g_app.cfg.rx_jb_min_pre = atoi(pj_optarg);
+ break;
+ case OPT_JB_MAX_PRE:
+ g_app.cfg.rx_jb_max_pre = atoi(pj_optarg);
+ break;
+ case OPT_JB_MAX:
+ g_app.cfg.rx_jb_max = atoi(pj_optarg);
+ break;
+ case OPT_HELP:
+ usage();
+ return 1;
+ default:
+ usage();
+ return 1;
+ }
+ }
+
+ /* Check for orphaned params */
+ if (pj_optind < argc) {
+ usage();
+ return 1;
+ }
+
+ /* Normalize options */
+ if (g_app.cfg.rx_jb_init < g_app.cfg.rx_jb_min_pre)
+ g_app.cfg.rx_jb_init = g_app.cfg.rx_jb_min_pre;
+ else if (g_app.cfg.rx_jb_init > g_app.cfg.rx_jb_max_pre)
+ g_app.cfg.rx_jb_init = g_app.cfg.rx_jb_max_pre;
+
+ if (g_app.cfg.tx_max_jitter < g_app.cfg.tx_min_jitter)
+ g_app.cfg.tx_max_jitter = g_app.cfg.tx_min_jitter;
+ return 0;
+}
+
+/*****************************************************************************
+ * main()
+ */
+int main(int argc, char *argv[])
+{
+ pj_status_t status;
+
+ if (init_options(argc, argv) != 0)
+ return 1;
+
+
+ /* Init */
+ status = test_init();
+ if (status != PJ_SUCCESS)
+ return 1;
+
+ /* Print parameters */
+ PJ_LOG(3,(THIS_FILE, "Starting simulation. Parameters: "));
+ PJ_LOG(3,(THIS_FILE, " Codec=%.*s, tx_ptime=%d, rx_ptime=%d",
+ (int)g_app.cfg.codec.slen,
+ g_app.cfg.codec.ptr,
+ g_app.cfg.tx_ptime,
+ g_app.cfg.rx_ptime));
+ PJ_LOG(3,(THIS_FILE, " Loss avg=%d%%, min_burst=%d, max_burst=%d",
+ g_app.cfg.tx_pct_avg_lost,
+ g_app.cfg.tx_min_lost_burst,
+ g_app.cfg.tx_max_lost_burst));
+ PJ_LOG(3,(THIS_FILE, " TX jitter min=%dms, max=%dms",
+ g_app.cfg.tx_min_jitter,
+ g_app.cfg.tx_max_jitter));
+ PJ_LOG(3,(THIS_FILE, " RX jb init:%dms, min_pre=%dms, max_pre=%dms, max=%dms",
+ g_app.cfg.rx_jb_init,
+ g_app.cfg.rx_jb_min_pre,
+ g_app.cfg.rx_jb_max_pre,
+ g_app.cfg.rx_jb_max));
+ PJ_LOG(3,(THIS_FILE, " RX sound burst:%d frames",
+ g_app.cfg.rx_snd_burst));
+ PJ_LOG(3,(THIS_FILE, " DTX=%d, PLC=%d",
+ g_app.cfg.tx_dtx, g_app.cfg.rx_plc));
+
+ /* Run test loop */
+ test_loop(g_app.cfg.duration_msec);
+
+ /* Print statistics */
+ PJ_LOG(3,(THIS_FILE, "Simulation done"));
+ PJ_LOG(3,(THIS_FILE, " TX packets=%u, dropped=%u/%5.1f%%",
+ g_app.tx->state.tx.total_tx,
+ g_app.tx->state.tx.total_lost,
+ (float)(g_app.tx->state.tx.total_lost * 100.0 / g_app.tx->state.tx.total_tx)));
+
+ /* Done */
+ test_destroy();
+
+ return 0;
+}