jackblockingaudioio.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_BLOCKING_AUDIO_IO_HPP
#define JACK_BLOCKING_AUDIO_IO_HPP

#include "jackaudioio.hpp"
#include "jackringbuffer.hpp"

namespace JackCpp {

        class BlockingAudioIO : public AudioIO {
                public:
                        BlockingAudioIO(std::string name, 
                                        unsigned int inChans = 2, unsigned int outChans = 2,
                                        unsigned int inBufSize = 0, unsigned int outBufSize = 0,
#ifdef __APPLE__
                                        bool startServer = false)
#else
                                        bool startServer = true)
#endif
                                        throw(std::runtime_error);
                        virtual ~BlockingAudioIO();

                        void write(unsigned int channel, jack_default_audio_sample_t val);

                        bool tryWrite(unsigned int channel, jack_default_audio_sample_t val);

                        jack_default_audio_sample_t read(unsigned int channel);

                        bool tryRead(unsigned int channel, jack_default_audio_sample_t &val);

                        //XXX reserve exists but is basically useless as you cannot
                        //add ports while the client is active
                        virtual void reserveOutPorts(unsigned int num)
                                throw(std::runtime_error);
                        virtual void reserveInPorts(unsigned int num)
                                throw(std::runtime_error);

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

                protected:
                        virtual int audioCallback(jack_nframes_t nframes, 
                                        std::vector<jack_default_audio_sample_t *> inBufs,
                                        std::vector<jack_default_audio_sample_t *> outBufs);
                private:
                        std::vector<RingBuffer<jack_default_audio_sample_t> *> mUserOutBuff;
                        std::vector<RingBuffer<jack_default_audio_sample_t> *> mUserInBuff;

                        //this is the size of the ring buffers that we alloc
                        const unsigned int mOutputBufferMaxSize;
                        const unsigned int mInputBufferMaxSize;
                        //this is the amount of free space we leave in the ring buffers
                        //this can decrease so that we'll have more latency but fewer glitches
                        unsigned int mOutputBufferFreeSize;
                        unsigned int mInputBufferFreeSize;
        };
}
#endif