source: roaraudio/roard/req.c @ 3530:8ca4bb4cc5b0

Last change on this file since 3530:8ca4bb4cc5b0 was 3530:8ca4bb4cc5b0, checked in by phi, 14 years ago

support to give scale parameter to roarctl

File size: 21.1 KB
Line 
1//req.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
28int req_on_noop        (int client, struct roar_message * mes, char * data) {
29 mes->cmd     = ROAR_CMD_OK;
30 mes->datalen = 0;
31 return 0;
32}
33
34int req_on_identify    (int client, struct roar_message * mes, char * data) {
35 struct roar_client * c;
36 int max_len;
37
38 if ( mes->datalen < 1 )
39  return -1;
40
41 clients_get(client, &c);
42
43 if ( mes->data[0] == 1 ) {
44  if ( c->pid == -1 ) {
45   c->pid       = ROAR_NET2HOST32(*(uint32_t*)((mes->data)+1));
46   ROAR_DBG("req_on_identify(): new PID: c->pid = %i", c->pid);
47  }
48
49  ROAR_DBG("req_on_identify(): final PID: c->pid = %i", c->pid);
50
51  max_len = (mes->datalen - 5) < (ROAR_BUFFER_NAME-1) ? (mes->datalen - 5) : (ROAR_BUFFER_NAME-1);
52
53  strncpy(c->name, mes->data + 5, max_len);
54  c->name[max_len] = 0;
55
56  mes->cmd     = ROAR_CMD_OK;
57  mes->datalen = 0;
58
59  ROAR_DBG("req_on_identify(*): client=%i, pid=%i", client, c->pid);
60  ROAR_DBG("req_on_identify(*) = 0");
61  return 0;
62 }
63
64 return -1;
65}
66
67int req_on_auth        (int client, struct roar_message * mes, char * data) {
68 // TODO: add code to support some auth.
69 mes->cmd     = ROAR_CMD_OK;
70 mes->datalen = 0;
71 return 0;
72}
73
74
75int req_on_whoami      (int client, struct roar_message * mes, char * data) {
76 mes->cmd     = ROAR_CMD_OK;
77 mes->datalen = 1;
78 mes->data[0] = client;
79 return 0;
80}
81
82
83int req_on_new_stream  (int client, struct roar_message * mes, char * data) {
84 int stream;
85 struct roar_stream * s;
86 struct roar_stream * source_stream;
87 struct roar_audio_info * info;
88 struct roar_audio_info * source_info;
89
90 ROAR_DBG("req_on_new_stream(client=%i, ...): creating stream...", client);
91 if ((stream = streams_new()) == -1 )
92  return -1;
93
94 ROAR_DBG("req_on_new_stream(client=%i, ...): getting stream...", client);
95 if ( streams_get(stream, (struct roar_stream_server **)&s) == -1 ) {
96  streams_delete(stream);
97  return -1;
98 }
99
100 ROAR_DBG("req_on_new_stream(client=%i, ...): set client of stream...", client);
101 if ( client_stream_add(client, stream) == -1 ) {
102  streams_delete(stream);
103  return -1;
104 }
105
106 ROAR_DBG("req_on_new_stream(client=%i, ...): loading stream from message...", client);
107 if ( roar_stream_m2s(s, mes) == -1 ) {
108  streams_delete(stream);
109  return -1;
110 }
111
112 ROAR_DBG("req_on_new_stream(client=%i, ...): setting id and codec of stream...", client);
113 ROAR_STREAM(s)->id = stream; // roar_stream_m2s() resets this
114 ROAR_STREAM_SERVER(s)->codec_orgi = ROAR_STREAM(s)->info.codec;
115
116 ROAR_DBG("req_on_new_stream(client=%i, ...): setting direction stream...", client);
117 // int streams_set_dir    (int id, int dir, int defaults)
118 if ( streams_set_dir(stream, ROAR_STREAM(s)->dir, 1) == -1 ) {
119  streams_delete(stream);
120  return -1;
121 }
122
123 ROAR_DBG("req_on_new_stream(client=%i, ...): setting up direction specific stream settings...", client);
124 switch (ROAR_STREAM(s)->dir) {
125  case ROAR_DIR_LIGHT_IN:
126  case ROAR_DIR_LIGHT_OUT:
127#ifndef ROAR_WITHOUT_DCOMP_LIGHT
128    info = &(ROAR_STREAM(s)->info);
129
130    info->channels = 0;
131    info->bits     = 0;
132    info->rate     = 0;
133#else
134    streams_delete(stream);
135    return -1;
136#endif
137
138   break;
139  case ROAR_DIR_MIDI_IN:
140  case ROAR_DIR_MIDI_OUT:
141#ifndef ROAR_WITHOUT_DCOMP_MIDI
142    info = &(ROAR_STREAM(s)->info);
143
144    info->channels = ROAR_MIDI_CHANNELS_DEFAULT;
145    info->bits     = ROAR_MIDI_BITS;
146    info->rate     = 0;
147#else
148    streams_delete(stream);
149    return -1;
150#endif
151
152   break;
153
154  case ROAR_DIR_RAW_IN:
155#ifndef ROAR_WITHOUT_DCOMP_RAW
156    if ( ROAR_STREAM(s)->pos_rel_id == -1     ||
157         ROAR_STREAM(s)->pos_rel_id == stream ||
158         streams_get_dir(ROAR_STREAM(s)->pos_rel_id) != ROAR_DIR_RAW_OUT
159       ) {
160     ROAR_STREAM(s)->pos_rel_id = -1; // force this here as it will try to delete itself while deleting
161                                      // in case rel_id == stream
162     streams_delete(stream);
163     return -1;
164    }
165#else
166  case ROAR_DIR_RAW_OUT:
167    streams_delete(stream);
168    return -1;
169#endif
170
171   break;
172  case ROAR_DIR_THRU:
173
174    if ( ROAR_STREAM(s)->pos_rel_id == -1 || ROAR_STREAM(s)->pos_rel_id == stream ) {
175     ROAR_STREAM(s)->pos_rel_id = -1; // force this here as it will try to delete itself while deleting
176                                      // in case rel_id == stream
177     streams_delete(stream);
178     return -1;
179    }
180
181    if ( streams_get(ROAR_STREAM(s)->pos_rel_id, (struct roar_stream_server **)&source_stream) == -1 ) {
182     streams_delete(stream);
183     return -1;
184    }
185
186    info        = &(ROAR_STREAM(s)->info);
187    source_info = &(ROAR_STREAM(source_stream)->info);
188
189    info->channels = source_info->channels;
190    info->bits     = source_info->bits;
191    info->rate     = source_info->rate;
192    info->codec    = source_info->codec;
193    ROAR_STREAM_SERVER(s)->codec_orgi = ROAR_STREAM_SERVER(source_stream)->codec_orgi;
194
195   break;
196 }
197
198 ROAR_DBG("req_on_new_stream(client=%i, ...): returning (OK)...", client);
199
200 mes->cmd     = ROAR_CMD_OK;
201 mes->stream  = stream;
202 mes->datalen = 0;
203
204 return 0;
205}
206
207int req_on_exec_stream (int client, struct roar_message * mes, char * data) {
208 int r;
209
210 ROAR_DBG("req_on_exec_stream(client=%i, mes={stream=%i,...},...): execing stream", client, mes->stream);
211
212 if ( (r = client_stream_exec(client, mes->stream)) == -1 )
213  return -1;
214
215 ROAR_DBG("req_on_exec_stream(client=%i, mes={stream=%i,...},...): returning (OK)...", client, mes->stream);
216 mes->cmd     = ROAR_CMD_OK;
217 mes->datalen = 0;
218
219 return 0;
220}
221
222int req_on_con_stream  (int client, struct roar_message * mes, char * data) {
223 char   host[80] = {0};
224 int    port = 0;
225 int    type;
226 int    fh;
227 int    len;
228
229 if ( mes->datalen < 4 )
230  return -1;
231
232 if ( *(mes->data) != 0 )
233  return -1;
234
235 if ( mes->datalen > 80 ) // we do not support long messages here
236  return -1;
237
238 type = (unsigned)mes->data[1];
239 port = ROAR_NET2HOST16(((uint16_t*)mes->data)[1]);
240
241 len = mes->datalen - 4;
242
243 strncpy(host, &(mes->data[4]), len);
244 host[len] = 0;
245
246 if ( type > ROAR_SOCKET_TYPE_MAX )
247  return -1;
248
249 if ( type == ROAR_SOCKET_TYPE_FILE ) // disabled because of security resons
250  return -1;
251
252 if ( type == ROAR_SOCKET_TYPE_FORK ) // why should we connect to ourself?
253  return -1;
254
255 ROAR_DBG("req_on_con_stream(*): CONNECT(type=%i, host='%s', port=%i)", type, host, port);
256
257 if ( (fh = roar_socket_open(ROAR_SOCKET_MODE_CONNECT, type, host, port)) == -1 )
258  return -1;
259
260 if ( client_stream_set_fh(client, mes->stream, fh) == -1 ) {
261  close(fh);
262  return 1;
263 }
264
265 mes->datalen = 0;
266 mes->cmd     = ROAR_CMD_OK;
267
268 return 0;
269}
270
271int req_on_passfh      (int client, struct roar_message * mes, char * data) {
272 int fh;
273 int sock = clients_get_fh(client);
274
275 if ( (fh = roar_socket_recv_fh(sock, NULL, NULL)) == -1 )
276  return -1;
277
278 if ( client_stream_set_fh(client, mes->stream, fh) == -1 ) {
279  close(fh);
280  return 1;
281 }
282
283
284 mes->datalen = 0;
285 mes->cmd     = ROAR_CMD_OK;
286
287 return 0;
288}
289
290#ifdef ROAR_SUPPORT_META
291int req_on_set_meta    (int client, struct roar_message * mes, char * data) {
292 int type;
293 int mode;
294 int namelen, vallen;
295 char   val[255+1];
296 char   name[ROAR_META_MAX_NAMELEN+1];
297
298 if ( mes->datalen < 3 )
299  return -1;
300
301 if ( mes->data[0] != 0 ) // version
302  return -1;
303
304 mode = (unsigned) mes->data[1];
305 type = (unsigned) mes->data[2];
306
307 ROAR_DBG("req_on_set_meta(*): mode=%i, type=%i", mode, type);
308
309 if ( mode == ROAR_META_MODE_CLEAR ) {
310  stream_meta_clear(mes->stream);
311  mes->datalen = 0;
312  mes->cmd     = ROAR_CMD_OK;
313  return 0;
314 } else if ( mode == ROAR_META_MODE_DELETE ) { // unsuppoerted at the moment
315  return -1;
316 } else if ( mode == ROAR_META_MODE_FINALIZE ) {
317  stream_meta_finalize(mes->stream);
318  mes->datalen = 0;
319  mes->cmd     = ROAR_CMD_OK;
320  return 0;
321 } else if ( mode == ROAR_META_MODE_SET || mode == ROAR_META_MODE_ADD ) {
322  if ( mes->datalen < 5 )
323   return -1;
324
325  namelen = (unsigned) mes->data[3];
326  vallen  = (unsigned) mes->data[4];
327
328  ROAR_DBG("req_on_set_meta(*): namelen=%i, vallen=%i", namelen, vallen);
329
330  if ( mes->datalen < (5 + namelen + vallen) )
331   return -1;
332
333  if ( namelen > ROAR_META_MAX_NAMELEN )
334   return -1;
335
336  strncpy(name, &(mes->data[5]), namelen);
337  name[namelen] = 0;
338
339  if ( vallen > 255 )
340   return -1;
341
342  strncpy(val, &(mes->data[5+namelen]), vallen);
343  val[vallen] = 0;
344
345  if ( mode == ROAR_META_MODE_SET ) {
346   if ( stream_meta_set(mes->stream, type, name, val) == -1 )
347    return -1;
348  } else {
349   if ( stream_meta_add(mes->stream, type, name, val) == -1 )
350    return -1;
351  }
352
353  mes->datalen = 0;
354  mes->cmd     = ROAR_CMD_OK;
355  return 0;
356 } else { // unknown mode!
357  return -1;
358 }
359
360 return -1;
361}
362
363int req_on_get_meta    (int client, struct roar_message * mes, char * data) {
364 int vallen;
365 int type;
366 char val[LIBROAR_BUFFER_MSGDATA-1];
367
368 if ( mes->datalen != 2 )
369  return -1;
370
371 if ( mes->data[0] != 0 ) // version
372  return -1;
373
374 type = (unsigned) mes->data[1];
375
376 if ( stream_meta_get(mes->stream, type, NULL, val, LIBROAR_BUFFER_MSGDATA-2) == -1 )
377  return -1;
378
379 vallen = strlen(val);
380
381 mes->cmd     = ROAR_CMD_OK;
382 mes->datalen = 2 + vallen;
383
384 mes->data[0] = 0;
385 mes->data[1] = (unsigned char) vallen;
386
387 val[vallen] = 0;
388
389 strncpy(&(mes->data[2]), val, vallen+1);
390
391 return 0;
392}
393
394int req_on_list_meta   (int client, struct roar_message * mes, char * data) {
395 int i;
396 int len = 0;
397 int types[ROAR_META_MAX_PER_STREAM];
398
399 if ( mes->datalen != 1 )
400  return -1;
401
402 if ( mes->data[0] != 0 ) // version
403  return -1;
404
405 if ( (len = stream_meta_list(mes->stream, types, ROAR_META_MAX_PER_STREAM)) == -1 )
406  return -1;
407
408 mes->cmd     = ROAR_CMD_OK;
409 mes->datalen = 1 + len;
410 mes->data[0] = 0;
411
412 for (i = 0; i < len; i++)
413  mes->data[i+1] = types[i];
414
415 return 0;
416}
417#endif
418
419int req_on_server_oinfo    (int client, struct roar_message * mes, char * data) {
420 struct roar_stream s;
421//ROAR_DIR_OUTPUT
422
423 memset(&s, 0, sizeof(struct roar_stream));
424
425 s.dir           = ROAR_DIR_MIXING;
426 s.pos_rel_id    = -1;
427 s.info.rate     = g_sa->rate;
428 s.info.bits     = g_sa->bits;
429 s.info.channels = g_sa->channels;
430 s.info.codec    = g_sa->codec;
431 s.pos           = g_pos;
432
433 if ( roar_stream_s2m(&s, mes) == -1 )
434  return -1;
435
436 mes->cmd = ROAR_CMD_OK;
437
438 return 0;
439}
440
441
442int req_on_get_standby (int client, struct roar_message * mes, char * data) {
443 mes->cmd = ROAR_CMD_OK;
444 mes->datalen = 2;
445
446 *((uint16_t*)mes->data) = ROAR_HOST2NET16((unsigned) g_standby);
447
448 return 0;
449}
450
451int req_on_set_standby (int client, struct roar_message * mes, char * data) {
452 if ( mes->datalen != 2 )
453  return -1;
454
455 g_standby = ROAR_NET2HOST16(*((uint16_t*)mes->data));
456
457 mes->cmd     = ROAR_CMD_OK;
458 mes->datalen = 0;
459
460 return 0;
461}
462
463int req_on_exit      (int client, struct roar_message * mes, char * data) {
464 int term = 0;
465
466 if ( mes->datalen == 1 )
467  term = mes->data[0];
468
469 mes->cmd     = ROAR_CMD_OK;
470 mes->datalen = 0;
471
472 ROAR_DBG("req_on_exit(*): term=%i", term);
473
474 if ( term ) {
475  cleanup_listen_socket(1);
476 } else {
477  alive = 0;
478 }
479
480 return 0;
481}
482
483int req_on_list_clients(int client, struct roar_message * mes, char * data) {
484 unsigned char filter, cmp;
485 uint32_t id;
486 int clients[ROAR_CLIENTS_MAX];
487 int i, c = 0;
488
489 if ( roar_ctl_m2f(mes, &filter, &cmp, &id) == -1 )
490  return -1;
491
492 // TODO: add code to support filter
493 if ( filter != ROAR_CTL_FILTER_ANY )
494  return -1;
495
496 for (i = 0; i < ROAR_CLIENTS_MAX; i++) {
497  if ( g_clients[i] != NULL ) {
498   clients[c++] = i;
499  }
500 }
501
502 roar_ctl_ia2m(mes, clients, c);
503
504 mes->cmd = ROAR_CMD_OK;
505
506 return 0;
507}
508int req_on_list_streams(int client, struct roar_message * mes, char * data) {
509 unsigned char filter, cmp;
510 uint32_t id;
511 int streams[ROAR_STREAMS_MAX];
512 int i, c = 0;
513
514 if ( roar_ctl_m2f(mes, &filter, &cmp, &id) == -1 )
515  return -1;
516
517 // TODO: add code to support filter
518 if ( filter != ROAR_CTL_FILTER_ANY )
519  return -1;
520
521 for (i = 0; i < ROAR_STREAMS_MAX; i++) {
522  if ( g_streams[i] != NULL ) {
523   streams[c++] = i;
524  }
525 }
526
527 roar_ctl_ia2m(mes, streams, c);
528
529 mes->cmd = ROAR_CMD_OK;
530
531 return 0;
532}
533
534int req_on_get_client  (int client, struct roar_message * mes, char * data) {
535 struct roar_client * c;
536
537 if ( mes->datalen != 1 )
538  return -1;
539
540 if ( clients_get(mes->data[0], &c) == -1 )
541  return -1;
542
543 mes->cmd = ROAR_CMD_OK;
544
545 return roar_ctl_c2m(mes, c);
546}
547
548int req_on_get_stream  (int client, struct roar_message * mes, char * data) {
549 struct roar_stream_server * s;
550
551 if ( mes->datalen != 1 )
552  return -1;
553
554 if ( streams_get(mes->data[0], &s) == -1 )
555  return -1;
556
557 mes->cmd = ROAR_CMD_OK;
558 mes->stream = mes->data[0];
559
560 return roar_stream_s2m(ROAR_STREAM(s), mes);
561}
562
563int req_on_get_stream_para (int client, struct roar_message * mes, char * data) {
564 struct roar_stream * s;
565 struct roar_stream_server * ss;
566 struct roar_audio_info * audio_info;
567 uint16_t * d = (uint16_t *) mes->data;
568 int i;
569 char * str;
570
571 if ( mes->datalen != 4 )
572  return -1;
573
574 for (i = 0; i < mes->datalen/2; i++) {
575  d[i] = ROAR_NET2HOST16(d[i]);
576 }
577
578 if ( d[0] != 0 ) {
579  ROAR_WARN("req_on_get_stream_para(*): unsupported command version: %i, %i", d[0], d[1]);
580  return -1;
581 }
582
583 switch (d[1]) {
584  case ROAR_STREAM_PARA_INFO:
585    if ( streams_get(mes->stream, &ss) == -1 ) {
586     ROAR_WARN("req_on_get_stream_para(*): request on non existing (or other error?) stream %i", mes->stream);
587     return -1;
588    }
589
590    if ( streams_calc_delay(mes->stream) == -1 ) {
591     ROAR_WARN("req_on_get_stream_para(*): can not calc delay for stream %i", mes->stream);
592    }
593
594    s = ROAR_STREAM(ss);
595
596    audio_info = &(s->info);
597
598    mes->datalen = 2*11;
599
600    d[ 2] = ROAR_OUTPUT_CALC_OUTBUFSIZE(audio_info);
601    d[ 3] = ss->pre_underruns;
602    d[ 4] = ss->post_underruns;
603    d[ 5] = ss->codec_orgi;
604    d[ 6] = (ss->flags & 0xFFFF) | (ss->primary ? ROAR_FLAG_PRIMARY : 0) | (ss->driver_id != -1 ? ROAR_FLAG_OUTPUT : 0);
605    d[ 7] = ss->delay/1000;
606    d[ 8] = ss->state;
607    d[ 9] = (ss->flags & 0xFFFF0000) >> 16;
608    d[10] = ss->mixer_stream;
609
610    ROAR_DBG("req_on_get_stream_para(*): ss->driver_id=%i", ss->driver_id);
611
612    ROAR_DBG("req_on_get_stream_para(*): delay=%i, send delay=%i", ss->delay, d[7]);
613
614    for (i = 0; i < mes->datalen/2; i++) {
615     d[i] = ROAR_HOST2NET16(d[i]);
616    }
617
618    mes->pos = s->pos;
619   break;
620
621  case ROAR_STREAM_PARA_NAME:
622   str = streams_get_name(mes->stream);
623
624   if ( str == NULL )
625    return -1;
626
627    mes->datalen = 4 + strlen(str);
628
629    if ( mes->datalen > LIBROAR_BUFFER_MSGDATA )
630     return -1;
631
632    strncpy(((char*)&(mes->data))+4, str, mes->datalen);
633
634    d[0] = ROAR_HOST2NET16(d[0]);
635    d[1] = ROAR_HOST2NET16(d[1]);
636   break;
637
638  default:
639    ROAR_WARN("req_on_get_stream_para(*): unsupported command: %i", d[1]);
640    return -1;
641 }
642
643 mes->cmd = ROAR_CMD_OK;
644 return 0;
645}
646
647int req_on_set_stream_para (int client, struct roar_message * mes, char * data) {
648 uint16_t * d = (uint16_t *) mes->data;
649 int i;
650
651 if ( mes->datalen != 8 )
652  return -1;
653
654 for (i = 0; i < mes->datalen/2; i++) {
655  d[i] = ROAR_NET2HOST16(d[i]);
656 }
657
658 if ( d[0] != 0 || d[1] != ROAR_STREAM_PARA_FLAGS ) {
659  ROAR_WARN("req_on_set_stream_para(*): unsupported command version: %i, %i", d[0], d[1]);
660  return -1;
661 }
662
663 mes->cmd     = ROAR_CMD_OK;
664 mes->datalen = 0;
665
666 ROAR_DBG("req_on_set_stream_para(*): request seems to be valid");
667
668 if ( d[2] == ROAR_RESET_FLAG ) {
669  return streams_reset_flag(mes->stream, d[3]);
670 } else {
671  return streams_set_flag(mes->stream, d[3]);
672 }
673
674 return -1;
675}
676
677int req_on_kick (int client, struct roar_message * mes, char * data) {
678 uint16_t * info = (uint16_t *) mes->data;
679
680 if ( mes->datalen != 4 )
681  return -1;
682
683 info[0] = ROAR_NET2HOST16(info[0]);
684 info[1] = ROAR_NET2HOST16(info[1]);
685
686 if ( info[0] == ROAR_OT_CLIENT ) {
687  clients_delete(info[1]);
688 } else if ( info[0] == ROAR_OT_STREAM ) {
689  if ( streams_get_flag(info[1], ROAR_FLAG_IMMUTABLE) == 1 )
690   return -1;
691
692  streams_delete(info[1]);
693 } else if ( info[0] == ROAR_OT_SOURCE ) {
694  if ( streams_get_flag(info[1], ROAR_FLAG_IMMUTABLE) == 1 )
695   return -1;
696
697  if ( streams_get_flag(info[1], ROAR_FLAG_SOURCE) == 1 ) {
698   streams_delete(info[1]);
699  } else {
700   return -1;
701  }
702 } else {
703  return -1;
704 }
705
706 mes->cmd     = ROAR_CMD_OK;
707 mes->datalen = 0;
708
709 return 0;
710}
711
712int req_on_attach      (int client, struct roar_message * mes, char * data) {
713 uint16_t * info = (uint16_t *) mes->data;
714
715 if ( mes->datalen < 6 )
716  return -1;
717
718 info[0] = ROAR_NET2HOST16(info[0]);
719 info[1] = ROAR_NET2HOST16(info[1]);
720 info[2] = ROAR_NET2HOST16(info[2]);
721
722 if ( info[0] != 0 )
723  return -1;
724
725 if ( info[1] == ROAR_ATTACH_SIMPLE ) {
726  if ( client_stream_move(info[2], mes->stream) == -1 )
727   return -1;
728 } else {
729  return -1;
730 }
731
732 mes->cmd     = ROAR_CMD_OK;
733 mes->datalen = 0;
734
735 return 0;
736}
737
738int req_on_set_vol (int client, struct roar_message * mes, char * data) {
739 struct roar_stream_server * s;
740 uint16_t * info = (uint16_t *) mes->data;
741 uint16_t   version;
742 uint16_t   scale = 65535;
743 int stream;
744 int i;
745 int chans;
746
747 ROAR_DBG("req_on_set_vol(*) = ?");
748 ROAR_DBG("req_on_set_vol(*): mes->datalen=%i", mes->datalen);
749
750 if ( mes->datalen < (4*2) )
751  return -1;
752
753 version = ROAR_NET2HOST16(info[0]);
754 ROAR_DBG("req_on_set_vol(*): version=%i", (int)version);
755
756 switch (version) {
757  case 0:
758    stream = ROAR_NET2HOST16(info[1]);
759   break;
760  case 1:
761    stream = mes->stream;
762    scale  = ROAR_NET2HOST16(info[1]);
763   break;
764  default:
765    return -1;
766   break;
767 }
768 ROAR_DBG("req_on_set_vol(*): stream=%i", stream);
769
770 // TODO: change this code.
771 //       we should not directly change the stream object but use some stream_*()-func
772 //       for that job.
773
774 if ( stream < 0 || stream >= ROAR_STREAMS_MAX )
775  return -1;
776
777 s = g_streams[stream];
778
779 if ( s == NULL )
780  return -1;
781
782 ROAR_DBG("req_on_set_vol(*): s=%p", s);
783
784 info[2] = ROAR_NET2HOST16(info[2]);
785
786 if ( info[2] == ROAR_SET_VOL_ALL ) {
787  chans = (mes->datalen/2) - 3;
788  ROAR_DBG("req_on_set_vol(*): mode is ROAR_SET_VOL_ALL, channes=%i", chans);
789
790  if ( chans >= ROAR_MAX_CHANNELS )
791   return -1;
792
793  ROAR_DBG("req_on_set_vol(*): mixer at %p", s->mixer.mixer);
794
795  for (i = 0; i < chans; i++) {
796   s->mixer.mixer[i] = ROAR_NET2HOST16(info[i+3]);
797   ROAR_DBG("req_on_set_vol(*): channel %i: %i", i, ROAR_NET2HOST16(info[i+3]));
798  }
799
800  s->mixer.scale = scale;
801
802  ROAR_DBG("req_on_set_vol(*): mixer changed!");
803
804 } else if ( info[2] == ROAR_SET_VOL_ONE ) {
805  ROAR_DBG("req_on_set_vol(*): mode is ROAR_SET_VOL_ONE");
806  if ( ROAR_NET2HOST16(info[3]) >= ROAR_MAX_CHANNELS )
807   return -1;
808
809  s->mixer.mixer[ROAR_NET2HOST16(info[3])] = ROAR_NET2HOST16(info[4]);
810
811  s->mixer.scale = scale;
812 } else {
813  return -1;
814 }
815
816 if ( streams_set_mixer(stream) == -1 )
817  return -1;
818
819 mes->cmd     = ROAR_CMD_OK;
820 mes->datalen = 0;
821
822 return 0;
823}
824
825int req_on_get_vol (int client, struct roar_message * mes, char * data) {
826 uint16_t * info = (uint16_t *) mes->data;
827 uint16_t   version = -1;
828 int stream;
829 struct roar_stream_server * s;
830 int i;
831 int chans;
832
833 ROAR_DBG("req_on_get_vol(*) = ?");
834 ROAR_DBG("req_on_get_vol(*): mes->datalen=%i", mes->datalen);
835
836 if ( mes->datalen < 2 ) {
837  return -1;
838 }
839
840 version = ROAR_NET2HOST16(info[0]);
841
842 switch (version) {
843  case 0:
844    if ( mes->datalen < (2*2) )
845     return -1;
846
847    stream = ROAR_NET2HOST16(info[1]);
848   break;
849  case 1:
850    stream = mes->stream;
851   break;
852  default:
853    return -1;
854   break;
855 }
856
857 ROAR_DBG("req_on_get_vol(*): stream=%i", stream);
858
859 // TODO: change this code.
860 //       we should not directly change the stream object but use some stream_*()-func
861 //       for that job.
862
863 if ( stream < 0 || stream >= ROAR_STREAMS_MAX )
864  return -1;
865
866 s = g_streams[stream];
867
868 if ( s == NULL )
869  return -1;
870
871 ROAR_DBG("req_on_get_vol(*): s=%p", s);
872
873 // ok, we have everything
874
875 info[0] = ROAR_HOST2NET16(version);
876
877 switch (version) {
878  case 0:
879    info[1] = ROAR_HOST2NET16(chans = ROAR_STREAM(s)->info.channels);
880
881    for (i = 0; i < chans; i++)
882     info[2+i] = ROAR_HOST2NET16(s->mixer.mixer[i]);
883
884     mes->datalen = (2 + chans)*2;
885   break;
886  case 1:
887    info[1] = ROAR_HOST2NET16(chans = ROAR_STREAM(s)->info.channels);
888    info[2] = ROAR_HOST2NET16(s->mixer.scale);
889    info[3] = ROAR_HOST2NET16(s->mixer.rpg_mul);
890    info[4] = ROAR_HOST2NET16(s->mixer.rpg_div);
891
892    for (i = 0; i < chans; i++)
893     info[5+i] = ROAR_HOST2NET16(s->mixer.mixer[i]);
894
895     mes->datalen = (5 + chans)*2;
896   break;
897  default:
898    return -1;
899   break;
900 }
901
902 mes->cmd = ROAR_CMD_OK;
903
904 return 0;
905}
906
907int req_on_add_data (int client, struct roar_message * mes, char * data) {
908 struct roar_buffer * b;
909 char               * buf;
910
911 if ( roar_buffer_new(&b, mes->datalen) == -1 ) {
912  ROAR_ERR("req_on_add_data(*): Can not alloc buffer space!");
913  ROAR_DBG("req_on_add_data(*) = -1");
914  return -1;
915 }
916
917 roar_buffer_get_data(b, (void **)&buf);
918
919 if ( data == NULL ) {
920  memcpy(buf, mes->data, mes->datalen);
921 } else {
922  memcpy(buf, data, mes->datalen);
923 }
924
925 if ( stream_add_buffer(mes->stream, b) == -1 ) {
926  roar_buffer_free(b);
927  return -1;
928 }
929
930 mes->cmd     = ROAR_CMD_OK_STOP;
931 mes->datalen = 0;
932
933 return 0;
934}
935
936//ll
Note: See TracBrowser for help on using the repository browser.