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