2 * OpenAL cross platform audio library
3 * Copyright (C) 1999-2007 by authors.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 * Or go to http://www.gnu.org/copyleft/lgpl.html
32 /* NOTE: This lockless ringbuffer implementation is copied from JACK, extended
33 * to include an element size. Consequently, parameters and return values for a
34 * size or count is in 'elements', not bytes. Additionally, it only supports
35 * single-consumer/single-provider operation. */
36 struct ll_ringbuffer
{
37 volatile size_t write_ptr
;
38 volatile size_t read_ptr
;
44 alignas(16) char buf
[];
47 /* Create a new ringbuffer to hold at least `sz' elements of `elem_sz' bytes.
48 * The number of elements is rounded up to the next power of two. */
49 ll_ringbuffer_t
*ll_ringbuffer_create(size_t sz
, size_t elem_sz
)
54 power_of_two
= NextPowerOf2(sz
);
58 rb
= al_malloc(16, sizeof(*rb
) + power_of_two
*elem_sz
);
61 rb
->size
= power_of_two
;
62 rb
->size_mask
= rb
->size
- 1;
63 rb
->elem_size
= elem_sz
;
70 /* Free all data associated with the ringbuffer `rb'. */
71 void ll_ringbuffer_free(ll_ringbuffer_t
*rb
)
77 munlock(rb
, sizeof(*rb
) + rb
->size
*rb
->elem_size
);
78 #endif /* USE_MLOCK */
83 /* Lock the data block of `rb' using the system call 'mlock'. */
84 int ll_ringbuffer_mlock(ll_ringbuffer_t
*rb
)
87 if(!rb
->locked
&& mlock(rb
, sizeof(*rb
) + rb
->size
*rb
->elem_size
))
89 #endif /* USE_MLOCK */
94 /* Reset the read and write pointers to zero. This is not thread safe. */
95 void ll_ringbuffer_reset(ll_ringbuffer_t
*rb
)
99 memset(rb
->buf
, 0, rb
->size
*rb
->elem_size
);
102 /* Return the number of elements available for reading. This is the number of
103 * elements in front of the read pointer and behind the write pointer. */
104 size_t ll_ringbuffer_read_space(const ll_ringbuffer_t
*rb
)
106 size_t w
= rb
->write_ptr
;
107 size_t r
= rb
->read_ptr
;
108 return (rb
->size
+w
-r
) & rb
->size_mask
;
110 /* Return the number of elements available for writing. This is the number of
111 * elements in front of the write pointer and behind the read pointer. */
112 size_t ll_ringbuffer_write_space(const ll_ringbuffer_t
*rb
)
114 size_t w
= rb
->write_ptr
;
115 size_t r
= rb
->read_ptr
;
116 return (rb
->size
+r
-w
-1) & rb
->size_mask
;
119 /* The copying data reader. Copy at most `cnt' elements from `rb' to `dest'.
120 * Returns the actual number of elements copied. */
121 size_t ll_ringbuffer_read(ll_ringbuffer_t
*rb
, char *dest
, size_t cnt
)
128 free_cnt
= ll_ringbuffer_read_space(rb
);
129 if(free_cnt
== 0) return 0;
131 to_read
= (cnt
> free_cnt
) ? free_cnt
: cnt
;
132 cnt2
= rb
->read_ptr
+ to_read
;
135 n1
= rb
->size
- rb
->read_ptr
;
136 n2
= cnt2
& rb
->size_mask
;
144 memcpy(dest
, &(rb
->buf
[rb
->read_ptr
*rb
->elem_size
]), n1
*rb
->elem_size
);
145 rb
->read_ptr
= (rb
->read_ptr
+ n1
) & rb
->size_mask
;
148 memcpy(dest
+ n1
*rb
->elem_size
, &(rb
->buf
[rb
->read_ptr
*rb
->elem_size
]), n2
*rb
->elem_size
);
149 rb
->read_ptr
= (rb
->read_ptr
+ n2
) & rb
->size_mask
;
154 /* The copying data reader w/o read pointer advance. Copy at most `cnt'
155 * elements from `rb' to `dest'. Returns the actual number of elements copied.
157 size_t ll_ringbuffer_peek(ll_ringbuffer_t
*rb
, char *dest
, size_t cnt
)
165 tmp_read_ptr
= rb
->read_ptr
;
166 free_cnt
= ll_ringbuffer_read_space(rb
);
167 if(free_cnt
== 0) return 0;
169 to_read
= (cnt
> free_cnt
) ? free_cnt
: cnt
;
170 cnt2
= tmp_read_ptr
+ to_read
;
173 n1
= rb
->size
- tmp_read_ptr
;
174 n2
= cnt2
& rb
->size_mask
;
182 memcpy(dest
, &(rb
->buf
[tmp_read_ptr
*rb
->elem_size
]), n1
*rb
->elem_size
);
183 tmp_read_ptr
= (tmp_read_ptr
+ n1
) & rb
->size_mask
;
185 memcpy(dest
+ n1
*rb
->elem_size
, &(rb
->buf
[tmp_read_ptr
*rb
->elem_size
]), n2
*rb
->elem_size
);
189 /* The copying data writer. Copy at most `cnt' elements to `rb' from `src'.
190 * Returns the actual number of elements copied. */
191 size_t ll_ringbuffer_write(ll_ringbuffer_t
*rb
, const char *src
, size_t cnt
)
198 free_cnt
= ll_ringbuffer_write_space(rb
);
199 if(free_cnt
== 0) return 0;
201 to_write
= (cnt
> free_cnt
) ? free_cnt
: cnt
;
202 cnt2
= rb
->write_ptr
+ to_write
;
205 n1
= rb
->size
- rb
->write_ptr
;
206 n2
= cnt2
& rb
->size_mask
;
214 memcpy(&(rb
->buf
[rb
->write_ptr
*rb
->elem_size
]), src
, n1
*rb
->elem_size
);
215 rb
->write_ptr
= (rb
->write_ptr
+ n1
) & rb
->size_mask
;
218 memcpy(&(rb
->buf
[rb
->write_ptr
*rb
->elem_size
]), src
+ n1
*rb
->elem_size
, n2
*rb
->elem_size
);
219 rb
->write_ptr
= (rb
->write_ptr
+ n2
) & rb
->size_mask
;
224 /* Advance the read pointer `cnt' places. */
225 void ll_ringbuffer_read_advance(ll_ringbuffer_t
*rb
, size_t cnt
)
227 size_t tmp
= (rb
->read_ptr
+ cnt
) & rb
->size_mask
;
231 /* Advance the write pointer `cnt' places. */
232 void ll_ringbuffer_write_advance(ll_ringbuffer_t
*rb
, size_t cnt
)
234 size_t tmp
= (rb
->write_ptr
+ cnt
) & rb
->size_mask
;
238 /* The non-copying data reader. `vec' is an array of two places. Set the values
239 * at `vec' to hold the current readable data at `rb'. If the readable data is
240 * in one segment the second segment has zero length. */
241 void ll_ringbuffer_get_read_vector(const ll_ringbuffer_t
*rb
, ll_ringbuffer_data_t
* vec
)
249 free_cnt
= (rb
->size
+w
-r
) & rb
->size_mask
;
254 /* Two part vector: the rest of the buffer after the current write ptr,
255 * plus some from the start of the buffer. */
256 vec
[0].buf
= (char*)&(rb
->buf
[r
*rb
->elem_size
]);
257 vec
[0].len
= rb
->size
- r
;
258 vec
[1].buf
= (char*)rb
->buf
;
259 vec
[1].len
= cnt2
& rb
->size_mask
;
263 /* Single part vector: just the rest of the buffer */
264 vec
[0].buf
= (char*)&(rb
->buf
[r
*rb
->elem_size
]);
265 vec
[0].len
= free_cnt
;
271 /* The non-copying data writer. `vec' is an array of two places. Set the values
272 * at `vec' to hold the current writeable data at `rb'. If the writeable data
273 * is in one segment the second segment has zero length. */
274 void ll_ringbuffer_get_write_vector(const ll_ringbuffer_t
*rb
, ll_ringbuffer_data_t
*vec
)
282 free_cnt
= (rb
->size
+r
-w
-1) & rb
->size_mask
;
287 /* Two part vector: the rest of the buffer after the current write ptr,
288 * plus some from the start of the buffer. */
289 vec
[0].buf
= (char*)&(rb
->buf
[w
*rb
->elem_size
]);
290 vec
[0].len
= rb
->size
- w
;
291 vec
[1].buf
= (char*)rb
->buf
;
292 vec
[1].len
= cnt2
& rb
->size_mask
;
296 vec
[0].buf
= (char*)&(rb
->buf
[w
*rb
->elem_size
]);
297 vec
[0].len
= free_cnt
;