AudibleT 0.0.1
A real-time A/B/X audio testing tool for subjective assessment of various audio parameters, compatible for general purpose computer as well as embedded systems.
Loading...
Searching...
No Matches
jackringbuffer.hpp
1//C++ Classes that wrap JACK
2//Copyright 2007 Alex Norman
3//
4//This file is part of JACKC++.
5//
6//JACKC++ is free software: you can redistribute it and/or modify
7//it under the terms of the GNU General Public License as published by
8//the Free Software Foundation, either version 3 of the License, or
9//(at your option) any later version.
10//
11//JACKC++ is distributed in the hope that it will be useful,
12//but WITHOUT ANY WARRANTY; without even the implied warranty of
13//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14//GNU General Public License for more details.
15//
16//You should have received a copy of the GNU General Public License
17//along with JACKC++. If not, see <http://www.gnu.org/licenses/>.
18
19#ifndef JACK_RING_BUFFER_CLASS_H
20#define JACK_RING_BUFFER_CLASS_H
21
22#ifndef NULL
23#define NULL 0
24#endif
25
26extern "C" {
27#include <jack/ringbuffer.h>
28}
29#include <string.h>
30
31namespace JackCpp {
32
33template<typename Type>
34
39 class RingBuffer {
40 private:
41 jack_ringbuffer_t *mRingBufferPtr;
42 size_t mLength;
43 bool isLocked;
44 public:
50 RingBuffer(size_t size, bool mlock = false){
51 mLength = size;
52 isLocked = mlock;
53 mRingBufferPtr = jack_ringbuffer_create(mLength * sizeof(Type));
54
55 //should we lock the memory for the ring buffer?
56 if(mlock)
57 jack_ringbuffer_mlock(mRingBufferPtr);
58 }
61 if(mRingBufferPtr != NULL)
62 jack_ringbuffer_free(mRingBufferPtr);
63 }
64
66 size_t length(){
67 return mLength;
68 }
69
72 return isLocked;
73 }
74
76 size_t getReadSpace(){
77 return jack_ringbuffer_read_space(mRingBufferPtr) / sizeof(Type);
78 }
79
81 size_t getWriteSpace(){
82 return jack_ringbuffer_write_space(mRingBufferPtr) / sizeof(Type);
83 }
84
92 void read(Type &dest){
93 if(getReadSpace() <= 0){
94 //throw error!!!!
95 return;
96 }
97 jack_ringbuffer_read(mRingBufferPtr, (char *)&dest, sizeof(Type));
98 }
99
108 void read(Type *dest, unsigned cnt){
109 jack_ringbuffer_data_t readVec[2];
110 unsigned int read_size = sizeof(Type) * cnt;
111 if(getReadSpace() <= 0){
112 //throw error!!!!
113 return;
114 }
115
116 //get the readvector
117 jack_ringbuffer_get_read_vector(mRingBufferPtr, readVec);
118
119 //if the first vector has enough data then just read from there
120 if(readVec[0].len >= read_size){
121 memcpy(dest, readVec[0].buf, read_size);
122 } else {
123 //if the first vector is zero length then read from the second
124 if(readVec[0].len == 0){
125 memcpy(dest, readVec[1].buf, read_size);
126 } else {
127 //this gets tricky
128 char * byterep = (char *)dest;
129 //first read the data out of the first vector
130 memcpy(byterep, readVec[0].buf, readVec[0].len);
131 //then read the rest out of the second
132 memcpy(byterep + readVec[0].len, readVec[1].buf, read_size - readVec[0].len);
133 }
134 }
135 //advance the read pointer
136 jack_ringbuffer_read_advance(mRingBufferPtr, read_size);
137 }
138
144 void write(Type src){
145 if(getWriteSpace() <= 0){
146 //throw error!!!!
147 return;
148 }
149 jack_ringbuffer_write(mRingBufferPtr, (char *)&src, sizeof(Type));
150 }
151
158 void write(Type *src, unsigned int cnt){
159 jack_ringbuffer_data_t writeVec[2];
160 unsigned int write_size = sizeof(Type) * cnt;
161 if(cnt > getWriteSpace()){
162 //throw error!!!!
163 return;
164 }
165
166 //get the write vector
167 jack_ringbuffer_get_write_vector(mRingBufferPtr, writeVec);
168 //if there is enough room in the first vector then just write there
169 if(writeVec[0].len >= write_size){
170 memcpy(writeVec[0].buf,src,write_size);
171 } else {
172 //if there is no room in the first vector then write into the second
173 if(writeVec[0].len == 0){
174 memcpy(writeVec[1].buf,src,write_size);
175 } else {
176 //this is more tricky, we have to split the data up
177 char * byterep = (char *)src;
178 //copy the first chunck
179 memcpy(writeVec[0].buf, byterep, writeVec[0].len);
180 //copy the second chunck
181 memcpy(writeVec[1].buf, byterep + writeVec[0].len, write_size - writeVec[0].len);
182 }
183 }
184 jack_ringbuffer_write_advance(mRingBufferPtr, write_size);
185 }
186
193 void reset(){
194 jack_ringbuffer_reset(mRingBufferPtr);
195 }
196 };
197
198}
199
200#endif
Definition: jackringbuffer.hpp:39
void reset()
Reset.
Definition: jackringbuffer.hpp:193
void read(Type *dest, unsigned cnt)
Read into an array.
Definition: jackringbuffer.hpp:108
size_t length()
Get the total length of the ring buffer.
Definition: jackringbuffer.hpp:66
size_t getReadSpace()
Get the number of items that can be read at this time.
Definition: jackringbuffer.hpp:76
RingBuffer(size_t size, bool mlock=false)
The Constructor.
Definition: jackringbuffer.hpp:50
void write(Type *src, unsigned int cnt)
Write an array of values into the ring buffer.
Definition: jackringbuffer.hpp:158
void write(Type src)
Write into the ring buffer.
Definition: jackringbuffer.hpp:144
size_t getWriteSpace()
Get the number of items that can be written at this time.
Definition: jackringbuffer.hpp:81
~RingBuffer()
The Destructor.
Definition: jackringbuffer.hpp:60
void read(Type &dest)
Read into dest.
Definition: jackringbuffer.hpp:92
bool isBufferMemoryLocked()
Get whether the ring buffer is locked into the memory.
Definition: jackringbuffer.hpp:71