3rdparty/iaxclient/lib/libiax2/src/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 #include <sys/types.h>
  20
  21 #include "jitterbuf.h"
  22
  23 /* define these here, just for ancient compiler systems */
  24 #define JB_LONGMAX 2147483647L
  25 #define JB_LONGMIN (-JB_LONGMAX - 1L)
  26
  27 /* MS VC can't do __VA_ARGS__ */
  28 #if (defined(WIN32)  ||  defined(_WIN32_WCE))  &&  defined(_MSC_VER)
  29 #define jb_warn if (warnf) warnf
  30 #define jb_err if (errf) errf
  31 #define jb_dbg if (dbgf) dbgf
  32
  33 #ifdef DEEP_DEBUG
  34   #define jb_dbg2 if (dbgf) dbgf
  35 #else
  36   #define jb_dbg2 if (0) dbgf
  37 #endif
  38
  39 #else
  40
  41 #define jb_warn(...) (warnf ? warnf(__VA_ARGS__) : (void)0)
  42 #define jb_err(...) (errf ? errf(__VA_ARGS__) : (void)0)
  43 #define jb_dbg(...) (dbgf ? dbgf(__VA_ARGS__) : (void)0)
  44
  45 #ifdef DEEP_DEBUG
  46 #define jb_dbg2(...) (dbgf ? dbgf(__VA_ARGS__) : (void)0)
  47 #else
  48 #define jb_dbg2(...) ((void)0)
  49 #endif
  50
  51 #endif
  52
  53 static jb_output_function_t warnf, errf, dbgf;
  54
  55 void jb_setoutput(jb_output_function_t err, jb_output_function_t warn, jb_output_function_t dbg)
  56 {
  57         errf = err;
  58         warnf = warn;
  59         dbgf = dbg;
  60 }
  61
  62 static void increment_losspct(jitterbuf *jb)
  63 {
  64         jb->info.losspct = (100000 + 499 * jb->info.losspct)/500;
  65 }
  66
  67 static void decrement_losspct(jitterbuf *jb)
  68 {
  69         jb->info.losspct = (499 * jb->info.losspct)/500;
  70 }
  71
  72 void jb_reset(jitterbuf *jb)
  73 {
  74         /* only save settings */
  75         jb_conf s = jb->info.conf;
  76         memset(jb, 0, sizeof(*jb));
  77         jb->info.conf = s;
  78
  79         /* initialize length, using the configured value */
  80         jb->info.current = jb->info.target = jb->info.conf.target_extra;
  81         jb->info.silence_begin_ts = -1;
  82 }
  83
  84 jitterbuf * jb_new()
  85 {
  86         jitterbuf *jb;
  87
  88         if (!(jb = (jitterbuf *)malloc(sizeof(*jb))))
  89                 return NULL;
  90
  91         jb->info.conf.target_extra = JB_TARGET_EXTRA;
  92
  93         jb_reset(jb);
  94
  95         jb_dbg2("jb_new() = %x\n", jb);
  96         return jb;
  97 }
  98
  99 void jb_destroy(jitterbuf *jb)
 100 {
 101         jb_frame *frame;
 102         jb_dbg2("jb_destroy(%x)\n", jb);
 103
 104         /* free all the frames on the "free list" */
 105         frame = jb->free;
 106         while (frame != NULL) {
 107                 jb_frame *next = frame->next;
 108                 free(frame);
 109                 frame = next;
 110         }
 111
 112         /* free ourselves! */
 113         free(jb);
 114 }
 115
 116
 117
 118 #if 0
 119 static int longcmp(const void *a, const void *b)
 120 {
 121         return *(long *)a - *(long *)b;
 122 }
 123 #endif
 124
 125 /* simple history manipulation */
 126 /* maybe later we can make the history buckets variable size, or something? */
 127 /* drop parameter determines whether we will drop outliers to minimize
 128  * delay */
 129 static int history_put(jitterbuf *jb, long ts, long now, long ms)
 130 {
 131         long delay = now - (ts - jb->info.resync_offset);
 132         long threshold = 2 * jb->info.jitter + jb->info.conf.resync_threshold;
 133         long kicked;
 134
 135         /* don't add special/negative times to history */
 136         if (ts <= 0)
 137                 return 0;
 138
 139         /* check for drastic change in delay */
 140         if (jb->info.conf.resync_threshold != -1) {
 141                 if (abs(delay - jb->info.last_delay) > threshold) {
 142                         jb->info.cnt_delay_discont++;
 143                         if (jb->info.cnt_delay_discont > 3) {
 144                                 /* resync the jitterbuffer */
 145                                 jb->info.cnt_delay_discont = 0;
 146                                 jb->hist_ptr = 0;
 147                                 jb->hist_maxbuf_valid = 0;
 148
 149                                 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);
 150                                 jb->info.resync_offset = ts - now;
 151                                 jb->info.last_delay = delay = 0; /* after resync, frame is right on time */
 152                         } else {
 153                                 return -1;
 154                         }
 155                 } else {
 156                         jb->info.last_delay = delay;
 157                         jb->info.cnt_delay_discont = 0;
 158                 }
 159         }
 160
 161         kicked = jb->history[jb->hist_ptr % JB_HISTORY_SZ];
 162
 163         jb->history[(jb->hist_ptr++) % JB_HISTORY_SZ] = delay;
 164
 165         /* optimization; the max/min buffers don't need to be recalculated,
 166          * if this packet's entry doesn't change them. This happens if this
 167          * packet is not involved, _and_ any packet that got kicked out of
 168          * the history is also not involved. We do a number of comparisons,
 169          * but it's probably still worthwhile, because it will usually
 170          * succeed, and should be a lot faster than going through all 500
 171          * 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 = (jb_frame *)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         jb_dbg2("jb_put(%x,%x,%ld,%ld,%ld)\n", jb, data, ms, ts, now);
 517
 518         jb->info.frames_in++;
 519
 520         if (type == JB_TYPE_VOICE) {
 521                 /* presently, I'm only adding VOICE frames to history and drift
 522                  * calculations; mostly because with the IAX integrations, I'm
 523                  * sending retransmitted control frames with their awkward
 524                  * timestamps through
 525                  */
 526                 if (history_put(jb,ts,now,ms))
 527                         return JB_DROP;
 528         }
 529
 530         /* if put into head of queue, caller needs to reschedule */
 531         if (queue_put(jb,data,type,ms,ts)) {
 532                 return JB_SCHED;
 533         }
 534
 535         return JB_OK;
 536 }
 537
 538
 539 static enum jb_return_code _jb_get(jitterbuf *jb, jb_frame *frameout, long now, long interpl)
 540 {
 541         jb_frame *frame;
 542         long diff;
 543
 544         /*if ((now - jb_next(jb)) > 2 * jb->info.last_voice_ms) jb_warn("SCHED: %ld", (now - jb_next(jb))); */
 545         /* get jitter info */
 546         history_get(jb);
 547
 548
 549         /* target */
 550         jb->info.target = jb->info.jitter + jb->info.min + jb->info.conf.target_extra;
 551
 552         /* if a hard clamp was requested, use it */
 553         if ((jb->info.conf.max_jitterbuf) && ((jb->info.target - jb->info.min) > jb->info.conf.max_jitterbuf)) {
 554                 jb_dbg("clamping target from %d to %d\n", (jb->info.target - jb->info.min), jb->info.conf.max_jitterbuf);
 555                 jb->info.target = jb->info.min + jb->info.conf.max_jitterbuf;
 556         }
 557
 558         diff = jb->info.target - jb->info.current;
 559
 560         /* jb_warn("diff = %d lms=%d last = %d now = %d\n", diff,  */
 561         /*      jb->info.last_voice_ms, jb->info.last_adjustment, now); */
 562
 563         /* let's work on non-silent case first */
 564         if (!jb->info.silence_begin_ts) {
 565                 /* we want to grow */
 566                 if ((diff > 0) &&
 567                         /* we haven't grown in the delay length */
 568                         (((jb->info.last_adjustment + JB_ADJUST_DELAY) < now) ||
 569                         /* we need to grow more than the "length" we have left */
 570                         (diff > queue_last(jb) - queue_next(jb)) ) ) {
 571                         /* grow by interp frame length */
 572                         jb->info.current += interpl;
 573                         jb->info.next_voice_ts += interpl;
 574                         jb->info.last_voice_ms = interpl;
 575                         jb->info.last_adjustment = now;
 576                         jb->info.cnt_contig_interp++;
 577                         /* assume silence instead of continuing to interpolate */
 578                         if (jb->info.conf.max_contig_interp && jb->info.cnt_contig_interp >= jb->info.conf.max_contig_interp) {
 579                                 jb->info.silence_begin_ts = jb->info.next_voice_ts - jb->info.current;
 580                         }
 581                         jb_dbg("G");
 582                         return JB_INTERP;
 583                 }
 584
 585                 frame = queue_get(jb, jb->info.next_voice_ts - jb->info.current);
 586
 587                 /* not a voice frame; just return it. */
 588                 if (frame && frame->type != JB_TYPE_VOICE) {
 589                         /* track start of silence */
 590                         if (frame->type == JB_TYPE_SILENCE) {
 591                                 jb->info.silence_begin_ts = frame->ts;
 592                                 jb->info.cnt_contig_interp = 0;
 593                         }
 594
 595                         *frameout = *frame;
 596                         jb->info.frames_out++;
 597                         jb_dbg("o");
 598                         return JB_OK;
 599                 }
 600
 601                 /* voice frame is later than expected */
 602                 if (frame && frame->ts + jb->info.current < jb->info.next_voice_ts) {
 603                         if (frame->ts + jb->info.current > jb->info.next_voice_ts - jb->info.last_voice_ms) {
 604                                 /* either we interpolated past this frame in the last jb_get */
 605                                 /* or the frame is still in order, but came a little too quick */
 606                                 *frameout = *frame;
 607                                 /* reset expectation for next frame */
 608                                 jb->info.next_voice_ts = frame->ts + jb->info.current + frame->ms;
 609                                 jb->info.frames_out++;
 610                                 decrement_losspct(jb);
 611                                 jb->info.cnt_contig_interp = 0;
 612                                 jb_dbg("v");
 613                                 return JB_OK;
 614                         } else {
 615                                 /* voice frame is late */
 616                                 *frameout = *frame;
 617                                 jb->info.frames_out++;
 618                                 decrement_losspct(jb);
 619                                 jb->info.frames_late++;
 620                                 jb->info.frames_lost--;
 621                                 jb_dbg("l");
 622                                 /*jb_warn("\nlate: wanted=%ld, this=%ld, next=%ld\n", jb->info.next_voice_ts - jb->info.current, frame->ts, queue_next(jb));
 623                                   jb_warninfo(jb); */
 624                                 return JB_DROP;
 625                         }
 626                 }
 627
 628                 /* keep track of frame sizes, to allow for variable sized-frames */
 629                 if (frame && frame->ms > 0) {
 630                         jb->info.last_voice_ms = frame->ms;
 631                 }
 632
 633                 /* we want to shrink; shrink at 1 frame / 500ms */
 634                 /* unless we don't have a frame, then shrink 1 frame */
 635                 /* every 80ms (though perhaps we can shrink even faster */
 636                 /* in this case) */
 637                 if (diff < -jb->info.conf.target_extra &&
 638                                 ((!frame && jb->info.last_adjustment + 80 < now) ||
 639                                  (jb->info.last_adjustment + 500 < now))) {
 640
 641                         jb->info.last_adjustment = now;
 642                         jb->info.cnt_contig_interp = 0;
 643
 644                         if (frame) {
 645                                 *frameout = *frame;
 646                                 /* shrink by frame size we're throwing out */
 647                                 jb->info.current -= frame->ms;
 648                                 jb->info.frames_out++;
 649                                 decrement_losspct(jb);
 650                                 jb->info.frames_dropped++;
 651                                 jb_dbg("s");
 652                                 return JB_DROP;
 653                         } else {
 654                                 /* shrink by last_voice_ms */
 655                                 jb->info.current -= jb->info.last_voice_ms;
 656                                 jb->info.frames_lost++;
 657                                 increment_losspct(jb);
 658                                 jb_dbg("S");
 659                                 return JB_NOFRAME;
 660                         }
 661                 }
 662
 663                 /* lost frame */
 664                 if (!frame) {
 665                         /* this is a bit of a hack for now, but if we're close to
 666                          * target, and we find a missing frame, it makes sense to
 667                          * grow, because the frame might just be a bit late;
 668                          * otherwise, we presently get into a pattern where we return
 669                          * INTERP for the lost frame, then it shows up next, and we
 670                          * throw it away because it's late */
 671                         /* I've recently only been able to replicate this using
 672                          * iaxclient talking to app_echo on asterisk.  In this case,
 673                          * my outgoing packets go through asterisk's (old)
 674                          * jitterbuffer, and then might get an unusual increasing delay
 675                          * there if it decides to grow?? */
 676                         /* Update: that might have been a different bug, that has been fixed..
 677                          * But, this still seemed like a good idea, except that it ended up making a single actual
 678                          * lost frame get interpolated two or more times, when there was "room" to grow, so it might
 679                          * be a bit of a bad idea overall */
 680                         /*if (diff > -1 * jb->info.last_voice_ms) {
 681                                 jb->info.current += jb->info.last_voice_ms;
 682                                 jb->info.last_adjustment = now;
 683                                 jb_warn("g");
 684                                 return JB_INTERP;
 685                         } */
 686                         jb->info.frames_lost++;
 687                         increment_losspct(jb);
 688                         jb->info.next_voice_ts += interpl;
 689                         jb->info.last_voice_ms = interpl;
 690                         jb->info.cnt_contig_interp++;
 691                         /* assume silence instead of continuing to interpolate */
 692                         if (jb->info.conf.max_contig_interp && jb->info.cnt_contig_interp >= jb->info.conf.max_contig_interp) {
 693                                 jb->info.silence_begin_ts = jb->info.next_voice_ts - jb->info.current;
 694                         }
 695                         jb_dbg("L");
 696                         return JB_INTERP;
 697                 }
 698
 699                 /* normal case; return the frame, increment stuff */
 700                 *frameout = *frame;
 701                 jb->info.next_voice_ts += frame->ms;
 702                 jb->info.frames_out++;
 703                 jb->info.cnt_contig_interp = 0;
 704                 decrement_losspct(jb);
 705                 jb_dbg("v");
 706                 return JB_OK;
 707         } else {
 708                 /* TODO: after we get the non-silent case down, we'll make the
 709                  * silent case -- basically, we'll just grow and shrink faster
 710                  * here, plus handle next_voice_ts a bit differently */
 711
 712                 /* to disable silent special case altogether, just uncomment this: */
 713                 /* jb->info.silence_begin_ts = 0; */
 714
 715                 /* shrink interpl len every 10ms during silence */
 716                 if (diff < -jb->info.conf.target_extra &&
 717                         jb->info.last_adjustment + 10 <= now) {
 718                         jb->info.current -= interpl;
 719                         jb->info.last_adjustment = now;
 720                 }
 721
 722                 frame = queue_get(jb, now - jb->info.current);
 723                 if (!frame) {
 724                         return JB_NOFRAME;
 725                 } else if (frame->type != JB_TYPE_VOICE) {
 726                         /* normal case; in silent mode, got a non-voice frame */
 727                         *frameout = *frame;
 728                         jb->info.frames_out++;
 729                         return JB_OK;
 730                 }
 731                 if (frame->ts < jb->info.silence_begin_ts) {
 732                         /* voice frame is late */
 733                         *frameout = *frame;
 734                         jb->info.frames_out++;
 735                         decrement_losspct(jb);
 736                         jb->info.frames_late++;
 737                         jb->info.frames_lost--;
 738                         jb_dbg("l");
 739                         /*jb_warn("\nlate: wanted=%ld, this=%ld, next=%ld\n", jb->info.next_voice_ts - jb->info.current, frame->ts, queue_next(jb));
 740                           jb_warninfo(jb); */
 741                         return JB_DROP;
 742                 } else {
 743                         /* voice frame */
 744                         /* try setting current to target right away here */
 745                         jb->info.current = jb->info.target;
 746                         jb->info.silence_begin_ts = 0;
 747                         jb->info.next_voice_ts = frame->ts + jb->info.current + frame->ms;
 748                         jb->info.last_voice_ms = frame->ms;
 749                         jb->info.frames_out++;
 750                         decrement_losspct(jb);
 751                         *frameout = *frame;
 752                         jb_dbg("V");
 753                         return JB_OK;
 754                 }
 755         }
 756 }
 757
 758 long jb_next(jitterbuf *jb)
 759 {
 760         if (jb->info.silence_begin_ts) {
 761                 if (jb->frames) {
 762                         long next = queue_next(jb);
 763                         history_get(jb);
 764                         /* shrink during silence */
 765                         if (jb->info.target - jb->info.current < -jb->info.conf.target_extra)
 766                                 return jb->info.last_adjustment + 10;
 767                         return next + jb->info.target;
 768                 }
 769                 else
 770                         return JB_LONGMAX;
 771         } else {
 772                 return jb->info.next_voice_ts;
 773         }
 774 }
 775
 776 enum jb_return_code jb_get(jitterbuf *jb, jb_frame *frameout, long now, long interpl)
 777 {
 778         enum jb_return_code ret = _jb_get(jb, frameout, now, interpl);
 779 #if 0
 780         static int lastts=0;
 781         int thists = ((ret == JB_OK) || (ret == JB_DROP)) ? frameout->ts : 0;
 782         jb_warn("jb_get(%x,%x,%ld) = %d (%d)\n", jb, frameout, now, ret, thists);
 783         if (thists && thists < lastts) jb_warn("XXXX timestamp roll-back!!!\n");
 784         lastts = thists;
 785 #endif
 786         return ret;
 787 }
 788
 789 enum jb_return_code jb_getall(jitterbuf *jb, jb_frame *frameout)
 790 {
 791         jb_frame *frame;
 792         frame = queue_getall(jb);
 793
 794         if (!frame) {
 795                 return JB_NOFRAME;
 796         }
 797
 798         *frameout = *frame;
 799         return JB_OK;
 800 }
 801
 802
 803 enum jb_return_code jb_getinfo(jitterbuf *jb, jb_info *stats)
 804 {
 805         history_get(jb);
 806
 807         *stats = jb->info;
 808
 809         return JB_OK;
 810 }
 811
 812 enum jb_return_code jb_setconf(jitterbuf *jb, jb_conf *conf)
 813 {
 814         /* take selected settings from the struct */
 815
 816         jb->info.conf.max_jitterbuf = conf->max_jitterbuf;
 817         jb->info.conf.resync_threshold = conf->resync_threshold;
 818         jb->info.conf.max_contig_interp = conf->max_contig_interp;
 819
 820         /* -1 indicates use of the default JB_TARGET_EXTRA value */
 821         jb->info.conf.target_extra = ( conf->target_extra == -1 )
 822                 ? JB_TARGET_EXTRA
 823                 : conf->target_extra
 824                 ;
 825
 826         /* update these to match new target_extra setting */
 827         jb->info.current = jb->info.conf.target_extra;
 828         jb->info.target = jb->info.conf.target_extra;
 829
 830         return JB_OK;
 831 }
 832
 833