--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/spandsp-0.0.6pre17/src/playout.c	Fri Jun 25 15:50:58 2010 +0200
@@ -0,0 +1,378 @@
+/*
+ * SpanDSP - a series of DSP components for telephony
+ *
+ * playout.c
+ *
+ * Written by Steve Underwood <steveu@coppice.org>
+ *
+ * Copyright (C) 2005 Steve Underwood
+ *
+ * All rights reserved.
+ *
+ * This was kicked off from jitter buffering code
+ *      Copyright (C) 2004, Horizon Wimba, Inc.
+ *      Author Steve Kann <stevek@stevek.com>
+ * However, there isn't a lot of the original left, now. The original
+ * was licenced under the LGPL, so any remaining fragments are
+ * compatible with the GPL licence used here.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id: playout.c,v 1.17 2009/02/10 13:06:46 steveu Exp $
+ */
+
+#if defined(HAVE_CONFIG_H)
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+#include "spandsp/telephony.h"
+#include "spandsp/playout.h"
+
+static playout_frame_t *queue_get(playout_state_t *s, timestamp_t sender_stamp)
+{
+    playout_frame_t *frame;
+
+    if ((frame = s->first_frame) == NULL)
+        return NULL;
+
+    if (sender_stamp >= frame->sender_stamp)
+    {
+        /* Remove this frame from the queue */
+        if (frame->later)
+        {
+            frame->later->earlier = NULL;
+            s->first_frame = frame->later;
+        }
+        else
+        {
+            /* The queue is now empty */
+            s->first_frame = NULL;
+            s->last_frame = NULL;
+        }
+        return frame;
+    } 
+
+    return NULL;
+}
+/*- End of function --------------------------------------------------------*/
+
+SPAN_DECLARE(timestamp_t) playout_next_due(playout_state_t *s)
+{
+    return s->last_speech_sender_stamp + s->last_speech_sender_len;
+}
+/*- End of function --------------------------------------------------------*/
+
+SPAN_DECLARE(timestamp_t) playout_current_length(playout_state_t *s)
+{
+    return s->target_buffer_length;
+}
+/*- End of function --------------------------------------------------------*/
+
+SPAN_DECLARE(playout_frame_t *) playout_get_unconditional(playout_state_t *s)
+{
+    playout_frame_t *frame;
+    
+    if ((frame = queue_get(s, 0x7FFFFFFF)))
+    {
+        /* Put it on the free list */
+        frame->later = s->free_frames;
+        s->free_frames = frame;
+
+        /* We return the frame pointer, even though it's on the free list.
+           The caller *must* copy the data before this frame has any chance
+           of being reused. */
+    }
+    return frame;
+}
+/*- End of function --------------------------------------------------------*/
+
+SPAN_DECLARE(int) playout_get(playout_state_t *s, playout_frame_t *frameout, timestamp_t now)
+{
+    playout_frame_t *frame;
+
+    /* Make the last_speech_sender_stamp the current expected one. */
+    s->last_speech_sender_stamp += s->last_speech_sender_len;
+    if ((frame = queue_get(s, s->last_speech_sender_stamp)) == NULL)
+    {
+        /* The required frame was not received (or at least not in time) */
+        s->frames_missing++;
+        return PLAYOUT_FILLIN;
+    }
+
+    if (s->dynamic  &&  frame->type == PLAYOUT_TYPE_SPEECH)
+    {
+        /* Assess whether the buffer length is appropriate */
+        if (!s->not_first)
+        {
+            /* Prime things the first time through */
+            s->not_first = TRUE;
+            s->latest_expected = frame->receiver_stamp + s->min_length;
+        }
+        /* Leaky integrate the rate of occurance of frames received just in time and late */
+        s->state_late += ((((frame->receiver_stamp > s->latest_expected)  ?  0x10000000  :  0) - s->state_late) >> 8);
+        s->state_just_in_time += ((((frame->receiver_stamp > s->latest_expected - frame->sender_len)  ?  0x10000000  :  0) - s->state_just_in_time) >> 8);
+        s->latest_expected += frame->sender_len;
+        
+        if (s->state_late > s->dropable_threshold)
+        {
+            if (s->since_last_step < 10)
+            {
+                if (s->target_buffer_length < s->max_length - 2)
+                {
+                    /* The late bin is too big - increase buffering */
+                    s->target_buffer_length += 3*frame->sender_len;
+                    s->latest_expected += 3*frame->sender_len;
+                    s->state_just_in_time = s->dropable_threshold;
+                    s->state_late = 0;
+                    s->since_last_step = 0;
+
+                    s->last_speech_sender_stamp -= 3*s->last_speech_sender_len;
+                }
+            }
+            else
+            {
+                if (s->target_buffer_length < s->max_length)
+                {
+                    /* The late bin is too big - increase buffering */
+                    s->target_buffer_length += frame->sender_len;
+                    s->latest_expected += frame->sender_len;
+                    s->state_just_in_time = s->dropable_threshold;
+                    s->state_late = 0;
+                    s->since_last_step = 0;
+
+                    s->last_speech_sender_stamp -= s->last_speech_sender_len;
+                }
+            }
+        }
+        else if (s->since_last_step > 500  &&  s->state_just_in_time < s->dropable_threshold)
+        {
+            if (s->target_buffer_length > s->min_length)
+            {
+                /* The just-in-time bin is pretty small - decrease buffering */
+                s->target_buffer_length -= frame->sender_len;
+                s->latest_expected -= frame->sender_len;
+                s->state_just_in_time = s->dropable_threshold;
+                s->state_late = 0;
+                s->since_last_step = 0;
+    
+                s->last_speech_sender_stamp += s->last_speech_sender_len;
+            }
+        }
+        s->since_last_step++;
+    }
+
+    /* If its not a speech frame, just return it. */
+    if (frame->type != PLAYOUT_TYPE_SPEECH)
+    {
+        /* Rewind last_speech_sender_stamp, since this isn't speech */
+        s->last_speech_sender_stamp -= s->last_speech_sender_len;
+            
+        *frameout = *frame;
+        /* Put it on the free list */
+        frame->later = s->free_frames;
+        s->free_frames = frame;
+        
+        s->frames_out++;
+        return PLAYOUT_OK;
+    }
+    if (frame->sender_stamp < s->last_speech_sender_stamp)
+    {
+        /* This speech frame is late */
+        *frameout = *frame;
+        /* Put it on the free list */
+        frame->later = s->free_frames;
+        s->free_frames = frame;
+
+        /* Rewind last_speech_sender_stamp, since we're just dumping */
+        s->last_speech_sender_stamp -= s->last_speech_sender_len;
+        s->frames_out++;
+        s->frames_late++;
+        s->frames_missing--;
+        return PLAYOUT_DROP;
+    }
+    /* Keep track of frame sizes, to allow for variable sized frames */
+    if (frame->sender_len > 0)
+        s->last_speech_sender_len = frame->sender_len;
+
+    /* Normal case. Return the frame, and increment stuff */
+    *frameout = *frame;
+    /* Put it on the free list */
+    frame->later = s->free_frames;
+    s->free_frames = frame;
+
+    s->frames_out++;
+    return PLAYOUT_OK;
+}
+/*- End of function --------------------------------------------------------*/
+
+SPAN_DECLARE(int) playout_put(playout_state_t *s, void *data, int type, timestamp_t sender_len, timestamp_t sender_stamp, timestamp_t receiver_stamp)
+{
+    playout_frame_t *frame;
+    playout_frame_t *p;
+
+    /* When a frame arrives we just queue it in order. We leave all the tricky stuff until frames
+       are read from the queue. */
+    s->frames_in++;
+
+    /* Acquire a frame */
+    if ((frame = s->free_frames))
+    {
+        s->free_frames = frame->later;
+    }
+    else
+    {
+        if ((frame = (playout_frame_t *) malloc(sizeof(*frame))) == NULL)
+            return PLAYOUT_ERROR;
+    }
+
+    /* Fill out the frame */
+    frame->data = data;
+    frame->type = type;
+    frame->sender_stamp = sender_stamp;
+    frame->sender_len = sender_len;
+    frame->receiver_stamp = receiver_stamp;
+
+    /* Frames are kept in a list, sorted by the timestamp assigned by the sender. */
+    if (s->last_frame == NULL)
+    {
+        /* The queue is empty. */
+        frame->later = NULL;
+        frame->earlier = NULL;
+        s->first_frame = frame;
+        s->last_frame = frame;
+    }
+    else if (sender_stamp >= s->last_frame->sender_stamp)
+    {
+        /* Frame goes at the end of the queue. */
+        frame->later = NULL;
+        frame->earlier = s->last_frame;
+        s->last_frame->later = frame;
+        s->last_frame = frame;
+    }
+    else
+    {
+        /* Frame is out of sequence. */
+        s->frames_oos++;
+
+        /* Find where it should go in the queue */
+        p = s->last_frame;
+        while (sender_stamp < p->sender_stamp  &&  p->earlier) 
+            p = p->earlier;
+
+        if (p->earlier)
+        {
+            /* It needs to go somewhere in the queue */
+            frame->later = p->later;
+            frame->earlier = p;
+            p->later->earlier = frame;
+            p->later = frame;
+        }
+        else
+        {
+            /* It needs to go at the very beginning of the queue */
+            frame->later = p;
+            frame->earlier = NULL;
+            p->earlier = frame;
+            s->first_frame = frame;
+        }
+    }
+
+    if (s->start  &&  type == PLAYOUT_TYPE_SPEECH)
+    {
+        s->last_speech_sender_stamp = sender_stamp - sender_len - s->min_length;
+        s->last_speech_sender_len = sender_len;
+        s->start = FALSE;
+    }
+
+    return PLAYOUT_OK;
+}
+/*- End of function --------------------------------------------------------*/
+
+SPAN_DECLARE(void) playout_restart(playout_state_t *s, int min_length, int max_length)
+{
+    playout_frame_t *frame;
+    playout_frame_t *next;
+
+    /* Free all the frames on the free list */
+    for (frame = s->free_frames;  frame;  frame = next)
+    {
+        next = frame->later;
+        free(frame);
+    }
+
+    memset(s, 0, sizeof(*s));
+    s->dynamic = (min_length < max_length);
+    s->min_length = min_length;
+    s->max_length = (max_length > min_length)  ?  max_length  :  min_length;
+    s->dropable_threshold = 1*0x10000000/100;
+    s->start = TRUE;
+    s->since_last_step = 0x7FFFFFFF;
+    /* Start with the minimum buffer length allowed, and work from there */
+    s->actual_buffer_length = 
+    s->target_buffer_length = (s->max_length - s->min_length)/2;
+}
+/*- End of function --------------------------------------------------------*/
+
+SPAN_DECLARE(playout_state_t *) playout_init(int min_length, int max_length)
+{
+    playout_state_t *s;
+
+    if ((s = (playout_state_t *) malloc(sizeof(playout_state_t))) == NULL)
+        return NULL;
+    memset(s, 0, sizeof(*s));
+    playout_restart(s, min_length, max_length);
+    return s;
+}
+/*- End of function --------------------------------------------------------*/
+
+SPAN_DECLARE(int) playout_release(playout_state_t *s)
+{
+    playout_frame_t *frame;
+    playout_frame_t *next;
+    
+    /* Free all the frames in the queue. In most cases these should have been
+       removed already, so their associated data could be freed. */
+    for (frame = s->first_frame;  frame;  frame = next)
+    {
+        next = frame->later;
+        free(frame);
+    }
+    /* Free all the frames on the free list */
+    for (frame = s->free_frames;  frame;  frame = next)
+    {
+        next = frame->later;
+        free(frame);
+    }
+    return 0;
+}
+/*- End of function --------------------------------------------------------*/
+
+SPAN_DECLARE(int) playout_free(playout_state_t *s)
+{
+    if (s)
+    {
+        playout_release(s);
+        /* Finally, free ourselves! */ 
+        free(s);
+    }
+    return 0;
+}
+/*- End of function --------------------------------------------------------*/
+/*- End of file ------------------------------------------------------------*/