audio_encode.c

/*
 * iaxclient: a cross-platform IAX softphone library
 *
 * Copyrights:
 * Copyright (C) 2003-2006, Horizon Wimba, Inc.
 * Copyright (C) 2007, Wimba, Inc.
 *
 * Contributors:
 * Steve Kann <stevek@stevek.com>
 * Michael Van Donselaar <mvand@vandonselaar.org>
 * Shawn Lawrence <shawn.lawrence@terracecomm.com>
 *
 * This program is free software, distributed under the terms of
 * the GNU Lesser (Library) General Public License.
 */

#include "iaxclient_lib.h"
#include "iax-client.h"
#ifdef CODEC_GSM
#include "codec_gsm.h"
#endif
#include "codec_ulaw.h"
#include "codec_alaw.h"
#include "codec_speex.h"
#include <speex/speex_preprocess.h>

#ifdef CODEC_ILBC
        #include "codec_ilbc.h"
#endif

float iaxci_silence_threshold = -99.0f;

static float input_level = 0.0f;
static float output_level = 0.0f;

static SpeexPreprocessState *st = NULL;
static int speex_state_size = 0;
static int speex_state_rate = 0;
int iaxci_filters = IAXC_FILTER_AGC|IAXC_FILTER_DENOISE|IAXC_FILTER_AAGC|IAXC_FILTER_CN;

/* use to measure time since last audio was processed */
static struct timeval timeLastInput ;
static struct timeval timeLastOutput ;

static struct iaxc_speex_settings speex_settings =
{
        1,    /* decode_enhance */
        -1,   /* float quality */
        -1,   /* bitrate */
        0,    /* vbr */
        0,    /* abr */
        3     /* complexity */
};


static float vol_to_db(float vol)
{
        /* avoid calling log10() on zero which yields inf or
         * negative numbers which yield nan */
        if ( vol <= 0.0 )
                return -99.9;
        else
                return log10f(vol) * 20;
}

static int do_level_callback()
{
        static struct timeval last = {0,0};
        struct timeval now;
        float input_db;
        float output_db;

        gettimeofday(&now, 0);

        if ( last.tv_sec != 0 && iaxci_usecdiff(&now, &last) < 100000 )
                return 0;

        last = now;

        /* if input has not been processed in the last second, set to silent */
        input_db = iaxci_usecdiff(&now, &timeLastInput) < 1000000 ?
                        vol_to_db(input_level) : -99.9f;

        /* if output has not been processed in the last second, set to silent */
        output_db = iaxci_usecdiff(&now, &timeLastOutput) < 1000000 ?
                vol_to_db(output_level) : -99.9f;

        iaxci_do_levels_callback(input_db, output_db);

        return 0;
}

static void set_speex_filters()
{
        int i;
        float f;

        if(!st)
                return;

        i = 1; /* always make VAD decision */
        speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_VAD, &i);
        i = (iaxci_filters & IAXC_FILTER_AGC) ? 1 : 0;
        speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_AGC, &i);
        i = (iaxci_filters & IAXC_FILTER_DENOISE) ? 1 : 0;
        speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_DENOISE, &i);

        /* make vad more sensitive */
        f = 0.30f;
        speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_PROB_START, &f);
        f = 0.07f;
        speex_preprocess_ctl(st, SPEEX_PREPROCESS_SET_PROB_CONTINUE, &f);
}

static void calculate_level(short *audio, int len, float *level)
{
        int big_sample = 0;
        int i;

        for ( i = 0; i < len; i++ )
        {
                const int sample = abs(audio[i]);
                big_sample = sample > big_sample ?
                        sample : big_sample;
        }

        *level += ((float)big_sample / 32767.0f - *level) / 5.0f;
}

static int input_postprocess(void *audio, int len, int rate)
{
        static float lowest_volume = 1.0f;
        float volume;
        int silent = 0;

        if ( !st || speex_state_size != len || speex_state_rate != rate )
        {
                if (st)
                        speex_preprocess_state_destroy(st);
                st = speex_preprocess_state_init(len,rate);
                speex_state_size = len;
                speex_state_rate = rate;
                set_speex_filters();
        }

        calculate_level((short *)audio, len, &input_level);

        /* only preprocess if we're interested in VAD, AGC, or DENOISE */
        if ( (iaxci_filters & (IAXC_FILTER_DENOISE | IAXC_FILTER_AGC)) ||
                        iaxci_silence_threshold > 0.0f )
                silent = !speex_preprocess(st, (spx_int16_t *)audio, NULL);

        /* Analog AGC: Bring speex AGC gain out to mixer, with lots of hysteresis */
        /* use a higher continuation threshold for AAGC than for VAD itself */
        if ( !silent &&
                        iaxci_silence_threshold != 0.0f &&
                        (iaxci_filters & IAXC_FILTER_AGC) &&
                        (iaxci_filters & IAXC_FILTER_AAGC) &&
                        st->speech_prob > 0.20f )
        {
                static int i = 0;

                i++;

                if ( (i & 0x3f) == 0 )
                {
                        const float loudness = st->loudness2;

                        if ( loudness > 8000.0f || loudness < 4000.0f )
                        {
                                const float level = iaxc_input_level_get();

                                if ( loudness > 16000.0f && level > 0.5f )
                                {
                                        /* lower quickly if we're really too hot */
                                        iaxc_input_level_set(level - 0.2f);
                                }
                                else if ( loudness > 8000.0f && level >= 0.15f )
                                {
                                        /* lower less quickly if we're a bit too hot */
                                        iaxc_input_level_set(level - 0.1f);
                                }
                                else if ( loudness < 4000.0f && level <= 0.9f )
                                {
                                        /* raise slowly if we're cold */
                                        iaxc_input_level_set(level + 0.1f);
                                }
                        }
                }
        }

        /* This is ugly. Basically just don't get volume level if speex thought
         * we were silent. Just set it to 0 in that case */
        if ( iaxci_silence_threshold > 0.0f && silent )
                input_level = 0.0f;

        do_level_callback();

        volume = vol_to_db(input_level);

        if ( volume < lowest_volume )
                lowest_volume = volume;

        if ( iaxci_silence_threshold > 0.0f )
                return silent;
        else
                return volume < iaxci_silence_threshold;
}

static int output_postprocess(void *audio, int len)
{
        calculate_level((short *)audio, len, &output_level);

        do_level_callback();

        return 0;
}

static struct iaxc_audio_codec *create_codec(int format)
{
        switch (format & IAXC_AUDIO_FORMAT_MASK)
        {
#ifdef CODEC_GSM
        case IAXC_FORMAT_GSM:
                return codec_audio_gsm_new();
#endif
        case IAXC_FORMAT_ULAW:
                return codec_audio_ulaw_new();
        case IAXC_FORMAT_ALAW:
                return codec_audio_alaw_new();
        case IAXC_FORMAT_SPEEX:
                return codec_audio_speex_new(&speex_settings);
#ifdef CODEC_ILBC
        case IAXC_FORMAT_ILBC:
                return codec_audio_ilbc_new();
#endif
        default:
                /* ERROR: codec not supported */
                fprintf(stderr, "ERROR: Codec not supported: %d\n", format);
                return NULL;
        }
}

EXPORT void iaxc_set_speex_settings(int decode_enhance, float quality,
                int bitrate, int vbr, int abr, int complexity)
{
        speex_settings.decode_enhance = decode_enhance;
        speex_settings.quality = quality;
        speex_settings.bitrate = bitrate;
        speex_settings.vbr = vbr;
        speex_settings.abr = abr;
        speex_settings.complexity = complexity;
}

int audio_send_encoded_audio(struct iaxc_call *call, int callNo, void *data,
                int format, int samples)
{
        unsigned char outbuf[1024];
        int outsize = 1024;
        int silent;
        int insize = samples;

        /* update last input timestamp */
        gettimeofday( &timeLastInput, NULL ) ;

        silent = input_postprocess(data, insize, 8000);

        if(silent)
        {
                if(!call->tx_silent)
                {  /* send a Comfort Noise Frame */
                        call->tx_silent = 1;
                        if ( iaxci_filters & IAXC_FILTER_CN )
                                iax_send_cng(call->session, 10, NULL, 0);
                }
                return 0;  /* poof! no encoding! */
        }

        /* we're going to send voice now */
        call->tx_silent = 0;

        /* destroy encoder if it is incorrect type */
        if(call->encoder && call->encoder->format != format)
        {
                call->encoder->destroy(call->encoder);
                call->encoder = NULL;
        }

        /* just break early if there's no format defined: this happens for the
         * first couple of frames of new calls */
        if(format == 0) return 0;

        /* create encoder if necessary */
        if(!call->encoder)
        {
                call->encoder = create_codec(format);
        }

        if(!call->encoder)
        {
                /* ERROR: no codec */
                fprintf(stderr, "ERROR: Codec could not be created: %d\n", format);
                return 0;
        }

        if(call->encoder->encode(call->encoder, &insize, (short *)data,
                                &outsize, outbuf))
        {
                /* ERROR: codec error */
                fprintf(stderr, "ERROR: encode error: %d\n", format);
                return 0;
        }

        if(samples-insize == 0)
        {
                fprintf(stderr, "ERROR encoding (no samples output (samples=%d)\n", samples);
                return -1;
        }

        // Send the encoded audio data back to the app if required
        // TODO: fix the stupid way in which the encoded audio size is returned
        if ( iaxc_get_audio_prefs() & IAXC_AUDIO_PREF_RECV_LOCAL_ENCODED )
                iaxci_do_audio_callback(callNo, 0, IAXC_SOURCE_LOCAL, 1,
                                call->encoder->format & IAXC_AUDIO_FORMAT_MASK,
                                sizeof(outbuf) - outsize, outbuf);

        if(iax_send_voice(call->session,format, outbuf,
                                sizeof(outbuf) - outsize, samples-insize) == -1)
        {
                puts("Failed to send voice!");
                return -1;
        }

        return 0;
}

/* decode encoded audio; return the number of bytes decoded
 * negative indicates error */
int audio_decode_audio(struct iaxc_call * call, void * out, void * data, int len,
                int format, int * samples)
{
        int insize = len;
        int outsize = *samples;

        gettimeofday( &timeLastOutput, NULL ) ;

        if ( format == 0 )
        {
                fprintf(stderr, "audio_decode_audio: Format is zero (should't happen)!\n");
                return -1;
        }

        /* destroy decoder if it is incorrect type */
        if ( call->decoder && call->decoder->format != format )
        {
                call->decoder->destroy(call->decoder);
                call->decoder = NULL;
        }

        /* create decoder if necessary */
        if ( !call->decoder )
        {
                call->decoder = create_codec(format);
        }

        if ( !call->decoder )
        {
                fprintf(stderr, "ERROR: Codec could not be created: %d\n",
                                format);
                return -1;
        }

        if ( call->decoder->decode(call->decoder,
                                &insize, (unsigned char *)data,
                                &outsize, (short *)out) )
        {
                fprintf(stderr, "ERROR: decode error: %d\n", format);
                return -1;
        }

        output_postprocess(out, *samples - outsize);

        *samples = outsize;
        return len - insize;
}

EXPORT int iaxc_get_filters(void)
{
        return iaxci_filters;
}

EXPORT void iaxc_set_filters(int filters)
{
        iaxci_filters = filters;
        set_speex_filters();
}

EXPORT void iaxc_set_silence_threshold(float thr)
{
        iaxci_silence_threshold = thr;
        set_speex_filters();
}

---