source: roaraudio/roard/streams.c @ 4544:d8158852ff37

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

fixed missing reset on delete of flag ROAR_FLAG_SINGLESINK, fixed pre-thru stream stuff.

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