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
27 #include "ringbuffer.h"
35 /* NOTE: This lockless ringbuffer implementation is copied from JACK, extended
36 * to include an element size. Consequently, parameters and return values for a
37 * size or count is in 'elements', not bytes. Additionally, it only supports
38 * single-consumer/single-provider operation. */
39 struct ll_ringbuffer
{
40 ATOMIC(size_t) write_ptr
;
41 ATOMIC(size_t) read_ptr
;
46 alignas(16) char buf
[];
49 /* Create a new ringbuffer to hold at least `sz' elements of `elem_sz' bytes.
50 * The number of elements is rounded up to the next power of two. */
51 ll_ringbuffer_t
*ll_ringbuffer_create(size_t sz
, size_t elem_sz
)
54 size_t power_of_two
= 0;
58 power_of_two
= sz
- 1;
59 power_of_two
|= power_of_two
>>1;
60 power_of_two
|= power_of_two
>>2;
61 power_of_two
|= power_of_two
>>4;
62 power_of_two
|= power_of_two
>>8;
63 power_of_two
|= power_of_two
>>16;
64 #if SIZE_MAX > UINT_MAX
65 power_of_two
|= power_of_two
>>32;
69 if(power_of_two
< sz
) return NULL
;
71 rb
= al_malloc(16, sizeof(*rb
) + power_of_two
*elem_sz
);
74 ATOMIC_INIT(&rb
->write_ptr
, 0);
75 ATOMIC_INIT(&rb
->read_ptr
, 0);
76 rb
->size
= power_of_two
;
77 rb
->size_mask
= rb
->size
- 1;
78 rb
->elem_size
= elem_sz
;
82 /* Free all data associated with the ringbuffer `rb'. */
83 void ll_ringbuffer_free(ll_ringbuffer_t
*rb
)
88 /* Reset the read and write pointers to zero. This is not thread safe. */
89 void ll_ringbuffer_reset(ll_ringbuffer_t
*rb
)
91 ATOMIC_STORE(&rb
->write_ptr
, 0, almemory_order_release
);
92 ATOMIC_STORE(&rb
->read_ptr
, 0, almemory_order_release
);
93 memset(rb
->buf
, 0, rb
->size
*rb
->elem_size
);
96 /* Return the number of elements available for reading. This is the number of
97 * elements in front of the read pointer and behind the write pointer. */
98 size_t ll_ringbuffer_read_space(const ll_ringbuffer_t
*rb
)
100 size_t w
= ATOMIC_LOAD(&CONST_CAST(ll_ringbuffer_t
*,rb
)->write_ptr
, almemory_order_acquire
);
101 size_t r
= ATOMIC_LOAD(&CONST_CAST(ll_ringbuffer_t
*,rb
)->read_ptr
, almemory_order_acquire
);
102 return (w
-r
) & rb
->size_mask
;
104 /* Return the number of elements available for writing. This is the number of
105 * elements in front of the write pointer and behind the read pointer. */
106 size_t ll_ringbuffer_write_space(const ll_ringbuffer_t
*rb
)
108 size_t w
= ATOMIC_LOAD(&CONST_CAST(ll_ringbuffer_t
*,rb
)->write_ptr
, almemory_order_acquire
);
109 size_t r
= ATOMIC_LOAD(&CONST_CAST(ll_ringbuffer_t
*,rb
)->read_ptr
, almemory_order_acquire
);
110 return (r
-w
-1) & rb
->size_mask
;
113 /* The copying data reader. Copy at most `cnt' elements from `rb' to `dest'.
114 * Returns the actual number of elements copied. */
115 size_t ll_ringbuffer_read(ll_ringbuffer_t
*rb
, char *dest
, size_t cnt
)
123 free_cnt
= ll_ringbuffer_read_space(rb
);
124 if(free_cnt
== 0) return 0;
126 to_read
= (cnt
> free_cnt
) ? free_cnt
: cnt
;
127 read_ptr
= ATOMIC_LOAD(&rb
->read_ptr
, almemory_order_relaxed
) & rb
->size_mask
;
129 cnt2
= read_ptr
+ to_read
;
132 n1
= rb
->size
- read_ptr
;
133 n2
= cnt2
& rb
->size_mask
;
141 memcpy(dest
, &rb
->buf
[read_ptr
*rb
->elem_size
], n1
*rb
->elem_size
);
145 memcpy(dest
+ n1
*rb
->elem_size
, &rb
->buf
[(read_ptr
&rb
->size_mask
)*rb
->elem_size
],
149 ATOMIC_STORE(&rb
->read_ptr
, read_ptr
, almemory_order_release
);
153 /* The copying data reader w/o read pointer advance. Copy at most `cnt'
154 * elements from `rb' to `dest'. Returns the actual number of elements copied.
156 size_t ll_ringbuffer_peek(ll_ringbuffer_t
*rb
, char *dest
, size_t cnt
)
164 free_cnt
= ll_ringbuffer_read_space(rb
);
165 if(free_cnt
== 0) return 0;
167 to_read
= (cnt
> free_cnt
) ? free_cnt
: cnt
;
168 read_ptr
= ATOMIC_LOAD(&rb
->read_ptr
, almemory_order_relaxed
) & rb
->size_mask
;
170 cnt2
= read_ptr
+ to_read
;
173 n1
= rb
->size
- read_ptr
;
174 n2
= cnt2
& rb
->size_mask
;
182 memcpy(dest
, &rb
->buf
[read_ptr
*rb
->elem_size
], n1
*rb
->elem_size
);
186 memcpy(dest
+ n1
*rb
->elem_size
, &rb
->buf
[(read_ptr
&rb
->size_mask
)*rb
->elem_size
],
192 /* The copying data writer. Copy at most `cnt' elements to `rb' from `src'.
193 * Returns the actual number of elements copied. */
194 size_t ll_ringbuffer_write(ll_ringbuffer_t
*rb
, const char *src
, size_t cnt
)
202 free_cnt
= ll_ringbuffer_write_space(rb
);
203 if(free_cnt
== 0) return 0;
205 to_write
= (cnt
> free_cnt
) ? free_cnt
: cnt
;
206 write_ptr
= ATOMIC_LOAD(&rb
->write_ptr
, almemory_order_relaxed
) & rb
->size_mask
;
208 cnt2
= write_ptr
+ to_write
;
211 n1
= rb
->size
- write_ptr
;
212 n2
= cnt2
& rb
->size_mask
;
220 memcpy(&rb
->buf
[write_ptr
*rb
->elem_size
], src
, n1
*rb
->elem_size
);
224 memcpy(&rb
->buf
[(write_ptr
&rb
->size_mask
)*rb
->elem_size
], src
+ n1
*rb
->elem_size
,
228 ATOMIC_STORE(&rb
->write_ptr
, write_ptr
, almemory_order_release
);
232 /* Advance the read pointer `cnt' places. */
233 void ll_ringbuffer_read_advance(ll_ringbuffer_t
*rb
, size_t cnt
)
235 ATOMIC_ADD(&rb
->read_ptr
, cnt
, almemory_order_acq_rel
);
238 /* Advance the write pointer `cnt' places. */
239 void ll_ringbuffer_write_advance(ll_ringbuffer_t
*rb
, size_t cnt
)
241 ATOMIC_ADD(&rb
->write_ptr
, cnt
, almemory_order_acq_rel
);
244 /* The non-copying data reader. `vec' is an array of two places. Set the values
245 * at `vec' to hold the current readable data at `rb'. If the readable data is
246 * in one segment the second segment has zero length. */
247 void ll_ringbuffer_get_read_vector(const ll_ringbuffer_t
*rb
, ll_ringbuffer_data_t
* vec
)
253 w
= ATOMIC_LOAD(&CONST_CAST(ll_ringbuffer_t
*,rb
)->write_ptr
, almemory_order_acquire
);
254 r
= ATOMIC_LOAD(&CONST_CAST(ll_ringbuffer_t
*,rb
)->read_ptr
, almemory_order_acquire
);
257 free_cnt
= (w
-r
) & rb
->size_mask
;
262 /* Two part vector: the rest of the buffer after the current write ptr,
263 * plus some from the start of the buffer. */
264 vec
[0].buf
= (char*)&rb
->buf
[r
*rb
->elem_size
];
265 vec
[0].len
= rb
->size
- r
;
266 vec
[1].buf
= (char*)rb
->buf
;
267 vec
[1].len
= cnt2
& rb
->size_mask
;
271 /* Single part vector: just the rest of the buffer */
272 vec
[0].buf
= (char*)&rb
->buf
[r
*rb
->elem_size
];
273 vec
[0].len
= free_cnt
;
279 /* The non-copying data writer. `vec' is an array of two places. Set the values
280 * at `vec' to hold the current writeable data at `rb'. If the writeable data
281 * is in one segment the second segment has zero length. */
282 void ll_ringbuffer_get_write_vector(const ll_ringbuffer_t
*rb
, ll_ringbuffer_data_t
*vec
)
288 w
= ATOMIC_LOAD(&CONST_CAST(ll_ringbuffer_t
*,rb
)->write_ptr
, almemory_order_acquire
);
289 r
= ATOMIC_LOAD(&CONST_CAST(ll_ringbuffer_t
*,rb
)->read_ptr
, almemory_order_acquire
);
292 free_cnt
= (r
-w
-1) & rb
->size_mask
;
297 /* Two part vector: the rest of the buffer after the current write ptr,
298 * plus some from the start of the buffer. */
299 vec
[0].buf
= (char*)&rb
->buf
[w
*rb
->elem_size
];
300 vec
[0].len
= rb
->size
- w
;
301 vec
[1].buf
= (char*)rb
->buf
;
302 vec
[1].len
= cnt2
& rb
->size_mask
;
306 vec
[0].buf
= (char*)&rb
->buf
[w
*rb
->elem_size
];
307 vec
[0].len
= free_cnt
;