source: roaraudio/libroar/vio_buffer.c @ 5278:b3e0dd3f3141

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

last parts of merging _nonblock into _ctl and fixed sizeof(cmd) of _ctls

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