source: roaraudio/libroar/vs.c @ 4637:f50df7324ec1

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

support non-symbolic backends

File size: 29.0 KB
Line 
1//vs.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 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
38#define FLAG_NONE      0x0000
39#define FLAG_STREAM    0x0001
40#define FLAG_NONBLOCK  0x0002
41#define FLAG_BUFFERED  0x0004
42#define FLAG_CLOSEFILE 0x0008
43#define FLAG_DIR_IN    0x1000
44#define FLAG_DIR_OUT   0x2000
45
46#define _initerr()  do { errno = 0; roar_err_clear(); } while(0)
47#define _seterr(x)  do { if ( error != NULL ) *error = (x); ROAR_DBG("roar_vs_*(*): *error=%s(%i)", roar_vs_strerr((x)), (x)); } while(0)
48#define _seterrre() do { _seterr(roar_errno); } while(0)
49#define _seterrse() do { roar_err_from_errno(); _seterr(roar_errno); } while(0)
50#define _ckvss(ret) do { if ( vss == NULL ) { _seterr(ROAR_ERROR_INVAL); return (ret); } } while(0)
51
52struct roar_vs {
53 int flags;
54 struct roar_connection con_store;
55 struct roar_connection * con;
56 struct roar_stream       stream;
57 struct roar_vio_calls    vio;
58 struct roar_audio_info   info;
59 size_t                   readc, writec;
60 int                      mixerid;
61 int                      first_primid;
62 struct roar_buffer     * readbuffer, * writebuffer;
63 struct roar_vio_calls    file_store;
64 struct roar_vio_calls  * file;
65 struct roar_buffer     * readring, * writering;
66};
67
68static int _roar_vs_find_first_prim(roar_vs_t * vss);
69
70const char * roar_vs_strerr(int error) {
71 const struct {
72  int err;
73  const char * msg;
74 } msgs[] = {
75  {ROAR_ERROR_NONE,        "No error"},
76  {ROAR_ERROR_PERM,        "Operation not permitted"},
77  {ROAR_ERROR_NOENT,       "No such object, file or directory"},
78  {ROAR_ERROR_BADMSG,      "Bad message"},
79  {ROAR_ERROR_BUSY,        "Device or resource busy"},
80  {ROAR_ERROR_CONNREFUSED, "Connection refused"},
81  {ROAR_ERROR_NOSYS,       "Function not implemented"},
82  {ROAR_ERROR_NOTSUP,      "Operation not supported"},
83  {ROAR_ERROR_PIPE,        "Broken pipe"},
84  {ROAR_ERROR_PROTO,       "Protocol error"},
85  {ROAR_ERROR_RANGE,       "Result too large or parameter out of range"},
86  {ROAR_ERROR_MSGSIZE,     "Message too long"},
87  {ROAR_ERROR_NOMEM,       "Not enough space"},
88  {ROAR_ERROR_INVAL,       "Invalid argument"},
89  {-1, NULL}
90 };
91 int i;
92
93 for (i = 0; msgs[i].msg != NULL; i++)
94  if ( msgs[i].err == error )
95   return msgs[i].msg;
96
97 return "(unknown)";
98}
99
100static roar_vs_t * roar_vs_init(int * error) {
101 roar_vs_t * vss = roar_mm_malloc(sizeof(roar_vs_t));
102
103 if ( vss == NULL ) {
104  _seterrse();
105  return NULL;
106 }
107
108 memset(vss, 0, sizeof(roar_vs_t));
109
110 vss->mixerid      = -1;
111 vss->first_primid = -1;
112
113 return vss;
114}
115
116roar_vs_t * roar_vs_new_from_con(struct roar_connection * con, int * error) {
117 roar_vs_t * vss = roar_vs_init(error);
118
119 if ( vss == NULL )
120  return NULL;
121
122 vss->con = con;
123
124 return vss;
125}
126
127roar_vs_t * roar_vs_new(const char * server, const char * name, int * error) {
128 roar_vs_t * vss = roar_vs_init(error);
129 int ret;
130
131 if ( vss == NULL )
132  return NULL;
133
134 vss->con = &(vss->con_store);
135
136 _initerr();
137
138 ret = roar_simple_connect(vss->con, (char*)server, (char*)name);
139
140 if ( ret == -1 ) {
141  roar_vs_close(vss, ROAR_VS_TRUE, NULL);
142  _seterrre();
143  return NULL;
144 }
145
146 return vss;
147}
148
149int roar_vs_stream(roar_vs_t * vss, const struct roar_audio_info * info, int dir, int * error) {
150 struct roar_stream_info sinfo;
151 int ret;
152
153 _ckvss(-1);
154
155 if ( vss->flags & FLAG_STREAM ) {
156  _seterr(ROAR_ERROR_INVAL);
157  return -1;
158 }
159
160 _initerr();
161
162 if ( info != &(vss->info) )
163  memcpy(&(vss->info), info, sizeof(struct roar_audio_info));
164
165 ret = roar_vio_simple_new_stream_obj(&(vss->vio), vss->con, &(vss->stream),
166                                      info->rate, info->channels, info->bits, info->codec,
167                                      dir
168                                     );
169
170 if ( ret == -1 ) {
171  _seterrre();
172  return -1;
173 }
174
175 if ( roar_stream_get_info(vss->con, &(vss->stream), &sinfo) != -1 ) {
176  // TODO: fix this:
177  // as we currently do not support to select mixer we just check if we hit the
178  // right one.
179  if ( vss->mixerid != -1 && vss->mixerid != sinfo.mixer ) {
180   _seterr(ROAR_ERROR_INVAL); // TODO: should we maybe use a diffrent value?
181   roar_vio_close(&(vss->vio));
182   return -1;
183  }
184
185  vss->mixerid = sinfo.mixer;
186  _roar_vs_find_first_prim(vss);
187 }
188
189 vss->flags |= FLAG_STREAM;
190
191 switch (dir) {
192  case ROAR_DIR_PLAY: vss->flags |= FLAG_DIR_OUT; break;
193 }
194
195 return 0;
196}
197
198roar_vs_t * roar_vs_new_simple(const char * server, const char * name, int rate, int channels, int codec, int bits, int dir, int * error) {
199 roar_vs_t * vss = roar_vs_new(server, name, error);
200 int ret;
201
202 if (vss == NULL)
203  return NULL;
204
205 memset(&(vss->info), 0, sizeof(vss->info));
206
207 vss->info.rate     = rate;
208 vss->info.channels = channels;
209 vss->info.codec    = codec;
210 vss->info.bits     = bits;
211
212 ret = roar_vs_stream(vss, &(vss->info), dir, error);
213
214 if (ret == -1) {
215  roar_vs_close(vss, ROAR_VS_TRUE, NULL);
216  return NULL;
217 }
218
219 return vss;
220}
221
222int roar_vs_file(roar_vs_t * vss, struct roar_vio_calls * vio, int closefile, int * error) {
223 _ckvss(-1);
224
225 if ( vio == NULL || (closefile != ROAR_VS_TRUE && closefile != ROAR_VS_FALSE)) {
226  _seterr(ROAR_ERROR_INVAL);
227  return -1;
228 }
229
230 if ( vss->file != NULL ) {
231  _seterr(ROAR_ERROR_INVAL);
232  return -1;
233 }
234
235 vss->file = vio;
236 if ( closefile == ROAR_VS_TRUE )
237  vss->flags |= FLAG_CLOSEFILE;
238
239 return 0;
240}
241
242int roar_vs_file_simple(roar_vs_t * vss, char * filename, int * error) {
243 struct roar_vio_defaults def;
244 struct roar_vio_calls * file;
245 char buf[64];
246 ssize_t ret;
247 int dir = O_RDONLY;
248 int codec = -1;
249 const char * content_type;
250
251 _ckvss(-1);
252
253 if ( vss->file != NULL ) {
254  _seterr(ROAR_ERROR_INVAL);
255  return -1;
256 }
257
258 if ( vss->flags & FLAG_STREAM ) {
259  switch (vss->flags & (FLAG_DIR_IN|FLAG_DIR_OUT)) {
260   case FLAG_DIR_IN:  dir = O_WRONLY; break;
261   case FLAG_DIR_OUT: dir = O_RDONLY; break;
262   case FLAG_DIR_IN|FLAG_DIR_OUT: dir = O_RDWR; break;
263   default:
264     _seterr(ROAR_ERROR_INVAL);
265     return -1;
266  }
267 }
268
269 file = &(vss->file_store);
270
271 _initerr();
272
273 if ( roar_vio_dstr_init_defaults(&def, ROAR_VIO_DEF_TYPE_NONE, dir, 0644) == -1 ) {
274  _seterrre();
275  return -1;
276 }
277
278 if ( roar_vio_open_dstr(file, filename, &def, 1) == -1 ) {
279  _seterrre();
280  return -1;
281 }
282
283 if ( !(vss->flags & FLAG_STREAM) ) {
284  if ( roar_vio_ctl(file, ROAR_VIO_CTL_GET_MIMETYPE, &content_type) != -1 ) {
285   codec = roar_mime2codec(content_type);
286  }
287
288  if ( codec == -1 ) {
289   ret = roar_vio_read(file, buf, sizeof(buf));
290
291   codec = roar_file_codecdetect(buf, ret);
292
293   if ( codec == -1 ) {
294    roar_vio_close(file);
295    _seterr(ROAR_ERROR_INVAL); // Other value?
296    return -1;
297   }
298
299   if ( roar_vio_lseek(file, 0, SEEK_SET) != 0 ) {
300    roar_vio_close(file);
301   _seterrre();
302    return -1;
303   }
304  }
305
306  memset(&(vss->info), 0, sizeof(vss->info));
307
308  vss->info.rate     = ROAR_RATE_DEFAULT;
309  vss->info.channels = ROAR_CHANNELS_DEFAULT;
310  vss->info.codec    = codec;
311  vss->info.bits     = ROAR_BITS_DEFAULT;
312
313  ret = roar_vs_stream(vss, &(vss->info), ROAR_DIR_PLAY, error);
314
315  if ( ret == -1 ) {
316   roar_vio_close(file);
317   return -1;
318  }
319 }
320
321 if ( roar_vs_file(vss, file, ROAR_VS_TRUE, error) == -1 ) {
322  roar_vio_close(file);
323  return -1;
324 }
325
326 return 0;
327}
328
329roar_vs_t * roar_vs_new_from_file(const char * server, const char * name, char * filename, int * error) {
330 roar_vs_t * vss = roar_vs_new(server, name, error);
331
332 if ( vss == NULL )
333  return NULL;
334
335 if ( roar_vs_file_simple(vss, filename, error) != 0 ) {
336  roar_vs_close(vss, ROAR_VS_TRUE, NULL);
337  return NULL;
338 }
339
340 return vss;
341}
342
343int roar_vs_buffer(roar_vs_t * vss, size_t buffer, int * error) {
344 _ckvss(-1);
345
346 if ( vss->flags & FLAG_BUFFERED )
347  return -1;
348
349 if ( roar_buffer_ring_new(&(vss->readring), buffer, 0) == -1 ) {
350  _seterrre();
351  return -1;
352 }
353
354 if ( roar_buffer_ring_new(&(vss->writering), buffer, 0) == -1 ) {
355  _seterrre();
356  roar_buffer_free(vss->readring);
357  vss->readring = NULL;
358  return -1;
359 }
360
361 vss->flags |= FLAG_BUFFERED;
362
363 return 0;
364}
365
366int roar_vs_close(roar_vs_t * vss, int killit, int * error) {
367 if ( killit != ROAR_VS_TRUE && killit != ROAR_VS_FALSE ) {
368  _seterr(ROAR_ERROR_INVAL);
369  return -1;
370 }
371
372 _ckvss(-1);
373
374 if ( vss->readbuffer != NULL )
375  roar_buffer_free(vss->readbuffer);
376 if ( vss->writebuffer != NULL )
377  roar_buffer_free(vss->writebuffer);
378
379 if ( vss->readring != NULL )
380  roar_buffer_free(vss->readring);
381 if ( vss->writering != NULL )
382  roar_buffer_free(vss->writering);
383
384 if ( vss->file != NULL && vss->flags & FLAG_CLOSEFILE )
385  roar_vio_close(vss->file);
386
387 if ( vss->flags & FLAG_STREAM ) {
388  if ( killit == ROAR_VS_TRUE ) {
389   roar_kick(vss->con, ROAR_OT_STREAM, roar_stream_get_id(&(vss->stream)));
390  }
391
392  roar_vio_close(&(vss->vio));
393 }
394
395 if ( vss->con == &(vss->con_store) ) {
396  roar_disconnect(vss->con);
397 }
398
399 roar_mm_free(vss);
400 return 0;
401}
402
403static ssize_t roar_vs_write_direct(roar_vs_t * vss, const void * buf, size_t len, int * error) {
404 ssize_t ret = roar_vio_write(&(vss->vio), (void*)buf, len);
405
406 if ( ret == -1 ) {
407#ifdef EAGAIN
408  if ( errno == EAGAIN )
409   return 0;
410#endif
411
412#ifdef EWOULDBLOCK
413  if ( errno == EWOULDBLOCK )
414   return 0;
415#endif
416
417  _seterrre();
418 } else {
419  if ( !(vss->flags & FLAG_BUFFERED) )
420   vss->writec += ret;
421 }
422
423 return ret;
424}
425
426ssize_t roar_vs_write(roar_vs_t * vss, const void * buf, size_t len, int * error) {
427 ssize_t ret;
428 size_t writelen;
429
430 _ckvss(-1);
431
432 if ( !(vss->flags & FLAG_STREAM) ) {
433  _seterr(ROAR_ERROR_INVAL);
434  return -1;
435 }
436
437 _initerr();
438
439 if ( vss->flags & FLAG_BUFFERED ) {
440  writelen = len;
441
442  if ( roar_buffer_ring_write(vss->writering, (void*)buf, &writelen) == -1 ) {
443   _seterrre();
444   return -1;
445  }
446
447  ret = writelen;
448  vss->writec += ret;
449 } else {
450  ret = roar_vs_write_direct(vss, buf, len, error);
451 }
452
453 return ret;
454}
455
456ssize_t roar_vs_read (roar_vs_t * vss,       void * buf, size_t len, int * error) {
457 ssize_t ret;
458
459 _ckvss(-1);
460
461 if ( !(vss->flags & FLAG_STREAM) ) {
462  _seterr(ROAR_ERROR_INVAL);
463  return -1;
464 }
465
466 _initerr();
467
468 ret = roar_vio_read(&(vss->vio), buf, len);
469
470 if ( ret == -1 ) {
471  _seterrre();
472 } else {
473  vss->readc += ret;
474 }
475
476 return ret;
477}
478
479int     roar_vs_sync (roar_vs_t * vss, int wait, int * error) {
480 struct roar_event waits, triggered;
481
482 _ckvss(-1);
483
484 if ( !(vss->flags & FLAG_STREAM) ) {
485  _seterr(ROAR_ERROR_INVAL);
486  return -1;
487 }
488
489 if ( wait != ROAR_VS_NOWAIT && wait != ROAR_VS_WAIT ) {
490  _seterr(ROAR_ERROR_INVAL);
491  return -1;
492 }
493
494 _initerr();
495
496 if ( roar_vio_sync(&(vss->vio)) == -1 ) {
497  _seterrre();
498  return -1;
499 }
500
501 if ( wait == ROAR_VS_WAIT ) {
502  memset(&waits, 0, sizeof(waits));
503  waits.event       = ROAR_OE_STREAM_XRUN;
504  waits.emitter     = -1;
505  waits.target      = roar_stream_get_id(&(vss->stream));
506  waits.target_type = ROAR_OT_STREAM;
507
508  if ( roar_wait(vss->con, &triggered, &waits, 1) == -1 ) {
509   _seterrre();
510   return -1;
511  }
512 }
513
514 return 0;
515}
516
517int     roar_vs_blocking (roar_vs_t * vss, int val, int * error) {
518 int old = -1;
519
520 _ckvss(-1);
521
522  if ( !(vss->flags & FLAG_STREAM) ) {
523  _seterr(ROAR_ERROR_INVAL);
524  return -1;
525 }
526
527 old = vss->flags & FLAG_NONBLOCK ? ROAR_VS_FALSE : ROAR_VS_TRUE;
528
529 _initerr();
530
531 switch (val) {
532  case ROAR_VS_TRUE:
533    if ( roar_vio_nonblock(&(vss->vio), ROAR_SOCKET_BLOCK) == -1 ) {
534     _seterrre();
535     return -1;
536    }
537    vss->flags |= FLAG_NONBLOCK;
538    vss->flags -= FLAG_NONBLOCK;
539    return old;
540   break;
541  case ROAR_VS_FALSE:
542    if ( roar_vio_nonblock(&(vss->vio), ROAR_SOCKET_NONBLOCK) == -1 ) {
543     _seterrre();
544     return -1;
545    }
546    vss->flags |= FLAG_NONBLOCK;
547    return old;
548   break;
549  case ROAR_VS_TOGGLE:
550    if ( old == ROAR_VS_TRUE ) {
551     return roar_vs_blocking(vss, ROAR_VS_FALSE, error);
552    } else {
553     return roar_vs_blocking(vss, ROAR_VS_TRUE, error);
554    }
555   break;
556  case ROAR_VS_ASK:
557    return old;
558   break;
559 }
560
561 _seterr(ROAR_ERROR_INVAL);
562 return -1;
563}
564
565static int _roar_vs_find_first_prim(roar_vs_t * vss) {
566 struct roar_stream stream;
567 struct roar_stream_info info;
568 int id[ROAR_STREAMS_MAX];
569 int num;
570 int i;
571
572 if ( vss->first_primid != -1 )
573  return vss->first_primid;
574
575 if ( vss->mixerid == -1 )
576  return -1;
577
578 if ( (num = roar_list_streams(vss->con, id, ROAR_STREAMS_MAX)) == -1 ) {
579  return -1;
580 }
581
582 for (i = 0; i < num; i++) {
583  if ( roar_get_stream(vss->con, &stream, id[i]) == -1 )
584   continue;
585
586  if ( stream.dir != ROAR_DIR_OUTPUT )
587   continue;
588
589  if ( roar_stream_get_info(vss->con, &stream, &info) == -1 )
590   continue;
591
592  if ( info.mixer == vss->mixerid ) {
593   vss->first_primid = id[i];
594   return id[i];
595  }
596 }
597
598 return -1;
599}
600
601ssize_t roar_vs_position(roar_vs_t * vss, int backend, int * error) {
602 struct roar_stream stream;
603 struct roar_stream      out_stream;
604 struct roar_stream_info out_info;
605 size_t offset = 0;
606
607 _ckvss(-1);
608
609 if ( !(vss->flags & FLAG_STREAM) ) {
610  _seterr(ROAR_ERROR_INVAL);
611  return -1;
612 }
613
614 _initerr();
615
616 if ( roar_get_stream(vss->con, &stream, roar_stream_get_id(&(vss->stream))) == -1 ) {
617  _seterrre();
618  return -1;
619 }
620
621 switch (backend) {
622  case ROAR_VS_BACKEND_NONE:
623    return stream.pos;
624   break;
625  case ROAR_VS_BACKEND_FIRST:
626    if ( vss->first_primid == -1 ) {
627     _seterr(ROAR_ERROR_UNKNOWN);
628     return -1;
629    }
630
631    backend = vss->first_primid;
632   break;
633  default:
634    if ( backend < 0 ) {
635     _seterr(ROAR_ERROR_INVAL);
636     return -1;
637    }
638   break;
639 }
640
641
642 if ( backend >= 0 ) {
643  roar_stream_new_by_id(&out_stream, backend);
644
645  if ( roar_stream_get_info(vss->con, &out_stream, &out_info) == -1 ) {
646   _seterrre();
647   return -1;
648  }
649
650  offset  = out_info.delay * vss->info.rate;
651  offset /= 1000000;
652 }
653
654 return stream.pos + offset;
655}
656
657roar_mus_t roar_vs_latency(roar_vs_t * vss, int backend, int * error) {
658 ssize_t pos  = roar_vs_position(vss, backend, error);
659 ssize_t bps;  // byte per sample
660 size_t  lioc; // local IO (byte) counter
661 size_t  lpos; // local possition
662 signed long long int lag;
663
664 _initerr();
665
666 _ckvss(-1);
667
668 if (pos == -1) {
669  _seterrre();
670  return 0;
671 }
672
673 if ( !(vss->flags & FLAG_STREAM) ) {
674  _seterr(ROAR_ERROR_INVAL);
675  return 0;
676 }
677
678 if ( vss->writec == 0 ) {
679  lioc = vss->readc;
680 } else {
681  lioc = vss->writec;
682 }
683
684 bps = roar_info2samplesize(&(vss->info));
685
686 if ( bps == -1 ) {
687  _seterrre();
688  return 0;
689 }
690
691 lpos = (lioc*8) / bps;
692
693// printf("pos=%zi, lpos=%zi, bps=%zi, diff[lpos-pos]=%zi\n", pos, lpos, bps, (lpos - pos));
694
695 lag = (signed long long int)lpos - (signed long long int)pos;
696 lag /= vss->info.channels;
697
698 // we now have the lag in frames
699 // return value are mus
700 // so we need to multiply with 1s/mus and
701 // multiply by 1/rate
702
703 lag *= 1000000; // 1s/mus
704 lag /= vss->info.rate;
705
706 if ( lag == 0 ) {
707  _seterr(ROAR_ERROR_NONE);
708 }
709
710 return lag;
711}
712
713static int roar_vs_flag(roar_vs_t * vss, int flag, int val, int * error) {
714 struct roar_stream_info info;
715 int old = -1;
716
717 _ckvss(-1);
718
719 if ( !(vss->flags & FLAG_STREAM) ) {
720  _seterr(ROAR_ERROR_INVAL);
721  return -1;
722 }
723
724 if ( val != ROAR_VS_ASK )
725  old = roar_vs_flag(vss, flag, ROAR_VS_ASK, error);
726
727 _initerr();
728
729 switch (val) {
730  case ROAR_VS_TRUE:
731  case ROAR_VS_FALSE:
732    if ( roar_stream_set_flags(vss->con, &(vss->stream), flag,
733                               val == ROAR_VS_TRUE ? ROAR_SET_FLAG : ROAR_RESET_FLAG) == -1 ) {
734     _seterrre();
735     return -1;
736    }
737    return old;
738   break;
739  case ROAR_VS_TOGGLE:
740    return roar_vs_flag(vss, flag, old == ROAR_VS_TRUE ? ROAR_VS_FALSE : ROAR_VS_TRUE, error);
741   break;
742  case ROAR_VS_ASK:
743    if ( roar_stream_get_info(vss->con, &(vss->stream), &info) == -1 ) {
744     _seterrre();
745     return -1;
746    }
747    return info.flags & flag ? ROAR_VS_TRUE : ROAR_VS_FALSE;
748   break;
749 }
750
751 _seterr(ROAR_ERROR_INVAL);
752 return -1;
753}
754
755int     roar_vs_pause(roar_vs_t * vss, int val, int * error) {
756 return roar_vs_flag(vss, ROAR_FLAG_PAUSE, val, error);
757}
758
759int     roar_vs_mute (roar_vs_t * vss, int val, int * error) {
760 return roar_vs_flag(vss, ROAR_FLAG_MUTE, val, error);
761}
762
763static int roar_vs_volume (roar_vs_t * vss, float * c, size_t channels, int * error) {
764 struct roar_mixer_settings mixer;
765 size_t i;
766 register float s;
767 int oldchannels;
768 int handled;
769
770 _ckvss(-1);
771
772 if ( !(vss->flags & FLAG_STREAM) ) {
773  _seterr(ROAR_ERROR_INVAL);
774  return -1;
775 }
776
777 if ( channels > ROAR_MAX_CHANNELS ) {
778  _seterr(ROAR_ERROR_INVAL);
779  return -1;
780 }
781
782 _initerr();
783
784 if ( roar_get_vol(vss->con, roar_stream_get_id(&(vss->stream)), &mixer, &oldchannels) == -1 ) {
785  _seterrre();
786  return -1;
787 }
788
789 for (i = 0; i < channels; i++) {
790  s = c[i] * 65535.0;
791  if ( s > 66190.0 || s < -655.0 ) {
792   _seterr(ROAR_ERROR_RANGE);
793   return -1;
794  } else if ( s > 65535.0 ) {
795   s = 65535.0;
796  } else if ( s <     0.0 ) {
797   s = 0.0;
798  }
799  mixer.mixer[i] = s;
800 }
801
802 mixer.scale = 65535;
803
804 if ( channels != oldchannels ) {
805  handled = 0;
806  switch (oldchannels) {
807   case 1:
808     if ( channels == 2 ) {
809      mixer.mixer[0] = (mixer.mixer[0] + mixer.mixer[1]) / 2;
810      handled = 1;
811     }
812    break;
813   case 2:
814     if ( channels == 1 ) {
815      mixer.mixer[1] = mixer.mixer[0];
816      handled = 1;
817     }
818    break;
819   case 4:
820     if ( channels == 1 ) {
821      mixer.mixer[1] = mixer.mixer[0];
822      mixer.mixer[2] = mixer.mixer[0];
823      mixer.mixer[3] = mixer.mixer[0];
824      handled = 1;
825     } else if ( channels == 2 ) {
826      mixer.mixer[2] = mixer.mixer[0];
827      mixer.mixer[3] = mixer.mixer[1];
828      handled = 1;
829     }
830    break;
831  }
832  if ( handled ) {
833   channels = oldchannels;
834  } else {
835   _seterr(ROAR_ERROR_INVAL);
836   return -1;
837  }
838 }
839
840 if ( roar_set_vol(vss->con, roar_stream_get_id(&(vss->stream)), &mixer, channels) == -1 ) {
841  _seterrre();
842  return -1;
843 }
844
845 return 0;
846}
847
848int     roar_vs_volume_mono   (roar_vs_t * vss, float c, int * error) {
849 return roar_vs_volume(vss, &c, 1, error);
850}
851
852int     roar_vs_volume_stereo (roar_vs_t * vss, float l, float r, int * error) {
853 float c[2] = {l, r};
854 return roar_vs_volume(vss, c, 2, error);
855}
856
857int     roar_vs_volume_get    (roar_vs_t * vss, float * l, float * r, int * error) {
858 struct roar_mixer_settings mixer;
859 int channels;
860
861 if ( vss == NULL || l == NULL || r == NULL ) {
862  _seterr(ROAR_ERROR_INVAL);
863  return -1;
864 }
865
866 if ( !(vss->flags & FLAG_STREAM) ) {
867  _seterr(ROAR_ERROR_INVAL);
868  return -1;
869 }
870
871 _initerr();
872
873 if ( roar_get_vol(vss->con, roar_stream_get_id(&(vss->stream)), &mixer, &channels) == -1 ) {
874  _seterrre();
875  return -1;
876 }
877
878 if ( channels == 1 )
879  mixer.mixer[1] = mixer.mixer[0];
880
881 *l = mixer.mixer[0] / (float)mixer.scale;
882 *r = mixer.mixer[1] / (float)mixer.scale;
883
884 return 0;
885}
886
887int     roar_vs_meta          (roar_vs_t * vss, struct roar_keyval * kv, size_t len, int * error) {
888 struct roar_meta meta;
889 size_t i;
890 int type;
891 int ret = 0;
892
893 _ckvss(-1);
894
895 if ( !(vss->flags & FLAG_STREAM) ) {
896  _seterr(ROAR_ERROR_INVAL);
897  return -1;
898 }
899
900 meta.type   = ROAR_META_TYPE_NONE;
901 meta.key[0] = 0;
902 meta.value  = NULL;
903
904 _initerr();
905
906 if ( roar_stream_meta_set(vss->con, &(vss->stream), ROAR_META_MODE_CLEAR, &meta) == -1 ) {
907  _seterrre();
908  ret = -1;
909 }
910
911 for (i = 0; i < len; i++) {
912  type = roar_meta_inttype(kv[i].key);
913  meta.type  = type;
914  meta.value = kv[i].value;
915
916  if ( roar_stream_meta_set(vss->con, &(vss->stream), ROAR_META_MODE_ADD, &meta) == -1 ) {
917   _seterrre();
918   ret = -1;
919  }
920 }
921
922 meta.type   = ROAR_META_TYPE_NONE;
923 meta.key[0] = 0;
924 meta.value  = NULL;
925 if ( roar_stream_meta_set(vss->con, &(vss->stream), ROAR_META_MODE_FINALIZE, &meta) == -1 ) {
926  _seterrre();
927  ret = -1;
928 }
929
930 return ret;
931}
932
933int     roar_vs_role          (roar_vs_t * vss, int role, int * error) {
934 _ckvss(-1);
935
936 if ( !(vss->flags & FLAG_STREAM) ) {
937  _seterr(ROAR_ERROR_INVAL);
938  return -1;
939 }
940
941 _initerr();
942
943 if ( roar_stream_set_role(vss->con, &(vss->stream), role) == -1 ) {
944  _seterrre();
945  return -1;
946 }
947
948 return 0;
949}
950
951
952int     roar_vs_iterate       (roar_vs_t * vss, int wait, int * error) {
953 struct roar_vio_select vios[3];
954 struct roar_vio_selecttv rtv = {.sec = 0, .nsec = 1};
955 size_t len = 0;
956 ssize_t i;
957 ssize_t ret;
958 int can_read = 0, can_write = 0;
959 int can_flush_stream = 0, can_flush_file = 0;
960 int is_eof = 0;
961 void * data;
962 size_t tmp;
963
964 // TODO: fix error handling below.
965
966 _ckvss(-1);
967
968 if ( wait != ROAR_VS_WAIT && wait != ROAR_VS_NOWAIT ) {
969  _seterr(ROAR_ERROR_INVAL);
970  return -1;
971 }
972
973 ROAR_VIO_SELECT_SETVIO(&(vios[len]), &(vss->vio), ((vss->flags & FLAG_DIR_IN  ? ROAR_VIO_SELECT_READ  : 0) |
974                                                    (vss->flags & FLAG_DIR_OUT ? ROAR_VIO_SELECT_WRITE : 0)));
975 vios[len].ud.vp = &(vss->vio);
976 len++;
977
978 ROAR_VIO_SELECT_SETVIO(&(vios[len]), roar_get_connection_vio2(vss->con), ROAR_VIO_SELECT_READ);
979 vios[len].ud.vp = vss->con;
980 len++;
981
982
983// TODO: FIXME: need to do two select()s so we can sleep more efficently and test for both directions.
984// for the moment we disable file direction and hope it will not block anyway...
985/*
986 if ( vss->file != NULL ) {
987  ROAR_VIO_SELECT_SETVIO(&(vios[len]), vss->file, ((vss->flags & FLAG_DIR_IN  ? ROAR_VIO_SELECT_WRITE : 0) |
988                                                   (vss->flags & FLAG_DIR_OUT ? ROAR_VIO_SELECT_READ  : 0)));
989  vios[len].ud.vp = vss->file;
990  len++;
991 }
992*/
993
994 ret = roar_vio_select(vios, len, (wait == ROAR_VS_NOWAIT ? &rtv : NULL), NULL);
995
996// part 2 of above hack:
997// emulate read handle.
998  if ( vss->file != NULL ) {
999   vios[len].ud.vp   = vss->file;
1000   vios[len].eventsa = ROAR_VIO_SELECT_WRITE|ROAR_VIO_SELECT_READ;
1001   len++;
1002  }
1003
1004 // no error here nor EOF.
1005 if ( ret == 0 )
1006  return 1;
1007
1008 for (i = 0; i < len; i++) {
1009  if ( !vios[i].eventsa )
1010   continue;
1011
1012  if ( vios[i].ud.vp == &(vss->vio) ) {
1013   if ( vios[i].eventsa & ROAR_VIO_SELECT_READ )
1014    can_read++;
1015
1016   if ( vios[i].eventsa & ROAR_VIO_SELECT_WRITE ) {
1017    can_write++;
1018    can_flush_stream = 1;
1019   }
1020  } else if ( vios[i].ud.vp == vss->con ) {
1021   roar_sync(vss->con);
1022  } else if ( vss->file != NULL && vios[i].ud.vp == vss->file ) {
1023   if ( vios[i].eventsa & ROAR_VIO_SELECT_READ )
1024    can_write++;
1025
1026   if ( vios[i].eventsa & ROAR_VIO_SELECT_WRITE ) {
1027    can_read++;
1028    can_flush_file = 1;
1029   }
1030  }
1031 }
1032
1033 if ( vss->flags & FLAG_BUFFERED ) {
1034  if ( roar_buffer_ring_avail(vss->readring, NULL, &tmp) != -1 )
1035   if ( tmp > 0 )
1036    can_read++;
1037
1038// no check here to just let the read return zero and we do EOF handling.
1039/*
1040  if ( roar_buffer_ring_avail(vss->writering, &tmp, NULL) != -1 )
1041   if ( tmp > 0 )
1042*/
1043    can_write++;
1044 }
1045
1046 ROAR_DBG("roar_vs_iterate(vss=%p, wait=%i, error=%p): can_read=%i, can_write=%i", vss, wait, error, can_read, can_write);
1047
1048 // TODO: FIXME: Need to correct error handling here!
1049
1050 if ( can_flush_stream && vss->writebuffer != NULL ) {
1051  if ( roar_buffer_get_data(vss->writebuffer, &data) == -1 )
1052   return -1;
1053
1054  if ( roar_buffer_get_len(vss->writebuffer, &len) == -1 )
1055   return -1;
1056
1057  ret = roar_vs_write_direct(vss, data, len, error);
1058
1059  if ( ret == -1 ) {
1060   return -1;
1061  } else if ( ret == len ) {
1062   roar_buffer_free(vss->writebuffer);
1063   vss->writebuffer = NULL;
1064  } else {
1065   if ( roar_buffer_set_offset(vss->writebuffer, ret) == -1 )
1066    return -1;
1067  }
1068 }
1069
1070 if ( can_flush_file && vss->readbuffer != NULL ) {
1071  if ( roar_buffer_get_data(vss->readbuffer, &data) == -1 )
1072   return -1;
1073
1074  if ( roar_buffer_get_len(vss->readbuffer, &len) == -1 )
1075   return -1;
1076
1077  ret = roar_vio_write(vss->file, data, len);
1078
1079  if ( ret == -1 ) {
1080   return -1;
1081  } else if ( ret == len ) {
1082   roar_buffer_free(vss->readbuffer);
1083   vss->readbuffer = NULL;
1084  } else {
1085   if ( roar_buffer_set_offset(vss->readbuffer, ret) == -1 )
1086    return -1;
1087  }
1088 }
1089
1090#define _READ_SIZE 1024
1091
1092 if ( can_read == 2 && vss->readbuffer == NULL ) {
1093  if ( roar_buffer_new_data(&(vss->readbuffer), (len = _READ_SIZE), &data) == -1 )
1094   return -1;
1095
1096  ret = roar_vs_read(vss, data, len, error);
1097
1098  if ( ret == -1 ) {
1099   roar_buffer_free(vss->readbuffer);
1100   vss->readbuffer = NULL;
1101   return -1;
1102  } else if ( ret == 0 ) {
1103   is_eof = 1;
1104   roar_buffer_free(vss->readbuffer);
1105   vss->readbuffer = NULL;
1106  } else {
1107   len = ret;
1108   if ( roar_buffer_set_len(vss->readbuffer, len) == -1 )
1109    return -1;
1110
1111   if ( vss->flags & FLAG_BUFFERED ) {
1112    tmp = len;
1113    if ( roar_buffer_ring_write(vss->readring, data, &tmp) == -1 ) {
1114     ret = -1;
1115    } else {
1116     ret = tmp;
1117    }
1118   } else {
1119    ret = roar_vio_write(vss->file, data, len);
1120   }
1121
1122   if ( ret == -1 ) {
1123    return -1;
1124   } else if ( ret == len ) {
1125    roar_buffer_free(vss->readbuffer);
1126    vss->readbuffer = NULL;
1127   } else {
1128    if ( roar_buffer_set_offset(vss->readbuffer, ret) == -1 )
1129     return -1;
1130   }
1131  }
1132 }
1133
1134 if ( can_write == 2 && vss->writebuffer == NULL ) {
1135  if ( roar_buffer_new_data(&(vss->writebuffer), (len = _READ_SIZE), &data) == -1 )
1136   return -1;
1137
1138  if ( vss->flags & FLAG_BUFFERED ) {
1139   tmp = len;
1140   if ( roar_buffer_ring_read(vss->writering, data, &tmp) == -1 ) {
1141    ret = -1;
1142   } else {
1143    ret = tmp;
1144   }
1145  } else {
1146   ret = roar_vio_read(vss->file, data, len);
1147  }
1148
1149  ROAR_DBG("roar_vs_iterate(vss=%p, wait=%i, error=%p): ret=%lli", vss, wait, error, (long long int)ret);
1150
1151  if ( ret == -1 ) {
1152   ROAR_DBG("roar_vs_iterate(vss=%p, wait=%i, error=%p) = ?", vss, wait, error);
1153
1154   roar_buffer_free(vss->writebuffer);
1155   vss->writebuffer = NULL;
1156   return -1;
1157  } else if ( ret == 0 ) {
1158   ROAR_DBG("roar_vs_iterate(vss=%p, wait=%i, error=%p) = ?", vss, wait, error);
1159
1160   is_eof = 1;
1161   roar_buffer_free(vss->writebuffer);
1162   vss->writebuffer = NULL;
1163  } else {
1164   ROAR_DBG("roar_vs_iterate(vss=%p, wait=%i, error=%p) = ?", vss, wait, error);
1165
1166   if ( len != ret ) {
1167    len = ret;
1168    if ( roar_buffer_set_len(vss->writebuffer, len) == -1 )
1169     return -1;
1170   }
1171
1172   ROAR_DBG("roar_vs_iterate(vss=%p, wait=%i, error=%p) = ?", vss, wait, error);
1173
1174   ret = roar_vs_write_direct(vss, data, len, error);
1175
1176   if ( ret == -1 ) {
1177    return -1;
1178   } else if ( ret == len ) {
1179    roar_buffer_free(vss->writebuffer);
1180    vss->writebuffer = NULL;
1181   } else {
1182    if ( roar_buffer_set_offset(vss->writebuffer, ret) == -1 )
1183     return -1;
1184   }
1185  }
1186 }
1187
1188 return is_eof ? 0 : 1;
1189}
1190
1191int     roar_vs_run           (roar_vs_t * vss, int * error) {
1192 int ret;
1193
1194 _ckvss(-1);
1195
1196 while ((ret = roar_vs_iterate(vss, ROAR_VS_WAIT, error)) > 0);
1197
1198 ROAR_DBG("roar_vs_run(vss=%p, error=%p): ret=%i", vss, error, ret);
1199
1200 if ( ret == 0 ) {
1201  // flush buffers:
1202  roar_vs_iterate(vss, ROAR_VS_WAIT, error);
1203 }
1204
1205 if ( roar_vs_sync(vss, ROAR_VS_WAIT, error) == -1 )
1206  return -1;
1207
1208 return ret;
1209}
1210
1211ssize_t roar_vs_get_avail_read(roar_vs_t * vss, int * error) {
1212 size_t len;
1213
1214 _ckvss(-1);
1215
1216 if ( !(vss->flags & FLAG_BUFFERED) ) {
1217  _seterr(ROAR_ERROR_INVAL);
1218  return -1;
1219 }
1220
1221 if ( roar_buffer_ring_avail(vss->readring, &len, NULL) == -1 ) {
1222  _seterrre();
1223  return -1;
1224 }
1225
1226 return len;
1227}
1228
1229ssize_t roar_vs_get_avail_write(roar_vs_t * vss, int * error) {
1230 size_t len;
1231
1232 _ckvss(-1);
1233
1234 if ( !(vss->flags & FLAG_BUFFERED) ) {
1235  _seterr(ROAR_ERROR_INVAL);
1236  return -1;
1237 }
1238
1239 if ( roar_buffer_ring_avail(vss->writering, NULL, &len) == -1 ) {
1240  _seterrre();
1241  return -1;
1242 }
1243
1244 return len;
1245}
1246
1247int     roar_vs_reset_buffer(roar_vs_t * vss, int writering, int readring, int * error) {
1248 _ckvss(-1);
1249
1250 if ( !(vss->flags & FLAG_BUFFERED) ) {
1251  _seterr(ROAR_ERROR_INVAL);
1252  return -1;
1253 }
1254
1255 if ( writering != ROAR_VS_TRUE || writering != ROAR_VS_FALSE ||
1256      readring  != ROAR_VS_TRUE || readring  != ROAR_VS_FALSE ) {
1257  _seterr(ROAR_ERROR_INVAL);
1258  return -1;
1259 }
1260
1261 if ( writering ) {
1262  if ( roar_buffer_ring_reset(vss->writering) == -1 ) {
1263   _seterrre();
1264   return -1;
1265  }
1266 }
1267
1268 if ( readring ) {
1269  if ( roar_buffer_ring_reset(vss->readring) == -1 ) {
1270   _seterrre();
1271   return -1;
1272  }
1273 }
1274
1275 return 0;
1276}
1277
1278int     roar_vs_ctl           (roar_vs_t * vss, roar_vs_ctlcmd cmd, void * argp, int * error) {
1279 _ckvss(-1);
1280
1281 switch (cmd) {
1282  case ROAR_VS_CMD_NOOP:
1283   break;
1284  case ROAR_VS_CMD_SET_MIXER:
1285    vss->mixerid = *(int*)argp;
1286   break;
1287  case ROAR_VS_CMD_GET_MIXER:
1288    *(int*)argp = vss->mixerid;
1289   break;
1290  case ROAR_VS_CMD_SET_FIRST_PRIM:
1291    vss->first_primid = *(int*)argp;
1292   break;
1293  case ROAR_VS_CMD_GET_FIRST_PRIM:
1294    *(int*)argp = vss->first_primid;
1295   break;
1296 }
1297
1298 return 0;
1299}
1300
1301struct roar_connection * roar_vs_connection_obj(roar_vs_t * vss, int * error) {
1302 _ckvss(NULL);
1303
1304 return vss->con;
1305}
1306
1307struct roar_stream     * roar_vs_stream_obj    (roar_vs_t * vss, int * error) {
1308 _ckvss(NULL);
1309
1310 if ( !(vss->flags & FLAG_STREAM) ) {
1311  _seterr(ROAR_ERROR_INVAL);
1312  return NULL;
1313 }
1314
1315 return &(vss->stream);
1316}
1317
1318struct roar_vio_calls  * roar_vs_vio_obj       (roar_vs_t * vss, int * error) {
1319 _ckvss(NULL);
1320
1321 if ( !(vss->flags & FLAG_STREAM) ) {
1322  _seterr(ROAR_ERROR_INVAL);
1323  return NULL;
1324 }
1325
1326 return &(vss->vio);
1327}
1328
1329//ll
Note: See TracBrowser for help on using the repository browser.