summaryrefslogtreecommitdiffstats
path: root/apps/codecs/libspeex/jitter.c
diff options
context:
space:
mode:
authorThom Johansen <thomj@rockbox.org>2007-11-22 01:29:14 +0000
committerThom Johansen <thomj@rockbox.org>2007-11-22 01:29:14 +0000
commit57a27c69a9f3b9b69aff9360c09f7298ffd7b670 (patch)
tree252dcf43c2ed5058047d1aac98c00ff24e97f067 /apps/codecs/libspeex/jitter.c
parent14ac7cafc81940f5f389515cb5134e6c52f37813 (diff)
downloadrockbox-57a27c69a9f3b9b69aff9360c09f7298ffd7b670.tar.gz
rockbox-57a27c69a9f3b9b69aff9360c09f7298ffd7b670.zip
Sync Speex to SVN.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@15750 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'apps/codecs/libspeex/jitter.c')
-rw-r--r--apps/codecs/libspeex/jitter.c423
1 files changed, 186 insertions, 237 deletions
diff --git a/apps/codecs/libspeex/jitter.c b/apps/codecs/libspeex/jitter.c
index e31a131bba..710e36272c 100644
--- a/apps/codecs/libspeex/jitter.c
+++ b/apps/codecs/libspeex/jitter.c
@@ -34,8 +34,10 @@
/*
TODO:
-- Write generic functions for computing stats and shifting the histogram
-- Take into account the delay step when computing the stats and when shifting
+- Add short-term estimate
+- Defensive programming
+ + warn when last returned < last desired (begative buffering)
+ + warn if update_delay not called between get() and tick() or is called twice in a row
- Linked list structure for holding the packets instead of the current fixed-size array
+ return memory to a pool
+ allow pre-allocation of the pool
@@ -62,9 +64,6 @@ TODO:
#define NULL 0
#endif
-#define LATE_BINS 15
-#define MAX_MARGIN 30 /**< Number of bins in margin histogram */
-
#define SPEEX_JITTER_MAX_BUFFER_SIZE 200 /**< Maximum number of packets in jitter buffer */
#define TSUB(a,b) ((spx_int32_t)((a)-(b)))
@@ -74,16 +73,18 @@ TODO:
#define LT32(a,b) (((spx_int32_t)((a)-(b)))<0)
#define LE32(a,b) (((spx_int32_t)((a)-(b)))<=0)
+#define ROUND_DOWN(x, step) ((x)<0 ? ((x)-(step)+1)/(step)*(step) : (x)/(step)*(step))
+
#define MAX_TIMINGS 20
#define MAX_BUFFERS 3
-#define TOP_DELAY 25
-#define WINDOW_SIZE 200
+#define TOP_DELAY 20
+/** Buffer that keeps the time of arrival of the latest packets */
struct TimingBuffer {
- int filled;
- int curr_count;
- spx_int16_t timing[MAX_TIMINGS];
- spx_int16_t counts[MAX_TIMINGS];
+ int filled; /**< Number of entries occupied in "timing" and "counts"*/
+ int curr_count; /**< Number of packet timings we got (including those we discarded) */
+ spx_int16_t timing[MAX_TIMINGS]; /**< Sorted list of all timings ("latest" packets first) */
+ spx_int16_t counts[MAX_TIMINGS]; /**< Order the packets were put in (will be used for short-term estimate) */
};
static void tb_init(struct TimingBuffer *tb)
@@ -92,16 +93,18 @@ static void tb_init(struct TimingBuffer *tb)
tb->curr_count = 0;
}
+/* Add the timing of a new packet to the TimingBuffer */
static void tb_add(struct TimingBuffer *tb, spx_int16_t timing)
{
int pos;
- /*fprintf(stderr, "timing = %d\n", timing);*/
- /*fprintf(stderr, "timing = %d, latest = %d, earliest = %d, filled = %d\n", timing, tb->timing[0], tb->timing[tb->filled-1], tb->filled);*/
+ /* Discard packet that won't make it into the list because they're too early */
if (tb->filled >= MAX_TIMINGS && timing >= tb->timing[tb->filled-1])
{
tb->curr_count++;
return;
}
+
+ /* Find where the timing info goes in the sorted list */
pos = 0;
/* FIXME: Do bisection instead of linear search */
while (pos<tb->filled && timing >= tb->timing[pos])
@@ -109,56 +112,107 @@ static void tb_add(struct TimingBuffer *tb, spx_int16_t timing)
pos++;
}
- /*fprintf(stderr, "pos = %d filled = %d\n", pos, tb->filled);*/
speex_assert(pos <= tb->filled && pos < MAX_TIMINGS);
- fprintf(stderr, "OK\n");
+
+ /* Shift everything so we can perform the insertion */
if (pos < tb->filled)
{
int move_size = tb->filled-pos;
if (tb->filled == MAX_TIMINGS)
move_size -= 1;
- /*fprintf(stderr, "speex_move(%d %d %d)\n", pos+1, pos, move_size);*/
speex_move(&tb->timing[pos+1], &tb->timing[pos], move_size*sizeof(tb->timing[0]));
speex_move(&tb->counts[pos+1], &tb->counts[pos], move_size*sizeof(tb->counts[0]));
}
- /*fprintf(stderr, "moved\n");*/
+ /* Insert */
tb->timing[pos] = timing;
tb->counts[pos] = tb->curr_count;
- /*{
- int i;
- for (i=0;i<MAX_TIMINGS;i++)
- fprintf(stderr, "%d ", tb->timing[i]);
- fprintf(stderr, "\n");
- }*/
+
tb->curr_count++;
if (tb->filled<MAX_TIMINGS)
tb->filled++;
- /*fprintf(stderr, "added\n");*/
}
+
+
+/** Jitter buffer structure */
+struct JitterBuffer_ {
+ spx_uint32_t pointer_timestamp; /**< Timestamp of what we will *get* next */
+ spx_uint32_t last_returned_timestamp; /**< Useful for getting the next packet with the same timestamp (for fragmented media) */
+ spx_uint32_t next_stop; /**< Estimated time the next get() will be called */
+
+ spx_int32_t buffered; /**< Amount of data we think is still buffered by the application (timestamp units)*/
+
+ JitterBufferPacket packets[SPEEX_JITTER_MAX_BUFFER_SIZE]; /**< Packets stored in the buffer */
+ spx_uint32_t arrival[SPEEX_JITTER_MAX_BUFFER_SIZE]; /**< Packet arrival time (0 means it was late, even though it's a valid timestamp) */
+
+ void (*destroy) (void *); /**< Callback for destroying a packet */
+
+ spx_int32_t delay_step; /**< Size of the steps when adjusting buffering (timestamp units) */
+ spx_int32_t concealment_size; /**< Size of the packet loss concealment "units" */
+ int reset_state; /**< True if state was just reset */
+ int buffer_margin; /**< How many frames we want to keep in the buffer (lower bound) */
+ int late_cutoff; /**< How late must a packet be for it not to be considered at all */
+ int interp_requested; /**< An interpolation is requested by speex_jitter_update_delay() */
+
+ struct TimingBuffer _tb[MAX_BUFFERS]; /**< Don't use those directly */
+ struct TimingBuffer *timeBuffers[MAX_BUFFERS]; /**< Storing arrival time of latest frames so we can compute some stats */
+ int window_size; /**< Total window over which the late frames are counted */
+ int subwindow_size; /**< Sub-window size for faster computation */
+ int max_late_rate; /**< Absolute maximum amount of late packets tolerable (in percent) */
+ int latency_tradeoff; /**< Latency equivalent of losing one percent of packets */
+ int auto_tradeoff; /**< Latency equivalent of losing one percent of packets (automatic default) */
+
+ int lost_count; /**< Number of consecutive lost packets */
+};
+
/** Based on available data, this computes the optimal delay for the jitter buffer.
The optimised function is in timestamp units and is:
cost = delay + late_factor*[number of frames that would be late if we used that delay]
@param tb Array of buffers
@param late_factor Equivalent cost of a late frame (in timestamp units)
-*/
-static spx_int16_t tbs_get_opt_delay(struct TimingBuffer *tb, spx_int32_t late_factor)
+ */
+static spx_int16_t compute_opt_delay(JitterBuffer *jitter)
{
int i;
spx_int16_t opt=0;
spx_int32_t best_cost=0x7fffffff;
int late = 0;
int pos[MAX_BUFFERS];
+ int tot_count;
+ float late_factor;
+ int penalty_taken = 0;
+ int best = 0;
+ int worst = 0;
+ spx_int32_t deltaT;
+ struct TimingBuffer *tb;
+
+ tb = jitter->_tb;
+
+ /* Number of packet timings we have received (including those we didn't keep) */
+ tot_count = 0;
+ for (i=0;i<MAX_BUFFERS;i++)
+ tot_count += tb[i].curr_count;
+ if (tot_count==0)
+ return 0;
+
+ /* Compute cost for one lost packet */
+ if (jitter->latency_tradeoff != 0)
+ late_factor = jitter->latency_tradeoff * 100.0f / tot_count;
+ else
+ late_factor = jitter->auto_tradeoff * jitter->window_size/tot_count;
- /*fprintf(stderr, "tbs_get_opt_delay\n");*/
+ /*fprintf(stderr, "late_factor = %f\n", late_factor);*/
for (i=0;i<MAX_BUFFERS;i++)
pos[i] = 0;
+ /* Pick the TOP_DELAY "latest" packets (doesn't need to actually be late
+ for the current settings) */
for (i=0;i<TOP_DELAY;i++)
{
int j;
int next=-1;
int latest = 32767;
+ /* Pick latest amoung all sub-windows */
for (j=0;j<MAX_BUFFERS;j++)
{
if (pos[j] < tb[j].filled && tb[j].timing[pos[j]] < latest)
@@ -167,16 +221,19 @@ static spx_int16_t tbs_get_opt_delay(struct TimingBuffer *tb, spx_int32_t late_f
latest = tb[j].timing[pos[j]];
}
}
- late++;
if (next != -1)
{
spx_int32_t cost;
+
+ if (i==0)
+ worst = latest;
+ best = latest;
+ latest = ROUND_DOWN(latest, jitter->delay_step);
pos[next]++;
- /* When considering reducing delay, "on-time" frames could twice (this provides hysteresis) */
- if (latest > 0)
- late++;
+
+ /* Actual cost function that tells us how bad using this delay would be */
cost = -latest + late_factor*late;
- /*fprintf(stderr, "cost %d = -%d + %d * %d\n", cost, latest, late_factor, late);*/
+ /*fprintf(stderr, "cost %d = %d + %f * %d\n", cost, -latest, late_factor, late);*/
if (cost < best_cost)
{
best_cost = cost;
@@ -185,61 +242,50 @@ static spx_int16_t tbs_get_opt_delay(struct TimingBuffer *tb, spx_int32_t late_f
} else {
break;
}
+
+ /* For the next timing we will consider, there will be one more late packet to count */
+ late++;
+ /* Two-frame penalty if we're going to increase the amount of late frames (hysteresis) */
+ if (latest >= 0 && !penalty_taken)
+ {
+ penalty_taken = 1;
+ late+=2;
+ }
}
+
+ deltaT = best-worst;
+ /* This is a default "automatic latency tradeoff" when none is provided */
+ jitter->auto_tradeoff = 1 + deltaT/TOP_DELAY;
+ /*fprintf(stderr, "auto_tradeoff = %d (%d %d %d)\n", jitter->auto_tradeoff, best, worst, i);*/
+
+ /* FIXME: Compute a short-term estimate too and combine with the long-term one */
+
+ /* Prevents reducing the buffer size when we haven't really had much data */
+ if (tot_count < TOP_DELAY && opt > 0)
+ return 0;
return opt;
}
-/** Jitter buffer structure */
-struct JitterBuffer_ {
- spx_uint32_t pointer_timestamp; /**< Timestamp of what we will *get* next */
- spx_uint32_t last_returned_timestamp;
- spx_uint32_t next_stop;
-
- JitterBufferPacket packets[SPEEX_JITTER_MAX_BUFFER_SIZE]; /**< Packets stored in the buffer */
- spx_uint32_t arrival[SPEEX_JITTER_MAX_BUFFER_SIZE]; /**< Packet arrival time (0 means it was late, even though it's a valid timestamp) */
-
- void (*destroy) (void *); /**< Callback for destroying a packet */
-
- int resolution; /**< Time resolution for histogram (timestamp units) */
- int delay_step; /**< Size of the steps when adjusting buffering (timestamp units) */
- int res_delay_step; /**< Size of the steps when adjusting buffering (resolution units) */
- int reset_state; /**< True if state was just reset */
- int buffer_margin; /**< How many frames we want to keep in the buffer (lower bound) */
- int late_cutoff; /**< How late must a packet be for it not to be considered at all */
- int interp_requested; /**< An interpolation is requested by speex_jitter_update_delay() */
-
- struct TimingBuffer _tb[MAX_BUFFERS]; /**< Don't use those directly */
- struct TimingBuffer *timeBuffers[MAX_BUFFERS]; /**< Storing arrival time of latest frames so we can compute some stats */
-
- float late_ratio_short;
- float late_ratio_long;
- float ontime_ratio_short;
- float ontime_ratio_long;
- float early_ratio_short;
- float early_ratio_long;
-
- int lost_count; /**< Number of consecutive lost packets */
- float shortterm_margin[MAX_MARGIN]; /**< Short term margin histogram */
- float longterm_margin[MAX_MARGIN]; /**< Long term margin histogram */
- float loss_rate; /**< Average loss rate */
-};
/** Initialise jitter buffer */
-JitterBuffer *jitter_buffer_init(int resolution)
+JitterBuffer *jitter_buffer_init(void)
{
JitterBuffer *jitter = (JitterBuffer*)speex_alloc(sizeof(JitterBuffer));
if (jitter)
{
int i;
+ spx_int32_t tmp;
for (i=0;i<SPEEX_JITTER_MAX_BUFFER_SIZE;i++)
jitter->packets[i].data=NULL;
- jitter->resolution = resolution;
- jitter->delay_step = resolution;
- jitter->res_delay_step = 1;
+ jitter->delay_step = 1;
+ jitter->concealment_size = 1;
/*FIXME: Should this be 0 or 1?*/
- jitter->buffer_margin = 1;
+ jitter->buffer_margin = 0;
jitter->late_cutoff = 50;
jitter->destroy = NULL;
+ jitter->latency_tradeoff = 0;
+ tmp = 4;
+ jitter_buffer_ctl(jitter, JITTER_BUFFER_SET_MAX_LATE_RATE, &tmp);
jitter_buffer_reset(jitter);
}
return jitter;
@@ -265,12 +311,8 @@ void jitter_buffer_reset(JitterBuffer *jitter)
jitter->next_stop = 0;
jitter->reset_state = 1;
jitter->lost_count = 0;
- jitter->loss_rate = 0;
- for (i=0;i<MAX_MARGIN;i++)
- {
- jitter->shortterm_margin[i] = 0;
- jitter->longterm_margin[i] = 0;
- }
+ jitter->buffered = 0;
+ jitter->auto_tradeoff = 32000;
for (i=0;i<MAX_BUFFERS;i++)
{
@@ -287,13 +329,15 @@ void jitter_buffer_destroy(JitterBuffer *jitter)
speex_free(jitter);
}
+/** Take the following timing into consideration for future calculations */
static void update_timings(JitterBuffer *jitter, spx_int32_t timing)
{
if (timing < -32767)
timing = -32767;
if (timing > 32767)
timing = 32767;
- if (jitter->timeBuffers[0]->curr_count >= WINDOW_SIZE)
+ /* If the current sub-window is full, perform a rotation and discard oldest sub-widow */
+ if (jitter->timeBuffers[0]->curr_count >= jitter->subwindow_size)
{
int i;
/*fprintf(stderr, "Rotate buffer\n");*/
@@ -304,129 +348,25 @@ static void update_timings(JitterBuffer *jitter, spx_int32_t timing)
tb_init(jitter->timeBuffers[0]);
}
tb_add(jitter->timeBuffers[0], timing);
- spx_int16_t opt = tbs_get_opt_delay(jitter->_tb, 2);
- /*fprintf(stderr, "opt adjustment is %d\n", opt);*/
}
+/** Compensate all timings when we do an adjustment of the buffering */
static void shift_timings(JitterBuffer *jitter, spx_int16_t amount)
{
int i, j;
for (i=0;i<MAX_BUFFERS;i++)
{
- for (j=0;j<jitter->timeBuffers[i]->filled;i++)
+ for (j=0;j<jitter->timeBuffers[i]->filled;j++)
jitter->timeBuffers[i]->timing[j] += amount;
}
}
-static void update_histogram(JitterBuffer *jitter, spx_int32_t arrival_margin)
-{
- int i;
- if (arrival_margin >= -jitter->late_cutoff)
- {
- /* Here we compute the histogram based on the time of arrival of the packet.
- This is based on a (first-order) recursive average. We keep both a short-term
- histogram and a long-term histogram */
- spx_int32_t int_margin;
- /* First, apply the "damping" of the recursive average to all bins */
- for (i=0;i<MAX_MARGIN;i++)
- {
- jitter->shortterm_margin[i] *= .98;
- jitter->longterm_margin[i] *= .995;
- }
- /* What histogram bin the packet should be counted in */
- int_margin = LATE_BINS + arrival_margin;
- if (int_margin>MAX_MARGIN-1)
- int_margin = MAX_MARGIN-1;
- if (int_margin<0)
- int_margin = 0;
- /* Add the packet to the right bin */
- jitter->shortterm_margin[int_margin] += .02;
- jitter->longterm_margin[int_margin] += .005;
- } else {
- /* Packet has arrived *way* too late, we pretty much consider it lost and not take it into account in the histogram */
- /*fprintf (stderr, "way too late = %d\n", arrival_margin);*/
- if (jitter->lost_count>20)
- {
- jitter_buffer_reset(jitter);
- }
- }
-}
-
-static void shift_histogram(JitterBuffer *jitter, int amount)
-{
- int i, c;
- if (amount == 0)
- return;
- if (amount > 0)
- {
- /* FIXME: This is terribly inefficient */
- for (c=0;c<amount;c++)
- {
- jitter->shortterm_margin[MAX_MARGIN-1] += jitter->shortterm_margin[MAX_MARGIN-2];
- jitter->longterm_margin[MAX_MARGIN-1] += jitter->longterm_margin[MAX_MARGIN-2];
- for (i=MAX_MARGIN-3;i>=0;i--)
- {
- jitter->shortterm_margin[i+1] = jitter->shortterm_margin[i];
- jitter->longterm_margin[i+1] = jitter->longterm_margin[i];
- }
- jitter->shortterm_margin[0] = 0;
- jitter->longterm_margin[0] = 0;
- }
- } else {
- /* FIXME: This is terribly inefficient */
- for (c=0;c<-amount;c++)
- {
- jitter->shortterm_margin[0] += jitter->shortterm_margin[1];
- jitter->longterm_margin[0] += jitter->longterm_margin[1];
- for (i=1;i<MAX_MARGIN-1;i++)
- {
- jitter->shortterm_margin[i] = jitter->shortterm_margin[i+1];
- jitter->longterm_margin[i] = jitter->longterm_margin[i+1];
- }
- jitter->shortterm_margin[MAX_MARGIN-1] = 0;
- jitter->longterm_margin[MAX_MARGIN-1] = 0;
- }
- }
-}
-
-static void compute_statistics(JitterBuffer *jitter)
-{
- int i;
- jitter->late_ratio_short = 0;
- jitter->late_ratio_long = 0;
- /* Count the proportion of packets that are late */
- for (i=0;i<LATE_BINS;i++)
- {
- jitter->late_ratio_short += jitter->shortterm_margin[i];
- jitter->late_ratio_long += jitter->longterm_margin[i];
- }
-
- /* Count the proportion of packets that are just on time */
- jitter->ontime_ratio_short = 0;
- jitter->ontime_ratio_long = 0;
- for (;i<LATE_BINS+jitter->res_delay_step;i++)
- {
- jitter->ontime_ratio_short = jitter->shortterm_margin[i];
- jitter->ontime_ratio_long = jitter->longterm_margin[i];
- }
-
- jitter->early_ratio_short = 0;
- jitter->early_ratio_long = 0;
- /* Count the proportion of packets that are early */
- for (;i<MAX_MARGIN;i++)
- {
- jitter->early_ratio_short += jitter->shortterm_margin[i];
- jitter->early_ratio_long += jitter->longterm_margin[i];
- }
-}
/** Put one packet into the jitter buffer */
void jitter_buffer_put(JitterBuffer *jitter, const JitterBufferPacket *packet)
{
int i,j;
int late;
- spx_int32_t arrival_margin;
- spx_int32_t arrival_time;
/*fprintf (stderr, "put packet %d %d\n", timestamp, span);*/
/* Syncing on the first packet to arrive */
@@ -457,14 +397,7 @@ void jitter_buffer_put(JitterBuffer *jitter, const JitterBufferPacket *packet)
/* Check if packet is late (could still be useful though) */
if (LT32(packet->timestamp, jitter->next_stop))
{
- /*fprintf(stderr, "late by %d\n", jitter->next_stop - packet->timestamp);*/
-
- /* The arrival margin is how much in advance (or in this case late) the packet it (in resolution units) */
- arrival_margin = (((spx_int32_t)packet->timestamp) - ((spx_int32_t)jitter->next_stop))/jitter->resolution - jitter->buffer_margin;
-
- /*fprintf(stderr, "put arrival_margin = %d\n", arrival_margin);*/
- /*update_timings(jitter, ((spx_int32_t)packet->timestamp) - ((spx_int32_t)jitter->next_stop));*/
- update_histogram(jitter, arrival_margin);
+ update_timings(jitter, ((spx_int32_t)packet->timestamp) - ((spx_int32_t)jitter->next_stop) - jitter->buffer_margin);
late = 1;
} else {
late = 0;
@@ -534,22 +467,26 @@ int jitter_buffer_get(JitterBuffer *jitter, JitterBufferPacket *packet, spx_int3
int i;
unsigned int j;
int incomplete = 0;
+ spx_int16_t opt;
jitter->last_returned_timestamp = jitter->pointer_timestamp;
- if (jitter->interp_requested)
+ if (jitter->interp_requested != 0)
{
- jitter->interp_requested = 0;
if (start_offset)
*start_offset = 0;
packet->timestamp = jitter->pointer_timestamp;
- packet->span = jitter->delay_step;
+ packet->span = jitter->interp_requested;
/* Increment the pointer because it got decremented in the delay update */
- jitter->pointer_timestamp += jitter->delay_step;
+ jitter->pointer_timestamp += jitter->interp_requested;
packet->len = 0;
/*fprintf (stderr, "Deferred interpolate\n");*/
+ jitter->interp_requested = 0;
+
+ jitter->buffered = packet->span - desired_span;
+
return JITTER_BUFFER_MISSING;
}
@@ -618,23 +555,11 @@ int jitter_buffer_get(JitterBuffer *jitter, JitterBufferPacket *packet, spx_int3
/* We (obviously) haven't lost this packet */
jitter->lost_count = 0;
- jitter->loss_rate = .999*jitter->loss_rate;
/* In this case, 0 isn't as a valid timestamp */
if (jitter->arrival[i] != 0)
{
- spx_int32_t arrival_margin;
- /*fprintf(stderr, "early by %d\n", jitter->packets[i].timestamp - jitter->arrival[i]);*/
-
- /* The arrival margin is how much in advance (or in this case late) the packet it (in resolution units) */
- arrival_margin = (((spx_int32_t)jitter->packets[i].timestamp) - ((spx_int32_t)jitter->arrival[i]))/jitter->resolution - jitter->buffer_margin;
-
- /*fprintf(stderr, "get arrival_margin = %d\n", arrival_margin);*/
-
- /*update_timings(jitter, ((spx_int32_t)jitter->packets[i].timestamp) - ((spx_int32_t)jitter->arrival[i]));*/
-
- update_histogram(jitter, arrival_margin);
-
+ update_timings(jitter, ((spx_int32_t)jitter->packets[i].timestamp) - ((spx_int32_t)jitter->arrival[i]) - jitter->buffer_margin);
}
@@ -663,6 +588,8 @@ int jitter_buffer_get(JitterBuffer *jitter, JitterBufferPacket *packet, spx_int3
/* Point to the end of the current packet */
jitter->pointer_timestamp = jitter->packets[i].timestamp+jitter->packets[i].span;
+ jitter->buffered = *start_offset + packet->span - desired_span;
+
if (incomplete)
return JITTER_BUFFER_INCOMPLETE;
else
@@ -676,22 +603,21 @@ int jitter_buffer_get(JitterBuffer *jitter, JitterBufferPacket *packet, spx_int3
jitter->lost_count++;
/*fprintf (stderr, "m");*/
/*fprintf (stderr, "lost_count = %d\n", jitter->lost_count);*/
- jitter->loss_rate = .999*jitter->loss_rate + .001;
if (start_offset)
*start_offset = 0;
- compute_statistics(jitter);
+ opt = compute_opt_delay(jitter);
/* Should we force an increase in the buffer or just do normal interpolation? */
- if (jitter->late_ratio_short > .1 || jitter->late_ratio_long > .03)
+ if (opt < 0)
{
- /* Increase buffering */
+ /* Need to increase buffering */
/* Shift histogram to compensate */
- shift_histogram(jitter, jitter->res_delay_step);
+ shift_timings(jitter, -opt);
packet->timestamp = jitter->pointer_timestamp;
- packet->span = jitter->delay_step;
+ packet->span = -opt;
/* Don't move the pointer_timestamp forward */
packet->len = 0;
@@ -700,12 +626,15 @@ int jitter_buffer_get(JitterBuffer *jitter, JitterBufferPacket *packet, spx_int3
} else {
/* Normal packet loss */
packet->timestamp = jitter->pointer_timestamp;
+
+ desired_span = ROUND_DOWN(desired_span, jitter->concealment_size);
packet->span = desired_span;
jitter->pointer_timestamp += desired_span;
packet->len = 0;
/*fprintf (stderr, "Normal loss\n");*/
}
+ jitter->buffered = packet->span - desired_span;
return JITTER_BUFFER_MISSING;
}
@@ -752,43 +681,44 @@ int jitter_buffer_get_pointer_timestamp(JitterBuffer *jitter)
void jitter_buffer_tick(JitterBuffer *jitter)
{
- jitter->next_stop = jitter->pointer_timestamp;
+ if (jitter->buffered >= 0)
+ {
+ jitter->next_stop = jitter->pointer_timestamp - jitter->buffered;
+ } else {
+ jitter->next_stop = jitter->pointer_timestamp;
+ speex_warning_int("jitter buffer sees negative buffering, you code might be broken. Value is ", jitter->buffered);
+ }
+ jitter->buffered = 0;
}
void jitter_buffer_remaining_span(JitterBuffer *jitter, spx_uint32_t rem)
{
+ if (jitter->buffered < 0)
+ speex_warning_int("jitter buffer sees negative buffering, you code might be broken. Value is ", jitter->buffered);
jitter->next_stop = jitter->pointer_timestamp - rem;
}
/* Let the jitter buffer know it's the right time to adjust the buffering delay to the network conditions */
int jitter_buffer_update_delay(JitterBuffer *jitter, JitterBufferPacket *packet, spx_int32_t *start_offset)
{
- int i;
+ spx_int16_t opt = compute_opt_delay(jitter);
+ /*fprintf(stderr, "opt adjustment is %d ", opt);*/
- compute_statistics(jitter);
-
- /* Adjusting the buffering bssed on the amount of packets that are early/on time/late */
- if (jitter->late_ratio_short > .1 || jitter->late_ratio_long > .03)
+ if (opt < 0)
{
- /* If too many packets are arriving late */
- shift_histogram(jitter, jitter->res_delay_step);
+ shift_timings(jitter, -opt);
- jitter->pointer_timestamp -= jitter->delay_step;
- jitter->interp_requested = 1;
- /*fprintf (stderr, "Decision to interpolate\n");*/
- return JITTER_BUFFER_ADJUST_INTERPOLATE;
-
- } else if (jitter->late_ratio_short + jitter->ontime_ratio_short < .005 && jitter->late_ratio_long + jitter->ontime_ratio_long < .01 && jitter->early_ratio_short > .8)
+ jitter->pointer_timestamp += opt;
+ jitter->interp_requested = -opt;
+ /*fprintf (stderr, "Decision to interpolate %d samples\n", -opt);*/
+ } else if (opt > 0)
{
- /* Many frames arriving early */
- shift_histogram(jitter, -jitter->res_delay_step);
-
- jitter->pointer_timestamp += jitter->delay_step;
- /*fprintf (stderr, "Decision to drop\n");*/
- return JITTER_BUFFER_ADJUST_DROP;
+ shift_timings(jitter, -opt);
+ jitter->pointer_timestamp += opt;
+ /*fprintf (stderr, "Decision to drop %d samples\n", opt);*/
}
- return JITTER_BUFFER_ADJUST_OK;
+ return opt;
}
/* Used like the ioctl function to control the jitter buffer parameters */
@@ -822,11 +752,30 @@ int jitter_buffer_ctl(JitterBuffer *jitter, int request, void *ptr)
break;
case JITTER_BUFFER_SET_DELAY_STEP:
jitter->delay_step = *(spx_int32_t*)ptr;
- jitter->res_delay_step = jitter->delay_step/jitter->resolution;
break;
case JITTER_BUFFER_GET_DELAY_STEP:
*(spx_int32_t*)ptr = jitter->delay_step;
break;
+ case JITTER_BUFFER_SET_CONCEALMENT_SIZE:
+ jitter->concealment_size = *(spx_int32_t*)ptr;
+ break;
+ case JITTER_BUFFER_GET_CONCEALMENT_SIZE:
+ *(spx_int32_t*)ptr = jitter->concealment_size;
+ break;
+ case JITTER_BUFFER_SET_MAX_LATE_RATE:
+ jitter->max_late_rate = *(spx_int32_t*)ptr;
+ jitter->window_size = 100*TOP_DELAY/jitter->max_late_rate;
+ jitter->subwindow_size = jitter->window_size/MAX_BUFFERS;
+ break;
+ case JITTER_BUFFER_GET_MAX_LATE_RATE:
+ *(spx_int32_t*)ptr = jitter->max_late_rate;
+ break;
+ case JITTER_BUFFER_SET_LATE_COST:
+ jitter->latency_tradeoff = *(spx_int32_t*)ptr;
+ break;
+ case JITTER_BUFFER_GET_LATE_COST:
+ *(spx_int32_t*)ptr = jitter->latency_tradeoff;
+ break;
default:
speex_warning_int("Unknown jitter_buffer_ctl request: ", request);
return -1;