source: roaraudio/roard/streams.c @ 4540:afaf515bb76a

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

more strict testing if a flag can be set or not

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