add missing break (issue #5154)
[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 = 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         static int dbg_cnt = 0;
530
531         /*if ((now - jb_next(jb)) > 2 * jb->info.last_voice_ms) jb_warn("SCHED: %ld", (now - jb_next(jb))); */
532         /* get jitter info */
533         history_get(jb);
534
535         if (dbg_cnt && dbg_cnt % 50 == 0) {
536                 jb_dbg("\n");
537         }
538         dbg_cnt++;
539
540         /* target */
541         jb->info.target = jb->info.jitter + jb->info.min + JB_TARGET_EXTRA; 
542
543         /* if a hard clamp was requested, use it */
544         if ((jb->info.conf.max_jitterbuf) && ((jb->info.target - jb->info.min) > jb->info.conf.max_jitterbuf)) {
545                 jb_dbg("clamping target from %d to %d\n", (jb->info.target - jb->info.min), jb->info.conf.max_jitterbuf);
546                 jb->info.target = jb->info.min + jb->info.conf.max_jitterbuf;
547         }
548
549         diff = jb->info.target - jb->info.current;
550
551         /* jb_warn("diff = %d lms=%d last = %d now = %d\n", diff,  */
552         /*      jb->info.last_voice_ms, jb->info.last_adjustment, now); */
553
554         /* let's work on non-silent case first */
555         if (!jb->info.silence_begin_ts) { 
556                 /* we want to grow */
557                 if ((diff > 0) && 
558                         /* we haven't grown in the delay length */
559                         (((jb->info.last_adjustment + JB_ADJUST_DELAY) < now) || 
560                         /* we need to grow more than the "length" we have left */
561                         (diff > queue_last(jb)  - queue_next(jb)) ) ) {
562                         /* grow by interp frame length */
563                         jb->info.current += interpl;
564                         jb->info.next_voice_ts += interpl;
565                         jb->info.last_voice_ms = interpl;
566                         jb->info.last_adjustment = now;
567                         jb->info.cnt_contig_interp++;
568                         if (jb->info.conf.max_contig_interp && jb->info.cnt_contig_interp >= jb->info.conf.max_contig_interp) {
569                                 jb->info.silence_begin_ts = jb->info.next_voice_ts - jb->info.current;
570                         }
571                         jb_dbg("G");
572                         return JB_INTERP;
573                 }
574
575                 frame = queue_get(jb, jb->info.next_voice_ts - jb->info.current);
576
577                 /* not a voice frame; just return it. */
578                 if (frame && frame->type != JB_TYPE_VOICE) {
579                         if (frame->type == JB_TYPE_SILENCE) {
580                                 jb->info.silence_begin_ts = frame->ts;
581                                 jb->info.cnt_contig_interp = 0;
582                         }
583
584                         *frameout = *frame;
585                         jb->info.frames_out++;
586                         jb_dbg("o");
587                         return JB_OK;
588                 }
589
590
591                 /* voice frame is later than expected */
592                 if (frame && frame->ts + jb->info.current < jb->info.next_voice_ts) {
593                         if (frame->ts + jb->info.current > jb->info.next_voice_ts - jb->info.last_voice_ms) {
594                                 /* either we interpolated past this frame in the last jb_get */
595                                 /* or the frame is still in order, but came a little too quick */ 
596                                 *frameout = *frame;
597                                 /* reset expectation for next frame */
598                                 jb->info.next_voice_ts = frame->ts + jb->info.current + frame->ms;
599                                 jb->info.frames_out++;
600                                 decrement_losspct(jb);
601                                 jb->info.cnt_contig_interp = 0;
602                                 jb_dbg("v");
603                                 return JB_OK;
604                         } else {
605                                 /* voice frame is late */
606                                 *frameout = *frame;
607                                 jb->info.frames_out++;
608                                 decrement_losspct(jb);
609                                 jb->info.frames_late++;
610                                 jb->info.frames_lost--;
611                                 jb_dbg("l");
612                                 /*jb_warn("\nlate: wanted=%ld, this=%ld, next=%ld\n", jb->info.next_voice_ts - jb->info.current, frame->ts, queue_next(jb));
613                                 jb_warninfo(jb); */
614                                 return JB_DROP;
615                         }
616                 }
617
618                 /* keep track of frame sizes, to allow for variable sized-frames */
619                 if (frame && frame->ms > 0) {
620                         jb->info.last_voice_ms = frame->ms;
621                 }
622
623                 /* we want to shrink; shrink at 1 frame / 500ms */
624                 /* unless we don't have a frame, then shrink 1 frame */
625                 /* every 80ms (though perhaps we can shrink even faster */
626                 /* in this case) */
627                 if (diff < -JB_TARGET_EXTRA && 
628                         ((!frame && jb->info.last_adjustment + 80 < now) || 
629                         (jb->info.last_adjustment + 500 < now))) {
630
631                         jb->info.last_adjustment = now;
632                         jb->info.cnt_contig_interp = 0;
633
634                         if (frame) {
635                                 *frameout = *frame;
636                                 /* shrink by frame size we're throwing out */
637                                 jb->info.current -= frame->ms;
638                                 jb->info.frames_out++;
639                                 decrement_losspct(jb);
640                                 jb->info.frames_dropped++;
641                                 jb_dbg("s");
642                                 return JB_DROP;
643                         } else {
644                                 /* shrink by last_voice_ms */
645                                 jb->info.current -= jb->info.last_voice_ms;
646                                 jb->info.frames_lost++;
647                                 increment_losspct(jb);
648                                 jb_dbg("S");
649                                 return JB_NOFRAME;
650                         }
651                 }
652
653                 /* lost frame */
654                 if (!frame) {
655                         /* this is a bit of a hack for now, but if we're close to
656                          * target, and we find a missing frame, it makes sense to
657                          * grow, because the frame might just be a bit late;
658                          * otherwise, we presently get into a pattern where we return
659                          * INTERP for the lost frame, then it shows up next, and we
660                          * throw it away because it's late */
661                         /* I've recently only been able to replicate this using
662                          * iaxclient talking to app_echo on asterisk.  In this case,
663                          * my outgoing packets go through asterisk's (old)
664                          * jitterbuffer, and then might get an unusual increasing delay 
665                          * there if it decides to grow?? */
666                         /* Update: that might have been a different bug, that has been fixed..
667                          * But, this still seemed like a good idea, except that it ended up making a single actual
668                          * lost frame get interpolated two or more times, when there was "room" to grow, so it might
669                          * be a bit of a bad idea overall */
670                         /*if (diff > -1 * jb->info.last_voice_ms) { 
671                                 jb->info.current += jb->info.last_voice_ms;
672                                 jb->info.last_adjustment = now;
673                                 jb_warn("g");
674                                 return JB_INTERP;
675                         } */
676                         jb->info.frames_lost++;
677                         increment_losspct(jb);
678                         jb->info.next_voice_ts += interpl;
679                         jb->info.last_voice_ms = interpl;
680                         jb->info.cnt_contig_interp++;
681                         if (jb->info.conf.max_contig_interp && jb->info.cnt_contig_interp >= jb->info.conf.max_contig_interp) {
682                                 jb->info.silence_begin_ts = jb->info.next_voice_ts - jb->info.current;
683                         }
684                         jb_dbg("L");
685                         return JB_INTERP;
686                 }
687
688                 /* normal case; return the frame, increment stuff */
689                 *frameout = *frame;
690                 jb->info.next_voice_ts += frame->ms;
691                 jb->info.frames_out++;
692                 jb->info.cnt_contig_interp = 0;
693                 decrement_losspct(jb);
694                 jb_dbg("v");
695                 return JB_OK;
696         } else {     
697                 /* TODO: after we get the non-silent case down, we'll make the
698                  * silent case -- basically, we'll just grow and shrink faster
699                  * here, plus handle next_voice_ts a bit differently */
700       
701                 /* to disable silent special case altogether, just uncomment this: */
702                 /* jb->info.silence_begin_ts = 0; */
703
704                 /* shrink interpl len every 10ms during silence */
705                 if (diff < -JB_TARGET_EXTRA &&
706                         jb->info.last_adjustment + 10 <= now) {
707                         jb->info.current -= interpl;
708                         jb->info.last_adjustment = now;
709                 }
710
711                 frame = queue_get(jb, now - jb->info.current);
712                 if (!frame) {
713                         return JB_NOFRAME;
714                 } else if (frame->type != JB_TYPE_VOICE) {
715                         /* normal case; in silent mode, got a non-voice frame */
716                         *frameout = *frame;
717                         jb->info.frames_out++;
718                         return JB_OK;
719                 }
720                 if (frame->ts < jb->info.silence_begin_ts) {
721                         /* voice frame is late */
722                         *frameout = *frame;
723                         jb->info.frames_out++;
724                         decrement_losspct(jb);
725                         jb->info.frames_late++;
726                         jb->info.frames_lost--;
727                         jb_dbg("l");
728                         /*jb_warn("\nlate: wanted=%ld, this=%ld, next=%ld\n", jb->info.next_voice_ts - jb->info.current, frame->ts, queue_next(jb));
729                         jb_warninfo(jb); */
730                         return JB_DROP;
731                 } else {
732                         /* voice frame */
733                         /* try setting current to target right away here */
734                         jb->info.current = jb->info.target;
735                         jb->info.silence_begin_ts = 0;
736                         jb->info.next_voice_ts = frame->ts + jb->info.current + frame->ms;
737                         jb->info.last_voice_ms = frame->ms;
738                         jb->info.frames_out++;
739                         decrement_losspct(jb);
740                         *frameout = *frame;
741                         jb_dbg("V");
742                         return JB_OK;
743                 }
744         }
745 }
746
747 long jb_next(jitterbuf *jb) 
748 {
749         if (jb->info.silence_begin_ts) {
750                 long next = queue_next(jb);
751                 if (next > 0) { 
752                         history_get(jb);
753                         /* shrink during silence */
754                         if (jb->info.target - jb->info.current < -JB_TARGET_EXTRA)
755                                 return jb->info.last_adjustment + 10;
756                         return next + jb->info.target;
757                 }
758                 else 
759                         return JB_LONGMAX;
760         } else {
761                 return jb->info.next_voice_ts;
762         }
763 }
764
765 int jb_get(jitterbuf *jb, jb_frame *frameout, long now, long interpl) 
766 {
767         int ret = _jb_get(jb,frameout,now,interpl);
768 #if 0
769         static int lastts=0;
770         int thists = ((ret == JB_OK) || (ret == JB_DROP)) ? frameout->ts : 0;
771         jb_warn("jb_get(%x,%x,%ld) = %d (%d)\n", jb, frameout, now, ret, thists);
772         if (thists && thists < lastts) jb_warn("XXXX timestamp roll-back!!!\n");
773         lastts = thists;
774 #endif
775         if(ret == JB_INTERP) 
776                 frameout->ms = jb->info.last_voice_ms;
777         
778         return ret;
779 }
780
781 int jb_getall(jitterbuf *jb, jb_frame *frameout) 
782 {
783         jb_frame *frame;
784         frame = queue_getall(jb);
785
786         if (!frame) {
787                 return JB_NOFRAME;
788         }
789
790         *frameout = *frame;
791         return JB_OK;
792 }
793
794
795 int jb_getinfo(jitterbuf *jb, jb_info *stats) 
796 {
797
798         history_get(jb);
799
800         *stats = jb->info;
801
802         return JB_OK;
803 }
804
805 int jb_setconf(jitterbuf *jb, jb_conf *conf) 
806 {
807         /* take selected settings from the struct */
808
809         jb->info.conf.max_jitterbuf = conf->max_jitterbuf;
810         jb->info.conf.resync_threshold = conf->resync_threshold;
811         jb->info.conf.max_contig_interp = conf->max_contig_interp;
812
813         return JB_OK;
814 }
815
816