clean up formatting (bug #3934)
authorKevin P. Fleming <kpfleming@digium.com>
Sat, 2 Apr 2005 23:31:29 +0000 (23:31 +0000)
committerKevin P. Fleming <kpfleming@digium.com>
Sat, 2 Apr 2005 23:31:29 +0000 (23:31 +0000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@5363 65c4cc65-6c06-0410-ace0-fbb531ad65f3

jitterbuf.c

index 047d036..15dbd6a 100755 (executable)
@@ -36,19 +36,19 @@ static jb_output_function_t warnf, errf, dbgf;
 
 void jb_setoutput(jb_output_function_t warn, jb_output_function_t err, jb_output_function_t dbg) 
 {
-    warnf = warn;
-    errf = err;
-    dbgf = dbg;
+       warnf = warn;
+       errf = err;
+       dbgf = dbg;
 }
 
 static void increment_losspct(jitterbuf *jb) 
 {
-    jb->info.losspct = (100000 + 499 * jb->info.losspct)/500;    
+       jb->info.losspct = (100000 + 499 * jb->info.losspct)/500;    
 }
 
 static void decrement_losspct(jitterbuf *jb) 
 {
-    jb->info.losspct = (499 * jb->info.losspct)/500;    
+       jb->info.losspct = (499 * jb->info.losspct)/500;    
 }
 
 
@@ -57,42 +57,43 @@ static void jb_dbginfo(jitterbuf *jb);
 
 void jb_reset(jitterbuf *jb) 
 {
-    memset(jb,0,sizeof(jitterbuf));
+       memset(jb,0,sizeof(jitterbuf));
 
-    /* initialize length */
-    jb->info.current = jb->info.target = 0; 
-    jb->info.silence = 1; 
+       /* initialize length */
+       jb->info.current = jb->info.target = 0; 
+       jb->info.silence = 1; 
 }
 
 jitterbuf * jb_new() 
 {
-    jitterbuf *jb;
+       jitterbuf *jb;
 
 
-    jb = malloc(sizeof(jitterbuf));
-    if(!jb) return NULL;
+       jb = malloc(sizeof(jitterbuf));
+       if (!jb) 
+               return NULL;
 
-    jb_reset(jb);
+       jb_reset(jb);
 
-    jb_dbg2("jb_new() = %x\n", jb);
-    return jb;
+       jb_dbg2("jb_new() = %x\n", jb);
+       return jb;
 }
 
 void jb_destroy(jitterbuf *jb) 
 {
-    jb_frame *frame; 
-    jb_dbg2("jb_destroy(%x)\n", jb);
-
-    /* free all the frames on the "free list" */
-    frame = jb->free;
-    while(frame != NULL) {
-      jb_frame *next = frame->next;
-      free(frame);
-      frame = next;
-    }
-
-    /* free ourselves! */ 
-    free(jb);
+       jb_frame *frame; 
+       jb_dbg2("jb_destroy(%x)\n", jb);
+
+       /* free all the frames on the "free list" */
+       frame = jb->free;
+       while (frame != NULL) {
+               jb_frame *next = frame->next;
+               free(frame);
+               frame = next;
+       }
+
+       /* free ourselves! */ 
+       free(jb);
 }
 
 
@@ -103,597 +104,607 @@ void jb_destroy(jitterbuf *jb)
  * delay */
 static int longcmp(const void *a, const void *b) 
 {
-    return *(long *)a - *(long *)b;
+       return *(long *)a - *(long *)b;
 }
 
 static void history_put(jitterbuf *jb, long ts, long now) 
 {
-    long delay = now - ts;
-    long kicked;
+       long delay = now - ts;
+       long kicked;
 
-    /* don't add special/negative times to history */
-    if(ts <= 0) return;
+       /* don't add special/negative times to history */
+       if (ts <= 0) 
+               return;
 
-    kicked = jb->history[jb->hist_ptr & JB_HISTORY_SZ];
+       kicked = jb->history[jb->hist_ptr & JB_HISTORY_SZ];
 
-    jb->history[(jb->hist_ptr++) % JB_HISTORY_SZ] = delay;
+       jb->history[(jb->hist_ptr++) % JB_HISTORY_SZ] = delay;
 
-    /* optimization; the max/min buffers don't need to be recalculated, if this packet's
-     * entry doesn't change them.  This happens if this packet is not involved, _and_ any packet
-     * that got kicked out of the history is also not involved 
-     * We do a number of comparisons, but it's probably still worthwhile, because it will usually
-     * succeed, and should be a lot faster than going through all 500 packets in history */
-    if(!jb->hist_maxbuf_valid)
-      return;
+       /* optimization; the max/min buffers don't need to be recalculated, if this packet's
+        * entry doesn't change them.  This happens if this packet is not involved, _and_ any packet
+        * that got kicked out of the history is also not involved 
+        * We do a number of comparisons, but it's probably still worthwhile, because it will usually
+        * succeed, and should be a lot faster than going through all 500 packets in history */
+       if (!jb->hist_maxbuf_valid)
+               return;
 
-    /* don't do this until we've filled history 
-     * (reduces some edge cases below) */
-    if(jb->hist_ptr < JB_HISTORY_SZ)
-      goto invalidate;
+       /* don't do this until we've filled history 
+        * (reduces some edge cases below) */
+       if (jb->hist_ptr < JB_HISTORY_SZ)
+               goto invalidate;
 
-    /* if the new delay would go into min */
-    if(delay < jb->hist_minbuf[JB_HISTORY_MAXBUF_SZ-1])
-      goto invalidate;
+       /* if the new delay would go into min */
+       if (delay < jb->hist_minbuf[JB_HISTORY_MAXBUF_SZ-1])
+               goto invalidate;
     
-    /* or max.. */
-    if(delay > jb->hist_maxbuf[JB_HISTORY_MAXBUF_SZ-1])
-      goto invalidate;
+       /* or max.. */
+       if (delay > jb->hist_maxbuf[JB_HISTORY_MAXBUF_SZ-1])
+               goto invalidate;
 
-    /* or the kicked delay would be in min */
-    if(kicked <= jb->hist_minbuf[JB_HISTORY_MAXBUF_SZ-1]) 
-      goto invalidate;
+       /* or the kicked delay would be in min */
+       if (kicked <= jb->hist_minbuf[JB_HISTORY_MAXBUF_SZ-1]) 
+               goto invalidate;
 
-    if(kicked >= jb->hist_maxbuf[JB_HISTORY_MAXBUF_SZ-1]) 
-      goto invalidate;
+       if (kicked >= jb->hist_maxbuf[JB_HISTORY_MAXBUF_SZ-1]) 
+               goto invalidate;
 
-    /* if we got here, we don't need to invalidate, 'cause this delay didn't 
-     * affect things */
-    return;
-    /* end optimization */
+       /* if we got here, we don't need to invalidate, 'cause this delay didn't 
+        * affect things */
+       return;
+       /* end optimization */
 
 
 invalidate:
-    jb->hist_maxbuf_valid = 0;
-    return;
+       jb->hist_maxbuf_valid = 0;
+       return;
 }
 
 static void history_calc_maxbuf(jitterbuf *jb) 
 {
-    int i,j;
+       int i,j;
 
-    if(jb->hist_ptr == 0) return;
+       if (jb->hist_ptr == 0) 
+               return;
 
 
-    /* initialize maxbuf/minbuf to the latest value */
-    for(i=0;i<JB_HISTORY_MAXBUF_SZ;i++) {
+       /* initialize maxbuf/minbuf to the latest value */
+       for (i=0;i<JB_HISTORY_MAXBUF_SZ;i++) {
 /*
  * jb->hist_maxbuf[i] = jb->history[(jb->hist_ptr-1) % JB_HISTORY_SZ];
  * jb->hist_minbuf[i] = jb->history[(jb->hist_ptr-1) % JB_HISTORY_SZ];
  */
-      jb->hist_maxbuf[i] = JB_LONGMIN;
-      jb->hist_minbuf[i] = JB_LONGMAX;
-    }
+               jb->hist_maxbuf[i] = JB_LONGMIN;
+               jb->hist_minbuf[i] = JB_LONGMAX;
+       }
 
-    /* use insertion sort to populate maxbuf */
-    /* we want it to be the top "n" values, in order */
+       /* use insertion sort to populate maxbuf */
+       /* we want it to be the top "n" values, in order */
 
-    /* start at the beginning, or JB_HISTORY_SZ frames ago */
-    i = (jb->hist_ptr > JB_HISTORY_SZ) ? (jb->hist_ptr - JB_HISTORY_SZ) : 0; 
+       /* start at the beginning, or JB_HISTORY_SZ frames ago */
+       i = (jb->hist_ptr > JB_HISTORY_SZ) ? (jb->hist_ptr - JB_HISTORY_SZ) : 0; 
 
-    for(;i<jb->hist_ptr;i++) {
-       long toins = jb->history[i % JB_HISTORY_SZ];
+       for (;i<jb->hist_ptr;i++) {
+               long toins = jb->history[i % JB_HISTORY_SZ];
 
-       /* if the maxbuf should get this */
-       if(toins > jb->hist_maxbuf[JB_HISTORY_MAXBUF_SZ-1])  {
+               /* if the maxbuf should get this */
+               if (toins > jb->hist_maxbuf[JB_HISTORY_MAXBUF_SZ-1])  {
 
-           /* insertion-sort it into the maxbuf */
-           for(j=0;j<JB_HISTORY_MAXBUF_SZ;j++) {
-               /* found where it fits */
-               if(toins > jb->hist_maxbuf[j]) {
-                   /* move over */
-                   memmove(jb->hist_maxbuf+j+1,jb->hist_maxbuf+j, (JB_HISTORY_MAXBUF_SZ-(j+1)) * sizeof(long));
-                   /* insert */
-                   jb->hist_maxbuf[j] = toins;
+                       /* insertion-sort it into the maxbuf */
+                       for (j=0;j<JB_HISTORY_MAXBUF_SZ;j++) {
+                               /* found where it fits */
+                               if (toins > jb->hist_maxbuf[j]) {
+                                       /* move over */
+                                       memmove(jb->hist_maxbuf+j+1,jb->hist_maxbuf+j, (JB_HISTORY_MAXBUF_SZ-(j+1)) * sizeof(long));
+                                       /* insert */
+                                       jb->hist_maxbuf[j] = toins;
 
-                   break;
+                                       break;
+                               }
+                       }
                }
-           }
-       }
-
-       /* if the minbuf should get this */
-       if(toins < jb->hist_minbuf[JB_HISTORY_MAXBUF_SZ-1])  {
-
-           /* insertion-sort it into the maxbuf */
-           for(j=0;j<JB_HISTORY_MAXBUF_SZ;j++) {
-               /* found where it fits */
-               if(toins < jb->hist_minbuf[j]) {
-                   /* move over */
-                   memmove(jb->hist_minbuf+j+1,jb->hist_minbuf+j, (JB_HISTORY_MAXBUF_SZ-(j+1)) * sizeof(long));
-                   /* insert */
-                   jb->hist_minbuf[j] = toins;
 
-                   break;
+               /* if the minbuf should get this */
+               if (toins < jb->hist_minbuf[JB_HISTORY_MAXBUF_SZ-1])  {
+
+                       /* insertion-sort it into the maxbuf */
+                       for (j=0;j<JB_HISTORY_MAXBUF_SZ;j++) {
+                               /* found where it fits */
+                               if (toins < jb->hist_minbuf[j]) {
+                                       /* move over */
+                                       memmove(jb->hist_minbuf+j+1,jb->hist_minbuf+j, (JB_HISTORY_MAXBUF_SZ-(j+1)) * sizeof(long));
+                                       /* insert */
+                                       jb->hist_minbuf[j] = toins;
+
+                                       break;
+                               }
+                       }
                }
-           }
-       }
 
-       if(0) { 
-         int k;
-         fprintf(stderr, "toins = %ld\n", toins);
-         fprintf(stderr, "maxbuf =");
-         for(k=0;k<JB_HISTORY_MAXBUF_SZ;k++) 
-             fprintf(stderr, "%ld ", jb->hist_maxbuf[k]);
-         fprintf(stderr, "\nminbuf =");
-         for(k=0;k<JB_HISTORY_MAXBUF_SZ;k++) 
-             fprintf(stderr, "%ld ", jb->hist_minbuf[k]);
-         fprintf(stderr, "\n");
+               if (0) { 
+                       int k;
+                       fprintf(stderr, "toins = %ld\n", toins);
+                       fprintf(stderr, "maxbuf =");
+                       for (k=0;k<JB_HISTORY_MAXBUF_SZ;k++) 
+                               fprintf(stderr, "%ld ", jb->hist_maxbuf[k]);
+                       fprintf(stderr, "\nminbuf =");
+                       for (k=0;k<JB_HISTORY_MAXBUF_SZ;k++) 
+                               fprintf(stderr, "%ld ", jb->hist_minbuf[k]);
+                       fprintf(stderr, "\n");
+               }
        }
-    }
 
-    jb->hist_maxbuf_valid = 1;
+       jb->hist_maxbuf_valid = 1;
 }
 
 static void history_get(jitterbuf *jb) 
 {
-    long max, min, jitter;
-    int index;
-    int count;
+       long max, min, jitter;
+       int index;
+       int count;
 
-    if(!jb->hist_maxbuf_valid) 
-      history_calc_maxbuf(jb);
+       if (!jb->hist_maxbuf_valid) 
+               history_calc_maxbuf(jb);
 
-    /* count is how many items in history we're examining */
-    count = (jb->hist_ptr < JB_HISTORY_SZ) ? jb->hist_ptr : JB_HISTORY_SZ;
+       /* count is how many items in history we're examining */
+       count = (jb->hist_ptr < JB_HISTORY_SZ) ? jb->hist_ptr : JB_HISTORY_SZ;
 
-    /* index is the "n"ths highest/lowest that we'll look for */
-    index = count * JB_HISTORY_DROPPCT / 100;
+       /* index is the "n"ths highest/lowest that we'll look for */
+       index = count * JB_HISTORY_DROPPCT / 100;
 
-    /* sanity checks for index */
-    if(index > (JB_HISTORY_MAXBUF_SZ - 1)) index = JB_HISTORY_MAXBUF_SZ - 1;
+       /* sanity checks for index */
+       if (index > (JB_HISTORY_MAXBUF_SZ - 1)) 
+               index = JB_HISTORY_MAXBUF_SZ - 1;
 
 
-    if(index < 0) {
-      jb->info.min = 0;
-      jb->info.jitter = 0;
-      return;
-    }
+       if (index < 0) {
+               jb->info.min = 0;
+               jb->info.jitter = 0;
+               return;
+       }
 
-    max = jb->hist_maxbuf[index];
-    min = jb->hist_minbuf[index];
+       max = jb->hist_maxbuf[index];
+       min = jb->hist_minbuf[index];
 
-    jitter = max - min;
+       jitter = max - min;
 
-    /* these debug stmts compare the difference between looking at the absolute jitter, and the
-     * values we get by throwing away the outliers */
-    /*
-    fprintf(stderr, "[%d] min=%d, max=%d, jitter=%d\n", index, min, max, jitter);
-    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]);
-    */
+       /* these debug stmts compare the difference between looking at the absolute jitter, and the
+        * values we get by throwing away the outliers */
+       /*
+       fprintf(stderr, "[%d] min=%d, max=%d, jitter=%d\n", index, min, max, jitter);
+       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]);
+       */
 
-    jb->info.min = min;
-    jb->info.jitter = jitter;
+       jb->info.min = min;
+       jb->info.jitter = jitter;
 }
 
 static void queue_put(jitterbuf *jb, void *data, int type, long ms, long ts) 
 {
-    jb_frame *frame;
-    jb_frame *p;
-
-    frame = jb->free;
-    if(frame) {
-       jb->free = frame->next;
-    } else {
-       frame = malloc(sizeof(jb_frame));
-    }
-
-    if(!frame) {
-       jb_err("cannot allocate frame\n");
-       return;
-    }
+       jb_frame *frame;
+       jb_frame *p;
 
-    jb->info.frames_cur++;
+       frame = jb->free;
+       if (frame) {
+               jb->free = frame->next;
+       } else {
+               frame = malloc(sizeof(jb_frame));
+       }
 
-    frame->data = data;
-    frame->ts = ts;
-    frame->ms = ms;
-    frame->type = type;
+       if (!frame) {
+               jb_err("cannot allocate frame\n");
+               return;
+       }
 
-    /* 
-     * frames are a circular list, jb-frames points to to the lowest ts, 
-     * jb->frames->prev points to the highest ts
-     */
+       jb->info.frames_cur++;
 
-    if(!jb->frames) {  /* queue is empty */
-       jb->frames = frame;
-       frame->next = frame;
-       frame->prev = frame;
-    } else if(ts < jb->frames->ts) { 
-       frame->next = jb->frames;
-       frame->prev = jb->frames->prev;
+       frame->data = data;
+       frame->ts = ts;
+       frame->ms = ms;
+       frame->type = type;
 
-       frame->next->prev = frame;
-       frame->prev->next = frame;
+       /* 
+        * frames are a circular list, jb-frames points to to the lowest ts, 
+        * jb->frames->prev points to the highest ts
+        */
 
-       jb->frames = frame;
-    } else { 
-       p = jb->frames;
+       if (!jb->frames) {  /* queue is empty */
+               jb->frames = frame;
+               frame->next = frame;
+               frame->prev = frame;
+               frame->prev = jb->frames->prev;
 
-       /* frame is out of order */
-       if(ts < p->prev->ts) jb->info.frames_ooo++;
+               frame->next->prev = frame;
+               frame->prev->next = frame;
 
-       while(ts < p->prev->ts && p->prev != jb->frames) 
-           p = p->prev;
+               jb->frames = frame;
+       } else { 
+               p = jb->frames;
 
-       frame->next = p;
-       frame->prev = p->prev;
+               /* frame is out of order */
+               if (ts < p->prev->ts) jb->info.frames_ooo++;
 
-       frame->next->prev = frame;
-       frame->prev->next = frame;
-    }
+               while (ts < p->prev->ts && p->prev != jb->frames) 
+                       p = p->prev;
+
+               frame->next = p;
+               frame->prev = p->prev;
+
+               frame->next->prev = frame;
+               frame->prev->next = frame;
+       }
 }
 
 static long queue_next(jitterbuf *jb) 
 {
-    if(jb->frames) return jb->frames->ts;
-    else return -1;
+       if (jb->frames) 
+               return jb->frames->ts;
+       else 
+               return -1;
 }
 
 static long queue_last(jitterbuf *jb) 
 {
-    if(jb->frames) return jb->frames->prev->ts;
-    else return -1;
+       if (jb->frames) 
+               return jb->frames->prev->ts;
+       else 
+               return -1;
 }
 
 static jb_frame *_queue_get(jitterbuf *jb, long ts, int all) 
 {
-    jb_frame *frame;
-    frame = jb->frames;
+       jb_frame *frame;
+       frame = jb->frames;
 
-    if(!frame)
-       return NULL;
+       if (!frame)
+               return NULL;
 
-    /*jb_warn("queue_get: ASK %ld FIRST %ld\n", ts, frame->ts); */
+       /*jb_warn("queue_get: ASK %ld FIRST %ld\n", ts, frame->ts); */
 
-    if(all || ts > frame->ts) {
-       /* remove this frame */
-       frame->prev->next = frame->next;
-       frame->next->prev = frame->prev;
+       if (all || ts > frame->ts) {
+               /* remove this frame */
+               frame->prev->next = frame->next;
+               frame->next->prev = frame->prev;
 
-       if(frame->next == frame)
-         jb->frames = NULL;
-       else
-         jb->frames = frame->next;
+               if (frame->next == frame)
+                       jb->frames = NULL;
+               else
+                       jb->frames = frame->next;
 
 
-       /* insert onto "free" single-linked list */
-       frame->next = jb->free;
-       jb->free = frame;
+               /* insert onto "free" single-linked list */
+               frame->next = jb->free;
+               jb->free = frame;
 
-       jb->info.frames_cur--;
+               jb->info.frames_cur--;
 
-       /* we return the frame pointer, even though it's on free list, 
-        * but caller must copy data */
-       return frame;
-    } 
+               /* we return the frame pointer, even though it's on free list, 
+                * but caller must copy data */
+               return frame;
+       } 
 
-    return NULL;
+       return NULL;
 }
 
 static jb_frame *queue_get(jitterbuf *jb, long ts) 
 {
-    return _queue_get(jb,ts,0);
+       return _queue_get(jb,ts,0);
 }
 
 static jb_frame *queue_getall(jitterbuf *jb) 
 {
-    return _queue_get(jb,0,1);
+       return _queue_get(jb,0,1);
 }
 
 /* some diagnostics */
 static void jb_dbginfo(jitterbuf *jb) 
 {
-    if(dbgf == NULL) return;
+       if (dbgf == NULL) 
+               return;
 
-    jb_dbg("\njb info: fin=%ld fout=%ld flate=%ld flost=%ld fdrop=%ld fcur=%ld\n",
-           jb->info.frames_in, jb->info.frames_out, jb->info.frames_late, jb->info.frames_lost, jb->info.frames_dropped, jb->info.frames_cur);
+       jb_dbg("\njb info: fin=%ld fout=%ld flate=%ld flost=%ld fdrop=%ld fcur=%ld\n",
+               jb->info.frames_in, jb->info.frames_out, jb->info.frames_late, jb->info.frames_lost, jb->info.frames_dropped, jb->info.frames_cur);
        
-    jb_dbg("   jitter=%ld current=%ld target=%ld min=%ld sil=%d len=%d len/fcur=%ld\n",
-           jb->info.jitter, jb->info.current, jb->info.target, jb->info.min, jb->info.silence, jb->info.current - jb->info.min, 
-           jb->info.frames_cur ? (jb->info.current - jb->info.min)/jb->info.frames_cur : -8);
-    if(jb->info.frames_in > 0) 
-       jb_dbg("jb info: Loss PCT = %ld%%, Late PCT = %ld%%\n",
-           jb->info.frames_lost * 100/(jb->info.frames_in + jb->info.frames_lost), 
-           jb->info.frames_late * 100/jb->info.frames_in);
+       jb_dbg("jitter=%ld current=%ld target=%ld min=%ld sil=%d len=%d len/fcur=%ld\n",
+               jb->info.jitter, jb->info.current, jb->info.target, jb->info.min, jb->info.silence, jb->info.current - jb->info.min, 
+               jb->info.frames_cur ? (jb->info.current - jb->info.min)/jb->info.frames_cur : -8);
+       if (jb->info.frames_in > 0) 
+               jb_dbg("jb info: Loss PCT = %ld%%, Late PCT = %ld%%\n",
+                       jb->info.frames_lost * 100/(jb->info.frames_in + jb->info.frames_lost), 
+                       jb->info.frames_late * 100/jb->info.frames_in);
        jb_dbg("jb info: queue %d -> %d.  last_ts %d (queue len: %d) last_ms %d\n",
-           queue_next(jb), 
-           queue_last(jb),
-           jb->info.last_voice_ts, 
-           queue_last(jb) - queue_next(jb),
-           jb->info.last_voice_ms);
+               queue_next(jb), 
+               queue_last(jb),
+               jb->info.last_voice_ts, 
+               queue_last(jb) - queue_next(jb),
+               jb->info.last_voice_ms);
 }
 
 #ifdef DEEP_DEBUG
 static void jb_chkqueue(jitterbuf *jb) 
 {
-    int i=0;
-    jb_frame *p = jb->frames;
-
-    if(!p) {
-      return;
-    }
+       int i=0;
+       jb_frame *p = jb->frames;
 
-    do {
-       if(p->next == NULL)  {
-         jb_err("Queue is BROKEN at item [%d]", i);    
+       if (!p) {
+               return;
        }
-       i++;
-       p=p->next;
-    } while (p->next != jb->frames);
+
+       do {
+               if (p->next == NULL)  {
+                       jb_err("Queue is BROKEN at item [%d]", i);      
+               }
+               i++;
+               p=p->next;
+       } while (p->next != jb->frames);
 }
 
 static void jb_dbgqueue(jitterbuf *jb) 
 {
-    int i=0;
-    jb_frame *p = jb->frames;
+       int i=0;
+       jb_frame *p = jb->frames;
 
-    jb_dbg("queue: ");
+       jb_dbg("queue: ");
 
-    if(!p) {
-      jb_dbg("EMPTY\n");
-      return;
-    }
+       if (!p) {
+               jb_dbg("EMPTY\n");
+               return;
+       }
 
-    do {
-       jb_dbg("[%d]=%ld ", i++, p->ts);
-       p=p->next;
-    } while (p->next != jb->frames);
+       do {
+               jb_dbg("[%d]=%ld ", i++, p->ts);
+               p=p->next;
+       } while (p->next != jb->frames);
 
-    jb_dbg("\n");
+       jb_dbg("\n");
 }
 #endif
 
 int jb_put(jitterbuf *jb, void *data, int type, long ms, long ts, long now) 
 {
-    jb_dbg2("jb_put(%x,%x,%ld,%ld,%ld)\n", jb, data, ms, ts, now);
+       jb_dbg2("jb_put(%x,%x,%ld,%ld,%ld)\n", jb, data, ms, ts, now);
 
-    jb->info.frames_in++;
+       jb->info.frames_in++;
 
-    if(type == JB_TYPE_VOICE) {
-      /* presently, I'm only adding VOICE frames to history and drift calculations; mostly because with the
-       * IAX integrations, I'm sending retransmitted control frames with their awkward timestamps through */
-      history_put(jb,ts,now);
-    }
+       if (type == JB_TYPE_VOICE) {
+               /* presently, I'm only adding VOICE frames to history and drift calculations; mostly because with the
+                * IAX integrations, I'm sending retransmitted control frames with their awkward timestamps through */
+               history_put(jb,ts,now);
+       }
 
-    queue_put(jb,data,type,ms,ts);
+       queue_put(jb,data,type,ms,ts);
 
-    return JB_OK;
+       return JB_OK;
 }
 
 
 static int _jb_get(jitterbuf *jb, jb_frame *frameout, long now) 
 {
-    jb_frame *frame;
-    long diff;
-
-    /*if((now - jb_next(jb)) > 2 * jb->info.last_voice_ms) jb_warn("SCHED: %ld", (now - jb_next(jb))); */
-    /* get jitter info */
-    history_get(jb);
+       jb_frame *frame;
+       long diff;
 
+       /*if ((now - jb_next(jb)) > 2 * jb->info.last_voice_ms) jb_warn("SCHED: %ld", (now - jb_next(jb))); */
+       /* get jitter info */
+       history_get(jb);
 
-    /* target */
-    jb->info.target = jb->info.jitter + jb->info.min + 2 * jb->info.last_voice_ms; 
 
-    /* if a hard clamp was requested, use it */
-    if((jb->info.max_jitterbuf) && ((jb->info.target - jb->info.min) > jb->info.max_jitterbuf)) {
-       jb_dbg("clamping target from %d to %d\n", (jb->info.target - jb->info.min), jb->info.max_jitterbuf);
-       jb->info.target = jb->info.min + jb->info.max_jitterbuf;
-    }
+       /* target */
+       jb->info.target = jb->info.jitter + jb->info.min + 2 * jb->info.last_voice_ms; 
 
-    diff = jb->info.target - jb->info.current;
+       /* if a hard clamp was requested, use it */
+       if ((jb->info.max_jitterbuf) && ((jb->info.target - jb->info.min) > jb->info.max_jitterbuf)) {
+               jb_dbg("clamping target from %d to %d\n", (jb->info.target - jb->info.min), jb->info.max_jitterbuf);
+                       jb->info.target = jb->info.min + jb->info.max_jitterbuf;
+       }
 
-    /*    jb_warn("diff = %d lms=%d last = %d now = %d\n", diff,  */
-    /* jb->info.last_voice_ms, jb->info.last_adjustment, now); */
+       diff = jb->info.target - jb->info.current;
+
+       /* jb_warn("diff = %d lms=%d last = %d now = %d\n", diff,  */
+       /*      jb->info.last_voice_ms, jb->info.last_adjustment, now); */
+
+       /* move up last_voice_ts; it is now the expected voice ts */
+       jb->info.last_voice_ts += jb->info.last_voice_ms;
+
+       /* let's work on non-silent case first */
+       if (!jb->info.silence) { 
+               /* we want to grow */
+               if ((diff > 0) && 
+                       /* we haven't grown in 2 frames' length */
+                       (((jb->info.last_adjustment + 2 * jb->info.last_voice_ms ) < now) || 
+                       /* we need to grow more than the "length" we have left */
+                       (diff > queue_last(jb)  - queue_next(jb)) ) ) {
+                       
+                       jb->info.current += jb->info.last_voice_ms;
+                       jb->info.last_adjustment = now;
+                       jb_dbg("G");
+                       return JB_INTERP;
+               }
 
-    /* move up last_voice_ts; it is now the expected voice ts */
-    jb->info.last_voice_ts += jb->info.last_voice_ms;
+               frame = queue_get(jb, jb->info.last_voice_ts - jb->info.current);
 
-    /* let's work on non-silent case first */
-    if(!jb->info.silence) { 
-         /* we want to grow */
-      if( (diff > 0) && 
-         /* we haven't grown in 2 frames' length */
-         (((jb->info.last_adjustment + 2 * jb->info.last_voice_ms ) < now) || 
-          /* we need to grow more than the "length" we have left */
-          (diff > queue_last(jb)  - queue_next(jb)) ) ) {
-             jb->info.current += jb->info.last_voice_ms;
-             jb->info.last_adjustment = now;
-             jb_dbg("G");
-             return JB_INTERP;
-      }
+               /* not a voice frame; just return it. */
+               if (frame && frame->type != JB_TYPE_VOICE) {
+                       /* rewind last_voice_ts, since this isn't voice */
+                       jb->info.last_voice_ts -= jb->info.last_voice_ms;
 
-      frame = queue_get(jb, jb->info.last_voice_ts - jb->info.current);
+                       if (frame->type == JB_TYPE_SILENCE) 
+                               jb->info.silence = 1;
 
-      /* not a voice frame; just return it. */
-      if(frame && frame->type != JB_TYPE_VOICE) {
-       /* rewind last_voice_ts, since this isn't voice */
-       jb->info.last_voice_ts -= jb->info.last_voice_ms;
+                       *frameout = *frame;
+                       jb->info.frames_out++;
+                       jb_dbg("o");
+                       return JB_OK;
+               }
 
-       if(frame->type == JB_TYPE_SILENCE) 
-         jb->info.silence = 1;
 
-       *frameout = *frame;
-       jb->info.frames_out++;
-       jb_dbg("o");
-       return JB_OK;
-      }
+               /* voice frame is late */
+               if (frame && frame->ts + jb->info.current < jb->info.last_voice_ts - jb->info.last_voice_ms ) {
+                       *frameout = *frame;
+                       /* rewind last_voice, since we're just dumping */
+                       jb->info.last_voice_ts -= jb->info.last_voice_ms;
+                       jb->info.frames_out++;
+                       decrement_losspct(jb);
+                       jb->info.frames_late++;
+                       jb->info.frames_lost--;
+                       jb_dbg("l");
+                       /*jb_warn("\nlate: wanted=%ld, this=%ld, next=%ld\n", jb->info.last_voice_ts - jb->info.current, frame->ts, queue_next(jb));
+                       jb_warninfo(jb); */
+                       return JB_DROP;
+               }
 
+               /* keep track of frame sizes, to allow for variable sized-frames */
+               if (frame && frame->ms > 0) {
+                       jb->info.last_voice_ms = frame->ms;
+               }
 
-      /* voice frame is late */
-      if(frame && frame->ts + jb->info.current < jb->info.last_voice_ts - jb->info.last_voice_ms ) {
-       *frameout = *frame;
-       /* rewind last_voice, since we're just dumping */
-       jb->info.last_voice_ts -= jb->info.last_voice_ms;
-       jb->info.frames_out++;
-       decrement_losspct(jb);
-       jb->info.frames_late++;
-       jb->info.frames_lost--;
-       jb_dbg("l");
-       /*jb_warn("\nlate: wanted=%ld, this=%ld, next=%ld\n", jb->info.last_voice_ts - jb->info.current, frame->ts, queue_next(jb));
-       jb_warninfo(jb); */
-       return JB_DROP;
-      }
-
-      /* keep track of frame sizes, to allow for variable sized-frames */
-      if(frame && frame->ms > 0) {
-       jb->info.last_voice_ms = frame->ms;
-      }
-
-      /* we want to shrink; shrink at 1 frame / 500ms */
-      if(diff < -2 * jb->info.last_voice_ms && 
+               /* we want to shrink; shrink at 1 frame / 500ms */
+               if (diff < -2 * jb->info.last_voice_ms && 
                ((!frame && jb->info.last_adjustment + 80 < now) || 
-                (jb->info.last_adjustment + 500 < now))) {
-
-       /* don't increment last_ts ?? */
-       jb->info.last_voice_ts -= jb->info.last_voice_ms;
-       jb->info.current -= jb->info.last_voice_ms;
-       jb->info.last_adjustment = now;
-
-       if(frame)  {
-         *frameout = *frame;
-         jb->info.frames_out++;
-         decrement_losspct(jb);
-         jb->info.frames_dropped++;
-         jb_dbg("s");
-         return JB_DROP;
-       } else {
-         increment_losspct(jb);
-         jb_dbg("S");
-         return JB_NOFRAME;
-       }
-      }
-
-      /* lost frame */
-      if(!frame) {
-         /* this is a bit of a hack for now, but if we're close to
-          * target, and we find a missing frame, it makes sense to
-          * grow, because the frame might just be a bit late;
-          * otherwise, we presently get into a pattern where we return
-          * INTERP for the lost frame, then it shows up next, and we
-          * throw it away because it's late */
-         /* I've recently only been able to replicate this using
-          * iaxclient talking to app_echo on asterisk.  In this case,
-          * my outgoing packets go through asterisk's (old)
-          * jitterbuffer, and then might get an unusual increasing delay 
-          * there if it decides to grow?? */
-         /* Update: that might have been a different bug, that has been fixed..
-          * But, this still seemed like a good idea, except that it ended up making a single actual
-          * lost frame get interpolated two or more times, when there was "room" to grow, so it might
-          * be a bit of a bad idea overall */
-         /*if(diff > -1 * jb->info.last_voice_ms) { 
-             jb->info.current += jb->info.last_voice_ms;
-             jb->info.last_adjustment = now;
-             jb_warn("g");
-             return JB_INTERP;
-         } */
-         jb->info.frames_lost++;
-         increment_losspct(jb);
-         jb_dbg("L");
-         return JB_INTERP;
-      }
-
-      /* normal case; return the frame, increment stuff */
-      *frameout = *frame;
-      jb->info.frames_out++;
-      decrement_losspct(jb);
-      jb_dbg("v");
-      return JB_OK;
-  } else {     
-      /* TODO: after we get the non-silent case down, we'll make the
-       * silent case -- basically, we'll just grow and shrink faster
-       * here, plus handle last_voice_ts a bit differently */
+                       (jb->info.last_adjustment + 500 < now))) {
+
+                       /* don't increment last_ts ?? */
+                       jb->info.last_voice_ts -= jb->info.last_voice_ms;
+                       jb->info.current -= jb->info.last_voice_ms;
+                       jb->info.last_adjustment = now;
+
+                       if (frame) {
+                               *frameout = *frame;
+                               jb->info.frames_out++;
+                               decrement_losspct(jb);
+                               jb->info.frames_dropped++;
+                               jb_dbg("s");
+                               return JB_DROP;
+                       } else {
+                               increment_losspct(jb);
+                               jb_dbg("S");
+                               return JB_NOFRAME;
+                       }
+               }
+
+               /* lost frame */
+               if (!frame) {
+                       /* this is a bit of a hack for now, but if we're close to
+                        * target, and we find a missing frame, it makes sense to
+                        * grow, because the frame might just be a bit late;
+                        * otherwise, we presently get into a pattern where we return
+                        * INTERP for the lost frame, then it shows up next, and we
+                        * throw it away because it's late */
+                       /* I've recently only been able to replicate this using
+                        * iaxclient talking to app_echo on asterisk.  In this case,
+                        * my outgoing packets go through asterisk's (old)
+                        * jitterbuffer, and then might get an unusual increasing delay 
+                        * there if it decides to grow?? */
+                       /* Update: that might have been a different bug, that has been fixed..
+                        * But, this still seemed like a good idea, except that it ended up making a single actual
+                        * lost frame get interpolated two or more times, when there was "room" to grow, so it might
+                        * be a bit of a bad idea overall */
+                       /*if (diff > -1 * jb->info.last_voice_ms) { 
+                               jb->info.current += jb->info.last_voice_ms;
+                               jb->info.last_adjustment = now;
+                               jb_warn("g");
+                               return JB_INTERP;
+                       } */
+                       jb->info.frames_lost++;
+                       increment_losspct(jb);
+                       jb_dbg("L");
+                       return JB_INTERP;
+               }
+
+               /* normal case; return the frame, increment stuff */
+               *frameout = *frame;
+               jb->info.frames_out++;
+               decrement_losspct(jb);
+               jb_dbg("v");
+               return JB_OK;
+       } else {     
+               /* TODO: after we get the non-silent case down, we'll make the
+                * silent case -- basically, we'll just grow and shrink faster
+                * here, plus handle last_voice_ts a bit differently */
       
-      /* to disable silent special case altogether, just uncomment this: */
-       /* jb->info.silence = 0; */
-
-       frame = queue_get(jb, now - jb->info.current);
-       if(!frame) {
-         return JB_NOFRAME;
-       }
-       if(frame && frame->type == JB_TYPE_VOICE) {
-         /* try setting current to target right away here */
-         jb->info.current = jb->info.target;
-         jb->info.silence = 0;
-         jb->info.last_voice_ts = frame->ts + jb->info.current + frame->ms;
-         jb->info.last_voice_ms = frame->ms;
-         *frameout = *frame;
-         jb_dbg("V");
-         return JB_OK;
-       }
-       /* normal case; in silent mode, got a non-voice frame */
-       *frameout = *frame;
-       return JB_OK;
-  }
+               /* to disable silent special case altogether, just uncomment this: */
+               /* jb->info.silence = 0; */
+
+               frame = queue_get(jb, now - jb->info.current);
+               if (!frame) {
+                       return JB_NOFRAME;
+               }
+               if (frame && frame->type == JB_TYPE_VOICE) {
+                       /* try setting current to target right away here */
+                       jb->info.current = jb->info.target;
+                       jb->info.silence = 0;
+                       jb->info.last_voice_ts = frame->ts + jb->info.current + frame->ms;
+                       jb->info.last_voice_ms = frame->ms;
+                       *frameout = *frame;
+                       jb_dbg("V");
+                       return JB_OK;
+               }
+               /* normal case; in silent mode, got a non-voice frame */
+               *frameout = *frame;
+               return JB_OK;
+       }
 }
 
 long jb_next(jitterbuf *jb) 
 {
-    if(jb->info.silence) {
-      long next = queue_next(jb);
-      if(next > 0) { 
-       history_get(jb);
-       return next + jb->info.target;
-      }
-      else return JB_LONGMAX;
-    } else {
-      return jb->info.last_voice_ts + jb->info.last_voice_ms;
-    }
+       if (jb->info.silence) {
+               long next = queue_next(jb);
+               if (next > 0) { 
+                       history_get(jb);
+                       return next + jb->info.target;
+               }
+               else 
+                       return JB_LONGMAX;
+       } else {
+               return jb->info.last_voice_ts + jb->info.last_voice_ms;
+       }
 }
 
 int jb_get(jitterbuf *jb, jb_frame *frameout, long now) 
 {
-    int ret = _jb_get(jb,frameout,now);
+       int ret = _jb_get(jb,frameout,now);
 #if 0
-    static int lastts=0;
-    int thists = ((ret == JB_OK) || (ret == JB_DROP)) ? frameout->ts : 0;
-    jb_warn("jb_get(%x,%x,%ld) = %d (%d)\n", jb, frameout, now, ret, thists);
-    if(thists && thists < lastts) jb_warn("XXXX timestamp roll-back!!!\n");
-    lastts = thists;
+       static int lastts=0;
+       int thists = ((ret == JB_OK) || (ret == JB_DROP)) ? frameout->ts : 0;
+       jb_warn("jb_get(%x,%x,%ld) = %d (%d)\n", jb, frameout, now, ret, thists);
+       if (thists && thists < lastts) jb_warn("XXXX timestamp roll-back!!!\n");
+       lastts = thists;
 #endif
-    if(ret == JB_INTERP) frameout->ms = jb->info.last_voice_ms;
-    return ret;
+       if(ret == JB_INTERP) 
+               frameout->ms = jb->info.last_voice_ms;
+       
+       return ret;
 }
 
 int jb_getall(jitterbuf *jb, jb_frame *frameout) 
 {
-    jb_frame *frame;
-    frame = queue_getall(jb);
+       jb_frame *frame;
+       frame = queue_getall(jb);
 
-    if(!frame) {
-      return JB_NOFRAME;
-    }
+       if (!frame) {
+               return JB_NOFRAME;
+       }
 
-    *frameout = *frame;
-    return JB_OK;
+       *frameout = *frame;
+       return JB_OK;
 }
 
 
 int jb_getinfo(jitterbuf *jb, jb_info *stats) 
 {
 
-    history_get(jb);
+       history_get(jb);
 
-    *stats = jb->info;
+       *stats = jb->info;
 
-  return JB_OK;
+       return JB_OK;
 }
 
 int jb_setinfo(jitterbuf *jb, jb_info *settings) 
 {
-  /* take selected settings from the struct */
+       /* take selected settings from the struct */
 
-  jb->info.max_jitterbuf = settings->max_jitterbuf;
+       jb->info.max_jitterbuf = settings->max_jitterbuf;
 
-  return JB_OK;
+       return JB_OK;
 }