jitterbuf.c

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