audio_internal.c

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
//     
//    __                                ______
//   / /_______________  ____  ___     / ____/
//  / __/ ___/ ___/ __ \/ __ \/ _ \   /___ )  
// / /_(__  ) /__/ /_/ / /_/ /  __/  ____/ /  
// \__/____/\___/\____/ .___/\___/  /_____/   
//                   /_/                      
//     
/// \file audio_internal.c
/// Definitions of internal audio functions.
////////////////////////////////////////////////////////////////////////////////


#include "../include/tscope5/audio_internal.h"
#include "../include/tscope5/timer_internal.h"
#include "../include/tscope5/system_internal.h"

#include <allegro5/allegro_acodec.h>

/// Is the audio subsystem installed?
int _ts5_is_audio_installed = 0;

/// Is the audio recorder subsystem installed?
int  _ts5_is_audio_recorder_installed = 0;

/// Is the audio recorder recording?
int _ts5_is_audio_recorder_recording = 0;

/// Is the voicekey subsystem installed?
int _ts5_is_voicekey_installed = 0;


////////////////////////////////////////////////////////////////////////////////
/// Do some checks at the start of each audio function.
///
/// \param calling_function Name the function that calls for 
/// this check or installation.
///
/// Checks whether the audio subsystem is installed. 
/// If not, the audio subsystem is installed.
////////////////////////////////////////////////////////////////////////////////
void ts5_check_audio(char *calling_function)
{
    ts5_log(TS5_LOGLEVEL_6, "%s: ts5_check_audio\n", calling_function);
    if (!_ts5_is_audio_installed) {
        ts5_install_audio(calling_function);
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Install the audio subsystem.
///
/// \param calling_function Name the function that calls for 
/// this check or installation.
///
/// This function is called automatically if necessary.
////////////////////////////////////////////////////////////////////////////////
void ts5_install_audio(char *calling_function)
{
    if (!_ts5_is_tscope5_installed) {
        ts5_install_tscope5(calling_function);
    }

    if (!_ts5_is_audio_installed) {

        _ts5_is_audio_installed = 1;
        ts5_log(TS5_LOGLEVEL_1, "%s: Installing Tscope5 audio\n", 
                calling_function);

        if (!al_install_audio()) {
            ts5_fatal("%s: could not install Tscope5 audio\n", 
                    calling_function);
        }

        if (!al_init_acodec_addon()) {
            ts5_fatal("%s: could not install Tscope5 audio codec addon\n", 
                    calling_function);
        }

        ALLEGRO_CHANNEL_CONF channels = 0;

        if (_ts5_status.audio.channels==TS5_MONO) {
            channels=ALLEGRO_CHANNEL_CONF_1;
        }
        else if (_ts5_status.audio.channels==TS5_STEREO) {
            channels=ALLEGRO_CHANNEL_CONF_2;
        }
        else {
            ts5_fatal("%s: unknown channel configuration requested\n", 
                    calling_function);
        }

        /*
        ALLEGRO_AUDIO_DEPTH depth;
        if (_ts5_status.audio.depth==TS5_INTEGER) {
            depth=ALLEGRO_AUDIO_DEPTH_INT16;
        }
        else if (_ts5_status.audio.depth==TS5_FLOAT) {
            depth=ALLEGRO_AUDIO_DEPTH_FLOAT32;
        }
        else {
            ts5_fatal("ts5_install_audio: unknown sample depth requested\n");
        }
        */

        _ts5_data.audio.voice = al_create_voice(_ts5_status.audio.samplerate,
                                        ALLEGRO_AUDIO_DEPTH_INT16, channels);

        if (!_ts5_data.audio.voice) {
            ts5_fatal("%s: could not create voice\n", calling_function);
        }

        _ts5_data.audio.mixer = al_create_mixer(_ts5_status.audio.samplerate,
                                        ALLEGRO_AUDIO_DEPTH_FLOAT32, channels);

        if (!_ts5_data.audio.mixer) {
            ts5_fatal("%s: could not create mixer\n", calling_function);
        }

        if (!al_attach_mixer_to_voice(_ts5_data.audio.mixer,
                _ts5_data.audio.voice)) {
            ts5_fatal("%s: could not attach mixer to voice\n", 
                    calling_function);
        }

        atexit(ts5_uninstall_audio);
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Uninstall the audio subsystem.
///
/// This function is called automatically at the end of the program.
////////////////////////////////////////////////////////////////////////////////
void ts5_uninstall_audio()
{
    if (_ts5_is_audio_installed) {

        ts5_log(TS5_LOGLEVEL_1, "Uninstalling Tscope5 audio\n");

        //al_detach_mixer(_ts5_data.audio.mixer);
        //al_detach_voice(_ts5_data.audio.voice);

        //al_destroy_mixer(_ts5_data.audio.mixer);
        //al_destroy_voice(_ts5_data.audio.voice);

        _ts5_data.audio.mixer = NULL;
        _ts5_data.audio.voice = NULL;

        //al_uninstall_audio();

        _ts5_is_audio_installed = 0;
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Do some checks at the start of each audio recorder function.
///
/// \param calling_function Name the function that calls for 
/// this check or installation.
///
/// Checks whether the audio recorder subsystem is installed. 
/// If not, the function audio recorder subsystem is installed.
////////////////////////////////////////////////////////////////////////////////
void ts5_check_audio_recorder(char *calling_function)
{
    ts5_log(TS5_LOGLEVEL_6, "%s: ts5_check_audio_recorder\n", calling_function);
    if (!_ts5_is_audio_recorder_installed) {
        ts5_install_audio_recorder(calling_function);
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Do some checks at the start of each audio recorder function.
///
/// \param calling_function Name the function that calls for 
/// this check or installation.
///
/// Checks whether the audio recorder subsystem is recording. 
///
/// Aborts if necessary.
////////////////////////////////////////////////////////////////////////////////
void ts5_check_audio_recorder2(char *calling_function)
{
    ts5_log(TS5_LOGLEVEL_6, "%s: ts5_check_audio_recorder2\n", calling_function);
    if (!_ts5_is_audio_recorder_recording) {
        ts5_fatal("%s: %s %s\n", calling_function,
                    "audio recorder not running,",
                    "add a call to ts5_start_audio_recorder()");
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Do some checks at the start of each audio recorder function.
///
/// \param calling_function Name the function that calls for 
/// this check or installation.
///
/// \param sample The sample that has to be checked.
/// 
/// Checks whether the audio sample is a recording buffer allocated by
/// ts5_alloc_sample.
/// 
/// Aborts if necessary.
////////////////////////////////////////////////////////////////////////////////
void ts5_check_audio_recorder3(char *calling_function, TS5_SAMPLE *sample)
{
    ts5_log(TS5_LOGLEVEL_6, "%s: ts5_check_audio_recorder3(%p)\n", 
                calling_function, sample);
                
    if (!sample) {
        ts5_fatal("%s: sample pointer is null\n", calling_function);
    }
                            
    if (!sample->isbuffer) {
        ts5_fatal("%s: %s %p %s\n", calling_function,
                    "audio sample", sample, 
                    "is not a recording buffer");
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Install the audio recorder subsystem.
///
/// \param calling_function Name the function that calls for 
/// this check or installation.
///
/// This function is called automatically if necessary.
////////////////////////////////////////////////////////////////////////////////
void ts5_install_audio_recorder(char *calling_function) 
{
    if (!_ts5_is_tscope5_installed) {
        ts5_install_tscope5(calling_function);
    }

    if (!_ts5_is_audio_installed) {
        ts5_install_audio(calling_function);
    }
    
    if (!_ts5_is_audio_recorder_installed) {

        _ts5_is_audio_recorder_installed = 1;
        
        ts5_log(TS5_LOGLEVEL_1, "%s: Installing Tscope5 audio recorder\n", 
                calling_function);
        
        // create a recorder with a buffer of 10.0 seconds
        unsigned int samplerate = _ts5_status.audio.samplerate;
        unsigned int samples = 4094;
        size_t fragment_count = 10.0 * samplerate / samples;
        
        _ts5_data.audio.recorder = 
            al_create_audio_recorder(fragment_count, 
                samples,
                samplerate, 
                ALLEGRO_AUDIO_DEPTH_INT16, 
                _ts5_status.audio.channels);    
                            
        if(!_ts5_data.audio.recorder) {
            ts5_fatal("%s: could create audio recorder\n", 
                calling_function);
        }
            
        // event queue for the buffer fragments
        _ts5_data.audio.recorder_queue = al_create_event_queue();
        if(!_ts5_data.audio.recorder_queue) {
            ts5_fatal("%s: could not create audio recorder event cue\n", 
                calling_function);
        }
        al_register_event_source(_ts5_data.audio.recorder_queue, 
                al_get_audio_recorder_event_source(_ts5_data.audio.recorder));
        
        atexit(ts5_uninstall_audio_recorder);   
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Uninstall the audio recoder subsystem.
///
/// This function is called automatically at the end of the program.
////////////////////////////////////////////////////////////////////////////////
void ts5_uninstall_audio_recorder()
{
    if (_ts5_is_audio_recorder_installed) {
        
        ts5_log(TS5_LOGLEVEL_1, "Uninstalling Tscope5 audio recorder\n");
                
        al_unregister_event_source(_ts5_data.audio.recorder_queue,
            al_get_audio_recorder_event_source(_ts5_data.audio.recorder));
    
        al_destroy_event_queue(_ts5_data.audio.recorder_queue);
        
        al_destroy_audio_recorder(_ts5_data.audio.recorder);
    
    //  al_fclose(_ts5_data.audio.fp);
        
        _ts5_is_audio_recorder_installed = 0;
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Do some checks at the start of each voicekey function.
///
/// \param calling_function Name the function that calls for 
/// this check or installation.
///
/// Checks whether the voicekey subsystem is installed. 
/// If not, the voicekey subsystem is installed.
////////////////////////////////////////////////////////////////////////////////
void ts5_check_voicekey(char *calling_function)
{
    ts5_log(TS5_LOGLEVEL_6, "%s: ts5_check_voicekey\n", calling_function);
    if (!_ts5_is_voicekey_installed) {
        ts5_install_voicekey(calling_function);
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Install the voicekey subsystem.
///
/// \param calling_function Name the function that calls for 
/// this check or installation.
///
/// This function is called automatically if necessary.
////////////////////////////////////////////////////////////////////////////////
void ts5_install_voicekey(char *calling_function) 
{
    if (!_ts5_is_tscope5_installed) {
        ts5_install_tscope5(calling_function);
    }
    
    if (!_ts5_is_timer_installed) {
        ts5_install_timer(calling_function);
    }

    if (!_ts5_is_audio_installed) {
        ts5_install_audio(calling_function);
    }
    
    if (!_ts5_is_audio_recorder_installed) {
        ts5_install_audio_recorder(calling_function);   
    }
    
    if (!_ts5_is_voicekey_installed) {

        _ts5_is_voicekey_installed = 1;
        
        ts5_log(TS5_LOGLEVEL_1, "%s: Installing Tscope5 voice key\n", 
                calling_function);

        // initialize event source
        al_init_user_event_source(
            &_ts5_data.timer.voicekey_response_event_source);

        // register event source
        al_register_event_source(_ts5_data.timer.response_queue,
            &_ts5_data.timer.voicekey_response_event_source);

        _ts5_status.timer.voicekey.num_buttons = 1;
        _ts5_status.timer.voicekey.num_defined_buttons = 0;
        _ts5_status.timer.voicekey.num_active_buttons = 0;
        
        _ts5_status.timer.voicekey.treshold = 0.5;
        _ts5_status.timer.voicekey.rise_delay = 0.2;
        _ts5_status.timer.voicekey.drop_delay = 0.2;

        _ts5_status.timer.voicekey.button_press_defined =
            (int *)al_malloc(sizeof(int)
            * _ts5_status.timer.voicekey.num_buttons);

        _ts5_status.timer.voicekey.button_press_active =
            (int *)al_malloc(sizeof(int)
            * _ts5_status.timer.voicekey.num_buttons);

        _ts5_status.timer.voicekey.button_release_defined =
            (int *)al_malloc(sizeof(int)
            * _ts5_status.timer.voicekey.num_buttons);

        _ts5_status.timer.voicekey.button_release_active =
            (int *)al_malloc(sizeof(int)
            * _ts5_status.timer.voicekey.num_buttons);

        int i;
        for (i=0; i<_ts5_status.timer.voicekey.num_buttons; i++) {
            _ts5_status.timer.voicekey.button_press_defined[i] = 0;
            _ts5_status.timer.voicekey.button_press_active[i] = 0;
            _ts5_status.timer.voicekey.button_release_defined[i] = 0;
            _ts5_status.timer.voicekey.button_release_active[i] = 0;
        }
        
        atexit(ts5_uninstall_voicekey); 
    }
}


////////////////////////////////////////////////////////////////////////////////
/// Uninstall the voicekey subsystem.
///
/// This function is called automatically at the end of the program.
////////////////////////////////////////////////////////////////////////////////
void ts5_uninstall_voicekey()
{
    if (_ts5_is_voicekey_installed) {
        
        ts5_log(TS5_LOGLEVEL_1, "Uninstalling Tscope5 voice key\n");
                
        _ts5_status.timer.voicekey.num_buttons = 0;
        _ts5_status.timer.voicekey.num_defined_buttons = 0;
        _ts5_status.timer.voicekey.num_active_buttons = 0;

        al_free(_ts5_status.timer.voicekey.button_press_defined);
        _ts5_status.timer.voicekey.button_press_defined = NULL;

        al_free(_ts5_status.timer.voicekey.button_press_active);
        _ts5_status.timer.voicekey.button_press_active = NULL;

        al_free(_ts5_status.timer.voicekey.button_release_defined);
        _ts5_status.timer.voicekey.button_release_defined = NULL;

        al_free(_ts5_status.timer.voicekey.button_release_active);
        _ts5_status.timer.voicekey.button_release_active = NULL;

        _ts5_status.timer.voicekey_is_response_device = 0;
        
        // unregister event source
        al_unregister_event_source(_ts5_data.timer.response_queue,
            &_ts5_data.timer.voicekey_response_event_source);

        // remove event source
        al_destroy_user_event_source(
            &_ts5_data.timer.voicekey_response_event_source);
        
        _ts5_is_voicekey_installed = 0;
    }
}