← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/jamin/jaunty

« back to all changes in this revision

Viewing changes to src/ringbuffer.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Jordens
  • Date: 2005-03-24 17:08:30 UTC
  • mfrom: (1.2.1 upstream) (2.1.1 hoary)
  • Revision ID: james.westby@ubuntu.com-20050324170830-3efg06mxys3gl55s
Tags: 0.9.0+0.95.0rc2-1
new upstream prerelease

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/ringbuffer.c
20
20
  This is safe for the case of one read thread and one write thread.
21
21
*/
22
22
 
 
23
/*
 
24
 * This entire module is a fallback for use when running with an older
 
25
 * version of JACK without ringbuffer support built-in.
 
26
 */
 
27
#include <config.h>
 
28
#ifndef HAVE_JACK_RINGBUFFER
 
29
 
23
30
#include <stdlib.h>
24
31
#include <string.h>
25
32
#include <sys/mman.h>
28
35
/* Create a new ringbuffer to hold at least `sz' bytes of data. The
29
36
   actual buffer size is rounded up to the next power of two.  */
30
37
 
31
 
ringbuffer_t *
32
 
ringbuffer_create (int sz)
 
38
jack_ringbuffer_t *
 
39
jack_ringbuffer_create (size_t sz)
33
40
{
34
41
  int power_of_two;
35
 
  ringbuffer_t *rb;
 
42
  jack_ringbuffer_t *rb;
36
43
 
37
 
  rb = malloc (sizeof (ringbuffer_t));
 
44
  rb = malloc (sizeof (jack_ringbuffer_t));
38
45
 
39
46
  for (power_of_two = 1; 1 << power_of_two < sz; power_of_two++);
40
47
 
52
59
/* Free all data associated with the ringbuffer `rb'. */
53
60
 
54
61
void
55
 
ringbuffer_free (ringbuffer_t * rb)
 
62
jack_ringbuffer_free (jack_ringbuffer_t * rb)
56
63
{
57
64
  if (rb->mlocked) {
58
65
    munlock (rb->buf, rb->size);
63
70
/* Lock the data block of `rb' using the system call 'mlock'.  */
64
71
 
65
72
int
66
 
ringbuffer_mlock (ringbuffer_t * rb)
 
73
jack_ringbuffer_mlock (jack_ringbuffer_t * rb)
67
74
{
68
75
  if (mlock (rb->buf, rb->size)) {
69
76
    return -1;
76
83
   safe. */
77
84
 
78
85
void
79
 
ringbuffer_reset (ringbuffer_t * rb)
 
86
jack_ringbuffer_reset (jack_ringbuffer_t * rb)
80
87
{
81
88
  rb->read_ptr = 0;
82
89
  rb->write_ptr = 0;
87
94
   pointer.  */
88
95
 
89
96
size_t
90
 
ringbuffer_read_space (ringbuffer_t * rb)
 
97
jack_ringbuffer_read_space (const jack_ringbuffer_t * rb)
91
98
{
92
99
  size_t w, r;
93
100
 
106
113
   pointer.  */
107
114
 
108
115
size_t
109
 
ringbuffer_write_space (ringbuffer_t * rb)
 
116
jack_ringbuffer_write_space (const jack_ringbuffer_t * rb)
110
117
{
111
118
  size_t w, r;
112
119
 
126
133
   `dest'.  Returns the actual number of bytes copied. */
127
134
 
128
135
size_t
129
 
ringbuffer_read (ringbuffer_t * rb, char *dest, size_t cnt)
 
136
jack_ringbuffer_read (jack_ringbuffer_t * rb, char *dest, size_t cnt)
130
137
{
131
138
  size_t free_cnt;
132
139
  size_t cnt2;
133
140
  size_t to_read;
134
141
  size_t n1, n2;
135
142
 
136
 
  if ((free_cnt = ringbuffer_read_space (rb)) == 0) {
 
143
  if ((free_cnt = jack_ringbuffer_read_space (rb)) == 0) {
137
144
    return 0;
138
145
  }
139
146
 
166
173
   `src'.  Returns the actual number of bytes copied. */
167
174
 
168
175
size_t
169
 
ringbuffer_write (ringbuffer_t * rb, char *src, size_t cnt)
 
176
jack_ringbuffer_write (jack_ringbuffer_t * rb, const char *src, size_t cnt)
170
177
{
171
178
  size_t free_cnt;
172
179
  size_t cnt2;
173
180
  size_t to_write;
174
181
  size_t n1, n2;
175
182
 
176
 
  if ((free_cnt = ringbuffer_write_space (rb)) == 0) {
 
183
  if ((free_cnt = jack_ringbuffer_write_space (rb)) == 0) {
177
184
    return 0;
178
185
  }
179
186
 
205
212
/* Advance the read pointer `cnt' places. */
206
213
 
207
214
void
208
 
ringbuffer_read_advance (ringbuffer_t * rb, size_t cnt)
 
215
jack_ringbuffer_read_advance (jack_ringbuffer_t * rb, size_t cnt)
209
216
{
210
217
  rb->read_ptr += cnt;
211
218
  rb->read_ptr &= rb->size_mask;
214
221
/* Advance the write pointer `cnt' places. */
215
222
 
216
223
void
217
 
ringbuffer_write_advance (ringbuffer_t * rb, size_t cnt)
 
224
jack_ringbuffer_write_advance (jack_ringbuffer_t * rb, size_t cnt)
218
225
{
219
226
  rb->write_ptr += cnt;
220
227
  rb->write_ptr &= rb->size_mask;
226
233
   length.  */
227
234
 
228
235
void
229
 
ringbuffer_get_read_vector (ringbuffer_t * rb,
230
 
                            ringbuffer_data_t * vec)
 
236
jack_ringbuffer_get_read_vector (const jack_ringbuffer_t * rb,
 
237
                                 jack_ringbuffer_data_t * vec)
231
238
{
232
239
  size_t free_cnt;
233
240
  size_t cnt2;
270
277
   length.  */
271
278
 
272
279
void
273
 
ringbuffer_get_write_vector (ringbuffer_t * rb,
274
 
                             ringbuffer_data_t * vec)
 
280
jack_ringbuffer_get_write_vector (const jack_ringbuffer_t * rb,
 
281
                                  jack_ringbuffer_data_t * vec)
275
282
{
276
283
  size_t free_cnt;
277
284
  size_t cnt2;
305
312
    vec[1].len = 0;
306
313
  }
307
314
}
 
315
 
 
316
#endif /* !HAVE_JACK_RINGBUFFER */