freeswitch/libs/spandsp/tests/sig_tone_tests.c

/*
 * SpanDSP - a series of DSP components for telephony
 *
 * sig_tone_tests.c
 *
 * Written by Steve Underwood <steveu@coppice.org>
 *
 * Copyright (C) 2004 Steve Underwood
 *
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2, 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/*! \file */

/*! \page sig_tone_tests_page The 2280/2400/2600Hz signalling tone Rx/Tx tests
\section sig_tone_tests_sec_1 What does it do?
???.

\section sig_tone_tests_sec_2 How does it work?
???.
*/

#if defined(HAVE_CONFIG_H)
#include "config.h"
#endif

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <memory.h>
#include <sndfile.h>

#include "spandsp.h"
#include "spandsp-sim.h"

#define OUT_FILE_NAME               "sig_tone.wav"

#define SAMPLES_PER_CHUNK           160

#define MITEL_DIR                   "../test-data/mitel/"
#define BELLCORE_DIR                "../test-data/bellcore/"

const char *bellcore_files[] =
{
    MITEL_DIR    "mitel-cm7291-talkoff.wav",
    BELLCORE_DIR "tr-tsy-00763-1.wav",
    BELLCORE_DIR "tr-tsy-00763-2.wav",
    BELLCORE_DIR "tr-tsy-00763-3.wav",
    BELLCORE_DIR "tr-tsy-00763-4.wav",
    BELLCORE_DIR "tr-tsy-00763-5.wav",
    BELLCORE_DIR "tr-tsy-00763-6.wav",
    ""
};

typedef struct
{
    double freq;
    double min_level;
    double max_level;
} template_t;

static int number_of_tones = 1;

static int sampleno = 0;
static int tone_1_present = 0;
static int tone_2_present = 0;
static int tx_section = 0;
static int dial_pulses = 0;

static int rx_handler_callbacks = 0;
static int tx_handler_callbacks = 0;

static bool use_gui = false;

static void plot_frequency_response(void)
{
    FILE *gnucmd;

    if ((gnucmd = popen("gnuplot", "w")) == NULL)
    {
        exit(2);
    }

    fprintf(gnucmd, "set autoscale\n");
    fprintf(gnucmd, "unset log\n");
    fprintf(gnucmd, "unset label\n");
    fprintf(gnucmd, "set xtic auto\n");
    fprintf(gnucmd, "set ytic auto\n");
    fprintf(gnucmd, "set title 'Notch filter frequency response'\n");
    fprintf(gnucmd, "set xlabel 'Frequency (Hz)'\n");
    fprintf(gnucmd, "set ylabel 'Gain (dB)'\n");
    fprintf(gnucmd, "plot 'sig_tone_notch' using 1:3 title 'min' with lines,"
                    "'sig_tone_notch' using 1:6 title 'actual' with lines,"
                    "'sig_tone_notch' using 1:9 title 'max' with lines\n");
    fflush(gnucmd);
    getchar();
    if (pclose(gnucmd) == -1)
    {
        exit(2);
    }
}
/*- End of function --------------------------------------------------------*/

static void tx_handler(void *user_data, int what, int level, int duration)
{
    sig_tone_tx_state_t *s;
    int tone;
    int time;
    static const int pattern_1_tone[][2] =
    {
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
        {600, SIG_TONE_1_PRESENT},
        {0, 0}
    };
    static const int pattern_2_tones[][2] =
    {
#if 0
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
        {33, SIG_TONE_1_PRESENT},
        {67, 0},
#endif
        {100, SIG_TONE_1_PRESENT},
        {100, SIG_TONE_1_PRESENT | SIG_TONE_2_PRESENT},
        {100, SIG_TONE_2_PRESENT},
#if 0
        {100, 0},
        {100, SIG_TONE_2_PRESENT},
        {100, SIG_TONE_1_PRESENT | SIG_TONE_2_PRESENT},
        {100, SIG_TONE_1_PRESENT},
#endif
        {0, 0}
    };

    s = (sig_tone_tx_state_t *) user_data;
    tx_handler_callbacks++;
    //printf("What - %d, duration - %d\n", what, duration);
    if ((what & SIG_TONE_TX_UPDATE_REQUEST))
    {
        /* The sig tone transmit side wants to know what to do next */
        printf("Tx: update request\n");

        if (number_of_tones == 1)
        {
            time = pattern_1_tone[tx_section][0];
            tone = pattern_1_tone[tx_section][1];
        }
        else
        {
            time = pattern_2_tones[tx_section][0];
            tone = pattern_2_tones[tx_section][1];
        }
        if (time)
        {
            printf("Tx: [%04x] %s %s for %d samples (%dms)\n",
                   tone,
                   (tone & SIG_TONE_1_PRESENT)  ?  "on "  :  "off",
                   (tone & SIG_TONE_2_PRESENT)  ?  "on "  :  "off",
                   ms_to_samples(time),
                   time);
            sig_tone_tx_set_mode(s, tone, ms_to_samples(time));
            tx_section++;
        }
        else
        {
            printf("End of sequence\n");
        }
    }
    /*endif*/
}
/*- End of function --------------------------------------------------------*/

static void rx_handler(void *user_data, int what, int level, int duration)
{
    float ms;
    int x;

    rx_handler_callbacks++;
    ms = 1000.0f*(float) duration/(float) SAMPLE_RATE;
    printf("Rx: [%04x]", what);
    x = what & SIG_TONE_1_PRESENT;
    if ((what & SIG_TONE_1_CHANGE))
    {
        printf(" %s", (x)  ?  "on "  : "off");
        if (x == tone_1_present)
            exit(2);
        tone_1_present = x;
    }
    else
    {
        printf(" ---");
        if (x != tone_1_present)
            exit(2);
    }
    /*endif*/
    x = what & SIG_TONE_2_PRESENT;
    if ((what & SIG_TONE_2_CHANGE))
    {
        printf(" %s", (x)  ?  "on "  : "off");
        if (x == tone_2_present)
            exit(2);
        tone_2_present = x;
    }
    else
    {
        if (x != tone_2_present)
            exit(2);
        printf(" ---");
    }
    /*endif*/
    printf(" after %d samples (%.3fms)\n", duration, ms);
}
/*- End of function --------------------------------------------------------*/

static void map_frequency_response(sig_tone_rx_state_t *s, template_t template[])
{
    int16_t buf[SAMPLES_PER_CHUNK];
    int i;
    int len;
    double sumin;
    double sumout;
    swept_tone_state_t *swept;
    double freq;
    double gain;
    int template_entry;
    FILE *file;

    /* Things like noise don't highlight the frequency response of the high Q notch
       very well. We use a slowly swept frequency to check it. */
    printf("Frequency response test\n");
    sig_tone_rx_set_mode(s, SIG_TONE_RX_PASSTHROUGH | SIG_TONE_RX_FILTER_TONE, 0);
    swept = swept_tone_init(NULL, 200.0f, 3900.0f, -10.0f, 120*SAMPLE_RATE, 0);
    template_entry = 0;
    file = fopen("sig_tone_notch", "wb");
    for (;;)
    {
        if ((len = swept_tone(swept, buf, SAMPLES_PER_CHUNK)) <= 0)
            break;
        /*endif*/
        sumin = 0.0;
        for (i = 0;  i < len;  i++)
            sumin += (double) buf[i]*(double) buf[i];
        /*endfor*/
        sig_tone_rx(s, buf, len);
        sumout = 0.0;
        for (i = 0;  i < len;  i++)
            sumout += (double) buf[i]*(double) buf[i];
        /*endfor*/
        freq = swept_tone_current_frequency(swept);
        gain = (sumin != 0.0)  ?  10.0*log10(sumout/sumin + 1.0e-10)  :  0.0;
        printf("%7.1f Hz %.3f dBm0 < %.3f dBm0 < %.3f dBm0\n",
               freq,
               template[template_entry].min_level,
               gain,
               template[template_entry].max_level);
        if (file)
        {
            fprintf(file,
                    "%7.1f Hz %.3f dBm0 < %.3f dBm0 < %.3f dBm0\n",
                    freq,
                    template[template_entry].min_level,
                    gain,
                    template[template_entry].max_level);
        }
        /*endif*/
        if (gain < template[template_entry].min_level  ||  gain > template[template_entry].max_level)
        {
            printf("Expected: %.3f dBm0 to  %.3f dBm0\n",
                   template[template_entry].min_level,
                   template[template_entry].max_level);
            printf("    Failed\n");
            exit(2);
        }
        /*endif*/
        if (freq > template[template_entry].freq)
            template_entry++;
    }
    /*endfor*/
    swept_tone_free(swept);
    if (file)
    {
        fclose(file);
        if (use_gui)
            plot_frequency_response();
        /*endif*/
    }
    /*endif*/
    printf("    Passed\n");
}
/*- End of function --------------------------------------------------------*/

static void speech_immunity_tests(sig_tone_rx_state_t *s)
{
    int j;
    int total_hits;
    SNDFILE *inhandle;
    int16_t amp[SAMPLE_RATE];
    int frames;

    printf("Speech immunity test\n");
    total_hits = 0;
    for (j = 0;  bellcore_files[j][0];  j++)
    {
        /* Push some silence through, so we should be in the tone off state */
        vec_zeroi16(amp, SAMPLE_RATE);
        sig_tone_rx(s, amp, SAMPLE_RATE);
        rx_handler_callbacks = 0;
        if ((inhandle = sf_open_telephony_read(bellcore_files[j], 1)) == NULL)
        {
            printf("    Cannot open speech file '%s'\n", bellcore_files[j]);
            exit(2);
        }
        /*endif*/
        while ((frames = sf_readf_short(inhandle, amp, SAMPLE_RATE)))
        {
            sig_tone_rx(s, amp, frames);
        }
        /*endwhile*/
        if (sf_close_telephony(inhandle))
        {
            printf("    Cannot close speech file '%s'\n", bellcore_files[j]);
            exit(2);
        }
        /*endif*/
        printf("    File %d gave %d false hits.\n", j + 1, rx_handler_callbacks);
        total_hits += rx_handler_callbacks;
    }
    /*endfor*/
    printf("    %d hits in total\n", total_hits);
    if (total_hits > 0)
    {
        printf("    Failed\n");
        exit(2);
    }
    /*endif*/
    printf("    Passed\n");
}
/*- End of function --------------------------------------------------------*/

static void level_and_ratio_tests(sig_tone_rx_state_t *s, double pitch[2])
{
    awgn_state_t noise_source;
    int32_t phase_rate[2];
    uint32_t phase[2];
    int16_t gain;
    int16_t amp[SAMPLE_RATE];
    int i;
    int j;
    int k;
    int l;
    float noise_level;
    float tone_level;
    power_meter_t noise_meter;
    power_meter_t tone_meter;
    int16_t noise;
    int16_t tone;

    printf("Acceptable level and ratio test - %.2f Hz + %.2f Hz\n", pitch[0], pitch[1]);
    for (l = 0;  l < 2;  l++)
    {
        phase[l] = 0;
        phase_rate[l] = (pitch[l] != 0.0)  ?  dds_phase_rate(pitch[l])  :  0;
    }
    for (k = -25;  k > -60;  k--)
    {
        noise_level = k;
        awgn_init_dbm0(&noise_source, 1234567, noise_level);
        tone_level = noise_level;
        /* Push some silence through, so we should be in the tone off state */
        vec_zeroi16(amp, SAMPLE_RATE);
        sig_tone_rx(s, amp, SAMPLE_RATE);
        power_meter_init(&noise_meter, 6);
        power_meter_init(&tone_meter, 6);
        for (j = 0;  j < 20;  j++)
        {
            rx_handler_callbacks = 0;
            gain = dds_scaling_dbm0(tone_level);
            for (i = 0;  i < SAMPLES_PER_CHUNK;  i++)
            {
                noise = awgn(&noise_source);
                tone = dds_mod(&phase[0], phase_rate[0], gain, 0);
                if (phase_rate[1])
                    tone += dds_mod(&phase[1], phase_rate[1], gain, 0);
                power_meter_update(&noise_meter, noise);
                power_meter_update(&tone_meter, tone);
                amp[i] = noise + tone;
            }
            /*endfor*/
            sig_tone_rx(s, amp, SAMPLES_PER_CHUNK);
            if (rx_handler_callbacks)
            {
                printf("Hit at   tone = %.2fdBm0, noise = %.2fdBm0\n", tone_level, noise_level);
                printf("Measured tone = %.2fdBm0, noise = %.2fdBm0\n", power_meter_current_dbm0(&tone_meter), power_meter_current_dbm0(&noise_meter));
                if (rx_handler_callbacks != 1)
                    printf("Callbacks = %d\n", rx_handler_callbacks);
            }
            /*endif*/
            tone_level += 1.0f;
        }
        /*endfor*/
    }
    /*endfor*/
    printf("    Passed\n");
}
/*- End of function --------------------------------------------------------*/

static void sequence_tests(sig_tone_tx_state_t *tx_state, sig_tone_rx_state_t *rx_state, codec_munge_state_t *munge)
{
    int i;
    awgn_state_t noise_source;
    SNDFILE *outhandle;
    int16_t amp[SAMPLES_PER_CHUNK];
    int16_t out_amp[2*SAMPLES_PER_CHUNK];
    int outframes;
    int rx_samples;
    int tx_samples;

    printf("Signalling sequence test\n");
    tx_section = 0;
    if ((outhandle = sf_open_telephony_write(OUT_FILE_NAME, 2)) == NULL)
    {
        fprintf(stderr, "    Cannot create audio file '%s'\n", OUT_FILE_NAME);
        exit(2);
    }
    /*endif*/

    awgn_init_dbm0(&noise_source, 1234567, -20.0f);
    sig_tone_tx_set_mode(tx_state, SIG_TONE_1_PRESENT | SIG_TONE_2_PRESENT | SIG_TONE_TX_PASSTHROUGH, 0);
    sig_tone_rx_set_mode(rx_state, SIG_TONE_RX_PASSTHROUGH, 0);
    for (sampleno = 0;  sampleno < 4000;  sampleno += SAMPLES_PER_CHUNK)
    {
        if (sampleno == 800)
        {
            /* 100ms seize */
            printf("Tx: [0000] off off for %d samples (%dms)\n", ms_to_samples(100), 100);
            dial_pulses = 0;
            sig_tone_tx_set_mode(tx_state, 0, ms_to_samples(100));
        }
        /*endif*/
        for (i = 0;  i < SAMPLES_PER_CHUNK;  i++)
            amp[i] = awgn(&noise_source);
        /*endfor*/
        tx_samples = sig_tone_tx(tx_state, amp, SAMPLES_PER_CHUNK);
        for (i = 0;  i < tx_samples;  i++)
            out_amp[2*i] = amp[i];
        /*endfor*/
        codec_munge(munge, amp, tx_samples);
        rx_samples = sig_tone_rx(rx_state, amp, tx_samples);
        for (i = 0;  i < rx_samples;  i++)
            out_amp[2*i + 1] = amp[i];
        /*endfor*/
        outframes = sf_writef_short(outhandle, out_amp, rx_samples);
        if (outframes != rx_samples)
        {
            fprintf(stderr, "    Error writing audio file\n");
            exit(2);
        }
        /*endif*/
    }
    /*endfor*/
    if (sf_close_telephony(outhandle))
    {
        fprintf(stderr, "    Cannot close audio file '%s'\n", OUT_FILE_NAME);
        exit(2);
    }
    /*endif*/
}
/*- End of function --------------------------------------------------------*/

int main(int argc, char *argv[])
{
    int type;
    sig_tone_tx_state_t tx_state;
    sig_tone_rx_state_t rx_state;
    codec_munge_state_t *munge;
    double fc[2];
    int i;
    template_t template[10];
    int opt;

    use_gui = false;
    while ((opt = getopt(argc, argv, "g")) != -1)
    {
        switch (opt)
        {
        case 'g':
            use_gui = true;
            break;
        default:
            //usage();
            exit(2);
            break;
        }
    }

    for (type = 1;  type <= 3;  type++)
    {
        sampleno = 0;
        tone_1_present = 0;
        tone_2_present = 0;
        munge = NULL;
        for (i = 0;  i < 10;  i++)
        {
            template[i].freq = 0.0;
            template[i].min_level = 0.0;
            template[i].max_level = 0.0;
        }
        fc[0] =
        fc[1] = 0.0;
        switch (type)
        {
        case 1:
            printf("2280Hz tests.\n");
            munge = codec_munge_init(MUNGE_CODEC_ALAW, 0);
            sig_tone_tx_init(&tx_state, SIG_TONE_2280HZ, tx_handler, &tx_state);
            sig_tone_rx_init(&rx_state, SIG_TONE_2280HZ, rx_handler, &rx_state);
            number_of_tones = 1;
            fc[0] = 2280.0;

            /* From BTNR 181 2.3.3.1 */
            template[0].freq = 1150.0;
            template[0].min_level = -0.2;
            template[0].max_level = 0.0;
            template[1].freq = 1880.0;
            template[1].min_level = -0.5;
            template[1].max_level = 0.0;
            template[2].freq = 2080.0;
            template[2].min_level = -5.0;
            template[2].max_level = 0.0;
            template[3].freq = 2280.0 - 20.0;
            template[3].min_level = -99.0;
            template[3].max_level = 0.0;
            template[4].freq = 2280.0 + 20.0;
            template[4].min_level = -99.0;
            template[4].max_level = -30.0;
            template[5].freq = 2480.0;
            template[5].min_level = -99.0;
            template[5].max_level = 0.0;
            template[6].freq = 2680.0;
            template[6].min_level = -5.0;
            template[6].max_level = 0.0;
            template[7].freq = 4000.0;
            template[7].min_level = -0.5;
            template[7].max_level = 0.0;
            break;
        case 2:
            printf("2600Hz tests.\n");
            munge = codec_munge_init(MUNGE_CODEC_ULAW, 0);
            sig_tone_tx_init(&tx_state, SIG_TONE_2600HZ, tx_handler, &tx_state);
            sig_tone_rx_init(&rx_state, SIG_TONE_2600HZ, rx_handler, &rx_state);
            number_of_tones = 1;
            fc[0] = 2600.0;

            template[0].freq = 2600.0 - 200.0;
            template[0].min_level = -1.0;
            template[0].max_level = 0.0;
            template[1].freq = 2600.0 - 20.0;
            template[1].min_level = -99.0;
            template[1].max_level = 0.0;
            template[2].freq = 2600.0 + 20.0;
            template[2].min_level = -99.0;
            template[2].max_level = -30.0;
            template[3].freq = 2600.0 + 200.0;
            template[3].min_level = -99.0;
            template[3].max_level = 0.0;
            template[4].freq = 4000.0;
            template[4].min_level = -1.0;
            template[4].max_level = 0.0;
            break;
        case 3:
            printf("2400Hz/2600Hz tests.\n");
            munge = codec_munge_init(MUNGE_CODEC_ULAW, 0);
            sig_tone_tx_init(&tx_state, SIG_TONE_2400HZ_2600HZ, tx_handler, &tx_state);
            sig_tone_rx_init(&rx_state, SIG_TONE_2400HZ_2600HZ, rx_handler, &rx_state);
            number_of_tones = 2;
            fc[0] = 2400.0;
            fc[1] = 2600.0;

            template[0].freq = 2400.0 - 200.0;
            template[0].min_level = -1.0;
            template[0].max_level = 0.0;
            template[1].freq = 2400.0 - 20.0;
            template[1].min_level = -99.0;
            template[1].max_level = 0.0;
            template[2].freq = 2400.0 + 20.0;
            template[2].min_level = -99.0;
            template[2].max_level = -30.0;
            template[3].freq = 2600.0 - 20.0;
            template[3].min_level = -99.0;
            template[3].max_level = 0.0;
            template[4].freq = 2600.0 + 20.0;
            template[4].min_level = -99.0;
            template[4].max_level = -30.0;
            template[5].freq = 2600.0 + 200.0;
            template[5].min_level = -99.0;
            template[5].max_level = 0.0;
            template[6].freq = 4000.0;
            template[6].min_level = -1.0;
            template[6].max_level = 0.0;
            break;
        }
        /*endswitch*/
        map_frequency_response(&rx_state, template);
        speech_immunity_tests(&rx_state);
        level_and_ratio_tests(&rx_state, fc);
        sequence_tests(&tx_state, &rx_state, munge);
        if (munge)
            codec_munge_free(munge);
    }
    /*endfor*/

    printf("Tests completed.\n");
    return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/