header ordering fixes for FreeBSD (pending a global merge into asterisk.h) (bug ...
[asterisk/asterisk.git] / jitterbuf.c
1 /*
2  * jitterbuf: an application-independent jitterbuffer
3  *
4  * Copyrights:
5  * Copyright (C) 2004-2005, Horizon Wimba, Inc.
6  *
7  * Contributors:
8  * Steve Kann <stevek@stevek.com>
9  *
10  * This program is free software, distributed under the terms of
11  * the GNU Lesser (Library) General Public License
12  *
13  * Copyright on this file is disclaimed to Digium for inclusion in Asterisk
14  */
15
16 #include <stdio.h>
17 #include <stdlib.h>
18 #include <string.h>
19
20 #include "asterisk.h"
21
22 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
23
24 #include "jitterbuf.h"
25
26 /* define these here, just for ancient compiler systems */
27 #define JB_LONGMAX 2147483647L
28 #define JB_LONGMIN (-JB_LONGMAX - 1L)
29
30 #define jb_warn(...) (warnf ? warnf(__VA_ARGS__) : (void)0)
31 #define jb_err(...) (errf ? errf(__VA_ARGS__) : (void)0)
32 #define jb_dbg(...) (dbgf ? dbgf(__VA_ARGS__) : (void)0)
33
34 #ifdef DEEP_DEBUG
35 #define jb_dbg2(...) (dbgf ? dbgf(__VA_ARGS__) : (void)0)
36 #else
37 #define jb_dbg2(...) ((void)0)
38 #endif
39
40 static jb_output_function_t warnf, errf, dbgf;
41
42 void jb_setoutput(jb_output_function_t err, jb_output_function_t warn, jb_output_function_t dbg) 
43 {
44         errf = err;
45         warnf = warn;
46         dbgf = dbg;
47 }
48
49 static void increment_losspct(jitterbuf *jb) 
50 {
51         jb->info.losspct = (100000 + 499 * jb->info.losspct)/500;    
52 }
53
54 static void decrement_losspct(jitterbuf *jb) 
55 {
56         jb->info.losspct = (499 * jb->info.losspct)/500;    
57 }
58
59 void jb_reset(jitterbuf *jb) 
60 {
61         /* only save settings */
62         jb_conf s = jb->info.conf;
63         memset(jb,0,sizeof(jitterbuf));
64         jb->info.conf = s;
65
66         /* initialize length */
67         jb->info.current = jb->info.target = JB_TARGET_EXTRA; 
68         jb->info.silence_begin_ts = -1; 
69 }
70
71 jitterbuf * jb_new() 
72 {
73         jitterbuf *jb;
74
75
76         jb = malloc(sizeof(jitterbuf));
77         if (!jb) 
78                 return NULL;
79
80         jb_reset(jb);
81
82         jb_dbg2("jb_new() = %x\n", jb);
83         return jb;
84 }
85
86 void jb_destroy(jitterbuf *jb) 
87 {
88         jb_frame *frame; 
89         jb_dbg2("jb_destroy(%x)\n", jb);
90
91         /* free all the frames on the "free list" */
92         frame = jb->free;
93         while (frame != NULL) {
94                 jb_frame *next = frame->next;
95                 free(frame);
96                 frame = next;
97         }
98
99         /* free ourselves! */ 
100         free(jb);
101 }
102
103
104
105 /* simple history manipulation */
106 /* maybe later we can make the history buckets variable size, or something? */
107 /* drop parameter determines whether we will drop outliers to minimize
108  * delay */
109 #if 0
110 static int longcmp(const void *a, const void *b) 
111 {
112         return *(long *)a - *(long *)b;
113 }
114 #endif
115
116 static int history_put(jitterbuf *jb, long ts, long now, long ms) 
117 {
118         long delay = now - (ts - jb->info.resync_offset);
119         long threshold = 2 * jb->info.jitter + jb->info.conf.resync_threshold;
120         long kicked;
121
122         /* don't add special/negative times to history */
123         if (ts <= 0) 
124                 return 0;
125
126         /* check for drastic change in delay */
127         if (jb->info.conf.resync_threshold != -1) {
128                 if (abs(delay - jb->info.last_delay) > threshold) {
129                         jb->info.cnt_delay_discont++;
130                         if (jb->info.cnt_delay_discont > 3) {
131                                 /* resync the jitterbuffer */
132                                 jb->info.cnt_delay_discont = 0;
133                                 jb->hist_ptr = 0;
134                                 jb->hist_maxbuf_valid = 0;
135
136                                 jb_warn("Resyncing the jb. last_delay %ld, this delay %ld, threshold %ld, new offset %ld\n", jb->info.last_delay, delay, threshold, ts - now);
137                                 jb->info.resync_offset = ts - now;
138                                 jb->info.last_delay = 0; /* after resync, frame is right on time */
139                         } else {
140                                 return -1;
141                         }
142                 } else {
143                         jb->info.last_delay = delay;
144                         jb->info.cnt_delay_discont = 0;
145                 }
146         }
147
148         kicked = jb->history[jb->hist_ptr & JB_HISTORY_SZ];
149
150         jb->history[(jb->hist_ptr++) % JB_HISTORY_SZ] = delay;
151
152         /* optimization; the max/min buffers don't need to be recalculated, if this packet's
153          * entry doesn't change them.  This happens if this packet is not involved, _and_ any packet
154          * that got kicked out of the history is also not involved 
155          * We do a number of comparisons, but it's probably still worthwhile, because it will usually
156          * succeed, and should be a lot faster than going through all 500 packets in history */
157         if (!jb->hist_maxbuf_valid)
158                 return 0;
159
160         /* don't do this until we've filled history 
161          * (reduces some edge cases below) */
162         if (jb->hist_ptr < JB_HISTORY_SZ)
163                 goto invalidate;
164
165         /* if the new delay would go into min */
166         if (delay < jb->hist_minbuf[JB_HISTORY_MAXBUF_SZ-1])
167                 goto invalidate;
168     
169         /* or max.. */
170         if (delay > jb->hist_maxbuf[JB_HISTORY_MAXBUF_SZ-1])
171                 goto invalidate;
172
173         /* or the kicked delay would be in min */
174         if (kicked <= jb->hist_minbuf[JB_HISTORY_MAXBUF_SZ-1]) 
175                 goto invalidate;
176
177         if (kicked >= jb->hist_maxbuf[JB_HISTORY_MAXBUF_SZ-1]) 
178                 goto invalidate;
179
180         /* if we got here, we don't need to invalidate, 'cause this delay didn't 
181          * affect things */
182         return 0;
183         /* end optimization */
184
185
186 invalidate:
187         jb->hist_maxbuf_valid = 0;
188         return 0;
189 }
190
191 static void history_calc_maxbuf(jitterbuf *jb) 
192 {
193         int i,j;
194
195         if (jb->hist_ptr == 0) 
196                 return;
197
198
199         /* initialize maxbuf/minbuf to the latest value */
200         for (i=0;i<JB_HISTORY_MAXBUF_SZ;i++) {
201 /*
202  * jb->hist_maxbuf[i] = jb->history[(jb->hist_ptr-1) % JB_HISTORY_SZ];
203  * jb->hist_minbuf[i] = jb->history[(jb->hist_ptr-1) % JB_HISTORY_SZ];
204  */
205                 jb->hist_maxbuf[i] = JB_LONGMIN;
206                 jb->hist_minbuf[i] = JB_LONGMAX;
207         }
208
209         /* use insertion sort to populate maxbuf */
210         /* we want it to be the top "n" values, in order */
211
212         /* start at the beginning, or JB_HISTORY_SZ frames ago */
213         i = (jb->hist_ptr > JB_HISTORY_SZ) ? (jb->hist_ptr - JB_HISTORY_SZ) : 0; 
214
215         for (;i<jb->hist_ptr;i++) {
216                 long toins = jb->history[i % JB_HISTORY_SZ];
217
218                 /* if the maxbuf should get this */
219                 if (toins > jb->hist_maxbuf[JB_HISTORY_MAXBUF_SZ-1])  {
220
221                         /* insertion-sort it into the maxbuf */
222                         for (j=0;j<JB_HISTORY_MAXBUF_SZ;j++) {
223                                 /* found where it fits */
224                                 if (toins > jb->hist_maxbuf[j]) {
225                                         /* move over */
226                                         memmove(jb->hist_maxbuf+j+1,jb->hist_maxbuf+j, (JB_HISTORY_MAXBUF_SZ-(j+1)) * sizeof(long));
227                                         /* insert */
228                                         jb->hist_maxbuf[j] = toins;
229
230                                         break;
231                                 }
232                         }
233                 }
234
235                 /* if the minbuf should get this */
236                 if (toins < jb->hist_minbuf[JB_HISTORY_MAXBUF_SZ-1])  {
237
238                         /* insertion-sort it into the maxbuf */
239                         for (j=0;j<JB_HISTORY_MAXBUF_SZ;j++) {
240                                 /* found where it fits */
241                                 if (toins < jb->hist_minbuf[j]) {
242                                         /* move over */
243                                         memmove(jb->hist_minbuf+j+1,jb->hist_minbuf+j, (JB_HISTORY_MAXBUF_SZ-(j+1)) * sizeof(long));
244                                         /* insert */
245                                         jb->hist_minbuf[j] = toins;
246
247                                         break;
248                                 }
249                         }
250                 }
251
252                 if (0) { 
253                         int k;
254                         fprintf(stderr, "toins = %ld\n", toins);
255                         fprintf(stderr, "maxbuf =");
256                         for (k=0;k<JB_HISTORY_MAXBUF_SZ;k++) 
257                                 fprintf(stderr, "%ld ", jb->hist_maxbuf[k]);
258                         fprintf(stderr, "\nminbuf =");
259                         for (k=0;k<JB_HISTORY_MAXBUF_SZ;k++) 
260                                 fprintf(stderr, "%ld ", jb->hist_minbuf[k]);
261                         fprintf(stderr, "\n");
262                 }
263         }
264
265         jb->hist_maxbuf_valid = 1;
266 }
267
268 static void history_get(jitterbuf *jb) 
269 {
270         long max, min, jitter;
271         int index;
272         int count;
273
274         if (!jb->hist_maxbuf_valid) 
275                 history_calc_maxbuf(jb);
276
277         /* count is how many items in history we're examining */
278         count = (jb->hist_ptr < JB_HISTORY_SZ) ? jb->hist_ptr : JB_HISTORY_SZ;
279
280         /* index is the "n"ths highest/lowest that we'll look for */
281         index = count * JB_HISTORY_DROPPCT / 100;
282
283         /* sanity checks for index */
284         if (index > (JB_HISTORY_MAXBUF_SZ - 1)) 
285                 index = JB_HISTORY_MAXBUF_SZ - 1;
286
287
288         if (index < 0) {
289                 jb->info.min = 0;
290                 jb->info.jitter = 0;
291                 return;
292         }
293
294         max = jb->hist_maxbuf[index];
295         min = jb->hist_minbuf[index];
296
297         jitter = max - min;
298
299         /* these debug stmts compare the difference between looking at the absolute jitter, and the
300          * values we get by throwing away the outliers */
301         /*
302         fprintf(stderr, "[%d] min=%d, max=%d, jitter=%d\n", index, min, max, jitter);
303         fprintf(stderr, "[%d] min=%d, max=%d, jitter=%d\n", 0, jb->hist_minbuf[0], jb->hist_maxbuf[0], jb->hist_maxbuf[0]-jb->hist_minbuf[0]);
304         */
305
306         jb->info.min = min;
307         jb->info.jitter = jitter;
308 }
309
310 /* returns 1 if frame was inserted into head of queue, 0 otherwise */
311 static int queue_put(jitterbuf *jb, void *data, int type, long ms, long ts) 
312 {
313         jb_frame *frame;
314         jb_frame *p;
315         int head = 0;
316         long resync_ts = ts - jb->info.resync_offset;
317
318         frame = jb->free;
319         if (frame) {
320                 jb->free = frame->next;
321         } else {
322                 frame = malloc(sizeof(jb_frame));
323         }
324
325         if (!frame) {
326                 jb_err("cannot allocate frame\n");
327                 return 0;
328         }
329
330         jb->info.frames_cur++;
331
332         frame->data = data;
333         frame->ts = resync_ts;
334         frame->ms = ms;
335         frame->type = type;
336
337         /* 
338          * frames are a circular list, jb-frames points to to the lowest ts, 
339          * jb->frames->prev points to the highest ts
340          */
341
342         if (!jb->frames) {  /* queue is empty */
343                 jb->frames = frame;
344                 frame->next = frame;
345                 frame->prev = frame;
346                 head = 1;
347         } else if (resync_ts < jb->frames->ts) {
348                 frame->next = jb->frames;
349                 frame->prev = jb->frames->prev;
350
351                 frame->next->prev = frame;
352                 frame->prev->next = frame;
353
354                 /* frame is out of order */
355                 jb->info.frames_ooo++;
356
357                 jb->frames = frame;
358                 head = 1;
359         } else { 
360                 p = jb->frames;
361
362                 /* frame is out of order */
363                 if (resync_ts < p->prev->ts) jb->info.frames_ooo++;
364
365                 while (resync_ts < p->prev->ts && p->prev != jb->frames) 
366                         p = p->prev;
367
368                 frame->next = p;
369                 frame->prev = p->prev;
370
371                 frame->next->prev = frame;
372                 frame->prev->next = frame;
373         }
374         return head;
375 }
376
377 static long queue_next(jitterbuf *jb) 
378 {
379         if (jb->frames) 
380                 return jb->frames->ts;
381         else 
382                 return -1;
383 }
384
385 static long queue_last(jitterbuf *jb) 
386 {
387         if (jb->frames) 
388                 return jb->frames->prev->ts;
389         else 
390                 return -1;
391 }
392
393 static jb_frame *_queue_get(jitterbuf *jb, long ts, int all) 
394 {
395         jb_frame *frame;
396         frame = jb->frames;
397
398         if (!frame)
399                 return NULL;
400
401         /*jb_warn("queue_get: ASK %ld FIRST %ld\n", ts, frame->ts); */
402
403         if (all || ts >= frame->ts) {
404                 /* remove this frame */
405                 frame->prev->next = frame->next;
406                 frame->next->prev = frame->prev;
407
408                 if (frame->next == frame)
409                         jb->frames = NULL;
410                 else
411                         jb->frames = frame->next;
412
413
414                 /* insert onto "free" single-linked list */
415                 frame->next = jb->free;
416                 jb->free = frame;
417
418                 jb->info.frames_cur--;
419
420                 /* we return the frame pointer, even though it's on free list, 
421                  * but caller must copy data */
422                 return frame;
423         } 
424
425         return NULL;
426 }
427
428 static jb_frame *queue_get(jitterbuf *jb, long ts) 
429 {
430         return _queue_get(jb,ts,0);
431 }
432
433 static jb_frame *queue_getall(jitterbuf *jb) 
434 {
435         return _queue_get(jb,0,1);
436 }
437
438 #if 0
439 /* some diagnostics */
440 static void jb_dbginfo(jitterbuf *jb) 
441 {
442         if (dbgf == NULL) 
443                 return;
444
445         jb_dbg("\njb info: fin=%ld fout=%ld flate=%ld flost=%ld fdrop=%ld fcur=%ld\n",
446                 jb->info.frames_in, jb->info.frames_out, jb->info.frames_late, jb->info.frames_lost, jb->info.frames_dropped, jb->info.frames_cur);
447         
448         jb_dbg("jitter=%ld current=%ld target=%ld min=%ld sil=%d len=%d len/fcur=%ld\n",
449                 jb->info.jitter, jb->info.current, jb->info.target, jb->info.min, jb->info.silence_begin_ts, jb->info.current - jb->info.min, 
450                 jb->info.frames_cur ? (jb->info.current - jb->info.min)/jb->info.frames_cur : -8);
451         if (jb->info.frames_in > 0) 
452                 jb_dbg("jb info: Loss PCT = %ld%%, Late PCT = %ld%%\n",
453                         jb->info.frames_lost * 100/(jb->info.frames_in + jb->info.frames_lost), 
454                         jb->info.frames_late * 100/jb->info.frames_in);
455         jb_dbg("jb info: queue %d -> %d.  last_ts %d (queue len: %d) last_ms %d\n",
456                 queue_next(jb), 
457                 queue_last(jb),
458                 jb->info.next_voice_ts, 
459                 queue_last(jb) - queue_next(jb),
460                 jb->info.last_voice_ms);
461 }
462 #endif
463
464 #ifdef DEEP_DEBUG
465 static void jb_chkqueue(jitterbuf *jb) 
466 {
467         int i=0;
468         jb_frame *p = jb->frames;
469
470         if (!p) {
471                 return;
472         }
473
474         do {
475                 if (p->next == NULL)  {
476                         jb_err("Queue is BROKEN at item [%d]", i);      
477                 }
478                 i++;
479                 p=p->next;
480         } while (p->next != jb->frames);
481 }
482
483 static void jb_dbgqueue(jitterbuf *jb) 
484 {
485         int i=0;
486         jb_frame *p = jb->frames;
487
488         jb_dbg("queue: ");
489
490         if (!p) {
491                 jb_dbg("EMPTY\n");
492                 return;
493         }
494
495         do {
496                 jb_dbg("[%d]=%ld ", i++, p->ts);
497                 p=p->next;
498         } while (p->next != jb->frames);
499
500         jb_dbg("\n");
501 }
502 #endif
503
504 int jb_put(jitterbuf *jb, void *data, int type, long ms, long ts, long now) 
505 {
506         jb_dbg2("jb_put(%x,%x,%ld,%ld,%ld)\n", jb, data, ms, ts, now);
507
508         jb->info.frames_in++;
509
510         if (type == JB_TYPE_VOICE) {
511                 /* presently, I'm only adding VOICE frames to history and drift calculations; mostly because with the
512                  * IAX integrations, I'm sending retransmitted control frames with their awkward timestamps through */
513                 if (history_put(jb,ts,now,ms))
514                         return JB_DROP;
515         }
516
517         /* if put into head of queue, caller needs to reschedule */
518         if (queue_put(jb,data,type,ms,ts)) {
519                 return JB_SCHED;
520         }
521         return JB_OK;
522 }
523
524
525 static int _jb_get(jitterbuf *jb, jb_frame *frameout, long now, long interpl) 
526 {
527         jb_frame *frame;
528         long diff;
529
530         /*if ((now - jb_next(jb)) > 2 * jb->info.last_voice_ms) jb_warn("SCHED: %ld", (now - jb_next(jb))); */
531         /* get jitter info */
532         history_get(jb);
533
534
535         /* target */
536         jb->info.target = jb->info.jitter + jb->info.min + JB_TARGET_EXTRA; 
537
538         /* if a hard clamp was requested, use it */
539         if ((jb->info.conf.max_jitterbuf) && ((jb->info.target - jb->info.min) > jb->info.conf.max_jitterbuf)) {
540                 jb_dbg("clamping target from %d to %d\n", (jb->info.target - jb->info.min), jb->info.conf.max_jitterbuf);
541                 jb->info.target = jb->info.min + jb->info.conf.max_jitterbuf;
542         }
543
544         diff = jb->info.target - jb->info.current;
545
546         /* jb_warn("diff = %d lms=%d last = %d now = %d\n", diff,  */
547         /*      jb->info.last_voice_ms, jb->info.last_adjustment, now); */
548
549         /* let's work on non-silent case first */
550         if (!jb->info.silence_begin_ts) { 
551                 /* we want to grow */
552                 if ((diff > 0) && 
553                         /* we haven't grown in the delay length */
554                         (((jb->info.last_adjustment + JB_ADJUST_DELAY) < now) || 
555                         /* we need to grow more than the "length" we have left */
556                         (diff > queue_last(jb)  - queue_next(jb)) ) ) {
557                         /* grow by interp frame length */
558                         jb->info.current += interpl;
559                         jb->info.next_voice_ts += interpl;
560                         jb->info.last_voice_ms = interpl;
561                         jb->info.last_adjustment = now;
562                         jb_dbg("G");
563                         return JB_INTERP;
564                 }
565
566                 frame = queue_get(jb, jb->info.next_voice_ts - jb->info.current);
567
568                 /* not a voice frame; just return it. */
569                 if (frame && frame->type != JB_TYPE_VOICE) {
570                         if (frame->type == JB_TYPE_SILENCE) 
571                                 jb->info.silence_begin_ts = frame->ts;
572
573                         *frameout = *frame;
574                         jb->info.frames_out++;
575                         jb_dbg("o");
576                         return JB_OK;
577                 }
578
579
580                 /* voice frame is later than expected */
581                 if (frame && frame->ts + jb->info.current < jb->info.next_voice_ts) {
582                         if (frame->ts + jb->info.current > jb->info.next_voice_ts - jb->info.last_voice_ms) {
583                                 /* either we interpolated past this frame in the last jb_get */
584                                 /* or the frame is still in order, but came a little too quick */ 
585                                 *frameout = *frame;
586                                 /* reset expectation for next frame */
587                                 jb->info.next_voice_ts = frame->ts + jb->info.current + frame->ms;
588                                 jb->info.frames_out++;
589                                 decrement_losspct(jb);
590                                 jb_dbg("v");
591                                 return JB_OK;
592                         } else {
593                                 /* voice frame is late */
594                                 *frameout = *frame;
595                                 jb->info.frames_out++;
596                                 decrement_losspct(jb);
597                                 jb->info.frames_late++;
598                                 jb->info.frames_lost--;
599                                 jb_dbg("l");
600                                 /*jb_warn("\nlate: wanted=%ld, this=%ld, next=%ld\n", jb->info.next_voice_ts - jb->info.current, frame->ts, queue_next(jb));
601                                 jb_warninfo(jb); */
602                                 return JB_DROP;
603                         }
604                 }
605
606                 /* keep track of frame sizes, to allow for variable sized-frames */
607                 if (frame && frame->ms > 0) {
608                         jb->info.last_voice_ms = frame->ms;
609                 }
610
611                 /* we want to shrink; shrink at 1 frame / 500ms */
612                 /* unless we don't have a frame, then shrink 1 frame */
613                 /* every 80ms (though perhaps we can shrink even faster */
614                 /* in this case) */
615                 if (diff < -JB_TARGET_EXTRA && 
616                         ((!frame && jb->info.last_adjustment + 80 < now) || 
617                         (jb->info.last_adjustment + 500 < now))) {
618
619                         jb->info.last_adjustment = now;
620
621                         if (frame) {
622                                 *frameout = *frame;
623                                 /* shrink by frame size we're throwing out */
624                                 jb->info.current -= frame->ms;
625                                 jb->info.frames_out++;
626                                 decrement_losspct(jb);
627                                 jb->info.frames_dropped++;
628                                 jb_dbg("s");
629                                 return JB_DROP;
630                         } else {
631                                 /* shrink by last_voice_ms */
632                                 jb->info.current -= jb->info.last_voice_ms;
633                                 jb->info.frames_lost++;
634                                 increment_losspct(jb);
635                                 jb_dbg("S");
636                                 return JB_NOFRAME;
637                         }
638                 }
639
640                 /* lost frame */
641                 if (!frame) {
642                         /* this is a bit of a hack for now, but if we're close to
643                          * target, and we find a missing frame, it makes sense to
644                          * grow, because the frame might just be a bit late;
645                          * otherwise, we presently get into a pattern where we return
646                          * INTERP for the lost frame, then it shows up next, and we
647                          * throw it away because it's late */
648                         /* I've recently only been able to replicate this using
649                          * iaxclient talking to app_echo on asterisk.  In this case,
650                          * my outgoing packets go through asterisk's (old)
651                          * jitterbuffer, and then might get an unusual increasing delay 
652                          * there if it decides to grow?? */
653                         /* Update: that might have been a different bug, that has been fixed..
654                          * But, this still seemed like a good idea, except that it ended up making a single actual
655                          * lost frame get interpolated two or more times, when there was "room" to grow, so it might
656                          * be a bit of a bad idea overall */
657                         /*if (diff > -1 * jb->info.last_voice_ms) { 
658                                 jb->info.current += jb->info.last_voice_ms;
659                                 jb->info.last_adjustment = now;
660                                 jb_warn("g");
661                                 return JB_INTERP;
662                         } */
663                         jb->info.frames_lost++;
664                         increment_losspct(jb);
665                         jb->info.next_voice_ts += interpl;
666                         jb->info.last_voice_ms = interpl;
667                         jb_dbg("L");
668                         return JB_INTERP;
669                 }
670
671                 /* normal case; return the frame, increment stuff */
672                 *frameout = *frame;
673                 jb->info.next_voice_ts += frame->ms;
674                 jb->info.frames_out++;
675                 decrement_losspct(jb);
676                 jb_dbg("v");
677                 return JB_OK;
678         } else {     
679                 /* TODO: after we get the non-silent case down, we'll make the
680                  * silent case -- basically, we'll just grow and shrink faster
681                  * here, plus handle next_voice_ts a bit differently */
682       
683                 /* to disable silent special case altogether, just uncomment this: */
684                 /* jb->info.silence_begin_ts = 0; */
685
686                 /* shrink interpl len every 10ms during silence */
687                 if (diff < -JB_TARGET_EXTRA &&
688                         jb->info.last_adjustment + 10 <= now) {
689                         jb->info.current -= interpl;
690                         jb->info.last_adjustment = now;
691                 }
692
693                 frame = queue_get(jb, now - jb->info.current);
694                 if (!frame) {
695                         return JB_NOFRAME;
696                 } else if (frame->type != JB_TYPE_VOICE) {
697                         /* normal case; in silent mode, got a non-voice frame */
698                         *frameout = *frame;
699                         jb->info.frames_out++;
700                         return JB_OK;
701                 }
702                 if (frame->ts < jb->info.silence_begin_ts) {
703                         /* voice frame is late */
704                         *frameout = *frame;
705                         jb->info.frames_out++;
706                         decrement_losspct(jb);
707                         jb->info.frames_late++;
708                         jb->info.frames_lost--;
709                         jb_dbg("l");
710                         /*jb_warn("\nlate: wanted=%ld, this=%ld, next=%ld\n", jb->info.next_voice_ts - jb->info.current, frame->ts, queue_next(jb));
711                         jb_warninfo(jb); */
712                         return JB_DROP;
713                 } else {
714                         /* voice frame */
715                         /* try setting current to target right away here */
716                         jb->info.current = jb->info.target;
717                         jb->info.silence_begin_ts = 0;
718                         jb->info.next_voice_ts = frame->ts + jb->info.current + frame->ms;
719                         jb->info.last_voice_ms = frame->ms;
720                         jb->info.frames_out++;
721                         decrement_losspct(jb);
722                         *frameout = *frame;
723                         jb_dbg("V");
724                         return JB_OK;
725                 }
726         }
727 }
728
729 long jb_next(jitterbuf *jb) 
730 {
731         if (jb->info.silence_begin_ts) {
732                 long next = queue_next(jb);
733                 if (next > 0) { 
734                         history_get(jb);
735                         /* shrink during silence */
736                         if (jb->info.target - jb->info.current < -JB_TARGET_EXTRA)
737                                 return jb->info.last_adjustment + 10;
738                         return next + jb->info.target;
739                 }
740                 else 
741                         return JB_LONGMAX;
742         } else {
743                 return jb->info.next_voice_ts;
744         }
745 }
746
747 int jb_get(jitterbuf *jb, jb_frame *frameout, long now, long interpl) 
748 {
749         int ret = _jb_get(jb,frameout,now,interpl);
750 #if 0
751         static int lastts=0;
752         int thists = ((ret == JB_OK) || (ret == JB_DROP)) ? frameout->ts : 0;
753         jb_warn("jb_get(%x,%x,%ld) = %d (%d)\n", jb, frameout, now, ret, thists);
754         if (thists && thists < lastts) jb_warn("XXXX timestamp roll-back!!!\n");
755         lastts = thists;
756 #endif
757         if(ret == JB_INTERP) 
758                 frameout->ms = jb->info.last_voice_ms;
759         
760         return ret;
761 }
762
763 int jb_getall(jitterbuf *jb, jb_frame *frameout) 
764 {
765         jb_frame *frame;
766         frame = queue_getall(jb);
767
768         if (!frame) {
769                 return JB_NOFRAME;
770         }
771
772         *frameout = *frame;
773         return JB_OK;
774 }
775
776
777 int jb_getinfo(jitterbuf *jb, jb_info *stats) 
778 {
779
780         history_get(jb);
781
782         *stats = jb->info;
783
784         return JB_OK;
785 }
786
787 int jb_setconf(jitterbuf *jb, jb_conf *conf) 
788 {
789         /* take selected settings from the struct */
790
791         jb->info.conf.max_jitterbuf = conf->max_jitterbuf;
792         jb->info.conf.resync_threshold = conf->resync_threshold;
793
794         return JB_OK;
795 }
796
797