root/ossiedev/branches/0.7.x/platform/AudioDevice/src/AudioDevice.cpp @ 8817

/**************************************************************************** 

Copyright 2009 Virginia Polytechnic Institute and State University

This file is part of the OSSIE AudioDevice.

OSSIE AudioDevice is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

OSSIE AudioDevice 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 OSSIE AudioDevice; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

****************************************************************************/

#include <iostream>
#include "AudioDevice.h"

#define AUDIODEVICE_PROPID_SAMPLERATERECORD     "DCE:90b8fe0b-3b0b-4aee-bb2b-a9a989d22ba9"
#define AUDIODEVICE_PROPID_SAMPLERATEPLAYBACK   "DCE:5a9b4f27-c604-4fe8-9661-4bf7a65e4ad4"
#define AUDIODEVICE_PROPID_BUFFERSIZERECORD     "DCE:849f63b4-9b18-40cb-b318-956bedae94aa"
#define AUDIODEVICE_PROPID_BUFFERSIZEPLAYBACK   "DCE:f3a3dd1f-b7e2-44a4-ad34-db0a6bea895f"

#define AUDIODEVICE_NUMCHANNELS     (2)
#define AUDIODEVICE_SAMPLEFORMAT    (paFloat32) // paInt16

// Initializing constructor
AudioDevice_i::AudioDevice_i(char *uuid, char *label, char *profile, omni_condition *condition) 
  : Device_impl(uuid, label, profile),
    component_running(condition),
    isRunning(false)
{
    DEBUG(3, AudioDevice, "constructor invoked")

    // set configured flags to false
    // All properties must be configured before the stream is opened,
    // after which any change in properties will be ignored
    configured = false;
    configured_prop_samplerate_record   = false;
    configured_prop_samplerate_playback = false;
    configured_prop_buffersize_record   = false;
    configured_prop_buffersize_playback = false;

    buffer_playback = NULL;
    buffer_record   = NULL;

    // Create Port for output sound
    dataOut = new standardInterfaces_i::complexShort_u("complexShortOut");
    dataIn  = new standardInterfaces_i::complexShort_p("complexShortIn");
    // TODO: create port for input sound

    // initialize portaudio stream
    PaError err = Pa_Initialize();
    if (err != paNoError) {
        std::cerr << "ERROR: AudioDevice_i::AudioDevice_i(), could not initialize portaudio" << std::endl;
        throw 0;
    }

    // Start the capture_sound thread
    //capture_thread = new omni_thread(run_capture, (void *) this);
    //capture_thread->start();

    // Start playback_sound thread
    //playback_thread = new omni_thread(run_playback, (void *) this);
    //playback_thread->start();
}

// Default destructor
AudioDevice_i::~AudioDevice_i()
{
    if (buffer_playback)
        delete [] buffer_playback;
    if (buffer_record)
        delete [] buffer_record;

    PaError err = Pa_Terminate();
    if (err != paNoError) {
        std::cerr << "ERROR: AudioDevice_i::~AudioDevice_i(), could not terminate portaudio" << std::endl;
        throw 0;
    }
}

// static function for omni thread
void AudioDevice_i::run_capture( void * data )
{
    ((AudioDevice_i*) data)->capture_sound();
}


// static function for omni thread
void AudioDevice_i::run_playback( void * data )
{
    ((AudioDevice_i*) data)->playback_sound();
}

void AudioDevice_i::start() 
throw (CF::Resource::StartError, CORBA::SystemException)
{
    DEBUG(3, AudioDevice, "start() invoked")

    isRunning = true;

    // start the streams
    StartStreams();
}


void AudioDevice_i::stop()
throw (CF::Resource::StopError, CORBA::SystemException)
{
    DEBUG(3, AudioDevice, "stop() invoked")

    isRunning = false;

    // stop the streams
    StopStreams();
}

CORBA::Object_ptr AudioDevice_i::getPort(const char* portName) 
throw(CF::PortSupplier::UnknownPort, CORBA::SystemException)

{
    DEBUG(3, AudioDevice, "getPort() invoked with: " << portName)

    CORBA::Object_var u;

    u = dataOut->getPort(portName);

    if (!CORBA::is_nil(u))
        return u._retn();

    // Port name not found; throw exception
    throw CF::PortSupplier::UnknownPort();
}

void AudioDevice_i::initialize() 
throw (CF::LifeCycle::InitializeError, CORBA::SystemException)
{
    DEBUG(3, AudioDevice, "initialize() invoked")
}

void AudioDevice_i::configure(const CF::Properties &props) 
throw (CORBA::SystemException, 
       CF::PropertySet::InvalidConfiguration, 
       CF::PropertySet::PartialConfiguration)
{
    DEBUG(3, AudioDevice, "configure() invoked. Number of props = " 
              << props.length()  
             )

    if (configured) {
        std::cout << "warning: AudioDevice_i::configure(), "
                  << "cannot reconfigure once all properties are set"
                  << std::endl;
        return;
    }

    // read properties from .prf
    
    CORBA::Short n;
    for (unsigned int i=0; i<props.length(); i++)
    {
        DEBUG(3, AudioDevice, "configure property id : " << props[i].id)

        if (strcmp(props[i].id, AUDIODEVICE_PROPID_SAMPLERATERECORD)==0) {
            // sample rate: record
            props[i].value >>= n;
            samplerate_record = n;
            configured_prop_samplerate_record = true;
            DEBUG(3, AudioDevice, "sample rate (record): " << samplerate_record << " Hz")

        } else if (strcmp(props[i].id, AUDIODEVICE_PROPID_SAMPLERATEPLAYBACK)==0) {
            // sample rate: playback
            props[i].value >>= n;
            samplerate_playback = n;
            configured_prop_samplerate_playback = true;
            DEBUG(3, AudioDevice, "sample rate (playback): " << samplerate_playback << " Hz")

        } else if (strcmp(props[i].id, AUDIODEVICE_PROPID_BUFFERSIZERECORD)==0) {
            // buffer size: record
            props[i].value >>= n;
            buffersize_record = n;
            configured_prop_samplerate_record = true;
            DEBUG(3, AudioDevice, "buffer size (record): " << buffersize_record)

        } else if (strcmp(props[i].id, AUDIODEVICE_PROPID_BUFFERSIZEPLAYBACK)==0) {
            // buffer size: playback
            props[i].value >>= n;
            buffersize_playback = n;
            configured_prop_buffersize_playback = true;
            DEBUG(3, AudioDevice, "buffer size (playback): " << buffersize_playback)

        } else {
            std::cerr << "ERROR AudioDevice_i::configure(): unkown property id "
                      << props[i].id << std::endl;
            throw(CF::PropertySet::InvalidConfiguration());
        }

        // check configured flags
        if (    configured_prop_samplerate_record   &&
                configured_prop_samplerate_playback &&
                configured_prop_buffersize_record   &&
                configured_prop_buffersize_playback)
        {
            configured = true;
            DEBUG(3, AudioDevice, "configured")
        }
    }

    // TODO: reconfigure streams
    if (!configured)
        return;

    // configure streams
    ConfigureStreams();

    // initialize buffers
    buffer_playback = new float[2*buffersize_playback];
    buffer_record   = new float[2*buffersize_record];
}

void AudioDevice_i::releaseObject()
throw (CF::LifeCycle::ReleaseError, CORBA::SystemException)
{
    DEBUG(3, AudioDevice, "releaseObject() invoked")

    component_running->signal();
}

void AudioDevice_i::OpenStreams()
    throw (CF::Resource::StartError)
{
    // ensure properties have been configured
    if (!configured) {
        std::cerr << "ERROR: AudioDevice_i::OpenStreams(), device not configured" << std::endl;
        throw CF::Resource::StartError();
    }

    PaError err;

    // open record stream
    err = Pa_OpenStream(
            &pa_stream_record,
            NULL,               // no input
            &pa_params_record,
            samplerate_record,
            buffersize_record,
            paClipOff,          // disable clipping
            portaudio_callback_record,
            (void*)this);

    if (err != paNoError) {
        std::cerr << "ERROR: AudioDevice_i::OpenStreams(), could not open portaudio stream: record" << std::endl;
        throw CF::Resource::StartError();
    }

    // open playback stream
    err = Pa_OpenStream(
            &pa_stream_playback,
            &pa_params_playback,
            NULL,               // no output
            samplerate_playback,
            buffersize_playback,
            paClipOff,          // disable clipping
            portaudio_callback_playback,
            (void*)this);

    if (err != paNoError) {
        std::cerr << "ERROR: AudioDevice_i::OpenStreams(), could not open portaudio stream: playback" << std::endl;
        throw CF::Resource::StartError();
    }
}

void AudioDevice_i::StartStreams()
    throw (CF::Resource::StartError)
{
    if (!configured) {
        std::cerr << "ERROR: AudioDevice_i::StartStreams(), device not configured" << std::endl;
        throw CF::Resource::StartError();
    }

    // start record, playback threads
    PaError err;


    err = Pa_StartStream(pa_stream_record);
    if (err != paNoError) {
        std::cerr << "ERROR: AudioDevice_i::StartStreams(), could not start portaudio stream: record" << std::endl;
        throw CF::Resource::StartError();
    }

    err = Pa_StartStream(pa_stream_playback);
    if (err != paNoError) {
        std::cerr << "ERROR: AudioDevice_i::StartStreams(), could not start portaudio stream: playback" << std::endl;
        throw CF::Resource::StartError();
    }
}

void AudioDevice_i::StopStreams()
    throw (CF::Resource::StopError)
{
    PaError err;

    err = Pa_StopStream(pa_stream_record);
    if (err != paNoError) {
        std::cerr << "ERROR: AudioDevice_i::StopStreams(), could not stop portaudio stream: record" << std::endl;
        throw CF::Resource::StopError();
    }

    err = Pa_StopStream(pa_stream_playback);
    if (err != paNoError) {
        std::cerr << "ERROR: AudioDevice_i::StopStreams(), could not stop portaudio stream: playback" << std::endl;
        throw CF::Resource::StopError();
    }

}

void AudioDevice_i::CloseStreams()
    throw (CF::Resource::StopError)
{
    PaError err;
    
    err = Pa_CloseStream(pa_stream_record);
    if (err != paNoError) {
        std::cerr << "ERROR: AudioDevice_i::CloseStreams(), could not close portaudio stream: record" << std::endl;
        throw CF::Resource::StopError();
    }
    
    err = Pa_CloseStream(pa_stream_playback);
    if (err != paNoError) {
        std::cerr << "ERROR: AudioDevice_i::CloseStreams(), could not close portaudio stream: playback" << std::endl;
        throw CF::Resource::StopError();
    }
}

void AudioDevice_i::ConfigureStreams()
{
    // configure parameters: record
    pa_params_record.device = Pa_GetDefaultOutputDevice();
    pa_params_record.channelCount = AUDIODEVICE_NUMCHANNELS;
    pa_params_record.sampleFormat = AUDIODEVICE_SAMPLEFORMAT;
    pa_params_record.suggestedLatency = 
        Pa_GetDeviceInfo( pa_params_record.device )->defaultLowOutputLatency;
    pa_params_record.hostApiSpecificStreamInfo = NULL;

    // configure parameters: playback
    pa_params_playback.device = Pa_GetDefaultOutputDevice();
    pa_params_playback.channelCount = AUDIODEVICE_NUMCHANNELS;
    pa_params_playback.sampleFormat = AUDIODEVICE_SAMPLEFORMAT;
    pa_params_playback.suggestedLatency = 
        Pa_GetDeviceInfo( pa_params_playback.device )->defaultLowOutputLatency;
    pa_params_playback.hostApiSpecificStreamInfo = NULL;
}

void AudioDevice_i::capture_sound()
{
    DEBUG(3, AudioDevice, "capture_sound() invoked")
    PortTypes::ShortSequence L_out, R_out;

    L_out.length(1);
    R_out.length(1);
   
    while(isRunning && configured) {
        //dataOut->pushPacket(L_out, R_out);
    }
}

void AudioDevice_i::playback_sound()
{
    DEBUG(3, AudioDevice, "playback_sound() invoked")
    PortTypes::ShortSequence L_out, R_out;

    L_out.length(1);
    R_out.length(1);
   
    while(isRunning && configured) {
        //dataOut->pushPacket(L_out, R_out);
    }
}

void AudioDevice_i::SetRecordData(float * _data)
{
    // copy data to buffer
    for (unsigned int i=0; i<buffersize_record; i++) {
        record_data_L[i] = buffer_record[2*i+0];
        record_data_R[i] = buffer_record[2*i+1];
    }

    // push data
    dataOut->pushPacket(record_data_L, record_data_R);
}

void AudioDevice_i::GetPlaybackData(float ** _data)
{
    // wait for data
    dataIn->getData(playback_data_L, playback_data_R);

    // copy to buffer
    for (unsigned int i=0; i<buffersize_playback; i++) {
        buffer_playback[2*i+0] = (*playback_data_L)[i];
        buffer_playback[2*i+1] = (*playback_data_R)[i];
    }

    // release input buffer
    dataIn->bufferEmptied();

    // return pointer to playback buffer
    _data = &buffer_playback;
}

int portaudio_callback_record(
    const void *inputBuffer,
    void *outputBuffer,
    unsigned long framesPerBuffer,
    const PaStreamCallbackTimeInfo* timeInfo,
    PaStreamCallbackFlags statusFlags,
    void *userData )
{
    //short int * in = (short int*)inputBuffer;

    // prevent unused variable warnings
    (void) timeInfo;
    (void) statusFlags;
    (void) inputBuffer;

    unsigned long int i;
    for (i=0; i<framesPerBuffer; i++) {
        // write data to port
    }

    return paContinue;
}

int portaudio_callback_playback(
    const void *inputBuffer,
    void *outputBuffer,
    unsigned long framesPerBuffer,
    const PaStreamCallbackTimeInfo* timeInfo,
    PaStreamCallbackFlags statusFlags,
    void *userData )
{
    AudioDevice_i * device = (AudioDevice_i*)userData;
    //short int * out = (short int*)outputBuffer;
    // wait for data
    float *data;
    device->GetPlaybackData(&data);

    // prevent unused variable warnings
    (void) timeInfo;
    (void) statusFlags;
    (void) inputBuffer;

    unsigned long int i;
    for (i=0; i<framesPerBuffer; i++) {
        // left
        //*out++ = device->playback_data_L[i];

        // right
        //*out++ = device->playback_data_R[i];
    }

    return paContinue;
}