root/ossiedev/branches/0.7.x/platform/AudioDevice/src/AudioDevice.h @ 8807

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

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


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

#ifndef __OSSIE_AUDIO_DEVICE_H__
#define __OSSIE_AUDIO_DEVICE_H__

#include <stdlib.h>
#include "ossie/cf.h"
#include "ossie/PortTypes.h"
#include "ossie/Device_impl.h"
#include "ossie/Resource_impl.h"
#include "ossie/debug.h"

#include "standardinterfaces/complexShort.h"
#include "standardinterfaces/complexShort_u.h"

#include "portaudio.h"

static int portaudio_callback_playback(
    const void *inputBuffer,
    void *outputBuffer,
    unsigned long framesPerBuffer,
    const PaStreamCallbackTimeInfo* timeInfo,
    PaStreamCallbackFlags statusFlags,
    void *userData );

static int portaudio_callback_record(
    const void *inputBuffer,
    void *outputBuffer,
    unsigned long framesPerBuffer,
    const PaStreamCallbackTimeInfo* timeInfo,
    PaStreamCallbackFlags statusFlags,
    void *userData );

/// Main sound card device (capture) definition
class AudioDevice_i : public virtual Device_impl 
{
public:
    /// Initializing constructor
    AudioDevice_i(char *uuid, char* label, char* profile, omni_condition *condition);

    /// Default destructor
    ~AudioDevice_i();

    /// Sets isRunning to True (start)
    void start() 
        throw (CF::Resource::StartError, CORBA::SystemException);

    /// static function for omni thread: capture_sound()
    static void run_capture( void * data );

    /// static function for omni thread: playback_sound()
    static void run_playback( void * data );

    /// Sets isRunning to False (pause)
    void stop() 
        throw (CF::Resource::StopError, CORBA::SystemException);

    /// Returns CORBA object pointer to port
    CORBA::Object_ptr getPort(const char* portName) 
        throw(CF::PortSupplier::UnknownPort, CORBA::SystemException);

    /// Checks if sound card device (capture) is already in use
    void initialize() 
        throw (CF::LifeCycle::InitializeError, CORBA::SystemException);

    /// Sets the following properties (currently NOT read from .prf.xml)
    ///   - Access mode
    ///   - Format
    ///   - Number of channels
    ///   - Sampling rate
    ///   - Period size
    ///   - Buffer size
    ///   - Hardware parameters
    void configure(const CF::Properties &props) 
        throw (CORBA::SystemException, 
               CF::PropertySet::InvalidConfiguration, 
               CF::PropertySet::PartialConfiguration);

    ///
    void releaseObject() 
        throw (CF::LifeCycle::ReleaseError, CORBA::SystemException);

private:
    /// Disallow default constructor
    AudioDevice_i();

    /// Disallow copy constructor
    AudioDevice_i(AudioDevice_i&);

    /// main processing loop for capturing sound
    void capture_sound();

    /// main processing loop for playing sound
    void playback_sound();

    omni_condition *component_running; ///< for component shutdown
    omni_thread *capture_thread;    ///< for component writer function
    omni_thread *playback_thread;    ///< for component writer function

    CORBA::UShort *simple_ptr;
    CORBA::UShort simple_value;
    unsigned int simplesequencelength;
    CORBA::ShortSeq *simplesequence_ptr;
    //simplesequence_ptr = new short[simplesequencelength];

    /// Port: output sound samples
    standardInterfaces_i::complexShort_u *dataOut;

    // properties configured flags
    bool configured;
    bool configured_prop_samplerate_record;
    bool configured_prop_samplerate_playback;
    bool configured_prop_buffersize_record;
    bool configured_prop_buffersize_playback;

    void ConfigureStreams();
    void OpenStreams()  throw (CF::Resource::StartError);
    void StartStreams() throw (CF::Resource::StartError);
    void StopStreams()  throw (CF::Resource::StopError);
    void CloseStreams() throw (CF::Resource::StopError);

    // Until I look at omni_condition... -TT
    bool isRunning;  ///< starts/stops loop in capture_sound()

    // portaudio: specific properties
    PaStreamParameters pa_params_record;
    PaStreamParameters pa_params_playback;
    PaStream *pa_stream_record;
    PaStream *pa_stream_playback;

    // 
    unsigned int samplerate_record;
    unsigned int samplerate_playback;
    unsigned int buffersize_record;
    unsigned int buffersize_playback;

    PortTypes::ShortSequence playback_data_L;
    PortTypes::ShortSequence playback_data_R;

    PortTypes::ShortSequence record_data_L;
    PortTypes::ShortSequence record_data_R;

};

#endif // __OSSIE_AUDIO_DEVICE_H__