source: roaraudio/libroar/buffer.c @ 5651:b0e163908378

Last change on this file since 5651:b0e163908378 was 5651:b0e163908378, checked in by phi, 12 years ago

Added compiler checks for printf() like format strings.

File size: 20.8 KB
Line 
1//buffer.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2012
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 int                  type;
56 struct roar_buffer * next;
57};
58
59#define _ckbuf_free(m)  if ( buf == NULL || (m) ) { roar_err_set(ROAR_ERROR_FAULT); return -1; }
60#define _ckbuf(m)       if ( _ckmem_corruption(buf, (m)) == -1 ) return -1;
61
62// if we use the 'inline' keyword here the program segfaults. why?
63static int _ckmem_corruption(volatile struct roar_buffer * buf, int m) {
64 int flags;
65
66 ROAR_DBG("_ckmem_corruption(buf=%p) = ?", buf);
67
68 // we need to recheck here, why?
69 // gcc changes the order of the above macros. why?
70 // this is a strange world.
71 if ( buf == NULL || m ) {
72  ROAR_DBG("_ckmem_corruption(buf=%p) = -1 // FAULT", buf);
73  roar_err_set(ROAR_ERROR_FAULT);
74  return -1;
75 }
76
77 ROAR_DBG("_ckmem_corruption(buf=%p) = ?", buf);
78
79 flags = buf->flags & (ROAR_BUFFER_FLAG_USEABLE|ROAR_BUFFER_FLAG_FREED);
80
81 ROAR_DBG("_ckmem_corruption(buf=%p{.flags=0x%.4x, ...} = ?", buf, buf->flags);
82
83 if ( flags == ROAR_BUFFER_FLAG_USEABLE ) {
84  // seems ok, continue with next check.
85 } else if ( flags == ROAR_BUFFER_FLAG_FREED ) {
86  roar_panic(ROAR_FATAL_ERROR_MEMORY_USED_AFTER_FREE, NULL);
87  roar_err_set(ROAR_ERROR_FAULT);
88  return -1;
89 } else {
90  roar_panic(ROAR_FATAL_ERROR_MEMORY_CORRUPTION, NULL);
91  roar_err_set(ROAR_ERROR_BADCKSUM);
92  return -1;
93 }
94
95 if ( buf->refc == 0 ) {
96  roar_panic(ROAR_FATAL_ERROR_MEMORY_CORRUPTION, NULL);
97  roar_err_set(ROAR_ERROR_FAULT);
98  return -1;
99 }
100
101 return 0;
102}
103
104int roar_buffer_new_data (struct roar_buffer ** buf, size_t len, void ** data) {
105 void * bufdata;
106 int err;
107
108 if ((bufdata = roar_mm_malloc(len)) == NULL) {
109  return -1;
110 }
111
112 if ( roar_buffer_new_no_ma(buf, len, bufdata) == -1 ) {
113  err = roar_error;
114  roar_mm_free(bufdata);
115  roar_err_set(err);
116  return -1;
117 }
118
119 if ( roar_buffer_set_flag(*buf, ROAR_BUFFER_FLAG_NOFREE, ROAR_BUFFER_RESET) == -1 ) {
120  err = roar_error;
121  roar_buffer_free(*buf);
122  roar_mm_free(bufdata);
123  roar_err_set(err);
124  return -1;
125 }
126
127 if ( data != NULL )
128  *data = bufdata;
129
130 return 0;
131}
132
133int roar_buffer_new_no_ma(struct roar_buffer ** buf, size_t len, void * data) { // no internal malloc
134 struct roar_buffer * new;
135
136 ROAR_DBG("buffer_new(buf=%p, len=%i) = ?", buf, len);
137
138 _ckbuf_free(data == NULL)
139
140 if ((new = roar_mm_malloc(sizeof(struct roar_buffer))) == NULL) {
141  *buf = NULL;
142  return -1;
143 }
144
145 new->refc      =  1;
146
147 new->data      = data;
148
149 new->flags     = ROAR_BUFFER_FLAG_NONE|ROAR_BUFFER_FLAG_NOFREE|ROAR_BUFFER_FLAG_USEABLE;
150 new->type      = -1;
151
152 new->user_data = new->data;
153
154 new->next      = NULL;
155
156 new->len       = len;
157 new->user_len  = len;
158 *buf           = new;
159
160 ROAR_DBG("buffer_new(buf=%p, len=%i): New buffer at %p", buf, len, new);
161
162 return 0;
163}
164
165int roar_buffer_ref      (struct roar_buffer *  buf) {
166 _ckbuf(0)
167
168 buf->refc++;
169
170 return 0;
171}
172
173int roar_buffer_unref     (struct roar_buffer * buf) {
174 struct roar_buffer * next, * cur;
175 int flags;
176
177 ROAR_DBG("roar_buffer_unref(buf=%p) = ?", buf);
178
179 _ckbuf_free(0)
180
181 ROAR_DBG("roar_buffer_unref(buf=%p) = ?", buf);
182
183 cur = buf;
184 while (cur != NULL) {
185  flags = cur->flags & (ROAR_BUFFER_FLAG_USEABLE|ROAR_BUFFER_FLAG_FREED);
186  if ( flags == ROAR_BUFFER_FLAG_FREED ) {
187   roar_panic(ROAR_FATAL_ERROR_MEMORY_DOUBLE_FREE, NULL);
188  }
189
190  _ckmem_corruption(cur, 0);
191
192  if ( cur->refc == 0 ) {
193   ROAR_WARN("roar_buffer_unref(buf=%p): Ref counter for buffer at %p is wrong. assuming one.", cur, cur);
194   cur->refc = 1;
195   roar_panic(ROAR_FATAL_ERROR_MEMORY_CORRUPTION, NULL);
196  } else if ( cur->refc > 1 ) {
197   cur->refc--;
198   return 0;
199  }
200
201  ROAR_DBG("roar_buffer_unref(buf=%p) = ?", buf);
202
203  if ( roar_buffer_get_flag(cur, ROAR_BUFFER_FLAG_NOFREE) != 1 )
204   roar_mm_free(cur->data);
205
206  cur->flags = ROAR_BUFFER_FLAG_FREED;
207  next = cur->next;
208  roar_mm_free(cur);
209  cur = next;
210 }
211
212 ROAR_DBG("roar_buffer_unref(buf=%p) = 0", buf);
213 return 0;
214}
215
216int roar_buffer_delete   (struct roar_buffer * buf, struct roar_buffer ** next) {
217 if ( buf == NULL ) {
218  if ( next != NULL )
219   *next = NULL;
220  roar_err_set(ROAR_ERROR_FAULT);
221  return -1;
222 }
223
224 ROAR_DBG("roar_buffer_delete(buf=%p, next=%p) = ?", buf, next);
225
226 if ( next != NULL ) {
227  *next = buf;
228  return roar_buffer_next(next);
229 } else {
230  return roar_buffer_unref(buf);
231 }
232}
233
234int roar_buffer_next     (struct roar_buffer ** buf) {
235 struct roar_buffer * ret;
236
237 if ( buf == NULL || *buf == NULL ) {
238  roar_err_set(ROAR_ERROR_FAULT);
239 }
240
241 ret = (*buf)->next;
242
243 if ( ret != NULL )
244  roar_buffer_ref(ret);
245
246 roar_buffer_unref(*buf);
247
248 *buf = ret;
249
250 return 0;
251}
252
253int roar_buffer_add      (struct roar_buffer * buf, struct roar_buffer *  next) {
254 if ( roar_buffer_ref(next) == -1 )
255  return -1;
256 return roar_buffer_moveinto(buf, &next);
257}
258
259int roar_buffer_moveinto (struct roar_buffer * buf, struct roar_buffer ** next) {
260 unsigned int deep = 0;
261
262 _ckbuf(next == NULL || _ckmem_corruption(*next, 0))
263
264 ROAR_DBG("buffer_add(buf=%p, next=%p) = ?", buf, next);
265 ROAR_DBG("buffer_add(buf=%p, next=%p): *next=%p", buf, next, *next);
266
267 if ( buf->flags & ROAR_BUFFER_FLAG_RING ) {
268  roar_err_set(ROAR_ERROR_INVAL);
269  return -1;
270 }
271
272 if ( buf == *next ) {
273  ROAR_ERR("buffer_add(*): both pointer are of the same destination, This is a error in the application");
274  roar_err_set(ROAR_ERROR_INVAL);
275  return -1;
276 }
277
278 while ( buf->next != NULL ) {
279  ROAR_DBG("buffer_add(*): buf=%p, next=%p (len=%i)", buf, buf->next, buf->user_len);
280//  ROAR_DBG("buffer_add(): buf=%p, buf->next=%p", buf, buf->next);
281  buf = buf->next;
282  deep++;
283
284  if ( buf == *next ) {
285   ROAR_ERR("buffer_add(*): Can not add buffer: loop detected at deep %u. This is a error in the application", deep);
286   // why don't we return here?
287  }
288 }
289
290 buf->next = *next;
291
292 ROAR_DBG("buffer_add(*): adding buffer at deep %u", deep);
293
294 *next = NULL;
295
296 return 0;
297}
298
299int roar_buffer_moveintoqueue(struct roar_buffer ** buf, struct roar_buffer ** next) {
300 if ( buf == NULL || next == NULL ) {
301  roar_err_set(ROAR_ERROR_FAULT);
302  return -1;
303 }
304
305 if ( *buf == NULL ) {
306  *buf = *next;
307  *next = NULL;
308  return 0;
309 } else {
310  return roar_buffer_moveinto(*buf, next);
311 }
312}
313
314int roar_buffer_get_next (struct roar_buffer *  buf, struct roar_buffer ** next) {
315 _ckbuf(0)
316
317 *next = buf->next;
318
319 return roar_buffer_ref(*next);
320}
321
322int roar_buffer_ring_new (struct roar_buffer ** buf, size_t len, int free_running) {
323 struct roar_buffer * n;
324
325 _ckbuf_free(0)
326
327 if ( len == 0 ) {
328  roar_err_set(ROAR_ERROR_RANGE);
329  return -1;
330 }
331
332 // just to be sure:
333 *buf = NULL;
334
335 if ( roar_buffer_new(&n, len) == -1 )
336  return -1;
337
338 n->flags |= ROAR_BUFFER_FLAG_RING;
339
340 if ( free_running )
341  n->flags |= ROAR_BUFFER_FLAG_FREE_RUNNING;
342
343 n->meta.ring.read_pos  = 0;
344 n->meta.ring.write_pos = 0;
345
346 memset(n->data, 0, n->len);
347
348 *buf = n;
349
350 return 0;
351}
352
353int roar_buffer_get_data (struct roar_buffer *  buf, void   ** data) {
354 _ckbuf(data == NULL)
355
356 *data = buf->user_data;
357
358 return 0;
359}
360
361int roar_buffer_get_datalen(struct roar_buffer * buf, void   ** data, size_t * len) {
362 _ckbuf(0)
363
364 if ( data != NULL )
365  *data = buf->user_data;
366 if ( len != NULL )
367 *len = buf->user_len;
368
369 return 0;
370}
371
372int roar_buffer_set_offset (struct roar_buffer *  buf, size_t off) {
373 _ckbuf(0)
374
375 if ( off > buf->user_len ) {
376  roar_err_set(ROAR_ERROR_RANGE);
377  return -1;
378 }
379
380 buf->user_len  -= off;
381 buf->user_data += off;
382
383 return 0;
384}
385
386int roar_buffer_shift_out (struct roar_buffer ** buf, void * data, size_t * len) {
387 size_t todo, cl;
388 struct roar_buffer * cur;
389 void * cd;
390
391 _ckbuf_free(len == NULL || data == NULL);
392
393 if ( *buf == NULL ) {
394  ROAR_DBG("roar_buffer_shift_out(buf=%p, data=%p, len={%lu}) = -1 // Invalid pointer to buffer ring", buf, data, (unsigned long)len);
395  roar_err_set(ROAR_ERROR_FAULT);
396  return -1;
397 }
398
399 todo = *len;
400 cur  = *buf;
401
402 *len = 0;
403
404 while (todo && cur != NULL) {
405  ROAR_DBG("roar_buffer_shift_out(*): todo=%u, cur=%p", (unsigned int) todo, cur);
406
407  _ckmem_corruption(cur, 0);
408
409  if ( roar_buffer_get_len(cur, &cl) == -1 )
410   return -1;
411
412  if ( cl > todo ) {
413   if ( roar_buffer_get_data(cur, &cd) == -1 )
414    return -1;
415
416   cl = todo;
417
418   memcpy(data, cd, cl);
419   todo -= cl;
420   data += cl;
421   *len += cl;
422
423   if ( roar_buffer_set_offset(cur, cl) == -1 )
424    return -1;
425  } else {
426   if ( roar_buffer_get_data(cur, &cd) == -1 )
427    return -1;
428
429   memcpy(data, cd, cl);
430   todo -= cl;
431   data += cl;
432   *len += cl;
433
434   if ( roar_buffer_next(&cur) == -1 )
435    return -1;
436  }
437
438/*
439  if ( cur == NULL )
440   break;
441*/
442 }
443
444 *buf = cur;
445
446 return 0;
447}
448
449int roar_buffer_set_meta (struct roar_buffer * buf, void *  meta) {
450 _ckbuf(0)
451
452 buf->meta.vp = meta;
453
454 return 0;
455}
456
457int roar_buffer_get_meta (struct roar_buffer * buf, void ** meta) {
458 _ckbuf(meta == NULL)
459
460 *meta = buf->meta.vp;
461
462 return 0;
463}
464
465int roar_buffer_set_meta_i32(struct roar_buffer *  buf, int32_t    meta) {
466 _ckbuf(0)
467
468 buf->meta.i32 = meta;
469
470 return 0;
471}
472
473int roar_buffer_get_meta_i32(struct roar_buffer *  buf, int32_t *  meta) {
474 _ckbuf(meta == NULL)
475
476 *meta = buf->meta.i32;
477
478 return 0;
479}
480
481int roar_buffer_set_type    (struct roar_buffer *  buf, int        type) {
482 _ckbuf(0)
483
484 switch (type) {
485  case ROAR_VIO_DFT_RAW:
486  case ROAR_VIO_DFT_PACKET:
487  case ROAR_VIO_DFT_UNFRAMED:
488  case ROAR_VIO_DFT_OGG_PACKET:
489  case ROAR_VIO_DFT_OGG_PAGE:
490   break;
491  default:
492    roar_err_set(ROAR_ERROR_NOTSUP);
493    return -1;
494 }
495
496 buf->type = type;
497
498 return 0;
499}
500
501int roar_buffer_get_type    (struct roar_buffer *  buf, int     *  type) {
502 _ckbuf(type == NULL)
503
504 *type = buf->type;
505
506 return 0;
507}
508
509int roar_buffer_set_len  (struct roar_buffer *  buf, size_t    len) {
510 size_t   totlen;
511 void   * newbuf;
512 size_t true_len;
513
514 ROAR_DBG("roar_buffer_set_len(buf=%p, len=%lu) = ?", buf, (long unsigned int)len);
515
516 _ckbuf(0)
517
518 ROAR_DBG("roar_buffer_set_len(buf=%p, len=%lu) = ?", buf, (long unsigned int)len);
519
520 // handle special case where user length is zero:
521 if ( len && !buf->user_len ) {
522  buf->user_data = buf->data;
523  buf->user_len  = buf->len;
524 }
525
526 ROAR_DBG("roar_buffer_set_len(buf=%p, len=%lu) = ?", buf, (long unsigned int)len);
527
528 // calculate the true length of our buffer starting at buf->user_data.
529 true_len = buf->len - (buf->user_data - buf->data);
530
531 if ( len > true_len ) {
532  ROAR_DBG("roar_buffer_set_len(buf=%p, len=%lu): We need to enlarge the buffer.", buf, (long unsigned int)len);
533
534  // we can only enlage a buffer if it's one of our own memory segments
535  if ( buf->flags & ROAR_BUFFER_FLAG_NOFREE )  {
536   ROAR_DBG("roar_buffer_set_len(buf=%p, len=%lu) = -1 //error=NOTSUP", buf, (long unsigned int)len);
537   roar_err_set(ROAR_ERROR_NOTSUP);
538   return -1;
539  }
540
541  totlen = (buf->len - buf->user_len) + len;
542  newbuf = roar_mm_realloc(buf->data, totlen);
543  if ( newbuf == NULL )
544   return -1;
545
546  buf->user_data = newbuf + (buf->user_data - buf->data);
547  buf->user_len = len;
548  buf->data = newbuf;
549  buf->len  = totlen;
550 } else {
551  ROAR_DBG("roar_buffer_set_len(buf=%p, len=%lu): No need to enlarge the buffer.", buf, (long unsigned int)len);
552  buf->user_len = len;
553 }
554
555 ROAR_DBG("roar_buffer_set_len(buf=%p, len=%lu) = 0", buf, (long unsigned int)len);
556 return 0;
557}
558
559int roar_buffer_get_len  (struct roar_buffer *  buf, size_t *  len) {
560 _ckbuf(0)
561
562 *len = buf->user_len;
563
564 return 0;
565}
566
567int roar_buffer_set_flag (struct roar_buffer *  buf, int flag, int reset) {
568 _ckbuf(0)
569
570 buf->flags |= flag;
571
572 if ( reset )
573  buf->flags -= flag;
574
575 return 0;
576}
577
578int roar_buffer_get_flag (struct roar_buffer *  buf, int flag) {
579 _ckbuf(0)
580
581 return buf->flags & flag;
582}
583
584int roar_buffer_duplicate (struct roar_buffer *  buf, struct roar_buffer ** copy) {
585 struct roar_buffer *  cur = buf;
586 struct roar_buffer *  new;
587 void * od, * nd;
588 int err;
589
590 _ckbuf(copy == NULL)
591
592 *copy = NULL;
593
594 // TODO:  This function does not handle ring buffers.
595 // FIXME: This function does not error out in case of wrong buffer type in buf.
596 // TODO:  This function does not handle buffer meta data.
597
598 while (cur != NULL) {
599  if ( roar_buffer_new(&new, cur->user_len) == -1 ) {
600   err = roar_error;
601   roar_buffer_free(*copy);
602   roar_err_set(err);
603   return -1;
604  }
605
606  if ( *copy == NULL )
607   *copy = new;
608
609  _LIBROAR_IGNORE_RET(roar_buffer_get_data(cur, &od));
610  _LIBROAR_IGNORE_RET(roar_buffer_get_data(new, &nd));
611  memcpy(nd, od, cur->user_len);
612
613  _LIBROAR_IGNORE_RET(roar_buffer_moveinto(*copy, &new));
614
615  cur = cur->next;
616 }
617
618 return 0;
619}
620
621int roar_buffer_ring_stats (struct roar_buffer *  buf, struct roar_buffer_stats * stats) {
622 ROAR_DBG("roar_buffer_ring_stats(buf=%p, stats=%p) = ?", buf, stats);
623
624 _ckbuf(0)
625
626 ROAR_DBG("roar_buffer_ring_stats(buf=%p, stats=%p) = ?", buf, stats);
627
628 stats->parts        = 0;
629 stats->bytes        = 0;
630 stats->memory_usage = 0;
631
632 while (buf != NULL ) {
633  stats->parts++;
634  stats->bytes        += buf->user_len;
635  stats->memory_usage += buf->len + sizeof(struct roar_buffer);
636  buf = buf->next;
637 }
638
639 return 0;
640}
641
642int roar_buffer_ring_read  (struct roar_buffer *  buf, void * data, size_t * len) {
643 struct roar_buffer_ring * ring;
644 size_t havelen;
645 size_t done;
646 size_t tmp;
647
648 _ckbuf(len == NULL)
649
650 if ( buf == NULL || len == NULL )
651  return -1;
652
653 if ( data == NULL && *len != 0 ) {
654  roar_err_set(ROAR_ERROR_FAULT);
655  return -1;
656 }
657
658 if ( !(buf->flags & ROAR_BUFFER_FLAG_RING) ) {
659  roar_err_set(ROAR_ERROR_TYPEMM);
660  return -1;
661 }
662
663 if ( *len == 0 )
664  return 0;
665
666 // we may handle this later:
667 if ( *len > buf->user_len ) {
668  roar_err_set(ROAR_ERROR_NOTSUP);
669  return -1;
670 }
671
672 if ( (buf->flags & ROAR_BUFFER_FLAG_FREE_RUNNING) ) {
673  if ( buf->meta.ring.read_pos >= buf->user_len )
674   buf->meta.ring.read_pos -= buf->user_len;
675
676  if ( (*len + buf->meta.ring.read_pos) > buf->user_len ) {
677   // wraped mode:
678   memcpy(data, buf->user_data+buf->meta.ring.read_pos, buf->user_len - buf->meta.ring.read_pos);
679   memcpy(data, buf->user_data, *len + buf->meta.ring.read_pos - buf->user_len);
680 
681   buf->meta.ring.read_pos += *len;
682   buf->meta.ring.read_pos -= buf->user_len;
683   return 0;
684  } else {
685   // unwarped mode:
686   memcpy(data, buf->user_data+buf->meta.ring.read_pos, *len);
687   buf->meta.ring.read_pos += *len;
688   return 0;
689  }
690 } else {
691  ring = &(buf->meta.ring);
692
693  if ( ring->read_pos == ring->write_pos ) {
694   *len = 0;
695   return 0;
696  } else if ( ring->read_pos < ring->write_pos ) {
697   havelen = ring->write_pos - ring->read_pos;
698
699   if ( havelen > *len )
700    havelen = *len;
701
702   memcpy(data, buf->user_data+ring->read_pos, havelen);
703   ring->read_pos += havelen;
704
705   *len = havelen;
706   return 0;
707  } else { // write_pos < read_pos
708   done = 0;
709
710   // first pass: use data up to end of buffer
711
712   havelen = buf->user_len - ring->read_pos;
713
714   if ( havelen > *len )
715    havelen = *len;
716
717   memcpy(data, buf->user_data+ring->read_pos, havelen);
718   ring->read_pos += havelen;
719
720   done += havelen;
721
722   if ( ring->read_pos == buf->user_len ) {
723    ring->read_pos = 0;
724   }
725
726   // second pass: use data from strat of buffer to write pointer
727
728   if ( *len > done ) {
729    tmp = *len - done;
730    if ( roar_buffer_ring_read(buf, data+done, &tmp) == 0 ) {
731     done += tmp;
732    }
733   }
734
735   *len = done;
736   return 0;
737  }
738 }
739
740 roar_err_set(ROAR_ERROR_UNKNOWN);
741 return -1;
742}
743
744int roar_buffer_ring_write (struct roar_buffer *  buf, void * data, size_t * len) {
745 struct roar_buffer_ring * ring;
746 size_t havelen;
747 size_t done;
748 size_t tmp;
749
750 ROAR_DBG("roar_buffer_ring_write(buf=%p, data=%p, len=%p) = ?", buf, data, len);
751
752 _ckbuf(len == NULL)
753
754 if ( data == NULL && *len != 0 ) {
755  roar_err_set(ROAR_ERROR_FAULT);
756  return -1;
757 }
758
759 if ( !(buf->flags & ROAR_BUFFER_FLAG_RING) ) {
760  roar_err_set(ROAR_ERROR_TYPEMM);
761  return -1;
762 }
763
764 if ( *len == 0 )
765  return 0;
766
767 // we may handle this later:
768 if ( *len > buf->user_len ) {
769  roar_err_set(ROAR_ERROR_NOTSUP);
770  return -1;
771 }
772
773 if ( (buf->flags & ROAR_BUFFER_FLAG_FREE_RUNNING) ) {
774  if ( buf->meta.ring.write_pos >= buf->user_len )
775   buf->meta.ring.write_pos -= buf->user_len;
776
777  if ( (*len + buf->meta.ring.write_pos) > buf->user_len ) {
778   // wraped mode:
779   memcpy(buf->user_data+buf->meta.ring.write_pos, data, buf->user_len - buf->meta.ring.write_pos);
780   memcpy(buf->user_data, data, *len + buf->meta.ring.write_pos - buf->user_len);
781
782   buf->meta.ring.write_pos += *len;
783   buf->meta.ring.write_pos -= buf->user_len;
784   return 0;
785  } else {
786   // unwarped mode:
787   memcpy(buf->user_data+buf->meta.ring.write_pos, data, *len);
788   buf->meta.ring.write_pos += *len;
789   return 0;
790  }
791 } else {
792  ring = &(buf->meta.ring);
793  done = 0;
794
795  ROAR_DBG("roar_buffer_ring_write(buf=%p, data=%p, len=%p): write_pos=%u, read_pos=%u, user_len=%u", buf, data, len, (unsigned int)ring->write_pos, (unsigned int)ring->read_pos, (unsigned int)buf->user_len);
796
797  if ( ring->write_pos >= ring->read_pos ) {
798   ROAR_DBG("roar_buffer_ring_write(buf=%p, data=%p, len=%p) = ?", buf, data, len);
799
800   havelen = buf->user_len - ring->write_pos;
801
802   if ( ring->read_pos == 0 )
803    havelen--;
804
805   if ( havelen > *len )
806    havelen = *len;
807
808   memcpy(buf->user_data+ring->write_pos, data, havelen);
809
810   done += havelen;
811   ring->write_pos += havelen;
812
813   if ( ring->write_pos == buf->user_len )
814    ring->write_pos = 0;
815
816   if ( *len > done && ring->read_pos != 0 ) {
817    tmp = *len - done;
818    if ( roar_buffer_ring_write(buf, data+done, &tmp) == 0 ) {
819     done += tmp;
820    }
821   }
822
823   *len = done;
824   ROAR_DBG("roar_buffer_ring_write(buf=%p, data=%p, len=%p) = 0", buf, data, len);
825   return 0;
826  } else {
827   ROAR_DBG("roar_buffer_ring_write(buf=%p, data=%p, len=%p) = ?", buf, data, len);
828
829   // test for buffer-is-full:
830   if ( (ring->write_pos + 1) == ring->read_pos ) {
831    *len = 0;
832    ROAR_DBG("roar_buffer_ring_write(buf=%p, data=%p, len=%p) = 0", buf, data, len);
833    return 0;
834   }
835
836   ROAR_DBG("roar_buffer_ring_write(buf=%p, data=%p, len=%p) = ?", buf, data, len);
837
838   havelen = ring->read_pos - ring->write_pos - 1;
839
840   if ( havelen > *len )
841    havelen = *len;
842
843   memcpy(buf->user_data+ring->write_pos, data, havelen);
844
845   ring->write_pos += havelen;
846   *len = havelen;
847
848   ROAR_DBG("roar_buffer_ring_write(buf=%p, data=%p, len=%p) = 0", buf, data, len);
849   return 0;
850  }
851 }
852
853 roar_err_set(ROAR_ERROR_UNKNOWN);
854 return -1;
855}
856
857int roar_buffer_ring_avail(struct roar_buffer *  buf, size_t * readlen, size_t * writelen) {
858 struct roar_buffer_ring * ring;
859 size_t have;
860
861 _ckbuf(0)
862
863 if ( !(buf->flags & ROAR_BUFFER_FLAG_RING) ) {
864  roar_err_set(ROAR_ERROR_TYPEMM);
865  return -1;
866 }
867
868 ring = &(buf->meta.ring);
869
870 ROAR_DBG("roar_buffer_ring_avail(buf=%p, readlen=%p, writelen=%p) = ?", buf, readlen, writelen);
871
872 if ( readlen != NULL ) {
873  have = 0;
874
875  if ( ring->write_pos >= ring->read_pos ) {
876   have  = ring->write_pos - ring->read_pos;
877  } else {
878   have  = buf->user_len - ring->read_pos;
879   have += ring->write_pos;
880   have -= 1;
881  }
882
883  *readlen = have;
884  ROAR_DBG("roar_buffer_ring_avail(buf=%p, readlen=%p, writelen=%p): readlen=%llu", buf, readlen, writelen, (unsigned long long int)have);
885 }
886
887 if ( writelen != NULL ) {
888  have = 0;
889
890  if ( ring->read_pos > ring->write_pos ) {
891   have  = ring->read_pos - ring->write_pos - 1;
892  } else {
893   have  = buf->user_len - ring->write_pos;
894   have += ring->read_pos;
895   have -= 1;
896  }
897
898  *writelen = have;
899  ROAR_DBG("roar_buffer_ring_avail(buf=%p, readlen=%p, writelen=%p): readlen=%llu", buf, readlen, writelen, (unsigned long long int)have);
900 }
901
902 ROAR_DBG("roar_buffer_ring_avail(buf=%p, readlen=%p, writelen=%p) = 0", buf, readlen, writelen);
903
904 return 0;
905}
906
907int roar_buffer_ring_reset(struct roar_buffer *  buf) {
908 _ckbuf(0)
909
910 if ( !(buf->flags & ROAR_BUFFER_FLAG_RING) ) {
911  roar_err_set(ROAR_ERROR_TYPEMM);
912  return -1;
913 }
914
915 buf->meta.ring.read_pos = buf->meta.ring.write_pos = 0;
916
917 return 0;
918}
919
920//ll
Note: See TracBrowser for help on using the repository browser.