source: roaraudio/roard/streams.c @ 4553:cf667cac6d4f

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

do init value

File size: 57.2 KB
Line 
1//streams.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2010
5 *
6 *  This file is part of roard 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 *  RoarAudio 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 */
25
26#include "roard.h"
27
28#define _CHECK_SID_RET(id,ret) if ( (id) < 0 || (id) > ROAR_STREAMS_MAX || g_streams[(id)] == NULL ) return (ret)
29#define _CHECK_SID(id)         _CHECK_SID_RET((id), -1)
30
31int streams_thru_num     =  0;
32int streams_recsource_id = -1;
33
34static void _streams_change_state(struct roar_stream_server * s, const int new, const char * func) {
35 register int id  = ROAR_STREAM(s)->id;
36 register int old = s->state;
37
38 s->state = new;
39
40 if ( func == NULL ) {
41  func = "(unknown)";
42 }
43
44 ROAR_INFO("_streams_change_state[by %s](id=%i): stream state: %s->%s", ROAR_DBG_INFO_VERBOSE,
45            func,
46            ROAR_STREAM(s)->id,
47            roar_streamstate2str(old), roar_streamstate2str(new));
48
49 roar_notify_core_emit_simple(ROAR_OE_BASICS_CHANGE_STATE, -1, id, ROAR_OT_STREAM, old, new, NULL, 0);
50}
51
52int streams_init (void) {
53 int i;
54
55 for (i = 0; i < ROAR_STREAMS_MAX; i++)
56  g_streams[i] = NULL;
57
58 return 0;
59}
60
61int streams_free (void) {
62 int i;
63
64 for (i = 0; i < ROAR_STREAMS_MAX; i++) {
65  if ( g_streams[i] != NULL ) {
66   streams_delete(i);
67  }
68 }
69
70 return 0;
71}
72
73
74int streams_new    (void) {
75 int i, j;
76 struct roar_stream        * n = NULL;
77 struct roar_stream_server * s = NULL;
78
79#ifdef ROAR_SUPPORT_LISTEN
80 if ( g_terminate && !g_no_listen ) // don't accept new streams in case of termination state
81  return -1;
82#else
83 if ( g_terminate )                 // don't accept new streams in case of termination state
84  return -1;
85#endif
86
87 for (i = 0; i < ROAR_STREAMS_MAX; i++) {
88  if ( g_streams[i] == NULL ) {
89   s = ROAR_STREAM_SERVER(n = ROAR_STREAM(roar_mm_malloc(sizeof(struct roar_stream_server))));
90   if ( n == NULL ) {
91    ROAR_ERR("streams_new(void): can not allocate memory for new stream: %s", strerror(errno));
92    ROAR_DBG("streams_new(void) = -1");
93    return -1;
94   }
95
96   memset(s, 0, sizeof(struct roar_stream_server));
97
98   n->id         = i;
99   n->fh         = -1;
100   n->pos_rel_id = -1;
101/*
102   n->database   = NULL;
103   n->dataoff    = NULL;
104   n->datalen    = 0;
105   n->offset     = 0;
106*/
107   n->pos        = 0;
108
109   s->name            = NULL;
110
111   s->state           = ROAR_STREAMSTATE_INITING;
112
113   s->client          = -1;
114   s->socktype        = ROAR_SOCKET_TYPE_UNKNOWN;
115   s->buffer          = NULL;
116   s->need_extra      =  0;
117   s->output          = NULL;
118   s->is_new          =  1;
119   s->codecfilter     = -1;
120   s->pre_underruns   =  0;
121   s->post_underruns  =  0;
122   s->delay           =  0;
123   s->codec_orgi      = -1;
124   s->primary         =  0;
125   s->ready           =  0;
126   s->outputbuffer    = NULL;
127   s->prethru         = NULL;
128   s->mixer_stream    = -1;
129   s->role            = ROAR_ROLE_UNKNOWN;
130   s->parent_stream   = -1;
131   s->single_sink_c   =  0;
132   s->single_sink_self_c =  0;
133
134   s->mixer.scale     = 65535;
135   s->mixer.rpg_mul   = 1;
136   s->mixer.rpg_div   = 1;
137   for (j = 0; j < ROAR_MAX_CHANNELS; j++)
138    s->mixer.mixer[j] = 65535;
139
140#ifdef ROAR_SUPPORT_META
141   for (j = 0; j < ROAR_META_MAX_PER_STREAM; j++) {
142    s->meta[j].type   = ROAR_META_TYPE_NONE;
143    s->meta[j].key[0] = 0;
144    s->meta[j].value  = NULL;
145   }
146#endif
147
148   roar_vio_init_calls(&(s->vio));
149   roar_vio_init_calls(&(s->jumbo));
150   s->viop      = &(s->vio);
151   s->driver_id = -1;
152   s->flags     =  ROAR_FLAG_NONE;
153
154   s->mixerstream =  NULL;
155
156   //roardsp_fchain_init(&(s->fc));
157
158   g_streams[i] = s;
159   counters_inc(streams, 1);
160   ROAR_INFO("streams_new(void): New stream %i created (state=initing)", ROAR_DBG_INFO_VERBOSE, i);
161   ROAR_DBG("streams_new(void): n->id=%i", n->id);
162   roar_notify_core_emit_snoargs(ROAR_OE_BASICS_NEW, -1, i, ROAR_OT_STREAM);
163   ROAR_DBG("streams_new(void) = %i", i);
164   return i;
165  }
166 }
167
168 return -1;
169}
170
171int streams_delete (int id) {
172 struct roar_stream_server * s;
173 int prim;
174 int no_vio_close = 0;
175 int i;
176 int client;
177
178 _CHECK_SID(id);
179
180 if ( (s = g_streams[id]) == NULL )
181  return 0;
182
183 ROAR_DBG("streams_delete(id=%i) = ?", id);
184 ROAR_DBG("streams_delete(id=%i): g_streams[id]->id=%i", id, ROAR_STREAM(s)->id);
185
186 // in case we are allready closing it...
187 if ( s->state == ROAR_STREAMSTATE_CLOSING )
188  return 0;
189
190 _streams_change_state(s, ROAR_STREAMSTATE_CLOSING, "streams_delete");
191 roar_notify_core_emit_snoargs(ROAR_OE_BASICS_DELETE, -1, id, ROAR_OT_STREAM);
192
193 if ( s->flags & ROAR_FLAG_SINGLESINK )
194  streams_set_single_sink(id, 1);
195
196 counters_inc(streams, -1);
197
198 if ( streams_get_flag(id, ROAR_FLAG_RECSOURCE) == 1 )
199  streams_reset_flag(id, ROAR_FLAG_RECSOURCE);
200
201 for (i = 0; i < ROAR_STREAMS_MAX; i++) {
202  if ( g_streams[i] != NULL && ROAR_STREAM(g_streams[i])->pos_rel_id == id ) {
203   switch (ROAR_STREAM(g_streams[i])->dir) {
204    case ROAR_DIR_THRU:
205    case ROAR_DIR_RAW_IN:
206      if ( i != id )
207       streams_delete(i);
208     break;
209    default:
210      if ( streams_get_flag(i, ROAR_FLAG_VIRTUAL) == 1 ) {
211       if ( i != id ) {
212        ROAR_DBG("streams_delete(id=%i): Deleting virtual child stream %i", id, i);
213        streams_delete(i);
214       }
215      } else {
216       ROAR_STREAM(g_streams[i])->pos_rel_id = -1;
217      }
218   }
219  }
220 }
221
222 if ( ROAR_STREAM(s)->dir == ROAR_DIR_THRU )
223  streams_thru_num--;
224
225 if ( streams_get_flag(id, ROAR_FLAG_VIRTUAL) == 1 ) {
226  // we un-group the stream here to avoid a client deleting the parent deleting the client deleting ...
227  i      = ROAR_STREAM(s)->pos_rel_id;
228  if ( i != -1 ) {
229   ROAR_STREAM(s)->pos_rel_id = -1;
230   client = streams_get_client(id);
231   streams_set_client(id, -1);
232   ROAR_DBG("streams_delete(id=%i): Stream has flag virtual, notifying parent stream %i", id, i);
233   streams_ctl(i, ROAR_CODECFILTER_CTL_VIRTUAL_DELETE|ROAR_STREAM_CTL_TYPE_INT, &id);
234   ROAR_DBG("streams_delete(id=%i): Notify send to stream %i", id, i);
235   streams_set_client(id, client);
236   ROAR_STREAM(s)->pos_rel_id = i;
237  }
238 }
239
240#ifdef ROAR_SUPPORT_META
241 // delete meta data form other meta streams if needed
242 if ( streams_get_flag(id, ROAR_FLAG_META) == 1 ) {
243  ROAR_DBG("streams_delete(id=%i): deleting meta stream!", id);
244  stream_meta_clear(id);
245  stream_meta_finalize(id);
246 }
247#endif
248
249 if ( s->codecfilter != -1 ) {
250  codecfilter_close(s->codecfilter_inst, s->codecfilter);
251  s->codecfilter_inst = NULL;
252  s->codecfilter = -1;
253 }
254
255 if ( s->driver_id != -1 ) {
256  driver_closevio(&(s->vio), s->driver_id);
257  roar_vio_init_calls(&(s->vio));
258  s->driver_id = -1;
259  no_vio_close =  1;
260 }
261
262 if ( s->mixerstream != NULL ) {
263  hwmixer_close(id);
264 }
265
266 //roardsp_fchain_uninit(&(s->fc));
267
268 if ( s->client != -1 ) {
269  ROAR_DBG("streams_delete(id=%i): Stream is owned by client %i", id, g_streams[id]->client);
270  client_stream_delete(s->client, id);
271 }
272
273 stream_outputbuffer_destroy(id);
274 stream_prethru_destroy(id);
275
276 if ( s->buffer != NULL )
277  roar_buffer_free(s->buffer);
278
279 if ( s->output != NULL )
280  free(s->output);
281
282/*
283 if ( ROAR_STREAM(s)->fh != -1 )
284  close(ROAR_STREAM(s)->fh);
285*/
286
287 if ( !no_vio_close )
288  roar_vio_close(s->viop);
289
290 prim = s->primary;
291
292 if ( s->name != NULL )
293  free(s->name);
294
295 roar_mm_free(s);
296
297 g_streams[id] = NULL;
298
299 if ( prim && alive ) {
300  alive = 0;
301  clean_quit();
302 }
303
304 ROAR_INFO("streams_delete(id=%i): stream deleted", ROAR_DBG_INFO_VERBOSE, id);
305 ROAR_DBG("streams_delete(id=%i) = 0", id);
306 return 0;
307}
308
309int streams_set_client (int id, int client) {
310
311 _CHECK_SID(id);
312
313 ROAR_DBG("streams_set_client(id=%i): g_streams[id]->id=%i", id, ROAR_STREAM(g_streams[id])->id);
314 g_streams[id]->client = client;
315
316 return 0;
317}
318
319int streams_get_client (int id) {
320 _CHECK_SID(id);
321
322 return g_streams[id]->client;
323}
324
325int streams_set_dir    (int id, int dir, int defaults) {
326 struct roar_stream_server * ss;
327 int mixer;
328
329 _CHECK_SID(id);
330
331 if ( (ss = g_streams[id]) == NULL )
332  return -1;
333
334 ROAR_STREAM(ss)->dir = dir;
335
336 if ( dir == ROAR_DIR_THRU )
337  streams_thru_num++;
338
339 if ( defaults ) {
340  if ( dir <= 0 || dir >= ROAR_DIR_DIRIDS )
341   return -1;
342
343  ROAR_DBG("streams_set_dir(*): g_config->streams[dir=%i].flags = 0x%.4x", dir, g_config->streams[dir].flags);
344
345  if ( streams_set_flag(id, g_config->streams[dir].flags) == -1 ) {
346   ROAR_DBG("streams_set_dir(*) = -1 // can not set stream flags");
347   return -1;
348  }
349
350   ss->mixer.scale   = g_config->streams[dir].mixer.scale;
351   ss->mixer.rpg_mul = g_config->streams[dir].mixer.rpg_mul;
352   ss->mixer.rpg_div = g_config->streams[dir].mixer.rpg_div;
353 }
354
355 if ( dir != ROAR_DIR_MIXING ) {
356  switch (streams_get_subsys(id)) {
357   case ROAR_SUBSYS_WAVEFORM:
358     streams_set_mixer_stream(id, g_waveform_mixer.stream);
359     roardsp_chanlist_init(ss->chanmap.in,  ROAR_STREAM(ss)->info.channels, ROARDSP_CHANLIST_MAP_ROARAUDIO);
360    break;
361#ifndef ROAR_WITHOUT_DCOMP_MIDI
362   case ROAR_SUBSYS_MIDI:
363     roardsp_chanlist_init(ss->chanmap.in,  ROAR_STREAM(ss)->info.channels, ROARDSP_CHANLIST_MAP_MIDI);
364     streams_set_mixer_stream(id, g_midi_mixer.stream);
365    break;
366#endif
367#ifndef ROAR_WITHOUT_DCOMP_LIGHT
368   case ROAR_SUBSYS_LIGHT:
369     streams_set_mixer_stream(id, g_light_mixer.stream);
370    break;
371#endif
372  }
373
374  if ( streams_get_ssdir(id) & STREAM_DIR_OUT ) {
375   if ( (mixer = streams_get_mixer_stream(id)) != -1 ) {
376    if ( g_streams[mixer]->flags & ROAR_FLAG_SINGLESINK ) {
377     streams_set_mixer_stream(id, -1);
378     return -1;
379    }
380   }
381  }
382
383  memcpy(ss->chanmap.out, ss->chanmap.in, sizeof(ss->chanmap.out));
384  streams_set_map(id, NULL, 0);
385 } else {
386  streams_set_mixer_stream(id, id);
387 }
388
389 ROAR_DBG("streams_set_dir(*) = 0");
390 return 0;
391}
392
393int streams_get_dir    (int id) {
394 struct roar_stream_server * ss;
395
396 _CHECK_SID(id);
397
398 if ( (ss = g_streams[id]) == NULL )
399  return -1;
400
401 return ROAR_STREAM(ss)->dir;
402}
403
404int streams_set_mixer_stream(int id, int mixer) {
405 struct roar_stream_server * ss;
406
407 _CHECK_SID(id);
408
409 if ( (ss = g_streams[id]) == NULL )
410  return -1;
411
412 ss->mixer_stream = mixer;
413
414 return 0;
415}
416
417int streams_get_mixer_stream(int id) {
418 struct roar_stream_server * ss;
419
420 _CHECK_SID(id);
421
422 if ( (ss = g_streams[id]) == NULL )
423  return -1;
424
425 return ss->mixer_stream;
426}
427
428int streams_set_role   (int id, int role) {
429 struct roar_stream_server * ss;
430
431 _CHECK_SID(id);
432
433 if ( (ss = g_streams[id]) == NULL )
434  return -1;
435
436 ss->role = role;
437
438 return 0;
439}
440
441int streams_get_subsys (int id) {
442 struct roar_stream_server * ss;
443
444 _CHECK_SID(id);
445
446 if ( (ss = g_streams[id]) == NULL )
447  return -1;
448
449 switch (ROAR_STREAM(ss)->dir) {
450  case ROAR_DIR_PLAY:
451  case ROAR_DIR_RECORD:
452  case ROAR_DIR_MONITOR:
453  case ROAR_DIR_FILTER:
454  case ROAR_DIR_OUTPUT:
455  case ROAR_DIR_BIDIR:
456    return ROAR_SUBSYS_WAVEFORM;
457   break;
458  case ROAR_DIR_MIDI_IN:
459  case ROAR_DIR_MIDI_OUT:
460    return ROAR_SUBSYS_MIDI;
461   break;
462  case ROAR_DIR_LIGHT_IN:
463  case ROAR_DIR_LIGHT_OUT:
464    return ROAR_SUBSYS_LIGHT;
465   break;
466  case ROAR_DIR_RAW_IN:
467  case ROAR_DIR_RAW_OUT:
468    return ROAR_SUBSYS_RAW;
469   break;
470  case ROAR_DIR_COMPLEX_IN:
471  case ROAR_DIR_COMPLEX_OUT:
472    return ROAR_SUBSYS_COMPLEX;
473   break;
474  case ROAR_DIR_THRU:
475    return streams_get_subsys(ROAR_STREAM(ss)->pos_rel_id);
476   break;
477  case ROAR_DIR_MIXING:
478    return ROAR_SUBSYS_NONE;
479   break;
480 }
481
482 return -1;
483}
484
485int streams_get_ssdir  (int id) {
486 struct roar_stream_server * ss;
487
488 _CHECK_SID(id);
489
490 if ( (ss = g_streams[id]) == NULL )
491  return -1;
492
493 switch (ROAR_STREAM(ss)->dir) {
494  case ROAR_DIR_PLAY:
495  case ROAR_DIR_MIDI_IN:
496  case ROAR_DIR_LIGHT_IN:
497  case ROAR_DIR_RAW_IN:
498  case ROAR_DIR_COMPLEX_IN:
499    return STREAM_DIR_IN;
500   break;
501  case ROAR_DIR_RECORD:
502  case ROAR_DIR_MONITOR:
503  case ROAR_DIR_OUTPUT:
504  case ROAR_DIR_MIDI_OUT:
505  case ROAR_DIR_LIGHT_OUT:
506  case ROAR_DIR_RAW_OUT:
507  case ROAR_DIR_COMPLEX_OUT:
508    return STREAM_DIR_OUT;
509   break;
510  case ROAR_DIR_MIXING:
511    return STREAM_DIR_NONE;
512   break;
513  case ROAR_DIR_FILTER:
514  case ROAR_DIR_BIDIR:
515    return STREAM_DIR_BIDIR;
516   break;
517  case ROAR_DIR_THRU:
518    return streams_get_ssdir(ROAR_STREAM(ss)->pos_rel_id);
519   break;
520 }
521
522 return -1;
523}
524
525#define _err() streams_delete(id); return -1;
526int streams_new_virtual (int parent, struct roar_stream_server ** stream) {
527 struct roar_stream_server * parent_ss, * ss;
528 struct roar_stream        * parent_s , *  s;
529 int id = -1;
530 int client, dir;
531
532 if ( streams_get(parent, &parent_ss) == -1 )
533  return -1;
534
535 if ( (client = streams_get_client(parent)) == -1 )
536  return -1;
537
538 if ( (dir = streams_get_dir(parent)) == -1 )
539  return -1;
540
541 if ( (id = streams_new()) == -1 ) {
542  return -1;
543 }
544
545 if ( client_stream_add(client, id) == -1 ) {
546  _err();
547 }
548
549 if ( streams_get(id, &ss) == -1 ) {
550  _err();
551 }
552
553 if ( streams_set_dir(id, dir, 1) == -1 ) {
554  _err();
555 }
556
557 s        = ROAR_STREAM(       ss);
558 parent_s = ROAR_STREAM(parent_ss);
559
560 s->pos_rel_id = parent;
561
562 if ( streams_set_rawflag(id, ROAR_FLAG_VIRTUAL) == -1 ) {
563  _err();
564 }
565
566 if ( stream != NULL )
567  *stream = ss;
568
569 return id;
570}
571#undef _err
572
573int streams_set_fh     (int id, int fh) {
574 struct roar_stream_server * ss;
575 struct roar_stream        * s;
576 int dir;
577 int nonblock = 1;
578
579 _CHECK_SID(id);
580
581 if ( (s = ROAR_STREAM(ss = g_streams[id])) == NULL )
582  return -1;
583
584 if ( ss->ready ) {
585  ROAR_DBG("streams_set_fh(id=%i, fh=%i) = -1 // try to set fh for stream which is already ready", id, fh);
586  return -1;
587 }
588
589 dir = ROAR_STREAM(ss)->dir;
590
591 ROAR_DBG("streams_set_fh(id=%i, fh=%i): g_streams[id]->id=%i", id, fh, s->id);
592
593 s->fh = fh;
594
595 ROAR_DBG("streams_set_fh(id=%i, fh=%i): driverID=%i", id, fh, ss->driver_id);
596
597 if ( ss->driver_id == -1 && fh != -2 ) {
598#ifndef ROAR_TARGET_WIN32
599  roar_vio_set_fh(&(ss->vio), fh);
600#else
601  roar_vio_open_fh_socket(&(ss->vio), fh);
602#endif
603 }
604
605 ROAR_DBG("streams_set_fh(id=%i, fh=%i) = ?", id, fh);
606
607 switch (dir) {
608  case ROAR_DIR_THRU:
609  case ROAR_DIR_RAW_IN:
610  case ROAR_DIR_RAW_OUT:
611   break;
612  default:
613    if ( codecfilter_open(&(ss->codecfilter_inst), &(ss->codecfilter), NULL,
614                     s->info.codec, ss) == -1 ) {
615     streams_delete(id); // TODO: FIXME: is this correct? shoudn't we return -1 in any case here?
616     return -1;
617    }
618   break;
619 }
620
621 ROAR_DBG("streams_set_fh(id=%i, fh=%i) = ?", id, fh);
622
623 if ( fh == -2 ) {
624  ROAR_DBG("streams_set_fh(id=%i, fh=%i) = ?", id, fh);
625  if ( roar_vio_ctl(&(ss->vio), ROAR_VIO_CTL_GET_READ_FH, &fh) == -1 ) {
626   fh = -2;
627  } else {
628   ROAR_DBG("streams_set_fh(id=%i, fh=%i) = ?", id, fh);
629   if ( fh < 0 ) {
630    fh = -2;
631   } else {
632    s->fh = fh;
633   }
634  }
635 }
636
637 ROAR_DBG("streams_set_fh(id=%i, fh=%i) = ?", id, fh);
638
639 if ( fh == -1 || fh == -2 ) { // yes, this is valid, indecats full vio!
640  ss->ready = 1;
641  //ROAR_INFO("streams_set_fh(id=%i, fh=%i): stream state: %s->new", ROAR_DBG_INFO_VERBOSE, id, fh, roar_streamstate2str(ss->state));
642  _streams_change_state(ss, ROAR_STREAMSTATE_NEW, "streams_set_fh");
643  return 0;
644 }
645
646 ROAR_DBG("streams_set_fh(id=%i, fh=%i) = ?", id, fh);
647
648// roar_socket_recvbuf(fh, ROAR_OUTPUT_CALC_OUTBUFSIZE( &(ROAR_STREAM(g_streams[id])->info) )); // set recv buffer to minimum
649
650 switch (dir) {
651  case ROAR_DIR_MONITOR:
652  case ROAR_DIR_RECORD:
653  case ROAR_DIR_OUTPUT:
654  case ROAR_DIR_MIDI_OUT:
655  case ROAR_DIR_LIGHT_OUT:
656  case ROAR_DIR_RAW_OUT:
657    ROAR_SHUTDOWN(fh, SHUT_RD);
658   break;
659 }
660
661 if ( dir >= ROAR_DIR_DIRIDS )
662  return -1;
663
664 if ( g_config->streams[dir].flags & ROAR_FLAG_SYNC ) {
665  switch (dir) {
666   case ROAR_DIR_BRIDGE:
667   case ROAR_DIR_MIDI_OUT:
668    break;
669   default:
670     nonblock = 0;
671    break;
672  }
673 }
674
675
676 if ( !nonblock ) {
677  ss->ready = 1;
678  //ROAR_INFO("streams_set_fh(id=%i, fh=%i): stream state: %s->new", ROAR_DBG_INFO_VERBOSE, id, fh, roar_streamstate2str(ss->state));
679  _streams_change_state(ss, ROAR_STREAMSTATE_NEW, "streams_set_fh");
680
681  ROAR_DBG("streams_set_fh(id=%i, fh=%i) = 0", id, fh);
682  return 0;
683 } else {
684#ifndef ROAR_TARGET_WIN32
685  if ( roar_socket_nonblock(fh, ROAR_SOCKET_NONBLOCK) == -1 )
686   return -1;
687#endif
688
689  ss->ready = 1;
690  //ROAR_INFO("streams_set_fh(id=%i, fh=%i): stream state: %s->new", ROAR_DBG_INFO_VERBOSE, id, fh, roar_streamstate2str(ss->state));
691  _streams_change_state(ss, ROAR_STREAMSTATE_NEW, "streams_set_fh");
692
693  ROAR_DBG("streams_set_fh(id=%i, fh=%i) = 0", id, fh);
694  return 0;
695 }
696}
697
698int streams_get_fh     (int id) {
699 _CHECK_SID(id);
700
701 return ROAR_STREAM(g_streams[id])->fh;
702}
703
704int streams_set_null_io(int id) {
705 struct roar_stream_server * ss;
706 struct roar_stream        * s;
707
708 _CHECK_SID(id);
709
710 if ( (s = ROAR_STREAM(ss = g_streams[id])) == NULL )
711  return -1;
712
713 s->fh = -1;
714
715 return 0;
716}
717
718int streams_get    (int id, struct roar_stream_server ** stream) {
719 _CHECK_SID(id);
720
721 *stream = g_streams[id];
722
723 return 0;
724}
725
726int streams_get_clientobj (int id, struct roar_stream        ** stream) {
727 _CHECK_SID(id);
728
729 *stream = ROAR_STREAM(g_streams[id]);
730
731 return 0;
732}
733
734int streams_set_socktype (int id, int socktype) {
735 _CHECK_SID(id);
736
737 g_streams[id]->socktype = socktype;
738
739 return 0;
740}
741
742int streams_get_socktype (int id) {
743 _CHECK_SID(id);
744
745 return g_streams[id]->socktype;
746}
747
748int streams_is_ready     (int id) {
749 _CHECK_SID(id);
750
751 return g_streams[id]->ready;
752}
753
754int streams_set_primary (int id, int prim) {
755 _CHECK_SID(id);
756
757 g_streams[id]->primary = prim;
758
759 return 0;
760}
761
762int streams_mark_primary (int id) {
763 return streams_set_primary(id, 1);
764}
765
766int streams_set_sync     (int id, int sync) {
767 int fh = streams_get_fh(id);
768
769 _CHECK_SID(id);
770
771 if ( fh != -1 ) {
772  if ( roar_socket_nonblock(fh, sync ? ROAR_SOCKET_BLOCK : ROAR_SOCKET_NONBLOCK) == -1 )
773   return -1;
774
775#ifdef ROAR_FDATASYNC
776  ROAR_FDATASYNC(fh);
777#endif
778
779  return 0;
780 } else {
781  return roar_vio_nonblock(&(g_streams[id]->vio), sync);
782 }
783}
784
785int streams_set_mmap (int id, int reset) {
786 int use = !reset;
787
788 _CHECK_SID(id);
789
790 return roar_vio_ctl(&(g_streams[id]->vio), ROAR_VIO_CTL_SET_UMMAP, &use);
791}
792
793int streams_set_single_sink(int id, int reset) {
794 struct roar_stream_server * self_ss, * ss;
795 struct roar_stream                   *  s;
796 int mixer;
797 size_t count = 0;
798 int i;
799 int ssdir;
800
801 /* FIXME: This code only uses one refc for the mixer shared with the inputs.
802  *        If the flag is unset on the mixer but got set by the sources the counter
803  *        may/will become corrupted.
804  */
805
806 _CHECK_SID(id);
807
808 self_ss = g_streams[id];
809
810 mixer = self_ss->mixer_stream;
811
812 ROAR_DBG("streams_set_single_sink(id=%i, reset=%i): mixer=%i", id, reset, mixer);
813
814 if ( !reset && id != mixer )
815  if ( self_ss->flags & ROAR_FLAG_SINGLESINK )
816   return 0;
817
818 if ( id == mixer ) {
819  if ( reset ) {
820   if ( self_ss->single_sink_self_c ) {
821    ROAR_DBG("streams_set_single_sink(id=%i, reset=%i): mixer=%i", id, reset, mixer);
822    self_ss->single_sink_self_c--;
823    self_ss->single_sink_c--;
824    if ( self_ss->single_sink_c == 0 ) {
825     ROAR_DBG("streams_set_single_sink(id=%i, reset=%i): mixer=%i", id, reset, mixer);
826     self_ss->flags |= ROAR_FLAG_SINGLESINK;
827     self_ss->flags -= ROAR_FLAG_SINGLESINK;
828    }
829    return 0;
830   } else {
831    return -1;
832   }
833  } else {
834   if ( self_ss->single_sink_c ) {
835    self_ss->single_sink_self_c++;
836    self_ss->single_sink_c++;
837    return 0;
838   }
839  }
840 } else if ( reset ) {
841  ROAR_DBG("streams_set_single_sink(id=%i, reset=%i): mixer=%i", id, reset, mixer);
842
843  if ( (ss = g_streams[mixer])->single_sink_c == 0 )
844   return -1;
845  ss->single_sink_c--;
846
847  if ( ss->single_sink_c == 0 ) {
848    self_ss->flags |= ROAR_FLAG_SINGLESINK;
849    self_ss->flags -= ROAR_FLAG_SINGLESINK;
850         ss->flags |= ROAR_FLAG_SINGLESINK;
851         ss->flags -= ROAR_FLAG_SINGLESINK;
852  }
853
854  return 0;
855 }
856
857
858
859 for (i = 0; i < ROAR_STREAMS_MAX; i++) {
860  if ( (s = ROAR_STREAM((ss = g_streams[i]))) != NULL ) {
861   if ( s->dir == ROAR_DIR_THRU )
862    if ( s->pos_rel_id == id || s->pos_rel_id == mixer || g_streams[s->pos_rel_id]->mixer_stream == mixer )
863     return -1;
864
865   if ( ss->mixer_stream != mixer )
866    continue;
867
868   ssdir = streams_get_ssdir(i);
869
870   if ( ssdir & STREAM_DIR_OUT )
871    count++;
872  }
873 }
874
875 if ( count > 1 )
876  return -1;
877
878 ss = g_streams[mixer];
879
880 if ( id == mixer )
881  ss->single_sink_self_c++;
882
883 ss->single_sink_c++;
884
885 self_ss->flags |= ROAR_FLAG_SINGLESINK;
886      ss->flags |= ROAR_FLAG_SINGLESINK;
887
888 return 0;
889}
890
891int streams_set_flag     (int id, uint32_t flag) {
892 int parent;
893
894 _CHECK_SID(id);
895
896 if ( flag & ROAR_FLAG_IMMUTABLE )
897  flag |= ROAR_FLAG_PRIMARY;
898
899
900 // check if flags we are going to change are protected:
901 if ( g_streams[id]->flags_protection & flag )
902  return -1;
903
904
905 if ( flag & ROAR_FLAG_MMAP ) {
906  if ( streams_set_mmap(id, 0) == -1 ) {
907   flag -= ROAR_FLAG_MMAP;
908   return -1;
909  }
910 }
911
912 if ( flag & ROAR_FLAG_PRIMARY ) {
913  streams_set_primary(id, 1);
914  flag -= ROAR_FLAG_PRIMARY;
915 }
916
917 if ( flag & ROAR_FLAG_SINGLESINK ) {
918  if ( streams_set_single_sink(id, 0) == -1 ) {
919   return -1;
920  }
921  flag -= ROAR_FLAG_SINGLESINK;
922 }
923
924 if ( flag & ROAR_FLAG_VIRTUAL ) {
925  if ( (parent = ROAR_STREAM(g_streams[id])->pos_rel_id) == -1 )
926   return -1;
927
928  if ( streams_ctl(parent, ROAR_CODECFILTER_CTL_VIRTUAL_NEW|ROAR_STREAM_CTL_TYPE_INT, &id) == -1 ) {
929//   flag -= ROAR_FLAG_VIRTUAL;
930   return -1;
931  }
932
933  if ( client_stream_move(streams_get_client(parent), id) == -1 ) {
934   return -1;
935  }
936 }
937
938 if ( flag & ROAR_FLAG_SYNC ) {
939  switch (ROAR_STREAM(g_streams[id])->dir) {
940   // for this stream types the flag is used in the subsystem:
941   case ROAR_DIR_BRIDGE:
942   case ROAR_DIR_MIDI_OUT:
943    break;
944
945   // normal behavor (vio blocking):
946   default:
947     // the fh is updated as soon as the fh get ready in case the default ask to set sync
948     if ( !g_streams[id]->ready && !(g_config->streams[ROAR_STREAM(g_streams[id])->dir].flags & ROAR_FLAG_SYNC) ) {
949      if ( streams_set_sync(id, 1) == -1 )
950       flag -= ROAR_FLAG_SYNC;
951     }
952  }
953 }
954
955 if ( flag & ROAR_FLAG_HWMIXER ) { // currently not supported -> ignored
956  g_streams[id]->flags |= flag;
957  if ( streams_set_mixer(id) == -1 ) {
958   g_streams[id]->flags -= flag;
959   return -1;
960  }
961 }
962
963 if ( flag & ROAR_FLAG_RECSOURCE ) {
964  if ( streams_recsource_id != -1 ) {
965   if ( streams_reset_flag(streams_recsource_id, ROAR_FLAG_RECSOURCE) == -1 )
966    return -1;
967  }
968
969  streams_recsource_id = id;
970 }
971
972 g_streams[id]->flags |= flag;
973
974#ifdef ROAR_SUPPORT_META
975 if ( flag & ROAR_FLAG_META )
976  stream_meta_finalize(id);
977#endif
978
979 return 0;
980}
981
982int streams_set_rawflag  (int id, uint32_t flag) {
983 _CHECK_SID(id);
984
985 g_streams[id]->flags |= flag;
986
987 return 0;
988}
989
990int streams_reset_flag   (int id, uint32_t flag) {
991 _CHECK_SID(id);
992
993 // check if flags we are going to change are protected:
994 if ( g_streams[id]->flags_protection & flag )
995  return -1;
996
997 if ( g_streams[id]->flags & ROAR_FLAG_IMMUTABLE ) {
998  flag |= ROAR_FLAG_PRIMARY;
999  flag -= ROAR_FLAG_PRIMARY;
1000 }
1001
1002 if ( flag & ROAR_FLAG_RECSOURCE )
1003  if ( streams_recsource_id == id )
1004   streams_recsource_id = -1;
1005
1006 if ( flag & ROAR_FLAG_MMAP ) {
1007  if ( streams_set_mmap(id, 1) == -1 ) {
1008   flag -= ROAR_FLAG_MMAP;
1009   return -1;
1010  }
1011 }
1012
1013 if ( flag & ROAR_FLAG_PRIMARY ) {
1014  streams_set_primary(id, 0);
1015  flag -= ROAR_FLAG_PRIMARY;
1016 }
1017
1018 if ( flag & ROAR_FLAG_SINGLESINK ) {
1019  if ( streams_set_single_sink(id, 1) == -1 ) {
1020   return -1;
1021  }
1022  flag -= ROAR_FLAG_SINGLESINK;
1023 }
1024
1025 if ( flag & ROAR_FLAG_SYNC ) {
1026  // we refuse to reset the flag on FILTER streams
1027  if ( streams_get_dir(id) == ROAR_DIR_FILTER ) {
1028//   flags -= ROAR_FLAG_SYNC;
1029   return -1;
1030  } else {
1031   streams_set_sync(id, 0);
1032  }
1033 }
1034
1035 g_streams[id]->flags |= flag;
1036 g_streams[id]->flags -= flag;
1037
1038 return 0;
1039}
1040
1041int streams_get_flag     (int id, uint32_t flag) {
1042 _CHECK_SID(id);
1043
1044 return g_streams[id]->flags & flag ? 1 : 0;
1045}
1046
1047int streams_protect_flag (int id, uint32_t flag) {
1048 _CHECK_SID(id);
1049
1050 g_streams[id]->flags_protection |= flag;
1051
1052 return 0;
1053}
1054
1055int streams_set_name     (int id, char * name) {
1056 char * str;
1057
1058 _CHECK_SID(id);
1059
1060 if ( (str = strdup(name)) == NULL )
1061  return -1;
1062
1063 if ( g_streams[id]->name != NULL )
1064  free(g_streams[id]->name);
1065
1066 g_streams[id]->name = str;
1067
1068 return 0;
1069}
1070
1071char * streams_get_name  (int id) {
1072 _CHECK_SID_RET(id, NULL);
1073
1074 return g_streams[id]->name;
1075}
1076
1077
1078int streams_calc_delay    (int id) {
1079 struct roar_stream_server * ss;
1080 struct roar_stream        * s;
1081 register uint_least32_t d = 0;
1082 uint_least32_t t[1];
1083 uint64_t       tmp;
1084
1085 _CHECK_SID(id);
1086
1087 if ( (s = ROAR_STREAM(ss = g_streams[id])) == NULL )
1088  return -1;
1089
1090 // mixer store there value in ss->delay directly
1091 if ( s->dir == ROAR_DIR_MIXING )
1092  return 0;
1093
1094#if 0
1095 // this only confuses the user...
1096 if ( ss->mixer_stream != id ) {
1097  if ( streams_calc_delay(ss->mixer_stream) != -1 ) {
1098   d += g_streams[ss->mixer_stream]->delay; // in case we can calc the delay
1099                                            // the stream must exist, so no check here
1100  }
1101 }
1102#endif
1103
1104 if ( ss->codecfilter != -1 ) {
1105  if ( codecfilter_delay(ss->codecfilter_inst, ss->codecfilter, t) != -1 )
1106   d += *t;
1107 }
1108
1109 if ( ss->vio.ctl != NULL ) {
1110  if ( roar_vio_ctl(&(ss->vio), ROAR_VIO_CTL_GET_DELAY, t) != -1 ) { // *t is in byte
1111   ROAR_DBG("streams_calc_delay(id=%i): VIO delay in byte: %i", id, *t);
1112   tmp = *t;
1113   tmp *= 1000000; // musec per sec
1114   tmp /= s->info.rate * s->info.channels * (s->info.bits/8);
1115   ROAR_DBG("streams_calc_delay(id=%i): VIO delay in musec: %llu", id, tmp);
1116
1117   d += tmp;
1118  }
1119 }
1120
1121 ROAR_DBG("streams_calc_delay(id=%i): delay in musec: %i", id, d);
1122
1123 ss->delay = d;
1124
1125 return 0;
1126}
1127
1128int streams_set_mixer    (int id) {
1129 struct roar_stream_server * ss;
1130 struct roar_stream_server * pmss;
1131 int i;
1132 int subsys;
1133 int tsubsys;
1134
1135 _CHECK_SID(id);
1136
1137 if ( (ss = g_streams[id]) == NULL )
1138  return -1;
1139
1140 if ( streams_get_flag(id, ROAR_FLAG_PASSMIXER) == 1 ) {
1141  if ( (subsys = streams_get_subsys(id)) == -1 )
1142   return -1;
1143
1144  for (i = 0; i < ROAR_STREAMS_MAX; i++) {
1145   if ( (pmss = g_streams[i]) != NULL ) {
1146    if ( streams_get_flag(i, ROAR_FLAG_PASSMIXER) == 1 ) {
1147     tsubsys = streams_get_subsys(i);
1148     if ( tsubsys == subsys || tsubsys == ROAR_SUBSYS_NONE ) {
1149      if ( &(pmss->mixer) != &(ss->mixer) ) {
1150       roar_conv_volume(&(pmss->mixer), &(ss->mixer), ROAR_STREAM(pmss)->info.channels, ROAR_STREAM(ss)->info.channels);
1151      }
1152
1153      // update hwmixers and the like but do not set mixer value recrusivly.
1154      streams_reset_flag(i, ROAR_FLAG_PASSMIXER);
1155      streams_set_mixer(i);
1156      streams_set_flag(i, ROAR_FLAG_PASSMIXER);
1157     }
1158    }
1159   }
1160  }
1161 }
1162
1163 roar_notify_core_emit_snoargs(ROAR_OE_STREAM_CHANGE_VOLUME, -1, id, ROAR_OT_STREAM);
1164
1165 if ( !streams_get_flag(id, ROAR_FLAG_HWMIXER) )
1166  return 0;
1167
1168 if ( ss->driver_id != -1 ) {
1169  return driver_set_volume(id, &(ss->mixer));
1170 } else if ( ss->mixerstream != NULL ) {
1171  return hwmixer_set_volume(id, ss, ss->mixerstream, &(ss->mixer));
1172 } else {
1173  return 0;
1174 }
1175}
1176
1177int streams_set_map      (int id, char * map, size_t len) {
1178 struct roar_stream_server * ss;
1179 int ssdir;
1180
1181 _CHECK_SID(id);
1182
1183 if ( (ss = g_streams[id]) == NULL )
1184  return -1;
1185
1186 if ( map != NULL ) {
1187  if ( ROAR_STREAM(ss)->info.channels != len )
1188   return -1;
1189 }
1190
1191 ssdir = streams_get_ssdir(id);
1192
1193 switch (ssdir) {
1194  case STREAM_DIR_IN:
1195  case STREAM_DIR_NONE:
1196    memset(ss->chanmap.in, 0, sizeof(ss->chanmap.in));
1197
1198    if ( map != NULL )
1199     memcpy(ss->chanmap.in, map, len);
1200
1201    roardsp_chanmap_calc(&(ss->chanmap), ROARDSP_CHANMAP_MAP, 0);
1202   break;
1203  case STREAM_DIR_OUT:
1204    memset(ss->chanmap.out, 0, sizeof(ss->chanmap.out));
1205
1206    if ( map != NULL )
1207     memcpy(ss->chanmap.out, map, len);
1208
1209    roardsp_chanmap_calc(&(ss->chanmap), ROARDSP_CHANMAP_MAP, 0);
1210   break;
1211  default:
1212    return -1;
1213 }
1214
1215 return 0;
1216}
1217
1218int streams_ltm_ctl      (int id, int mt, int window, int cmd) {
1219 struct roar_stream_server * ss;
1220 struct roar_stream_ltm *    ltm;
1221 int i;
1222
1223 _CHECK_SID(id);
1224
1225 // currently we only support the WORKBLOCK window
1226 if ( window != ROAR_LTM_WIN_WORKBLOCK )
1227  return -1;
1228
1229 // currently we only support ROAR_LTM_MT_RMS
1230 if ( (mt | ROAR_LTM_MT_RMS) - ROAR_LTM_MT_RMS )
1231  return -1;
1232
1233 if ( (ss = g_streams[id]) == NULL )
1234  return -1;
1235
1236 switch (cmd) {
1237  case ROAR_LTM_SST_NOOP:
1238    return 0;
1239   break;
1240  case ROAR_LTM_SST_REGISTER:
1241    // test if the window is already registered:
1242    for (i = 0; i < MAX_LTM_WINDOWS_PER_STREAM; i++) {
1243     ltm = &(ss->ltm[i]);
1244     if ( ltm->refc && ltm->window == window ) {
1245      ltm->refc++;
1246      ltm->mt |= mt;
1247      return 0;
1248     }
1249    }
1250
1251    // register
1252    for (i = 0; i < MAX_LTM_WINDOWS_PER_STREAM; i++) {
1253     ltm = &(ss->ltm[i]);
1254     if ( ltm->refc == 0 ) {
1255      memset(ltm, 0, sizeof(struct roar_stream_ltm));
1256      ltm->refc = 1;
1257      ltm->window = window;
1258      ltm->parent_window = -1;
1259      ltm->mt = mt;
1260      ltm->channels = ROAR_STREAM(ss)->info.channels;
1261      if ( (ltm->cur = roar_mm_malloc(ltm->channels*sizeof(struct roar_ltm_vals))) == NULL ) {
1262       ltm->refc = 0; // reset
1263       return -1;
1264      }
1265      memset(ltm->cur, 0, ltm->channels*sizeof(struct roar_ltm_vals));
1266      return 0;
1267     }
1268    }
1269    return -1;
1270   break;
1271  case ROAR_LTM_SST_UNREGISTER:
1272    for (i = 0; i < MAX_LTM_WINDOWS_PER_STREAM; i++) {
1273     ltm = &(ss->ltm[i]);
1274     if ( ltm->refc && ltm->window == window ) {
1275      ltm->refc--;
1276      if ( ! ltm->refc ) {
1277       roar_mm_free(ltm->cur);
1278       return 0;
1279      }
1280     }
1281    }
1282    return -1;
1283   break;
1284  default:
1285    return -1;
1286   break;
1287 }
1288}
1289
1290int streams_ltm_calc     (int id, struct roar_audio_info * info, void * data, size_t len) {
1291 struct roar_stream_server * ss;
1292 struct roar_stream_ltm *    ltm = NULL;
1293 int64_t rmsbuf_real[8];
1294 int64_t * rmsbuf = rmsbuf_real;
1295 size_t samples = 0;
1296 int i;
1297
1298 _CHECK_SID(id);
1299
1300 if ( data == NULL || info == NULL )
1301  return -1;
1302
1303 if ( info->codec != ROAR_CODEC_DEFAULT )
1304  return -1;
1305
1306 if ( (ss = g_streams[id]) == NULL )
1307  return -1;
1308
1309 for (i = 0; i < MAX_LTM_WINDOWS_PER_STREAM; i++) {
1310  if ( ss->ltm[i].refc && ss->ltm[i].window == ROAR_LTM_WIN_WORKBLOCK ) {
1311   ltm = &(ss->ltm[i]);
1312   break;
1313  }
1314 }
1315
1316 if ( ltm == NULL )
1317  return -1;
1318
1319 // TODO: support change of number of channels
1320 if ( ltm->channels != info->channels )
1321  return -1;
1322
1323 if ( len == 0 ) {
1324  memset(ltm->cur, 0, ltm->channels * sizeof(struct roar_ltm_vals));
1325  return 0;
1326 }
1327
1328 // TODO: support more channels then rmsbuf_real has space for
1329 if ( ltm->channels > (sizeof(rmsbuf_real)/sizeof(*rmsbuf_real)) ) {
1330  return -1;
1331 }
1332
1333 samples = len / info->bits;
1334
1335 if ( ltm->mt & ROAR_LTM_MT_RMS ) {
1336  if ( roar_rms2_1_b_n(data, samples, rmsbuf, ltm->channels, info->bits) == -1 )
1337   return -1;
1338
1339  for (i = 0; i < ltm->channels; i++) {
1340   ltm->cur[i].rms = rmsbuf[i] << (64 - info->bits*2);
1341  }
1342
1343  ROAR_DBG("streams_ltm_calc(id=%i,...): rmsbuf[0]=%lli", id, (long long int)rmsbuf[0]);
1344 }
1345
1346 return 0;
1347}
1348
1349struct roar_stream_ltm * streams_ltm_get(int id, int mt, int window) {
1350 struct roar_stream_server * ss;
1351 struct roar_stream_ltm *    ltm = NULL;
1352 int i;
1353
1354 _CHECK_SID_RET(id, NULL);
1355
1356 if ( (ss = g_streams[id]) == NULL )
1357  return NULL;
1358
1359 for (i = 0; i < MAX_LTM_WINDOWS_PER_STREAM; i++) {
1360  if ( ss->ltm[i].refc && ss->ltm[i].window == window ) {
1361   ltm = &(ss->ltm[i]);
1362   break;
1363  }
1364 }
1365
1366 if ( ltm == NULL )
1367  return NULL;
1368
1369 if ( (ltm->mt & mt) != mt )
1370  return NULL;
1371
1372 return ltm;
1373}
1374
1375struct hwmixer_stream * streams_get_mixerstream(int id) {
1376 _CHECK_SID_RET(id, NULL);
1377
1378 return g_streams[id]->mixerstream;
1379}
1380
1381int streams_set_mixerstream(int id, struct hwmixer_stream * mstream) {
1382 _CHECK_SID(id);
1383
1384 g_streams[id]->mixerstream = mstream;
1385
1386 return 0;
1387}
1388
1389int streams_read_mixervalues(int id) {
1390 struct roar_stream_server * ss;
1391
1392 _CHECK_SID(id);
1393
1394 if ( (ss = g_streams[id]) == NULL )
1395  return -1;
1396
1397 if ( ss->mixerstream == NULL )
1398  return -1;
1399
1400 return hwmixer_get_volume(id, ss, ss->mixerstream, &(ss->mixer));
1401}
1402
1403int streams_ctl          (int id, int_least32_t cmd, void * data) {
1404 struct roar_stream_server * ss;
1405 int_least32_t comp;
1406
1407 _CHECK_SID(id);
1408
1409 if ( (ss = g_streams[id]) == NULL )
1410  return -1;
1411
1412 comp = cmd & ROAR_STREAM_CTL_COMPMASK;
1413
1414 cmd &= ~comp;
1415
1416 ROAR_DBG("streams_ctl(id=%i, cmd=?, data=%p): comp=0x%.8x, cmd=0x%.4x", id, data, comp, cmd);
1417
1418 switch (comp) {
1419  case ROAR_STREAM_CTL_COMP_BASE:
1420   break;
1421  case ROAR_STREAM_CTL_COMP_CF:
1422    return codecfilter_ctl(ss->codecfilter_inst, ss->codecfilter, cmd, data);
1423   break;
1424  case ROAR_STREAM_CTL_COMP_DRV:
1425   break;
1426  default:
1427   return -1;
1428 }
1429
1430 return -1;
1431}
1432
1433int streams_get_outputbuffer  (int id, void ** buffer, size_t size) {
1434 _CHECK_SID(id);
1435
1436 // output buffer size does never change.
1437 if ( g_streams[id]->output != NULL ) {
1438  *buffer = g_streams[id]->output;
1439  return 0;
1440 }
1441
1442 if ( (g_streams[id]->output = malloc(size)) == NULL ) {
1443  ROAR_ERR("streams_get_outputbuffer(*): Can not alloc: %s", strerror(errno));
1444  return -1;
1445 }
1446
1447 *buffer = g_streams[id]->output;
1448
1449 return 0;
1450}
1451
1452int streams_fill_mixbuffer2 (int id, struct roar_audio_info * info) {
1453 size_t   outlen = ROAR_OUTPUT_CALC_OUTBUFSIZE(info);
1454 void   * outdata;
1455 size_t   inlen;
1456 size_t   inlen_got;
1457 void   * indata = NULL;
1458 size_t   buflen;
1459 void   * bufdata = NULL;
1460 struct roar_buffer * bufbuf = NULL;
1461 int      is_the_same = 0;
1462 struct roar_audio_info    * stream_info;
1463 struct roar_stream        * s;
1464 struct roar_stream_server * ss;
1465
1466 _CHECK_SID(id);
1467
1468 if ( (s = ROAR_STREAM(ss = g_streams[id])) == NULL )
1469  return -1;
1470
1471 // set up stream_info
1472 stream_info = &(s->info);
1473
1474 // calc todo_in
1475 inlen = ROAR_OUTPUT_CALC_OUTBUFSIZE(stream_info);
1476
1477 buflen = ROAR_OUTPUT_CALC_OUTBUFSIZE_MAX(info, stream_info);
1478
1479 ROAR_DBG("streams_fill_mixbuffer2(id=%i, info=%p{...}): inlen=%lu, buflen=%lu", id, info, (unsigned long)inlen, (unsigned long)buflen);
1480
1481 if ( inlen == 0 ) {
1482  ROAR_WARN("streams_fill_mixbuffer2(id=%i, info=%p{...}): inlen == 0, this should not happen!", id, info);
1483  return -1;
1484 }
1485
1486 if ( streams_get_outputbuffer(id, &outdata, outlen) == -1 ) {
1487  return -1;
1488 }
1489
1490 if ( outdata == NULL ) {
1491  return -1;
1492 }
1493
1494 ROAR_DBG("streams_fill_mixbuffer2(*): outdata=%p, len=%i->%i (in->out)", outdata, inlen, outlen);
1495
1496 is_the_same = stream_info->rate     == info->rate     && stream_info->bits  == info->bits &&
1497               stream_info->channels == info->channels && stream_info->codec == info->codec;
1498
1499 ROAR_DBG("streams_fill_mixbuffer2(*): is_the_same=%i", is_the_same);
1500
1501 if ( !is_the_same && buflen > outlen ) {
1502/*
1503  // this is not supported at the moment
1504  memset(outdata, 0, outlen);
1505  return -1;
1506*/
1507
1508  if ( roar_buffer_new(&bufbuf, buflen) == -1 )
1509   return -1;
1510
1511  if ( roar_buffer_get_data(bufbuf, &bufdata) == -1 )
1512   return -1;
1513  indata  = bufdata;
1514 } else {
1515  indata  = outdata;
1516  bufdata = outdata;
1517 }
1518
1519 inlen_got = inlen;
1520
1521 ROAR_DBG("streams_fill_mixbuffer2(id=%i, info=...): inlen_got=%u", id, inlen_got);
1522
1523 if ( stream_shift_out_buffer(id, indata, &inlen_got) == -1 ) {
1524  if ( ss->is_new ) {
1525   ss->pre_underruns++;
1526   roar_notify_core_emit_simple(ROAR_OE_STREAM_XRUN, -1, id, ROAR_OT_STREAM, ROAR_XRUN_UNDER_PRE, ss->pre_underruns, NULL, 0);
1527  } else {
1528   ROAR_WARN("streams_fill_mixbuffer2(id=%i, info=...): underrun in stream", id);
1529   ss->post_underruns++;
1530   roar_notify_core_emit_simple(ROAR_OE_STREAM_XRUN, -1, id, ROAR_OT_STREAM, ROAR_XRUN_UNDER_POST, ss->post_underruns, NULL, 0);
1531  }
1532  memset(outdata, 0, outlen);
1533  return 0;
1534 }
1535
1536 ROAR_DBG("streams_fill_mixbuffer2(id=%i, info=...): inlen_got=%u", id, inlen_got);
1537
1538 if ( ss->is_new ) {
1539  //ROAR_INFO("streams_fill_mixbuffer2(id=%i, info=...): stream state: new->old", ROAR_DBG_INFO_VERBOSE, id);
1540  _streams_change_state(ss, ROAR_STREAMSTATE_OLD, "streams_fill_mixbuffer2");
1541 }
1542
1543 ss->is_new = 0;
1544
1545 // check channel map:
1546#if 0
1547 if ( roardsp_chanmap_mappcm(indata, indata, inlen, stream_info->channels, &(ss->chanmap), stream_info->bits) == -1 ) {
1548  if ( bufbuf != NULL )
1549   roar_buffer_free(bufbuf);
1550  return -1;
1551 }
1552#endif
1553
1554 // TODO: this only works in case a we have a amp for the given stream parameters.
1555 if ( !streams_get_flag(id, ROAR_FLAG_HWMIXER) && !streams_get_flag(id, ROAR_FLAG_PASSMIXER) ) {
1556  ROAR_DBG("streams_fill_mixbuffer2(*): CALL roar_amp_pcm(*)...");
1557  if ( roar_amp_pcm(indata, stream_info->bits, indata, 8*inlen / stream_info->bits, stream_info->channels, &(ss->mixer)) == -1 )
1558   return -1;
1559 }
1560
1561 // check codec, bits, channels, rate...
1562 if ( is_the_same ) {
1563  if ( indata != outdata )
1564   memcpy(outdata, indata, inlen);
1565
1566  if ( inlen < outlen )
1567   memset(outdata+inlen, 0, outlen-inlen);
1568 } else {
1569//  if ( roar_conv(outdata, indata, (8*inlen_got*info->rate)/(stream_info->rate * stream_info->bits), stream_info, info) == -1 ) {
1570  ROAR_DBG("streams_fill_mixbuffer2(*): CALL roar_conv2(*)...");
1571  if ( roar_conv2(bufdata, indata, inlen, stream_info, info, outlen) == -1 ) {
1572   if ( bufbuf != NULL )
1573    roar_buffer_free(bufbuf);
1574   return -1;
1575  }
1576
1577//  memset(outdata, 0, outlen);
1578 }
1579
1580 if ( bufbuf != NULL ) {
1581  memcpy(outdata, bufdata, outlen);
1582  roar_buffer_free(bufbuf);
1583 }
1584
1585 streams_ltm_calc(id, stream_info, outdata, outlen);
1586
1587 if ( streams_get_flag(id, ROAR_FLAG_ANTIECHO) ) {
1588  ROAR_DBG("streams_fill_mixbuffer2(*): Calcing antiecho...");
1589  // we can ignore errors here:
1590  if ( stream_outputbuffer_request(id, &bufbuf, buflen) == 0 ) {
1591   if ( roar_buffer_get_data(bufbuf, &bufdata) != -1 )
1592    memcpy(bufdata, outdata, outlen);
1593  }
1594 }
1595
1596 ROAR_DBG("streams_fill_mixbuffer2(*): inlen_got=%llu, stream_info={.bits=%i, .rate=%i,...}", (long long unsigned int)inlen_got, stream_info->bits, stream_info->rate);
1597 s->pos = ROAR_MATH_OVERFLOW_ADD(s->pos, (inlen_got*8)/stream_info->bits);
1598
1599 ROAR_DBG("streams_fill_mixbuffer2(*) = 0");
1600 return 0;
1601}
1602
1603
1604int streams_get_mixbuffers (void *** bufferlist, struct roar_audio_info * info, unsigned int pos) {
1605 static void * bufs[ROAR_STREAMS_MAX+1];
1606 int i;
1607 int have = 0;
1608 int dir;
1609
1610 for (i = 0; i < ROAR_STREAMS_MAX; i++) {
1611  if ( g_streams[i] != NULL ) {
1612   dir = streams_get_dir(i);
1613
1614   switch (dir) {
1615    case ROAR_DIR_PLAY:
1616    case ROAR_DIR_BIDIR:
1617     break;
1618    case ROAR_DIR_BRIDGE:
1619      if ( g_streams[i]->buffer == NULL )
1620       continue;
1621     break;
1622    default:
1623      continue;
1624   }
1625
1626   if ( streams_get_flag(i, ROAR_FLAG_PAUSE) )
1627    continue;
1628
1629   if ( streams_get_outputbuffer(i, &bufs[have], ROAR_OUTPUT_CALC_OUTBUFSIZE(info)) == -1 ) {
1630    ROAR_ERR("streams_get_mixbuffer(*): Can not alloc output buffer for stream %i, BAD!", i);
1631    ROAR_ERR("streams_get_mixbuffer(*): Ignoring stream for this round.");
1632    continue;
1633   }
1634   if ( streams_fill_mixbuffer2(i, info) == -1 ) {
1635    ROAR_ERR("streams_get_mixbuffer(*): Can not fill output buffer for stream %i, this should not happen", i);
1636    continue;
1637   }
1638
1639//   printf("D: bufs[have=%i] = %p\n", have, bufs[have]);
1640
1641   ROAR_DBG("streams_get_mixbuffers(*):  bufs[have] = %p", bufs[have]);
1642   ROAR_DBG("streams_get_mixbuffers(*): *bufs[have] = 0x%08x...", *(uint32_t*)bufs[have]);
1643
1644   if ( !streams_get_flag(i, ROAR_FLAG_MUTE) )
1645    have++; // we have a new stream!
1646  }
1647 }
1648
1649 bufs[have] = NULL;
1650 //printf("D: bufs[have=%i] = %p\n", have, bufs[have]);
1651
1652 ROAR_DBG("streams_get_mixbuffers(*): have = %i", have);
1653
1654 *bufferlist = bufs;
1655 return have;
1656}
1657
1658
1659int stream_add_buffer  (int id, struct roar_buffer * buf) {
1660 ROAR_DBG("stream_add_buffer(id=%i, buf=%p) = ?", id, buf);
1661
1662 _CHECK_SID(id);
1663
1664 if ( g_streams[id]->buffer == NULL ) {
1665  g_streams[id]->buffer = buf;
1666  ROAR_DBG("stream_add_buffer(id=%i, buf=%p) = 0", id, buf);
1667  return 0;
1668 }
1669
1670 ROAR_DBG("stream_add_buffer(id=%i, buf=%p) = ?", id, buf);
1671 return roar_buffer_add(g_streams[id]->buffer, buf);
1672}
1673
1674int stream_shift_out_buffer   (int id, void * data, size_t * len) {
1675 _CHECK_SID(id);
1676
1677 if ( g_streams[id]->buffer == NULL )
1678  return -1;
1679
1680 return roar_buffer_shift_out(&(g_streams[id]->buffer), data, len);
1681}
1682
1683int stream_shift_buffer   (int id, struct roar_buffer ** buf) {
1684 struct roar_buffer * next;
1685
1686 _CHECK_SID(id);
1687
1688 if ( g_streams[id]->buffer == NULL ) {
1689  *buf = NULL;
1690  return 0;
1691 }
1692
1693 roar_buffer_get_next(g_streams[id]->buffer, &next);
1694
1695 *buf                  = g_streams[id]->buffer;
1696 g_streams[id]->buffer = next;
1697
1698 return 0;
1699}
1700int stream_unshift_buffer (int id, struct roar_buffer *  buf) {
1701 _CHECK_SID(id);
1702
1703 if ( g_streams[id]->buffer == NULL ) {
1704  g_streams[id]->buffer = buf;
1705  return 0;
1706 }
1707
1708 roar_buffer_clear_next(buf);
1709
1710 roar_buffer_add(buf, g_streams[id]->buffer);
1711
1712 g_streams[id]->buffer = buf;
1713
1714 return 0;
1715}
1716
1717int stream_outputbuffer_request(int id, struct roar_buffer ** buf, size_t len) {
1718 register struct roar_stream_server *  ss;
1719 size_t buflen;
1720 void * bufdata;
1721 int ret;
1722
1723 _CHECK_SID(id);
1724
1725 if ( (ss = g_streams[id]) == NULL )
1726  return -1;
1727
1728 if ( buf != NULL ) /* just be be sure */
1729  *buf = NULL;
1730
1731 if ( ss->outputbuffer != NULL ) {
1732  if ( roar_buffer_get_len(ss->outputbuffer, &buflen) == 0 ) {
1733   if ( buflen == len ) {
1734    if ( buf != NULL )
1735     *buf = ss->outputbuffer;
1736    return 0;
1737   } else if ( buflen > len ) {
1738    if ( roar_buffer_set_len(ss->outputbuffer, len) == 0 ) {
1739     if ( buf != NULL )
1740      *buf = ss->outputbuffer;
1741     return 0;
1742    }
1743   }
1744  }
1745
1746  // if the buffer is not suitable:
1747
1748  ret = roar_buffer_free(ss->outputbuffer);
1749  ss->outputbuffer = NULL;
1750  if ( ret == -1 )
1751   return ret;
1752 }
1753
1754 if ( roar_buffer_new(&(ss->outputbuffer), len) == -1 )
1755  return -1;
1756
1757 if ( roar_buffer_get_data(ss->outputbuffer, &bufdata) == -1 ) {
1758  roar_buffer_free(ss->outputbuffer);
1759  ss->outputbuffer = NULL;
1760  return -1;
1761 }
1762
1763 memset(bufdata, 0, len);
1764
1765 if ( buf != NULL )
1766  *buf = ss->outputbuffer;
1767
1768 return 0;
1769}
1770
1771int stream_outputbuffer_destroy(int id) {
1772 int ret;
1773 register struct roar_stream_server *  ss;
1774
1775 _CHECK_SID(id);
1776
1777 if ( (ss = g_streams[id]) == NULL )
1778  return -1;
1779
1780 if ( ss->outputbuffer != NULL ) {
1781  ret = roar_buffer_free(ss->outputbuffer);
1782  ss->outputbuffer = NULL;
1783  return ret;
1784 }
1785
1786 return 0;
1787}
1788
1789int stream_prethru_add(int id, struct roar_buffer * buf) {
1790 register struct roar_stream_server *  ss;
1791
1792 _CHECK_SID(id);
1793
1794 if ( (ss = g_streams[id]) == NULL )
1795  return -1;
1796
1797 if ( ss->prethru == NULL ) {
1798  ss->prethru = buf;
1799  return 0;
1800 }
1801
1802 if ( roar_buffer_add(ss->prethru, buf) == -1 ) {
1803  return -1;
1804 }
1805
1806 return 0;
1807}
1808
1809int stream_prethru_add_data(int id, void ** buf, size_t len) {
1810 struct roar_buffer * buffer;
1811
1812 _CHECK_SID(id);
1813
1814 if ( roar_buffer_new(&buffer, len) == -1 )
1815  return -1;
1816
1817 if ( roar_buffer_get_data(buffer, buf) == -1 ) {
1818  roar_buffer_free(buffer);
1819  return -1;
1820 }
1821
1822 if ( stream_prethru_add(id, buffer) == -1 ) {
1823  roar_buffer_free(buffer);
1824  return -1;
1825 }
1826
1827 return 0;
1828}
1829
1830int stream_prethru_destroy(int id) {
1831 int ret;
1832 register struct roar_stream_server *  ss;
1833
1834 _CHECK_SID(id);
1835
1836 if ( (ss = g_streams[id]) == NULL )
1837  return -1;
1838
1839 if ( ss->prethru != NULL ) {
1840  ret = roar_buffer_free(ss->prethru);
1841  ss->prethru = NULL;
1842  return ret;
1843 }
1844
1845 return 0;
1846}
1847
1848int stream_prethru_send(int dst, int src) {
1849 struct roar_stream_server *  dst_ss, * src_ss;
1850 struct roar_buffer * bufbuf;
1851 void * bufdata;
1852 size_t buflen;
1853
1854 ROAR_DBG("stream_prethru_send(dst=%i, src=%i) = ?", dst, src);
1855
1856 _CHECK_SID(dst);
1857 _CHECK_SID(src);
1858
1859 if ( (dst_ss = g_streams[dst]) == NULL )
1860  return -1;
1861
1862 if ( (src_ss = g_streams[src]) == NULL )
1863  return -1;
1864
1865 bufbuf = src_ss->prethru;
1866
1867 ROAR_DBG("stream_prethru_send(dst=%i, src=%i): prethru buffer at %p", dst, src, bufbuf);
1868
1869 while (bufbuf != NULL) {
1870  ROAR_DBG("stream_prethru_send(dst=%i, src=%i): looping with buffer at %p", dst, src, bufbuf);
1871
1872  if ( roar_buffer_get_data(bufbuf, &bufdata) == -1 )
1873   return -1;
1874
1875  if ( roar_buffer_get_len(bufbuf, &buflen) == -1 )
1876   return -1;
1877
1878  if ( stream_vio_s_write(dst_ss, bufdata, buflen) != buflen )
1879   return -1;
1880
1881  if ( roar_buffer_get_next(bufbuf, &bufbuf) == -1 )
1882   return -1;
1883 }
1884
1885 ROAR_DBG("stream_prethru_send(dst=%i, src=%i) = 0", dst, src);
1886 return 0;
1887}
1888
1889int streams_check  (int id) {
1890 int fh;
1891 ssize_t req, realreq, done;
1892 struct roar_stream        *   s;
1893 struct roar_stream_server *  ss;
1894 struct roar_buffer        *   b;
1895 void                      * buf;
1896// char                        tmp;
1897
1898 _CHECK_SID(id);
1899
1900 ROAR_DBG("streams_check(id=%i) = ?", id);
1901
1902 s = ROAR_STREAM(ss = g_streams[id]);
1903
1904 if ( (fh = s->fh) == -1 )
1905  return 0;
1906
1907 if ( streams_get_flag(id, ROAR_FLAG_PAUSE) )
1908  return 0;
1909
1910 switch (s->dir) {
1911  case ROAR_DIR_LIGHT_IN:
1912#ifndef ROAR_WITHOUT_DCOMP_LIGHT
1913    return light_check_stream(id);
1914#else
1915    streams_delete(id);
1916    return -1;
1917#endif
1918   break;
1919  case ROAR_DIR_MIDI_IN:
1920#ifndef ROAR_WITHOUT_DCOMP_MIDI
1921    return midi_check_stream(id);
1922#else
1923    streams_delete(id);
1924    return -1;
1925#endif
1926   break;
1927  case ROAR_DIR_RAW_IN:
1928#ifndef ROAR_WITHOUT_DCOMP_RAW
1929    return raw_check_stream(id);
1930#else
1931    streams_delete(id);
1932    return -1;
1933#endif
1934   break;
1935  case ROAR_DIR_RDTCS_IN:
1936#ifndef ROAR_WITHOUT_DCOMP_RDTCS
1937    return rdtcs_check_stream(id);
1938#else
1939    streams_delete(id);
1940    return -1;
1941#endif
1942   break;
1943  case ROAR_DIR_PLAY:
1944  case ROAR_DIR_BIDIR:
1945   break;
1946  default:
1947/*
1948    ROAR_WARN("streams_check(id=%i): Read event on non input stream of type/dir %s", id, roar_dir2str(s->dir));
1949    errno = 0;
1950    req = stream_vio_s_read(ss, &tmp, 1);
1951    ROAR_DBG("streams_check(id=%i): stream_vio_s_read(ss, &tmp, 1) = %li // errno=%s(%i)", id, req, strerror(errno), errno);
1952    if ( req == 1 ) {
1953     ROAR_ERR("streams_check(id=%i): Client violates protocol, got one byte of data on output stream, kicking stream");
1954     streams_delete(id);
1955     return -1;
1956    }
1957*/
1958    return 0;
1959   break;
1960 }
1961
1962 ROAR_DBG("streams_check(id=%i): fh = %i", id, fh);
1963
1964/*
1965 ROAR_DBG("streams_check(id=%i): ROAR_OUTPUT_BUFFER_SAMPLES=%i, s->info.channels=%i, s->info.bits=%i, s->info.rat=%i, g_sa->rate=%i", id, ROAR_OUTPUT_BUFFER_SAMPLES, s->info.channels, s->info.bits, s->info.rate, g_sa->rate);
1966*/
1967
1968 req  = ROAR_OUTPUT_CALC_OUTBUFSIZE(&(s->info)); // optimal size
1969// req  = ROAR_OUTPUT_BUFFER_SAMPLES * s->info.channels * (s->info.bits / 8) * ((float)s->info.rate/g_sa->rate);
1970 req += ss->need_extra; // bytes left we sould get....
1971
1972 ROAR_DBG("streams_check(id=%i): asking for %i bytes", id, req);
1973
1974 if ( roar_buffer_new(&b, req) == -1 ) {
1975  ROAR_ERR("streams_check(*): Can not alloc buffer space!");
1976  ROAR_DBG("streams_check(*) = -1");
1977  return -1;
1978 }
1979
1980 roar_buffer_get_data(b, &buf);
1981
1982 ROAR_DBG("streams_check(id=%i): buffer is up and ready ;)", id);
1983 ROAR_DBG("streams_check(id=%i): asking for %i bytes", id, req);
1984
1985 if ( ss->codecfilter == -1 ) {
1986  realreq = req;
1987/*
1988  req = read(fh, buf, req);
1989  if ( req < realreq ) { // we can do this as the stream is in nonblocking mode!
1990   if ( (realreq = read(fh, buf+req, realreq-req)) > 0 )
1991    req += realreq;
1992  }
1993*/
1994  done = 0;
1995  while (req > 0 && done != realreq) {
1996   if ( (req = stream_vio_s_read(ss, buf+done, realreq-done)) > 0 )
1997    done += req;
1998  }
1999  req = done;
2000
2001  roar_buffer_get_data(b, &buf);
2002 } else {
2003  req = codecfilter_read(ss->codecfilter_inst, ss->codecfilter, buf, req);
2004 }
2005
2006 if ( req > 0 ) {
2007  ROAR_DBG("streams_check(id=%i): got %i bytes", id, req);
2008
2009  roar_buffer_set_len(b, req);
2010
2011  if ( stream_add_buffer(id, b) != -1 )
2012   return 0;
2013
2014  ROAR_ERR("streams_check(id=%i): something is wrong, could not add buffer to stream!", id);
2015  roar_buffer_free(b);
2016 } else {
2017  ROAR_DBG("streams_check(id=%i): read() = %i // errno: %s", id, req, strerror(errno));
2018#ifdef ROAR_HAVE_LIBVORBISFILE
2019  if ( errno != EAGAIN && errno != ESPIPE ) { // libvorbis file trys to seek a bit ofen :)
2020#else
2021  if ( errno != EAGAIN ) {
2022#endif
2023   ROAR_DBG("streams_check(id=%i): EOF!", id);
2024   streams_delete(id);
2025   ROAR_DBG("streams_check(id=%i) = 0", id);
2026  }
2027  roar_buffer_free(b);
2028  return 0;
2029 }
2030
2031
2032 ROAR_DBG("streams_check(id=%i) = -1", id);
2033 return -1;
2034}
2035
2036
2037#define _return(x) return (x)
2038int streams_send_mon   (int id) {
2039// int fh;
2040 struct roar_stream        *   s;
2041 struct roar_stream_server *  ss;
2042 struct roar_buffer        *  bufbuf = NULL;
2043 struct roar_remove_state     removalstate;
2044 void  * ip;
2045 void  * obuf;
2046 int     olen;
2047 int     is_the_same     = 1;
2048 int     is_vol_eq       = 1;
2049 int     antiecho        = 0;
2050 ssize_t ret;
2051
2052 _CHECK_SID(id);
2053
2054 ROAR_DBG("streams_send_mon(id=%i) = ?", id);
2055
2056 s = ROAR_STREAM((ss = g_streams[id]));
2057
2058/*
2059 if ( (fh = s->fh) == -1 )
2060  return 0;
2061*/
2062
2063 if ( !ss->ready )
2064  return 0;
2065
2066 if ( g_config->jumbo_mtu )
2067  roar_vio_sync(ss->viop);
2068
2069 if ( streams_get_flag(id, ROAR_FLAG_PAUSE) )
2070  return 0;
2071
2072 switch (s->dir) {
2073  case ROAR_DIR_LIGHT_OUT:
2074#ifndef ROAR_WITHOUT_DCOMP_LIGHT
2075    return light_send_stream(id);
2076#else
2077    streams_delete(id);
2078    return -1;
2079#endif
2080   break;
2081  case ROAR_DIR_MIDI_OUT:
2082#ifndef ROAR_WITHOUT_DCOMP_MIDI
2083    return midi_send_stream(id);
2084#else
2085    streams_delete(id);
2086    return -1;
2087#endif
2088   break;
2089  case ROAR_DIR_RDTCS_OUT:
2090#ifndef ROAR_WITHOUT_DCOMP_RDTCS
2091    return rdtcs_send_stream(id);
2092#else
2093    streams_delete(id);
2094    return -1;
2095#endif
2096   break;
2097
2098  case ROAR_DIR_COMPLEX_OUT:
2099    // send a tick:
2100    if ( ss->codecfilter != -1 ) {
2101     if ( codecfilter_write(ss->codecfilter_inst, ss->codecfilter, NULL, 0) == 0 )
2102      if ( ss->state != ROAR_STREAMSTATE_OLD ) {
2103       //ROAR_INFO("streams_send_mon(id=%i): stream state: %s->old", ROAR_DBG_INFO_VERBOSE, id, roar_streamstate2str(ss->state));
2104       _streams_change_state(ss, ROAR_STREAMSTATE_OLD, "streams_send_mon");
2105      }
2106    }
2107    return 0;
2108   break;
2109
2110  case ROAR_DIR_OUTPUT:
2111    if ( g_standby )
2112     return 0;
2113  case ROAR_DIR_MONITOR:
2114  case ROAR_DIR_BIDIR:
2115   break;
2116
2117  default:
2118    return 0;
2119   break;
2120 }
2121
2122
2123 ROAR_DBG("streams_send_mon(id=%i): fh = %i", id, s->fh);
2124
2125 if ( s->info.channels != g_sa->channels || s->info.bits  != g_sa->bits ||
2126      s->info.rate     != g_sa->rate     || s->info.codec != g_sa->codec  )
2127  is_the_same = 0;
2128
2129 if ( !streams_get_flag(id, ROAR_FLAG_HWMIXER) ) {
2130  is_vol_eq = need_vol_change(g_sa->channels, &(ss->mixer)) ? 0 : 1;
2131 }
2132
2133 if ( streams_get_flag(id, ROAR_FLAG_ANTIECHO) )
2134  antiecho = 1;
2135
2136 if ( !is_the_same || !is_vol_eq || antiecho ) {
2137  olen = ROAR_OUTPUT_CALC_OUTBUFSIZE(&(s->info)); // we hope g_output_buffer_len
2138                                                  // is ROAR_OUTPUT_CALC_OUTBUFSIZE(g_sa) here
2139  if ( stream_outputbuffer_request(id, &bufbuf, ROAR_OUTPUT_CALC_OUTBUFSIZE_MAX(&(s->info), g_sa)) == -1 )
2140   return -1;
2141
2142  if ( roar_buffer_get_data(bufbuf, &obuf) == -1 ) {
2143   _return(-1);
2144  }
2145
2146  ROAR_DBG("streams_send_mon(id=%i): obuf=%p, olen=%i", id, obuf, olen);
2147 } else {
2148  obuf = g_output_buffer;
2149  olen = g_output_buffer_len;
2150 }
2151
2152 ip = g_output_buffer;
2153
2154 if ( antiecho ) {
2155  ROAR_DBG("streams_send_mon(id=%i): antiecho=%i", id, antiecho);
2156  if ( roar_remove_init(&removalstate) == -1 ) {
2157   _return(-1);
2158  }
2159
2160  ROAR_DBG("streams_send_mon(id=%i): antiecho=%i", id, antiecho);
2161  if ( roar_remove_so(obuf, ip, ROAR_OUTPUT_BUFFER_SAMPLES*g_sa->channels, g_sa->bits, &removalstate) == -1 ) {
2162   ROAR_DBG("streams_send_mon(id=%i): anti echo failed", id);
2163   _return(-1);
2164  }
2165  ROAR_DBG("streams_send_mon(id=%i): antiecho=%i", id, antiecho);
2166 }
2167
2168 if ( !is_vol_eq ) {
2169  if ( roar_amp_pcm(obuf, g_sa->bits, ip, ROAR_OUTPUT_BUFFER_SAMPLES*g_sa->channels, g_sa->channels, &(ss->mixer)) == -1 ) {
2170   _return(-1);
2171  }
2172
2173  ip = obuf;
2174 }
2175
2176 streams_ltm_calc(id, &(s->info), ip, (ROAR_OUTPUT_BUFFER_SAMPLES*g_sa->channels*g_sa->bits)/8);
2177
2178 if ( !is_the_same ) {
2179  if ( roar_conv(obuf, ip, ROAR_OUTPUT_BUFFER_SAMPLES*g_sa->channels, g_sa, &(s->info)) == -1 ) {
2180   _return(-1);
2181  }
2182 }
2183
2184 errno = 0;
2185
2186 if ( ss->codecfilter == -1 ) {
2187  ROAR_DBG("streams_send_mon(id=%i): not a CF stream", id);
2188  if ( s->fh == -1 && roar_vio_get_fh(&(ss->vio)) == -1 ) {
2189   ROAR_DBG("streams_send_mon(id=%i) = 0", id);
2190   _return(0);
2191  }
2192
2193  ROAR_DBG("streams_send_mon(id=%i) = ?", id);
2194
2195  if ( (ret = stream_vio_s_write(ss, obuf, olen)) == olen ) {
2196   s->pos = ROAR_MATH_OVERFLOW_ADD(s->pos, ROAR_OUTPUT_CALC_OUTBUFSAMP(&(s->info), olen)*s->info.channels);
2197   if ( ss->state != ROAR_STREAMSTATE_OLD ) {
2198    //ROAR_INFO("streams_send_mon(id=%i): stream state: %s->old", ROAR_DBG_INFO_VERBOSE, id, roar_streamstate2str(ss->state));
2199    _streams_change_state(ss, ROAR_STREAMSTATE_OLD, "streams_send_mon");
2200   }
2201   ROAR_DBG("streams_send_mon(id=%i) = 0", id);
2202   _return(0);
2203  }
2204
2205  ROAR_DBG("streams_send_mon(id=%i) = ?", id);
2206
2207  if ( ret > 0 && errno == 0 ) {
2208   ROAR_WARN("streams_send_mon(id=%i): Overrun in stream: wrote %i of %i bytes, %i bytes missing", id, (int)ret, olen, olen-(int)ret);
2209   roar_notify_core_emit_simple(ROAR_OE_STREAM_XRUN, -1, id, ROAR_OT_STREAM, ROAR_XRUN_OVER_POST, -1, NULL, 0);
2210   s->pos = ROAR_MATH_OVERFLOW_ADD(s->pos, ROAR_OUTPUT_CALC_OUTBUFSAMP(&(s->info), ret)*s->info.channels);
2211   if ( ss->state != ROAR_STREAMSTATE_OLD ) {
2212    //ROAR_INFO("streams_send_mon(id=%i): stream state: %s->old", ROAR_DBG_INFO_VERBOSE, id, roar_streamstate2str(ss->state));
2213    _streams_change_state(ss, ROAR_STREAMSTATE_OLD, "streams_send_mon");
2214   }
2215   _return(0);
2216  }
2217 } else {
2218  errno = 0;
2219  if ( codecfilter_write(ss->codecfilter_inst, ss->codecfilter, obuf, olen)
2220            == olen ) {
2221   s->pos = ROAR_MATH_OVERFLOW_ADD(s->pos, ROAR_OUTPUT_CALC_OUTBUFSAMP(&(s->info), olen)*s->info.channels);
2222   if ( ss->state != ROAR_STREAMSTATE_OLD ) {
2223    //ROAR_INFO("streams_send_mon(id=%i): stream state: %s->old", ROAR_DBG_INFO_VERBOSE, id, roar_streamstate2str(ss->state));
2224    _streams_change_state(ss, ROAR_STREAMSTATE_OLD, "streams_send_mon");
2225   }
2226   _return(0);
2227  } else { // we cann't retry on codec filetered streams
2228   if ( errno != EAGAIN ) {
2229    streams_delete(id);
2230    _return(-1);
2231   }
2232  }
2233 }
2234
2235 if ( errno == EAGAIN ) {
2236  // ok, the client blocks for a moment, we try to sleep a bit an retry in the hope not to
2237  // make any gapes in any output because of this
2238
2239#ifdef ROAR_HAVE_USLEEP
2240  usleep(100); // 0.1ms
2241#endif
2242
2243  if ( stream_vio_s_write(ss, obuf, olen) == olen ) {
2244   s->pos = ROAR_MATH_OVERFLOW_ADD(s->pos, ROAR_OUTPUT_CALC_OUTBUFSAMP(&(s->info), olen)*s->info.channels);
2245   if ( ss->state != ROAR_STREAMSTATE_OLD ) {
2246    //ROAR_INFO("streams_send_mon(id=%i): stream state: %s->old", ROAR_DBG_INFO_VERBOSE, id, roar_streamstate2str(ss->state));
2247    _streams_change_state(ss, ROAR_STREAMSTATE_OLD, "streams_send_mon");
2248   }
2249   _return(0);
2250  } else if ( errno == EAGAIN ) {
2251   ROAR_WARN("streams_send_mon(id=%i): Can not send data to client: %s", id, strerror(errno));
2252   _return(0);
2253  }
2254 }
2255
2256 // ug... error... delete stream!
2257
2258 streams_delete(id);
2259
2260 _return(-1);
2261}
2262#undef _return
2263
2264int streams_send_filter(int id) {
2265 int fh;
2266 int have = 0;
2267 int len;
2268 struct roar_stream        *   s;
2269 struct roar_stream_server *  ss;
2270
2271 _CHECK_SID(id);
2272
2273 ROAR_DBG("streams_send_filter(id=%i) = ?", id);
2274
2275 s = ROAR_STREAM(ss = g_streams[id]);
2276
2277 if ( (fh = s->fh) == -1 )
2278  return 0;
2279
2280 if ( s->dir != ROAR_DIR_FILTER )
2281  return 0;
2282
2283 if ( streams_get_flag(id, ROAR_FLAG_PAUSE) )
2284  return 0;
2285
2286
2287 ROAR_DBG("streams_send_filter(id=%i): fh = %i", id, fh);
2288
2289 if ( stream_vio_s_write(ss, g_output_buffer, g_output_buffer_len) == g_output_buffer_len ) {
2290  while ( have < g_output_buffer_len ) {
2291   if ( (len = stream_vio_s_read(ss, g_output_buffer+have, g_output_buffer_len-have)) < 1 ) {
2292    streams_delete(id);
2293    return -1;
2294   }
2295   have += len;
2296  }
2297  return 0;
2298 }
2299
2300 // ug... error... delete stream!
2301
2302 streams_delete(id);
2303
2304 return -1;
2305}
2306
2307
2308// VIO:
2309
2310ssize_t stream_vio_read (int stream, void *buf, size_t count) {
2311 _CHECK_SID(stream);
2312
2313 return stream_vio_s_read(g_streams[stream], buf, count);
2314}
2315
2316ssize_t stream_vio_write(int stream, void *buf, size_t count) {
2317 _CHECK_SID(stream);
2318
2319 return stream_vio_s_write(g_streams[stream], buf, count);
2320}
2321
2322
2323ssize_t stream_vio_s_read (struct roar_stream_server * stream, void *buf, size_t count) {
2324 void    * orig_buf = buf;
2325  size_t   len      =  0;
2326 ssize_t   r        = -1;
2327 int       i;
2328
2329 errno = 0;
2330
2331 if ( !stream )
2332  return -1;
2333
2334 //roar_vio_set_fh(&(stream->vio), ROAR_STREAM(stream)->fh);
2335
2336 if ( ! stream->vio.read )
2337  return -1;
2338
2339 while ( (r = roar_vio_read(&(stream->vio), buf, count)) > 0 ) {
2340  len   += r;
2341  buf   += r;
2342  count -= r;
2343  if ( count == 0 )
2344   break;
2345 }
2346
2347 if ( len == 0 && r == -1 )
2348  return -1;
2349
2350 if ( streams_thru_num ) {
2351  for (i = 0; i < ROAR_STREAMS_MAX; i++) {
2352   if ( g_streams[i] != NULL && ROAR_STREAM(g_streams[i])->pos_rel_id == ROAR_STREAM(stream)->id ) {
2353    if ( ROAR_STREAM(g_streams[i])->dir == ROAR_DIR_THRU ) {
2354     if ( g_streams[i]->ready ) {
2355      if ( stream_vio_write(i, orig_buf, len) != len )
2356       streams_delete(i);
2357
2358      if ( g_streams[i] != NULL ) {
2359       if ( g_streams[i]->state != ROAR_STREAMSTATE_OLD ) {
2360        //ROAR_INFO("stream_vio_s_read(*): (stream: %i) stream state: %s->old", ROAR_DBG_INFO_VERBOSE, i, roar_streamstate2str(g_streams[i]->state));
2361        _streams_change_state(g_streams[i], ROAR_STREAMSTATE_OLD, "stream_vio_s_read");
2362       }
2363      }
2364     }
2365    }
2366   }
2367  }
2368 }
2369
2370 return len;
2371}
2372
2373ssize_t stream_vio_s_write(struct roar_stream_server * stream, void *buf, size_t count) {
2374 int i;
2375
2376 errno = 0;
2377
2378 if ( !stream )
2379  return -1;
2380
2381/*
2382 if ( roar_vio_get_fh(&(stream->vio)) == -1 && ROAR_STREAM(stream)->fh != -1 )
2383  roar_vio_set_fh(&(stream->vio), ROAR_STREAM(stream)->fh);
2384*/
2385
2386// ROAR_WARN("stream_vio_s_write(*): writing...");
2387
2388 if ( streams_thru_num ) {
2389  for (i = 0; i < ROAR_STREAMS_MAX; i++) {
2390   if ( g_streams[i] != NULL && ROAR_STREAM(g_streams[i])->pos_rel_id == ROAR_STREAM(stream)->id ) {
2391    if ( ROAR_STREAM(g_streams[i])->dir == ROAR_DIR_THRU ) {
2392     if ( g_streams[i]->ready ) {
2393      if ( g_streams[i]->state == ROAR_STREAMSTATE_NEW ) {
2394       if ( streams_get_flag(i, ROAR_FLAG_PRETHRU) == 1 ) {
2395        if ( stream_prethru_send(i, ROAR_STREAM(stream)->id) == -1 ) {
2396         streams_delete(i);
2397        }
2398       }
2399      }
2400
2401      if ( stream_vio_write(i, buf, count) != count ) {
2402       streams_delete(i);
2403      }
2404
2405      if ( g_streams[i] != NULL ) {
2406       if ( g_streams[i]->state != ROAR_STREAMSTATE_OLD ) {
2407        //ROAR_INFO("stream_vio_s_write(*): (stream: %i) stream state: %s->old", ROAR_DBG_INFO_VERBOSE, i, roar_streamstate2str(g_streams[i]->state));
2408        _streams_change_state(g_streams[i], ROAR_STREAMSTATE_OLD, "stream_vio_s_write");
2409       }
2410      }
2411     }
2412    }
2413   }
2414  }
2415 }
2416
2417 if ( g_config->jumbo_mtu ) {
2418  if ( stream->viop != &(stream->jumbo) ) {
2419   if ( roar_vio_open_jumbo(&(stream->jumbo), &(stream->vio), g_config->jumbo_mtu) != -1 ) {
2420    // if that works we continue using the jumbo vio,
2421    // in case it didn't we dont, just use normal VIO.
2422    stream->viop = &(stream->jumbo);
2423   }
2424  }
2425 }
2426
2427 return roar_vio_write(stream->viop, buf, count);
2428}
2429
2430//ll
Note: See TracBrowser for help on using the repository browser.