source: roaraudio/libroar/buffer.c @ 4522:c335603c6371

Last change on this file since 4522:c335603c6371 was 4522:c335603c6371, checked in by phi, 13 years ago

added refing and unrefing of buffers

File size: 11.6 KB
Line 
1//buffer.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2010
5 *
6 *  This file is part of libroar a part of RoarAudio,
7 *  a cross-platform sound system for both, home and professional use.
8 *  See README for details.
9 *
10 *  This file is free software; you can redistribute it and/or modify
11 *  it under the terms of the GNU General Public License version 3
12 *  as published by the Free Software Foundation.
13 *
14 *  libroar is distributed in the hope that it will be useful,
15 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 *  GNU General Public License for more details.
18 *
19 *  You should have received a copy of the GNU General Public License
20 *  along with this software; see the file COPYING.  If not, write to
21 *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 *  Boston, MA 02110-1301, USA.
23 *
24 *  NOTE for everyone want's to change something and send patches:
25 *  read README and HACKING! There a addition information on
26 *  the license of this document you need to read before you send
27 *  any patches.
28 *
29 *  NOTE for uses of non-GPL (LGPL,...) software using libesd, libartsc
30 *  or libpulse*:
31 *  The libs libroaresd, libroararts and libroarpulse link this lib
32 *  and are therefore GPL. Because of this it may be illigal to use
33 *  them with any software that uses libesd, libartsc or libpulse*.
34 */
35
36#include "libroar.h"
37
38struct roar_buffer_ring {
39 size_t read_pos;
40 size_t write_pos;
41};
42
43struct roar_buffer {
44 size_t               refc;
45 size_t               len;
46 size_t               user_len;
47 int                  flags;
48 void               * data;
49 void               * user_data;
50 union {
51  void                    * vp;
52  int32_t                   i32;
53  struct roar_buffer_ring   ring;
54 }                    meta;
55 struct roar_buffer * next;
56};
57
58int roar_buffer_new_data (struct roar_buffer ** buf, size_t len, void ** data) {
59 void * bufdata;
60
61 if ((bufdata = roar_mm_malloc(len)) == NULL) {
62  return -1;
63 }
64
65 if ( roar_buffer_new_no_ma(buf, len, bufdata) == -1 ) {
66  roar_mm_free(bufdata);
67  return -1;
68 }
69
70 if ( roar_buffer_set_flag(*buf, ROAR_BUFFER_FLAG_NOFREE, ROAR_BUFFER_RESET) == -1 ) {
71  roar_buffer_free(*buf);
72  roar_mm_free(bufdata);
73  return -1;
74 }
75
76 if ( data != NULL )
77  *data = bufdata;
78
79 return 0;
80}
81
82int roar_buffer_new_no_ma(struct roar_buffer ** buf, size_t len, void * data) { // no internal malloc
83 struct roar_buffer * new;
84
85 ROAR_DBG("buffer_new(buf=%p, len=%i) = ?", buf, len);
86
87 if ( buf == NULL || data == NULL )
88  return -1;
89
90 if ((new = roar_mm_malloc(sizeof(struct roar_buffer))) == NULL) {
91  *buf = NULL;
92  return -1;
93 }
94
95 new->refc      = 1;
96
97 new->data      = data;
98
99 new->flags     = ROAR_BUFFER_FLAG_NONE|ROAR_BUFFER_FLAG_NOFREE;
100
101 new->user_data = new->data;
102
103 new->next      = NULL;
104
105 new->len       = len;
106 new->user_len  = len;
107 *buf           = new;
108
109 ROAR_DBG("buffer_new(buf=%p, len=%i): New buffer at %p", buf, len, new);
110
111 return 0;
112}
113
114int roar_buffer_ref      (struct roar_buffer *  buf) {
115 if ( buf == NULL )
116  return -1;
117
118 buf->refc++;
119
120 return 0;
121}
122
123int roar_buffer_unref     (struct roar_buffer * buf) {
124 struct roar_buffer * next;
125
126 if ( buf == NULL )
127  return -1;
128
129 if ( buf->refc == 0 ) {
130  ROAR_WARN("roar_buffer_unref(buf=%p): Ref counter is wrong. assuming one.");
131  buf->refc = 1;
132 }
133
134 buf->refc--;
135
136 if ( buf->refc )
137  return 0;
138
139 while ((next = buf->next)) {
140  if ( roar_buffer_get_flag(buf, ROAR_BUFFER_FLAG_NOFREE) != 1 )
141   roar_mm_free(buf->data);
142
143  roar_mm_free(buf);
144  buf = next;
145 }
146
147 if ( roar_buffer_get_flag(buf, ROAR_BUFFER_FLAG_NOFREE) != 1 )
148  roar_mm_free(buf->data);
149
150 roar_mm_free(buf);
151
152 return 0;
153}
154
155int roar_buffer_delete   (struct roar_buffer * buf, struct roar_buffer ** next) {
156 if ( buf == NULL ) {
157  if ( next != NULL )
158   *next = NULL;
159  return -1;
160 }
161
162 ROAR_DBG("buffer_delete(buf=%p, next=%p) = ?", buf, next);
163
164 if ( next != NULL )
165  *next = buf->next;
166
167 if ( roar_buffer_get_flag(buf, ROAR_BUFFER_FLAG_NOFREE) != 1 )
168  roar_mm_free(buf->data);
169
170 roar_mm_free(buf);
171
172 ROAR_DBG("buffer_delete(buf=%p, next=%p) = 0", buf, next);
173 return 0;
174}
175
176int roar_buffer_add      (struct roar_buffer * buf, struct roar_buffer *  next) {
177 unsigned int deep = 0;
178
179 if ( buf == NULL )
180  return -1;
181
182 ROAR_DBG("buffer_add(buf=%p, next=%p) = ?", buf, next);
183
184 if ( buf->flags & ROAR_BUFFER_FLAG_RING )
185  return -1;
186
187 if ( buf == next ) {
188  ROAR_ERR("buffer_add(*): both pointer are of the same destination, This is a error in the application");
189  return -1;
190 }
191
192 while ( buf->next != NULL ) {
193  ROAR_DBG("buffer_add(*): buf=%p, next=%p (len=%i)", buf, buf->next, buf->user_len);
194//  ROAR_DBG("buffer_add(): buf=%p, buf->next=%p", buf, buf->next);
195  buf = buf->next;
196  deep++;
197
198  if ( buf == next ) {
199   ROAR_ERR("buffer_add(*): Can not add buffer: loop detected at deep %u. This is a error in the application", deep);
200  }
201 }
202
203 buf->next = next;
204
205 ROAR_DBG("buffer_add(*): adding buffer at deep %u", deep);
206
207 return 0;
208}
209
210int roar_buffer_clear_next (struct roar_buffer *  buf) {
211 if ( buf == NULL )
212  return -1;
213
214 buf->next = NULL;
215
216 return 0;
217}
218
219int roar_buffer_get_next (struct roar_buffer *  buf, struct roar_buffer ** next) {
220 if ( buf == NULL )
221  return -1;
222
223 *next = buf->next;
224
225 return 0;
226}
227
228int roar_buffer_ring_new (struct roar_buffer ** buf, size_t len, int free_running) {
229 struct roar_buffer * n;
230
231 if ( buf == NULL || len == 0 )
232  return -1;
233
234 // just to be sure:
235 *buf = NULL;
236
237 // currently we are limited to free running mode
238 if ( !free_running )
239  return -1;
240
241 if ( roar_buffer_new(&n, len) == -1 )
242  return -1;
243
244 n->flags |= ROAR_BUFFER_FLAG_RING;
245
246 if ( free_running )
247  n->flags |= ROAR_BUFFER_FLAG_FREE_RUNNING;
248
249 n->meta.ring.read_pos  = 0;
250 n->meta.ring.write_pos = 0;
251
252 memset(n->data, 0, n->len);
253
254 *buf = n;
255
256 return 0;
257}
258
259int roar_buffer_get_data (struct roar_buffer *  buf, void   ** data) {
260 if ( buf == NULL )
261  return -1;
262
263 *data = buf->user_data;
264
265 return 0;
266}
267
268int roar_buffer_set_offset (struct roar_buffer *  buf, size_t off) {
269 if ( buf == NULL )
270  return -1;
271
272 buf->user_len  -= off;
273 buf->user_data += off;
274
275 return 0;
276}
277
278int roar_buffer_shift_out (struct roar_buffer ** buf, void * data, size_t * len) {
279 size_t todo, cl;
280 struct roar_buffer * cur;
281 void * cd;
282
283 if ( len == NULL || buf == NULL || data == NULL ) {
284  ROAR_DBG("roar_buffer_shift_out(buf=%p, data=%p, len={%lu}) = -1 // Invalid input", buf, data, (unsigned long)*len);
285  return -1;
286 }
287
288 if ( *buf == NULL ) {
289  ROAR_DBG("roar_buffer_shift_out(buf=%p, data=%p, len={%lu}) = -1 // Invalid pointer to buffer ring", buf, data, (unsigned long)len);
290  return -1;
291 }
292
293 todo = *len;
294 cur  = *buf;
295
296 *len = 0;
297
298 while (todo && cur != NULL) {
299  ROAR_DBG("roar_buffer_shift_out(*): todo=%u, cur=%p", (unsigned int) todo, cur);
300
301  if ( roar_buffer_get_len(cur, &cl) == -1 )
302   return -1;
303
304  if ( cl > todo ) {
305   if ( roar_buffer_get_data(cur, &cd) == -1 )
306    return -1;
307
308   cl = todo;
309
310   memcpy(data, cd, cl);
311   todo -= cl;
312   data += cl;
313   *len += cl;
314
315   if ( roar_buffer_set_offset(cur, cl) == -1 )
316    return -1;
317  } else {
318   if ( roar_buffer_get_data(cur, &cd) == -1 )
319    return -1;
320
321   memcpy(data, cd, cl);
322   todo -= cl;
323   data += cl;
324   *len += cl;
325
326   if ( roar_buffer_next(&cur) == -1 )
327    return -1;
328  }
329
330/*
331  if ( cur == NULL )
332   break;
333*/
334 }
335
336 *buf = cur;
337
338 return 0;
339}
340
341int roar_buffer_set_meta (struct roar_buffer * buf, void *  meta) {
342 if ( buf == NULL )
343  return -1;
344
345 buf->meta.vp = meta;
346
347 return 0;
348}
349
350int roar_buffer_get_meta (struct roar_buffer * buf, void ** meta) {
351 if ( buf == NULL || meta == NULL )
352  return -1;
353
354 *meta = buf->meta.vp;
355
356 return 0;
357}
358
359int roar_buffer_set_meta_i32(struct roar_buffer *  buf, int32_t    meta) {
360 if ( buf == NULL )
361  return -1;
362
363 buf->meta.i32 = meta;
364
365 return 0;
366}
367
368int roar_buffer_get_meta_i32(struct roar_buffer *  buf, int32_t *  meta) {
369 if ( buf == NULL || meta == NULL )
370  return -1;
371
372 *meta = buf->meta.i32;
373
374 return 0;
375}
376
377int roar_buffer_set_len  (struct roar_buffer *  buf, size_t    len) {
378 size_t   totlen;
379 void   * newbuf;
380
381 if ( buf == NULL )
382  return -1;
383
384 // handle specal case where user length is zero:
385 if ( len && !buf->user_len ) {
386  buf->user_data = buf->data;
387  buf->user_len  = buf->len;
388 }
389
390 if ( len > buf->user_len ) {
391  // we can only enlage a buffer if it's one of our own memory segments
392  if ( buf->flags & ROAR_BUFFER_FLAG_NOFREE )
393   return -1;
394
395  totlen = buf->len - buf->user_len + len;
396  newbuf = roar_mm_realloc(buf->data, totlen);
397  if ( newbuf == NULL )
398   return -1;
399
400  buf->data = newbuf;
401  buf->user_len = len;
402 } else {
403  buf->user_len = len;
404 }
405
406 return 0;
407}
408
409int roar_buffer_get_len  (struct roar_buffer *  buf, size_t *  len) {
410 if ( buf == NULL )
411  return -1;
412
413 *len = buf->user_len;
414
415 return 0;
416}
417
418int roar_buffer_set_flag (struct roar_buffer *  buf, int flag, int reset) {
419 if ( buf == NULL )
420  return -1;
421
422 buf->flags |= flag;
423
424 if ( reset )
425  buf->flags -= flag;
426
427 return 0;
428}
429
430int roar_buffer_get_flag (struct roar_buffer *  buf, int flag) {
431 if ( buf == NULL )
432  return -1;
433
434 return buf->flags & flag;
435}
436
437int roar_buffer_duplicate (struct roar_buffer *  buf, struct roar_buffer ** copy) {
438 struct roar_buffer *  cur = buf;
439 struct roar_buffer *  new;
440 void * od, * nd;
441
442 *copy = NULL;
443
444 while (cur) {
445  if ( roar_buffer_new(&new, cur->user_len) == -1 ) {
446   roar_buffer_free(*copy);
447   return -1;
448  }
449
450  if ( *copy == NULL )
451   *copy = new;
452
453  roar_buffer_get_data(cur, &od);
454  roar_buffer_get_data(new, &nd);
455  memcpy(nd, od, cur->user_len);
456
457  roar_buffer_add(*copy, new);
458
459  cur = cur->next;
460 }
461 return 0;
462}
463
464int roar_buffer_ring_stats (struct roar_buffer *  buf, struct roar_buffer_stats * stats) {
465 if ( buf == NULL )
466  return -1;
467
468 stats->parts        = 0;
469 stats->bytes        = 0;
470 stats->memory_usage = 0;
471
472 while (buf) {
473  stats->parts++;
474  stats->bytes        += buf->user_len;
475  stats->memory_usage += buf->len + sizeof(struct roar_buffer);
476  buf = buf->next;
477 }
478
479 return 0;
480}
481
482int roar_buffer_ring_read  (struct roar_buffer *  buf, void * data, size_t * len) {
483 if ( buf == NULL || len == NULL )
484  return -1;
485
486 if ( data == NULL && *len != 0 )
487  return -1;
488
489 if ( !(buf->flags & ROAR_BUFFER_FLAG_RING) )
490  return -1;
491
492 if ( *len == 0 )
493  return 0;
494
495 // we may handle this later:
496 if ( *len > buf->user_len )
497  return -1;
498
499 if ( buf->meta.ring.read_pos >= buf->user_len )
500  buf->meta.ring.read_pos -= buf->user_len;
501
502 if ( (*len + buf->meta.ring.read_pos) > buf->user_len ) {
503  // wraped mode:
504  memcpy(data, buf->user_data+buf->meta.ring.read_pos, buf->user_len - buf->meta.ring.read_pos);
505  memcpy(data, buf->user_data, *len + buf->meta.ring.read_pos - buf->user_len);
506
507  buf->meta.ring.read_pos += *len;
508  buf->meta.ring.read_pos -= buf->user_len;
509  return 0;
510 } else {
511  // unwarped mode:
512  memcpy(data, buf->user_data+buf->meta.ring.read_pos, *len);
513  buf->meta.ring.read_pos += *len;
514  return 0;
515 }
516
517 return -1;
518}
519
520int roar_buffer_ring_write (struct roar_buffer *  buf, void * data, size_t * len) {
521 if ( buf == NULL || len == NULL )
522  return -1;
523
524 if ( data == NULL && *len != 0 )
525  return -1;
526
527 if ( !(buf->flags & ROAR_BUFFER_FLAG_RING) )
528  return -1;
529
530 if ( *len == 0 )
531  return 0;
532
533 // we may handle this later:
534 if ( *len > buf->user_len )
535  return -1;
536
537 if ( buf->meta.ring.write_pos >= buf->user_len )
538  buf->meta.ring.write_pos -= buf->user_len;
539
540 if ( (*len + buf->meta.ring.write_pos) > buf->user_len ) {
541  // wraped mode:
542  memcpy(buf->user_data+buf->meta.ring.write_pos, data, buf->user_len - buf->meta.ring.write_pos);
543  memcpy(buf->user_data, data, *len + buf->meta.ring.write_pos - buf->user_len);
544
545  buf->meta.ring.write_pos += *len;
546  buf->meta.ring.write_pos -= buf->user_len;
547  return 0;
548 } else {
549  // unwarped mode:
550  memcpy(buf->user_data+buf->meta.ring.write_pos, data, *len);
551  buf->meta.ring.write_pos += *len;
552  return 0;
553 }
554
555 return -1;
556}
557
558//ll
Note: See TracBrowser for help on using the repository browser.