jackaudioio.hpp

//C++ Classes that wrap JACK
//Copyright 2007 Alex Norman
//
//This file is part of JACKC++.
//
//JACKC++ 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 3 of the License, or
//(at your option) any later version.
//
//JACKC++ 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 JACKC++.  If not, see <http://www.gnu.org/licenses/>.

#ifndef JACK_AUDIO_IO_H
#define JACK_AUDIO_IO_H

extern "C" {
#include <jack/jack.h>
#include <jack/types.h>
#include <jack/ringbuffer.h>
}
#include <string>
#include <vector>
#include <stdexcept>
#include "jackringbuffer.hpp"

namespace JackCpp {

        class AudioIO {
                public:
                        enum jack_state_t {notActive,active,closed};
                        typedef std::vector<jack_default_audio_sample_t *> audioBufVector;
                private:
                        //commands
                        enum cmd_t {add_in_port, add_out_port};
                        RingBuffer<cmd_t> mCmdBuffer;
                        /* the client */
                        jack_client_t *mJackClient;
                        // an vector of i/o ports
                        std::vector<jack_port_t *> mOutputPorts;
                        std::vector<jack_port_t *> mInputPorts;

                        //these are only accessed by the callback [once it is activated]
                        //they will usually be equal mOutputPorts.size() etc, except when
                        //a new port is added, before the callback
                        unsigned int mNumOutputPorts;
                        unsigned int mNumInputPorts;

                        //these items are used for grabbing data for the jack callback
                        audioBufVector mJackInBuf;
                        audioBufVector mJackOutBuf;
                        //this stores the state of this jack process [active,notActive,closed]
                        jack_state_t mJackState;
                        //this prepares the input/output buffers to be passed 
                        //to the callback function that a user writes
                        //XXX should this be virtual?
                        inline int jackToClassAudioCallback(jack_nframes_t nframes);
                        std::vector<std::string> mPortNames;
                protected:
                        virtual int audioCallback(jack_nframes_t nframes, 
                                        audioBufVector inBufs,
                                        audioBufVector outBufs) = 0;
                        jack_client_t * client();
                public:
                        AudioIO(std::string name, 
                                        unsigned int inPorts = 0, 
                                        unsigned int outPorts = 2, 
#ifdef __APPLE__
                                        bool startServer = false)
#else
                                        bool startServer = true)
#endif
                                throw(std::runtime_error);

                        virtual ~AudioIO();

                        static int jackProcessCallback(jack_nframes_t nframes, void *arg);

                        bool portExists(std::string name);

                        virtual void reserveOutPorts(unsigned int num)
                                throw(std::runtime_error);
                        virtual void reserveInPorts(unsigned int num)
                                throw(std::runtime_error);

                        void start()
                                throw(std::runtime_error);
                        void stop()
                                throw(std::runtime_error);
                        void close()
                                throw(std::runtime_error);

                        unsigned int inPorts();
                        unsigned int outPorts();

                        virtual unsigned int addInPort(std::string name)
                                throw(std::runtime_error);
                        virtual unsigned int addOutPort(std::string name)
                                throw(std::runtime_error);

                        void connectTo(unsigned int index, std::string sourcePortName) 
                                throw(std::range_error, std::runtime_error);
                        void connectFrom(unsigned int index, std::string destPortName)
                                throw(std::range_error, std::runtime_error);
                        void connectToPhysical(unsigned int index, unsigned physical_index)
                                throw(std::range_error, std::runtime_error);
                        void connectFromPhysical(unsigned int index, unsigned physical_index)
                                throw(std::range_error, std::runtime_error);
                        void disconnectInPort(unsigned int index)
                                throw(std::range_error, std::runtime_error);
                        void disconnectOutPort(unsigned int index)
                                throw(std::range_error, std::runtime_error);

                        unsigned int numConnectionsInPort(unsigned int index)
                                throw(std::range_error);
                        unsigned int numConnectionsOutPort(unsigned int index)
                                throw(std::range_error);

                        unsigned int numPhysicalSourcePorts();
                        unsigned int numPhysicalDestinationPorts();

                        std::string getInputPortName(unsigned int index)
                                throw(std::range_error);
                        std::string getOutputPortName(unsigned int index)
                                throw(std::range_error);

                        virtual void jackShutdownCallback();
                        float getCpuLoad();
                        jack_nframes_t getSampleRate();
                        jack_nframes_t getBufferSize();
                        bool isRealTime(){return jack_is_realtime(mJackClient);}
                        std::string getName(){return std::string(jack_get_client_name(mJackClient));}
                        jack_state_t getState(){return mJackState;}

                        jack_nframes_t getFrameTime(){return jack_frame_time(mJackClient);}

                        jack_nframes_t getFramesSinceCycleStart(){return jack_frames_since_cycle_start(mJackClient);}
        };

}

#endif