RtAudioModule.h

Go to the documentation of this file.

/*
  RtAudio Module
  1.0-1.2
  
  Copyright (C) 2010 Alexandre R.J. Francois

  Previous versions Copyright (C) 2006 University of Southern California
  
  Author: Alexandre R.J. Francois - alexandrefrancois@yahoo.com
  www.alexandrefrancois.org
  
  Modular Flow Scheduling Middleware
  mfsm.sourceForge.net
  
  This code is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
  
  This code 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
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this code; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef RTAUDIO_MODULE_H
#define RTAUDIO_MODULE_H

#include "FsfNode.h"
#include "FsfCell.h"

// #include "FsfTypeNode.h"
// #include "FsfTypeCell.h"

#include "AudioModule.h"
#include "RtAudio.h"

#include <iostream>


namespace rtaudiom{



    void registerFactories();


    const long STREAM_OUTPUT_DEVICE=0;
    const long STREAM_OUTPUT_CHANNELS=1;
    const long STREAM_INPUT_DEVICE=2;
    const long STREAM_INPUT_CHANNELS=3;
    const long STREAM_AUDIO_FORMAT=4;
    const long STREAM_SAMPLE_RATE=5;
    const long STREAM_BUFFER_FRAMES=6;

    const unsigned int RTAUDIO_FORMAT[6] = { 0x20, 0x10, 0x8, 0x4, 0x2, 0x1 };

    
    class CReceive : public fsf::CCell {
    public:
        CReceive();
        virtual void getTypeID(std::string &str) const { str.assign("RTAUDIO_RECEIVE"); }
        void makePulse(fsf::CNode *pNode=NULL);
    };
   

    class CInputInterface : public fsf::CNode {
    private:
        fsf::CMutex m_csInterface; 
        RtAudio m_audio; 
        RtAudio::StreamParameters m_parameters; 
        unsigned int m_nFormat; 
        unsigned int m_nSampleRate; 
        unsigned int m_nBufferFrames; 
        int m_nBufferSize; 
        CReceive *m_pReceiveCell; 

        static int callback(void *outputBuffer, void *inputBuffer, unsigned int nBufferFrames,
                            double streamTime, RtAudioStreamStatus status, void *pData);

        void pushNode(fsf::CNode *pNode=NULL) const { if(m_pReceiveCell) m_pReceiveCell->makePulse(pNode); }
        
    public:


        CInputInterface();
        CInputInterface(fsf::CNode *pParent, fsf::Time tTime=0);
        CInputInterface(const std::string &strName, fsf::CNode *pParent=NULL, fsf::Time tTime=0);
        CInputInterface(const CInputInterface& rhs);
        virtual ~CInputInterface();
        virtual fsf::CNode *clone() const { return new CInputInterface(*this); }



        CInputInterface& operator=(const CInputInterface& rhs);

        void setReceiveCell(CReceive *pCell) { m_pReceiveCell=pCell; }

        bool open(int nInputDevice, int nInputChannels,
                  unsigned int nFormat, unsigned int nSampleRate, unsigned int nBufferSize);
        bool close();
            


        virtual void getTypeID(std::string &str) const { str.assign("RTAUDIO_INPUT_INTERFACE"); }

    };

    class COpenInputStream : public fsf::CCell {
    public:
        COpenInputStream();
        virtual void getTypeID(std::string &str) const { str.assign("RTAUDIO_OPEN_INPUT_STREAM"); }
        virtual void process(fsf::CPassiveHandle *pPassiveHandle, fsf::CActiveHandle *pActiveHandle, fsf::CActivePulse *pActivePulse);
    };
        
    class CCloseInputStream : public fsf::CCell {
    public:
        CCloseInputStream();
        virtual void getTypeID(std::string &str) const { str.assign("RTAUDIO_CLOSE_INPUTSTREAM"); }
        virtual void process(fsf::CPassiveHandle *pPassiveHandle, fsf::CActiveHandle *pActiveHandle, fsf::CActivePulse *pActivePulse);
    };
        


    class CSend : public fsf::CCell {
    public:
        CSend();
        virtual void getTypeID(std::string &str) const { str.assign("RTAUDIO_SEND"); }
        virtual void process(fsf::CPassiveHandle *pPassiveHandle, fsf::CActiveHandle *pActiveHandle, fsf::CActivePulse *pActivePulse);
    };


    class COutputInterface : public fsf::CNode {
    private:
        fsf::CMutex m_csInterface; 
        RtAudio m_audio; 
        RtAudio::StreamParameters m_parameters; 
        unsigned int m_nFormat; 
        unsigned int m_nSampleRate; 
        unsigned int m_nBufferFrames; 
        int m_nBufferSize; 
        char *m_pBuffer; 

        static int callback(void *outputBuffer, void *inputBuffer, unsigned int nBufferFrames,
                            double streamTime, RtAudioStreamStatus status, void *pData);

    public:


        COutputInterface();
        COutputInterface(fsf::CNode *pParent, fsf::Time tTime=0);
        COutputInterface(const std::string &strName, fsf::CNode *pParent=NULL, fsf::Time tTime=0);
        COutputInterface(const COutputInterface& rhs);
        virtual ~COutputInterface();
        virtual fsf::CNode *clone() const { return new COutputInterface(*this); }



        COutputInterface& operator=(const COutputInterface& rhs);
        bool open(int nOutputDevice, int nOutputChannels,
                  unsigned int nFormat, unsigned int nSampleRate, unsigned int nBufferSize);
        bool close();
        void loadBuffer(audio::CAudioBuffer *pNode);
            


        virtual void GetTypeID(std::string &str) { str.assign("RTAUDIO_OUTPUT_INTERFACE"); }
    };

    class COpenOutputStream : public fsf::CCell {
    public:
        COpenOutputStream();
        virtual void getTypeID(std::string &str) const { str.assign("RTAUDIO_OPEN_OUTPUT_STREAM"); }
        // Specialized processing function
        virtual void process(fsf::CPassiveHandle *pPassiveHandle, fsf::CActiveHandle *pActiveHandle, fsf::CActivePulse *pActivePulse);
    };
        
    class CCloseOutputStream : public fsf::CCell {
    public:
        CCloseOutputStream();
        virtual void getTypeID(std::string &str) const { str.assign("RTAUDIO_CLOSE_OUTPUT_STREAM"); }
        virtual void process(fsf::CPassiveHandle *pPassiveHandle, fsf::CActiveHandle *pActiveHandle, fsf::CActivePulse *pActivePulse);
    };







    bool openInputStream(fsf::CRepository *pRepository, std::string &strInterfaceName,
                    int nInputDevice, int nInputChannels,
                    unsigned int nFormat, unsigned int nSampleRate, unsigned int nBufferFrames=0);
    bool closeInputStream(fsf::CRepository *pRepository, std::string &strInterfaceName);

    bool openOutputStream(fsf::CRepository *pRepository, std::string &strInterfaceName,
                    int nOutputDevice, int nOutputChannels,
                    unsigned int nFormat, unsigned int nSampleRate, unsigned int nBufferFrames=0);
    bool closeOutputStream(fsf::CRepository *pRepository, std::string &strInterfaceName);

    int selectInputDevice();
    int selectOutputDevice();

    
} // namespace rtaudiom

#endif // RTAUDIO_MODULE_H

---