source: roaraudio/libroar/vio_buffer.c @ 5921:2fa512f52879

Last change on this file since 5921:2fa512f52879 was 5823:f9f70dbaa376, checked in by phi, 11 years ago

updated copyright

File size: 8.8 KB
Line 
1//vio_buffer.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2010-2013
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
38int     roar_vio_open_buffer    (struct roar_vio_calls * calls, struct roar_vio_calls * dst, ssize_t minsize, int use_re) {
39 struct roar_vio_buffer * self;;
40
41 if ( calls == NULL || dst == NULL )
42  return -1;
43
44 if ( (self = roar_mm_malloc(sizeof(struct roar_vio_buffer))) == NULL )
45  return -1;
46
47 memset(self, 0, sizeof(struct roar_vio_buffer));
48
49 self->backend     = dst;
50 self->min_bufsize = minsize;
51 self->use_re      = use_re;
52
53 if ( use_re ) {
54  if ( roar_vio_open_re(&(self->re_vio), dst) == -1 ) {
55   roar_mm_free(self);
56   return -1;
57  }
58 }
59
60 memset(calls, 0, sizeof(struct roar_vio_calls));
61 calls->flags    = ROAR_VIO_FLAGS_NONE;
62 calls->refc     = 1;
63
64 calls->inst     = self;
65 calls->close    = roar_vio_buffer_close;
66 calls->write    = roar_vio_buffer_write;
67 calls->ctl      = roar_vio_buffer_ctl;
68 calls->sync     = roar_vio_buffer_sync;
69 calls->lseek    = roar_vio_buffer_lseek;
70
71 return 0;
72}
73
74int     roar_vio_buffer_close   (struct roar_vio_calls * vio) {
75 struct roar_vio_buffer * self = vio->inst;
76 int ret;
77
78 if ( self->buf_old != NULL )
79  roar_buffer_free(self->buf_old);
80
81 if ( self->buf_cur != NULL )
82  roar_buffer_free(self->buf_cur);
83
84 if ( self->use_re ) {
85  ret = roar_vio_close(&(self->re_vio));
86 } else {
87  ret = roar_vio_close(self->backend);
88 }
89
90 roar_mm_free(self);
91
92 return ret;
93}
94
95ssize_t roar_vio_buffer_read    (struct roar_vio_calls * vio, void *buf, size_t count) {
96 struct roar_vio_buffer * self = vio->inst;
97 size_t                   havelen;
98 size_t                   buflen;
99 ssize_t                  ret;
100
101 if ( count == 0 )
102  return 0;
103
104 if ( buf == NULL )
105  return -1;
106
107 if ( self->offset.is_old ) {
108  havelen = (self->len_old + self->len_cur) - self->offset.offset;
109 } else {
110  havelen = self->len_cur - self->offset.offset;
111 }
112
113 if ( havelen == 0 ) {
114  if ( self->use_re ) {
115   ret = roar_vio_read(&(self->re_vio), buf, count);
116  } else {
117   ret = roar_vio_read(self->backend, buf, count);
118  }
119  // TODO...
120  return ret;
121 } else if ( count == havelen ) {
122  if (self->offset.is_old) {
123   buflen = count;
124   if ( roar_buffer_shift_out(&(self->buf_old), buf, &buflen) == -1 )
125    return -1;
126
127   if ( self->buf_old != NULL ) // strange error
128    return buflen;
129
130   buf   += buflen;
131   count -= buflen;
132
133   self->len_old       = 0;
134   self->offset.is_old = 0;
135   self->offset.offset = 0;
136  }
137
138  return -1;
139
140 } else if ( count <  havelen ) {
141 } else if ( count >  havelen ) {
142 }
143
144 return -1;
145}
146
147int     roar_vio_buffer_sync    (struct roar_vio_calls * vio) {
148 struct roar_vio_buffer * self = vio->inst;
149 struct roar_vio_calls  * backend;
150 roar_off_t dst = 0;
151
152 if ( self->use_re ) {
153  backend = &(self->re_vio);
154 } else {
155  backend = self->backend;
156 }
157
158 // bring backend in sync state, if this fails we do not need to continue...
159 if ( self->use_re ) {
160  if ( roar_vio_sync(backend) == -1 )
161   return -1;
162 } else {
163  if ( roar_vio_sync(backend) == -1 )
164   return -1;
165 }
166
167 if ( self->buf_old == NULL && self->buf_cur == NULL )
168  return 0; // we are in sync in case no buffers are currently used.
169
170 if (self->buf_old != NULL && self->buf_cur == NULL ) {
171  // we just finished the segment
172  roar_buffer_free(self->buf_old);
173  return 0;
174 }
175
176 // calc seek pos:
177 if ( self->offset.is_old ) {
178  dst = (self->len_cur + self->len_old) - self->offset.offset;
179 } else {
180  dst = self->len_cur - self->offset.offset;
181 }
182
183 dst = -dst;
184
185 // do the seek:
186 if ( roar_vio_lseek(backend, dst, SEEK_CUR) == (roar_off_t)-1 )
187  return -1;
188
189 // free all internal buffers:
190 if ( self->buf_old != NULL )
191  roar_buffer_free(self->buf_old);
192
193 if ( self->buf_cur != NULL )
194  roar_buffer_free(self->buf_cur);
195
196 self->offset.is_old = 0;
197 self->offset.offset = 0;
198
199 // funally bring the backend in sync state again, to be sure all changes are done.
200 if ( self->use_re ) {
201  if ( roar_vio_sync(backend) == -1 )
202   return -1;
203 } else {
204  if ( roar_vio_sync(backend) == -1 )
205   return -1;
206 }
207
208 return 0;
209}
210
211roar_off_t   roar_vio_buffer_lseek   (struct roar_vio_calls * vio, roar_off_t offset, int whence) {
212 struct roar_vio_buffer * self = vio->inst;
213 size_t newoff;
214 roar_off_t  ret;
215 roar_off_t  invoff;
216
217 // in-memory seeking is only supported for SEEK_CUR:
218 if ( whence == SEEK_CUR ) {
219  if ( offset == 0 ) {
220   return 0;
221  } else if ( offset > 0 ) {
222   newoff = self->offset.offset + offset;
223
224   if ( self->offset.is_old ) {
225    if ( newoff == self->len_old ) {
226     self->offset.is_old = 0;
227     self->offset.offset = 0;
228     self->abspos += offset;
229     return self->abspos;
230    } else if ( newoff < self->len_old ) {
231     self->offset.offset = newoff;
232     self->abspos += offset;
233     return self->abspos;
234    } else if ( newoff > self->len_old ) {
235     if ( newoff < (self->len_old + self->len_cur ) ) {
236      self->offset.is_old = 0;
237      self->offset.offset = offset + self->offset.offset - self->len_old;
238      self->abspos += offset;
239      return self->abspos;
240     }
241    }
242   } else {
243    if ( newoff == self->len_cur ) {
244     roar_buffer_free(self->buf_old);
245     self->buf_old = self->buf_cur;
246     self->buf_cur = NULL;
247     self->offset.offset = 0;
248     self->abspos += offset;
249     return self->abspos;
250    } else if ( newoff < self->len_cur ) {
251     self->offset.offset = newoff;
252     self->abspos += offset;
253     return self->abspos;
254    }
255   }
256  } else {
257   invoff = -offset;
258
259   if ( invoff <= self->offset.offset ) {
260    self->offset.offset = 0;
261    self->abspos -= invoff;
262    return self->abspos;
263   }
264
265   if ( !self->offset.is_old ) {
266    if ( invoff > self->offset.offset ) {
267     if ( invoff <= (self->len_old + self->offset.offset) ) {
268      self->offset.is_old = 1;
269      self->offset.offset = (self->len_old + self->offset.offset) - invoff;
270      self->abspos -= invoff;
271      return self->abspos;
272     }
273    }
274   }
275  }
276 }
277
278 // we need to do a physical seek;
279 // get in sync with current position, flush all buffers,...
280 if ( roar_vio_buffer_sync(vio) == -1 )
281  return -1;
282
283 // do the seek:
284 if ( self->use_re ) {
285  ret = roar_vio_lseek(&(self->re_vio), offset, whence);
286 } else {
287  ret = roar_vio_lseek(self->backend, offset, whence);
288 }
289
290 if (ret != (roar_off_t)-1)
291  self->abspos = ret;
292
293 return ret;
294}
295
296int     roar_vio_buffer_ctl     (struct roar_vio_calls * vio, roar_vio_ctl_t cmd, void * data) {
297 struct roar_vio_buffer * self;
298
299 if (vio == NULL || cmd == -1)
300  return -1;
301
302 ROAR_DBG("roar_vio_buffer_ctl(vio=%p, cmd=0x%.8x, data=%p) = ?", vio, cmd, data);
303
304 self = vio->inst;
305
306 switch (cmd) {
307  case ROAR_VIO_CTL_GET_NAME:
308    if ( data == NULL )
309     return -1;
310
311    *(char**)data = "buffer";
312    return 0;
313   break;
314  case ROAR_VIO_CTL_GET_NEXT:
315    if ( self->use_re ) {
316     *(struct roar_vio_calls **)data = &(self->re_vio);
317    } else {
318     *(struct roar_vio_calls **)data = self->backend;
319    }
320    return 0;
321   break;
322  case ROAR_VIO_CTL_SET_NEXT:
323    if ( self->use_re ) {
324     return roar_vio_ctl(&(self->re_vio), ROAR_VIO_CTL_SET_NEXT, data);
325    } else {
326     self->backend = *(struct roar_vio_calls **)data;
327    }
328    return 0;
329   break;
330  case ROAR_VIO_CTL_NONBLOCK:
331    if ( self->use_re ) {
332     return roar_vio_ctl(&(self->re_vio), ROAR_VIO_CTL_NONBLOCK, data);
333    } else {
334     return roar_vio_ctl(self->backend, ROAR_VIO_CTL_NONBLOCK, data);
335    }
336   break;
337 }
338
339 return roar_vio_ctl((struct roar_vio_calls *) vio->inst, cmd, data);
340}
341
342ssize_t roar_vio_buffer_write   (struct roar_vio_calls * vio, void *buf, size_t count) {
343 struct roar_vio_buffer * self = vio->inst;
344
345 if ( self->use_re ) {
346  return roar_vio_write(&(self->re_vio), buf, count);
347 } else {
348  return roar_vio_write(self->backend, buf, count);
349 }
350}
351
352//ll
Note: See TracBrowser for help on using the repository browser.