hlrc

/*

* This file is part of hlrc_server

*

* Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

* http://opensource.cit-ec.de/projects/hlrc_server

*

* This file may be licensed under the terms of the

* GNU General Public License Version 3 (the ``GPL''),

* or (at your option) any later version.

*

* Software distributed under the License is distributed

* on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

* express or implied. See the GPL for the specific language

* governing rights and limitations.

*

* You should have received a copy of the GPL along with this

* program. If not, go to http://www.gnu.org/licenses/gpl.html

* or write to the Free Software Foundation, Inc.,

* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

*

* The development of this software was supported by the

* Excellence Cluster EXC 277 Cognitive Interaction Technology.

* The Excellence Cluster EXC 277 is a grant of the Deutsche

* Forschungsgemeinschaft (DFG) in the context of the German

* Excellence Initiative.

*

*/

#include "AudioPlayerLibAO.h"

#include <thread>

#include <chrono>

using namespace std;

//new audio player with gievn device type (default is pulse)

AudioPlayerLibAO::AudioPlayerLibAO(string driver): AudioPlayer(driver){

    printf("> using libao for playback\n");

    //initialize

    ao_initialize();

    //configure driver

    if (audio_driver.empty()){

        //use default:

        driver = ao_default_driver_id();

    }else{

        driver = ao_driver_id(audio_driver.c_str());

    }

    //start audio playback thread:

    playback_thread_ptr = new boost::thread(boost::bind(&AudioPlayerLibAO::playback_thread, this));

}

//this will return once we start playing

void AudioPlayerLibAO::play(std::shared_ptr<AudioData> audio){

    audio_data = audio;

    printf("> AudioPlayerLibAO: play() %d samples requested\n",(int)audio_data->samples.size());

    //skip empty audio data

    if (audio_data->samples.size() == 0){

        printf("> warning: empty audio data - skipped.\n");

        return;

    }

    //check if we can play this file:

    while(playback_state != IDLE){

        printf("> player not ready yet, waiting for 10ms\n");

        std::this_thread::sleep_for(std::chrono::milliseconds(10));

    }

    audio_format = extract_ao_format(audio_data);

    playback_requested = true;

    //wait for playback to start:

    printf("> waiting for playback start...\n");

    while(playback_requested){

        std::this_thread::sleep_for(std::chrono::milliseconds(1));

    }

    printf("> playback running.\n");

}

ao_sample_format AudioPlayerLibAO::extract_ao_format(std::shared_ptr<AudioData> audio){

    ao_sample_format ao_format;

    //get bits per sample

    ao_format.bits = audio->sample_bit;

    //bitrate

    ao_format.rate = audio->sample_rate;

    //endianess

    ao_format.byte_format = audio->sample_big_endian?AO_FMT_BIG:AO_FMT_LITTLE;

    //number of channels

    ao_format.channels = audio->sample_channels;

    //format matrix:

    if (ao_format.channels == 1){

        ao_format.matrix = (char *)"L";

    }else if(ao_format.channels == 2){

        ao_format.matrix = (char *)"L,R";

    }else{

        printf("> invalid AudioData channel count given. ignoring request\n");

        throw runtime_error("AudioPlayerLibAO::extract_ao_format() unsupported number of audio channels given in AudioData");

    }

    printf("> AudioPlayerLibAO: format=%d rate=%d endianess=%d channels=%d\n", ao_format.bits, ao_format.rate, ao_format.byte_format, ao_format.channels);

    return ao_format;

}

void AudioPlayerLibAO::playback_thread(){

    printf("> playback thread started\n");

    playback_state = IDLE;

    while(playback_state != EXITING){

        switch (playback_state){

            default:

            case(INITIALIZING):

                //waiting to be ready

                break;

            case(IDLE):

                //nothing to do, wait here until we are triggered to play!

                if (playback_requested){

                    printf("> AudioPlayer: loading\n");

                    playback_state = LOADING;

                }

                break;

            case(LOADING):

                //check if we can play that format:

                device = ao_open_live(driver, &audio_format, NULL /* no options */);

                if (device == NULL){

                    printf("> AudioPlayer: WARNING: can not open requested audio device. trying to fall back to default driver\n");

                    driver = ao_default_driver_id();

                    device = ao_open_live(driver, &audio_format, NULL /* no options */);

                }

                if (device == NULL){

                    //failed to init device for format:

                    printf("> AudioPlayer: WARNING: can not open audio device, not playing audio file!\n");

                    playback_active = false;

                    playback_requested = false;

                    playback_state = IDLE;

                    break;

                }else{

                    //ok we can now play the data

                    printf("> AudioPlayer: playback started\n");

                    //mark request as beeing processed

                    playback_requested = false;

                    //enter actual playing state

                    playback_state = PLAYING;

                    playback_active = true;

                    ao_play(device, audio_data->samples.data(), audio_data->samples.size());

                    printf("> AudioPlayer: finished playback\n");

                }

                break;

            case(PLAYING):

                //when we reach this case, the ao_play() call finished

                //-> we can close this now:

                ao_close(device);

                playback_state = IDLE;

                playback_active = false;

                printf("> AudioPlayer: device closed\n");

                break;

            case(ERROR):

                printf("> AudioPlayer ERROR! exiting\n");

                exit(EXIT_FAILURE);

                break;

        }

        //1ms delay to safe cpu time

        std::this_thread::sleep_for(std::chrono::milliseconds(1));

    }

    //shutdown audio!

    ao_shutdown();

    //done

    playback_state = CLOSED;

}

AudioPlayerLibAO::~AudioPlayerLibAO(){

}