jackringbuffer.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_RING_BUFFER_CLASS_H
#define JACK_RING_BUFFER_CLASS_H

#ifndef NULL
#define NULL 0
#endif

extern "C" {
#include <jack/ringbuffer.h>
}
#include <string.h>

namespace JackCpp {

template<typename Type>

        class RingBuffer {
                private:
                        jack_ringbuffer_t *mRingBufferPtr;
                        size_t mLength;
                public:
                        RingBuffer(size_t size, bool mlock = false){
                                mLength = size;
                                mRingBufferPtr = jack_ringbuffer_create(mLength * sizeof(Type));

                                //should we lock the memory for the ring buffer?
                                if(mlock)
                                        jack_ringbuffer_mlock(mRingBufferPtr);
                        }
                        ~RingBuffer(){
                                if(mRingBufferPtr != NULL)
                                        jack_ringbuffer_free(mRingBufferPtr);
                        }

                        size_t length(){
                                return mLength;
                        }

                        size_t getReadSpace(){ 
                                return jack_ringbuffer_read_space(mRingBufferPtr) / sizeof(Type);
                        }

                        size_t getWriteSpace(){
                                return jack_ringbuffer_write_space(mRingBufferPtr) / sizeof(Type);
                        }
                        
                        void read(Type &dest){
                                if(getReadSpace() <= 0){
                                        //throw error!!!!
                                        return;
                                }
                                jack_ringbuffer_read(mRingBufferPtr, (char *)&dest, sizeof(Type));
                        }

                        void read(Type *dest, unsigned cnt){
                                jack_ringbuffer_data_t readVec[2];
                                unsigned int read_size = sizeof(Type) * cnt;
                                if(getReadSpace() <= 0){
                                        //throw error!!!!
                                        return;
                                }

                                //get the readvector
                                jack_ringbuffer_get_read_vector(mRingBufferPtr, readVec);

                                //if the first vector has enough data then just read from there
                                if(readVec[0].len >= read_size){
                                        memcpy(dest, readVec[0].buf, read_size);
                                } else {
                                        //if the first vector is zero length then read from the second
                                        if(readVec[0].len == 0){
                                                memcpy(dest, readVec[1].buf, read_size);
                                        } else {
                                                //this gets tricky
                                                char * byterep = (char *)dest;
                                                //first read the data out of the first vector
                                                memcpy(byterep, readVec[0].buf, readVec[0].len);
                                                //then read the rest out of the second
                                                memcpy(byterep + readVec[0].len, readVec[1].buf, read_size - readVec[0].len);
                                        }
                                }
                                //advance the read pointer
                                jack_ringbuffer_read_advance(mRingBufferPtr, read_size);
                        }
                        
                        void write(Type src){
                                if(getWriteSpace() <= 0){
                                        //throw error!!!!
                                        return;
                                }
                                jack_ringbuffer_write(mRingBufferPtr, (char *)&src, sizeof(Type));
                        }

                        void write(Type *src, unsigned int cnt){
                                jack_ringbuffer_data_t writeVec[2];
                                unsigned int write_size = sizeof(Type) * cnt;
                                if(cnt > getWriteSpace()){
                                        //throw error!!!!
                                        return;
                                }

                                //get the write vector
                                jack_ringbuffer_get_write_vector(mRingBufferPtr, writeVec);
                                //if there is enough room in the first vector then just write there
                                if(writeVec[0].len >= write_size){
                                        memcpy(writeVec[0].buf,src,write_size);
                                } else {
                                        //if there is no room in the first vector then write into the second
                                        if(writeVec[0].len == 0){
                                                memcpy(writeVec[1].buf,src,write_size);
                                        } else {
                                                //this is more tricky, we have to split the data up
                                                char * byterep = (char *)src;
                                                //copy the first chunck
                                                memcpy(writeVec[0].buf, byterep, writeVec[0].len);
                                                //copy the second chunck
                                                memcpy(writeVec[1].buf, byterep + writeVec[0].len, write_size - writeVec[0].len);
                                        }
                                }
                                jack_ringbuffer_write_advance(mRingBufferPtr, write_size);
                        }

                        void reset(){
                                jack_ringbuffer_reset(mRingBufferPtr);
                        }
        };

}

#endif