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
26 #include "ringbuffer.h"
34 /* NOTE: This lockless ringbuffer implementation is copied from JACK, extended
35 * to include an element size. Consequently, parameters and return values for a
36 * size or count is in 'elements', not bytes. Additionally, it only supports
37 * single-consumer/single-provider operation. */
38 struct ll_ringbuffer
{
39 ATOMIC(size_t) write_ptr
;
40 ATOMIC(size_t) read_ptr
;
45 alignas(16) char buf
[];
48 /* Create a new ringbuffer to hold at least `sz' elements of `elem_sz' bytes.
49 * The number of elements is rounded up to the next power of two. */
50 ll_ringbuffer_t
*ll_ringbuffer_create(size_t sz
, size_t elem_sz
)
53 size_t power_of_two
= 0;
57 power_of_two
= sz
- 1;
58 power_of_two
|= power_of_two
>>1;
59 power_of_two
|= power_of_two
>>2;
60 power_of_two
|= power_of_two
>>4;
61 power_of_two
|= power_of_two
>>8;
62 power_of_two
|= power_of_two
>>16;
63 #if SIZE_MAX > UINT_MAX
64 power_of_two
|= power_of_two
>>32;
68 if(power_of_two
< sz
) return NULL
;
70 rb
= al_malloc(16, sizeof(*rb
) + power_of_two
*elem_sz
);
73 ATOMIC_INIT(&rb
->write_ptr
, 0);
74 ATOMIC_INIT(&rb
->read_ptr
, 0);
75 rb
->size
= power_of_two
;
76 rb
->size_mask
= rb
->size
- 1;
77 rb
->elem_size
= elem_sz
;
81 /* Free all data associated with the ringbuffer `rb'. */
82 void ll_ringbuffer_free(ll_ringbuffer_t
*rb
)
87 /* Reset the read and write pointers to zero. This is not thread safe. */
88 void ll_ringbuffer_reset(ll_ringbuffer_t
*rb
)
90 ATOMIC_STORE(&rb
->write_ptr
, 0, almemory_order_release
);
91 ATOMIC_STORE(&rb
->read_ptr
, 0, almemory_order_release
);
92 memset(rb
->buf
, 0, rb
->size
*rb
->elem_size
);
95 /* Return the number of elements available for reading. This is the number of
96 * elements in front of the read pointer and behind the write pointer. */
97 size_t ll_ringbuffer_read_space(const ll_ringbuffer_t
*rb
)
99 size_t w
= ATOMIC_LOAD(&CONST_CAST(ll_ringbuffer_t
*,rb
)->write_ptr
, almemory_order_acquire
);
100 size_t r
= ATOMIC_LOAD(&CONST_CAST(ll_ringbuffer_t
*,rb
)->read_ptr
, almemory_order_acquire
);
101 return (w
-r
) & rb
->size_mask
;
103 /* Return the number of elements available for writing. This is the number of
104 * elements in front of the write pointer and behind the read pointer. */
105 size_t ll_ringbuffer_write_space(const ll_ringbuffer_t
*rb
)
107 size_t w
= ATOMIC_LOAD(&CONST_CAST(ll_ringbuffer_t
*,rb
)->write_ptr
, almemory_order_acquire
);
108 size_t r
= ATOMIC_LOAD(&CONST_CAST(ll_ringbuffer_t
*,rb
)->read_ptr
, almemory_order_acquire
);
109 return (r
-w
-1) & rb
->size_mask
;
112 /* The copying data reader. Copy at most `cnt' elements from `rb' to `dest'.
113 * Returns the actual number of elements copied. */
114 size_t ll_ringbuffer_read(ll_ringbuffer_t
*rb
, char *dest
, size_t cnt
)
122 free_cnt
= ll_ringbuffer_read_space(rb
);
123 if(free_cnt
== 0) return 0;
125 to_read
= (cnt
> free_cnt
) ? free_cnt
: cnt
;
126 read_ptr
= ATOMIC_LOAD(&rb
->read_ptr
, almemory_order_relaxed
) & rb
->size_mask
;
128 cnt2
= read_ptr
+ to_read
;
131 n1
= rb
->size
- read_ptr
;
132 n2
= cnt2
& rb
->size_mask
;
140 memcpy(dest
, &rb
->buf
[read_ptr
*rb
->elem_size
], n1
*rb
->elem_size
);
144 memcpy(dest
+ n1
*rb
->elem_size
, &rb
->buf
[(read_ptr
&rb
->size_mask
)*rb
->elem_size
],
148 ATOMIC_STORE(&rb
->read_ptr
, read_ptr
, almemory_order_release
);
152 /* The copying data reader w/o read pointer advance. Copy at most `cnt'
153 * elements from `rb' to `dest'. Returns the actual number of elements copied.
155 size_t ll_ringbuffer_peek(ll_ringbuffer_t
*rb
, char *dest
, size_t cnt
)
163 free_cnt
= ll_ringbuffer_read_space(rb
);
164 if(free_cnt
== 0) return 0;
166 to_read
= (cnt
> free_cnt
) ? free_cnt
: cnt
;
167 read_ptr
= ATOMIC_LOAD(&rb
->read_ptr
, almemory_order_relaxed
) & rb
->size_mask
;
169 cnt2
= read_ptr
+ to_read
;
172 n1
= rb
->size
- read_ptr
;
173 n2
= cnt2
& rb
->size_mask
;
181 memcpy(dest
, &rb
->buf
[read_ptr
*rb
->elem_size
], n1
*rb
->elem_size
);
185 memcpy(dest
+ n1
*rb
->elem_size
, &rb
->buf
[(read_ptr
&rb
->size_mask
)*rb
->elem_size
],
191 /* The copying data writer. Copy at most `cnt' elements to `rb' from `src'.
192 * Returns the actual number of elements copied. */
193 size_t ll_ringbuffer_write(ll_ringbuffer_t
*rb
, const char *src
, size_t cnt
)
201 free_cnt
= ll_ringbuffer_write_space(rb
);
202 if(free_cnt
== 0) return 0;
204 to_write
= (cnt
> free_cnt
) ? free_cnt
: cnt
;
205 write_ptr
= ATOMIC_LOAD(&rb
->write_ptr
, almemory_order_relaxed
) & rb
->size_mask
;
207 cnt2
= write_ptr
+ to_write
;
210 n1
= rb
->size
- write_ptr
;
211 n2
= cnt2
& rb
->size_mask
;
219 memcpy(&rb
->buf
[write_ptr
*rb
->elem_size
], src
, n1
*rb
->elem_size
);
223 memcpy(&rb
->buf
[(write_ptr
&rb
->size_mask
)*rb
->elem_size
], src
+ n1
*rb
->elem_size
,
227 ATOMIC_STORE(&rb
->write_ptr
, write_ptr
, almemory_order_release
);
231 /* Advance the read pointer `cnt' places. */
232 void ll_ringbuffer_read_advance(ll_ringbuffer_t
*rb
, size_t cnt
)
234 ATOMIC_ADD(&rb
->read_ptr
, cnt
, almemory_order_acq_rel
);
237 /* Advance the write pointer `cnt' places. */
238 void ll_ringbuffer_write_advance(ll_ringbuffer_t
*rb
, size_t cnt
)
240 ATOMIC_ADD(&rb
->write_ptr
, cnt
, almemory_order_acq_rel
);
243 /* The non-copying data reader. `vec' is an array of two places. Set the values
244 * at `vec' to hold the current readable data at `rb'. If the readable data is
245 * in one segment the second segment has zero length. */
246 void ll_ringbuffer_get_read_vector(const ll_ringbuffer_t
*rb
, ll_ringbuffer_data_t
* vec
)
252 w
= ATOMIC_LOAD(&CONST_CAST(ll_ringbuffer_t
*,rb
)->write_ptr
, almemory_order_acquire
);
253 r
= ATOMIC_LOAD(&CONST_CAST(ll_ringbuffer_t
*,rb
)->read_ptr
, almemory_order_acquire
);
256 free_cnt
= (w
-r
) & rb
->size_mask
;
261 /* Two part vector: the rest of the buffer after the current write ptr,
262 * plus some from the start of the buffer. */
263 vec
[0].buf
= (char*)&rb
->buf
[r
*rb
->elem_size
];
264 vec
[0].len
= rb
->size
- r
;
265 vec
[1].buf
= (char*)rb
->buf
;
266 vec
[1].len
= cnt2
& rb
->size_mask
;
270 /* Single part vector: just the rest of the buffer */
271 vec
[0].buf
= (char*)&rb
->buf
[r
*rb
->elem_size
];
272 vec
[0].len
= free_cnt
;
278 /* The non-copying data writer. `vec' is an array of two places. Set the values
279 * at `vec' to hold the current writeable data at `rb'. If the writeable data
280 * is in one segment the second segment has zero length. */
281 void ll_ringbuffer_get_write_vector(const ll_ringbuffer_t
*rb
, ll_ringbuffer_data_t
*vec
)
287 w
= ATOMIC_LOAD(&CONST_CAST(ll_ringbuffer_t
*,rb
)->write_ptr
, almemory_order_acquire
);
288 r
= ATOMIC_LOAD(&CONST_CAST(ll_ringbuffer_t
*,rb
)->read_ptr
, almemory_order_acquire
);
291 free_cnt
= (r
-w
-1) & rb
->size_mask
;
296 /* Two part vector: the rest of the buffer after the current write ptr,
297 * plus some from the start of the buffer. */
298 vec
[0].buf
= (char*)&rb
->buf
[w
*rb
->elem_size
];
299 vec
[0].len
= rb
->size
- w
;
300 vec
[1].buf
= (char*)rb
->buf
;
301 vec
[1].len
= cnt2
& rb
->size_mask
;
305 vec
[0].buf
= (char*)&rb
->buf
[w
*rb
->elem_size
];
306 vec
[0].len
= free_cnt
;