source: roaraudio/libroar/ctl.c @ 6036:3068a825a29e

Last change on this file since 6036:3068a825a29e was 6036:3068a825a29e, checked in by phi, 9 years ago

killed some compiler warnings

File size: 22.7 KB
Line 
1//ctl.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2014
5 *
6 *  This file is part of libroar a part of RoarAudio,
7 *  a cross-platform sound system for both, home and professional use.
8 *  See README for details.
9 *
10 *  This file is free software; you can redistribute it and/or modify
11 *  it under the terms of the GNU General Public License version 3
12 *  as published by the Free Software Foundation.
13 *
14 *  libroar is distributed in the hope that it will be useful,
15 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 *  GNU General Public License for more details.
18 *
19 *  You should have received a copy of the GNU General Public License
20 *  along with this software; see the file COPYING.  If not, write to
21 *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 *  Boston, MA 02110-1301, USA.
23 *
24 *  NOTE for everyone want's to change something and send patches:
25 *  read README and HACKING! There a addition information on
26 *  the license of this document you need to read before you send
27 *  any patches.
28 *
29 *  NOTE for uses of non-GPL (LGPL,...) software using libesd, libartsc
30 *  or libpulse*:
31 *  The libs libroaresd, libroararts and libroarpulse link this lib
32 *  and are therefore GPL. Because of this it may be illigal to use
33 *  them with any software that uses libesd, libartsc or libpulse*.
34 */
35
36#include "libroar.h"
37
38int roar_get_clientid  (struct roar_connection * con) {
39 struct roar_message mes;
40
41 memset(&mes, 0, sizeof(struct roar_message)); // make valgrind happy!
42
43 mes.cmd     = ROAR_CMD_WHOAMI;
44 mes.stream  = -1;
45 mes.datalen =  0;
46
47 if ( roar_req(con, &mes, NULL) == -1 )
48  return -1;
49
50 if ( mes.cmd != ROAR_CMD_OK )
51  return -1;
52
53 if ( mes.datalen != 1 )
54  return -1;
55
56 return mes.data[0];
57}
58
59int roar_server_oinfo  (struct roar_connection * con, struct roar_stream * s, int dir) {
60 struct roar_message mes;
61
62 memset(&mes, 0, sizeof(struct roar_message)); // make valgrind happy!
63
64 mes.cmd     = ROAR_CMD_SERVER_OINFO;
65
66 if ( dir == -1 ) {
67  mes.datalen = 0;
68 } else {
69  mes.datalen = 2;
70  mes.data[0] = 0;
71  mes.data[1] = dir;
72 }
73
74 if ( roar_req(con, &mes, NULL) == -1 )
75  return -1;
76
77 if ( mes.cmd != ROAR_CMD_OK )
78  return -1;
79
80 if ( roar_stream_m2s(s, &mes) == -1 )
81  return -1;
82
83 return 0;
84}
85
86int roar_get_standby   (struct roar_connection * con) {
87 struct roar_message mes;
88 uint16_t * d16 = (uint16_t *)mes.data;
89
90 memset(&mes, 0, sizeof(struct roar_message)); // make valgrind happy!
91
92 mes.cmd = ROAR_CMD_GET_STANDBY;
93 mes.stream  = -1;
94 mes.datalen =  0;
95
96 if ( roar_req(con, &mes, NULL) == -1 )
97  return -1;
98
99 if ( mes.cmd != ROAR_CMD_OK )
100  return -1;
101
102 return ROAR_NET2HOST16(*d16);
103}
104
105int roar_set_standby   (struct roar_connection * con, int state) {
106 struct roar_message mes;
107 uint16_t * d16 = (uint16_t *)mes.data;
108
109 memset(&mes, 0, sizeof(struct roar_message)); // make valgrind happy!
110
111 mes.cmd = ROAR_CMD_SET_STANDBY;
112 mes.stream  = -1;
113 mes.datalen =  2;
114
115 *d16 = ROAR_HOST2NET16((unsigned) state);
116
117 if ( roar_req(con, &mes, NULL) == -1 )
118  return -1;
119
120 if ( mes.cmd != ROAR_CMD_OK )
121  return -1;
122
123 return 0;
124}
125
126int roar_terminate (struct roar_connection * con, int terminate) {
127 struct roar_message mes;
128
129 memset(&mes, 0, sizeof(struct roar_message)); // make valgrind happy!
130
131 mes.cmd     = ROAR_CMD_EXIT;
132 mes.stream  = -1;
133 mes.datalen =  1;
134 mes.data[0] = terminate;
135
136 if ( roar_req(con, &mes, NULL) == -1 )
137  return -1;
138
139 if ( mes.cmd != ROAR_CMD_OK )
140  return -1;
141
142 return 0;
143}
144
145int roar_list_filtered(struct roar_connection * con, int * items,   int max, int cmd, unsigned char filter, unsigned char cmp, uint32_t id) {
146 struct roar_message m;
147
148 memset(&m, 0, sizeof(struct roar_message)); // make valgrind happy!
149
150 roar_ctl_f2m(&m, filter, cmp, id);
151 m.cmd = cmd;
152
153 if ( roar_req(con, &m, NULL) == -1 )
154  return -1;
155
156 return roar_ctl_m2ia(&m, items, max);
157}
158
159int roar_list         (struct roar_connection * con, int * items,   int max, int cmd) {
160 return roar_list_filtered(con, items, max, cmd, ROAR_CTL_FILTER_ANY, ROAR_CTL_CMP_ANY, ROAR_CTL_FILTER_ANY);
161}
162
163int roar_get_client   (struct roar_connection * con, struct roar_client * client, int id) {
164 struct roar_message m;
165 char * data = NULL;
166 int ret;
167
168 memset(&m, 0, sizeof(struct roar_message)); // make valgrind happy!
169
170 m.cmd     = ROAR_CMD_GET_CLIENT;
171 m.stream  = -1;
172 m.datalen =  1;
173 m.data[0] = id;
174
175 ROAR_DBG("roar_get_client(*): id = %i", id);
176
177 if ( roar_req(con, &m, &data) == -1 )
178  return -1;
179
180 if ( m.cmd != ROAR_CMD_OK )
181  return -1;
182
183 ROAR_DBG("roar_get_client(*): got ok");
184
185 ret = roar_ctl_m2c2(&m, client, data);
186
187 if ( data != NULL )
188  roar_mm_free(data);
189
190 return ret;
191}
192
193int roar_get_stream   (struct roar_connection * con, struct roar_stream * stream, int id) {
194 struct roar_message m;
195
196 memset(&m, 0, sizeof(struct roar_message)); // make valgrind happy!
197
198 m.cmd     = ROAR_CMD_GET_STREAM;
199 m.datalen = 1;
200 m.data[0] = id;
201
202 roar_err_set(ROAR_ERROR_UNKNOWN);
203
204 if ( roar_req(con, &m, NULL) == -1 ) {
205  roar_err_set(ROAR_ERROR_PROTO);
206  return -1;
207 }
208
209 if ( m.cmd != ROAR_CMD_OK )
210  return -1;
211
212 return roar_stream_m2s(stream, &m);
213}
214
215int roar_kick         (struct roar_connection * con, int type, int id) {
216 struct roar_message m;
217 uint16_t * info = (uint16_t *) m.data;
218
219 memset(&m, 0, sizeof(struct roar_message)); // make valgrind happy!
220
221 m.cmd     = ROAR_CMD_KICK;
222 m.datalen = 4;
223 info[0] = ROAR_HOST2NET16(type);
224 info[1] = ROAR_HOST2NET16(id);
225
226 if ( roar_req(con, &m, NULL) == -1 )
227  return -1;
228
229 if ( m.cmd != ROAR_CMD_OK )
230  return -1;
231
232 return 0;
233}
234
235int roar_set_vol     (struct roar_connection * con, int id, struct roar_mixer_settings * mixer, int   channels, int mode) {
236 struct roar_message m;
237 uint16_t * info = (uint16_t *) m.data;
238 int i;
239
240 memset(&m, 0, sizeof(struct roar_message)); // make valgrind happy!
241
242 m.cmd     = ROAR_CMD_SET_VOL;
243 m.datalen = (3 + channels) * 2;
244 m.stream  = id;
245 info[0] = ROAR_HOST2NET16(1);
246 info[1] = ROAR_HOST2NET16(mixer->scale);
247 info[2] = ROAR_HOST2NET16(mode);
248
249 for (i = 0; i < channels; i++)
250  info[i+3] = ROAR_HOST2NET16(mixer->mixer[i]);
251
252 if ( roar_req(con, &m, NULL) == -1 )
253  return -1;
254
255 if ( m.cmd != ROAR_CMD_OK )
256  return -1;
257
258 return 0;
259}
260
261int roar_get_vol      (struct roar_connection * con, int id, struct roar_mixer_settings * mixer, int * channels) {
262 struct roar_message m;
263 uint16_t * info = (uint16_t *) m.data;
264 int i;
265
266 memset(&m, 0, sizeof(struct roar_message)); // make valgrind happy!
267
268 m.cmd     = ROAR_CMD_GET_VOL;
269 m.datalen = 2*2;
270 m.stream  = id;
271
272 info[0]   = ROAR_HOST2NET16(1);
273
274 if ( roar_req(con, &m, NULL) == -1 )
275  return -1;
276
277 if ( m.cmd != ROAR_CMD_OK )
278  return -1;
279
280 if ( ROAR_NET2HOST16(info[0]) != 1 )
281  return -1;
282
283 info[1] = ROAR_NET2HOST16(info[1]);
284
285 if ( channels != NULL )
286  *channels = info[1];
287
288 if ( info[1] > ROAR_MAX_CHANNELS )
289  return -1;
290
291 mixer->scale   = ROAR_NET2HOST16(info[2]);
292 mixer->rpg_mul = ROAR_NET2HOST16(info[3]);
293 mixer->rpg_div = ROAR_NET2HOST16(info[4]);
294
295 for (i = 0; i < info[1]; i++)
296  mixer->mixer[i] = ROAR_NET2HOST16(info[i+5]);
297
298 return 0;
299}
300
301// converts: *_m2*, *_*2m
302
303int roar_ctl_f2m      (struct roar_message * m, unsigned char   filter, unsigned char   cmp, uint32_t   id) {
304
305 m->datalen = 7;
306
307 m->data[0] = 0;
308 m->data[1] = filter;
309 m->data[2] = cmp;
310 m->data[3] = (id & 0xFF000000LU) >> 24;
311 m->data[4] = (id & 0x00FF0000LU) >> 16;
312 m->data[5] = (id & 0x0000FF00LU) >>  8;
313 m->data[6] = (id & 0x000000FFLU) >>  0;
314
315 return 0;
316}
317int roar_ctl_m2f      (struct roar_message * m, unsigned char * filter, unsigned char * cmp, uint32_t * id) {
318 register uint32_t idreg;
319
320 if ( m->datalen != 7 )
321  return -1;
322
323 if ( m->data[0] != 0 ) {
324  ROAR_DBG("roar_ctl_m2f(*): version %i not supported!", (int)m->data[0]);
325  roar_err_set(ROAR_ERROR_NSVERSION);
326  return -1;
327 }
328
329 *filter = m->data[1];
330 *cmp    = m->data[2];
331
332 idreg   = ((uint32_t)(unsigned char)m->data[3]) << 24;
333 idreg  |= ((uint32_t)(unsigned char)m->data[4]) << 16;
334 idreg  |= ((uint32_t)(unsigned char)m->data[5]) <<  8;
335 idreg  |= ((uint32_t)(unsigned char)m->data[6]) <<  0;
336 *id     = idreg;
337
338 return 0;
339}
340
341int roar_filter_match (const unsigned cmp, const uint32_t a, const uint32_t b) {
342 switch (cmp) {
343  case ROAR_CTL_CMP_ANY:
344    return 1;
345   break;
346  case ROAR_CTL_CMP_EQ:
347    return a == b;
348   break;
349  case ROAR_CTL_CMP_NE:
350    return a != b;
351   break;
352  default:
353    roar_err_set(ROAR_ERROR_NOTSUP);
354    return -1;
355 }
356}
357
358int roar_ctl_ia2m     (struct roar_message * m, int * data, size_t len) {
359 size_t i;
360
361 if ( len > LIBROAR_BUFFER_MSGDATA ) {
362  roar_err_set(ROAR_ERROR_MSGSIZE);
363  return -1;
364 }
365
366 m->datalen = len;
367
368 for (i = 0; i < len; i++)
369  m->data[i] = data[i];
370
371 return 0;
372}
373int roar_ctl_m2ia     (struct roar_message * m, int * data, size_t len) {
374 size_t i;
375
376 if ( m->datalen > len ) {
377  roar_err_set(ROAR_ERROR_MSGSIZE);
378  return -1;
379 }
380
381 for (i = 0; i < m->datalen; i++)
382  data[i] = m->data[i];
383
384 return m->datalen;
385}
386
387int roar_ctl_c2m2     (struct roar_message * m, struct roar_client * c, void ** data) {
388 char * d;
389 size_t cur = 0;
390 int h;
391 int i;
392 int max_len;
393 uint32_t pid;
394 size_t nnode_len;
395 size_t needed_len = 3 + 5*4 + 18 /* 18 = current max size for blob */;
396
397 if ( c == NULL )
398  return -1;
399
400 if ( data != NULL )
401  *data = NULL;
402
403 max_len = strlen(c->name);
404 needed_len += max_len;
405
406 for (i = 0; i < ROAR_CLIENTS_MAX_STREAMS_PER_CLIENT; i++)
407  if ( c->streams[i] != -1 )
408   needed_len++;
409
410 if ( needed_len > sizeof(m->data) ) {
411  if ( data == NULL ) {
412   needed_len -= max_len;
413   if ( needed_len > sizeof(m->data) ) {
414    roar_panic(ROAR_FATAL_ERROR_CPU_FAILURE, "needed_len > sizeof(m->data) happend.");
415    roar_err_set(ROAR_ERROR_BADCKSUM);
416    return -1;
417   }
418   max_len = sizeof(m->data) - needed_len;
419   needed_len = sizeof(m->data);
420   d = m->data;
421  } else {
422   d = roar_mm_malloc(needed_len);
423   if ( d == NULL )
424    return -1;
425   *data = d;
426  }
427 } else {
428  d = m->data;
429 }
430
431 d[cur++] = 0;                       // 0: Version
432 d[cur++] = c->execed;               // 1: execed
433
434 h = 0;
435 for (i = 0; i < ROAR_CLIENTS_MAX_STREAMS_PER_CLIENT; i++)
436  if ( c->streams[i] != -1 )
437   d[cur+1+h++] = c->streams[i];
438
439 d[cur++] = h;                       // 2: num of streams
440 cur += h;
441
442 // TODO: add some code to check if this fits in the pkg
443 // NOTE: add this code after we are sure how long this pkg will be
444 //       and fully decieded about this function.
445
446 d[cur++] = max_len;
447
448 strncpy(d+cur, c->name, max_len);
449
450 cur += max_len;
451
452 pid = ROAR_HOST2NET32(c->pid);
453 memcpy(&(d[cur]), &pid, 4);
454 cur += 4;
455
456 pid = ROAR_HOST2NET32(c->uid);
457 memcpy(&(d[cur]), &pid, 4);
458 cur += 4;
459
460 pid = ROAR_HOST2NET32(c->gid);
461 memcpy(&(d[cur]), &pid, 4);
462 cur += 4;
463
464 pid = ROAR_HOST2NET32(c->proto);
465 memcpy(&(d[cur]), &pid, 4);
466 cur += 4;
467
468 pid = ROAR_HOST2NET32(c->byteorder);
469 memcpy(&(d[cur]), &pid, 4);
470 cur += 4;
471
472 if ( cur > needed_len ) {
473  roar_panic(ROAR_FATAL_ERROR_MEMORY_CORRUPTION, NULL);
474 }
475
476 nnode_len = needed_len - cur;
477 if ( roar_nnode_to_blob(&(c->nnode), &(d[cur]), &nnode_len) == 0 ) {
478  cur += nnode_len;
479 }
480
481 if ( cur > needed_len ) {
482  roar_panic(ROAR_FATAL_ERROR_MEMORY_CORRUPTION, NULL);
483 }
484
485 m->datalen = cur;
486
487 return 0;
488}
489
490int roar_ctl_m2c2      (struct roar_message * m, struct roar_client * c, void * data) {
491 char * d = data;
492 uint32_t pid;
493 size_t len;
494 size_t cur;
495 int i;
496
497 if ( m == NULL || c == NULL ) {
498  roar_err_set(ROAR_ERROR_FAULT);
499  return -1;
500 }
501
502 if ( m->datalen == 0 ) {
503  roar_err_set(ROAR_ERROR_MSGSIZE);
504  return -1;
505 }
506
507 if ( d == NULL ) {
508  if ( m->datalen > sizeof(m->data) ) {
509   roar_err_set(ROAR_ERROR_FAULT);
510   return -1;
511  }
512  d = m->data;
513 }
514
515 ROAR_DBG("roar_ctl_m2c(*): got data!, len = %i", m->datalen);
516
517 if ( d[0] != 0 ) {
518  ROAR_DBG("roar_ctl_m2c(*): wrong version!");
519  roar_err_set(ROAR_ERROR_NSVERSION);
520  return -1;
521 }
522
523 if ( m->datalen < 3 ) {
524  roar_err_set(ROAR_ERROR_MSGSIZE);
525  return -1;
526 }
527
528 ROAR_DBG("roar_ctl_m2c(*): have usable data!");
529
530 c->execed = d[1];
531
532 for (i = 0; i < ROAR_CLIENTS_MAX_STREAMS_PER_CLIENT; i++)
533  c->streams[i] = -1;
534
535 if ( d[2] < 0 || d[2] > ROAR_CLIENTS_MAX_STREAMS_PER_CLIENT ) {
536  roar_err_set(ROAR_ERROR_TOOMANYARGS);
537  return -1;
538 }
539
540 for (i = 0; i < d[2]; i++)
541  c->streams[i] = d[3+i];
542
543 cur = 3 + d[2];
544
545 // check length here!
546 strncpy(c->name, d+cur+1, d[cur] > (sizeof(c->name)-1) ? sizeof(c->name)-1 : d[cur]);
547 c->name[(size_t)d[cur] > (sizeof(c->name)-1) ? sizeof(c->name)-1 : (size_t)d[cur]] = 0;
548
549 cur += d[cur] + 1;
550
551 memcpy(&pid, &(d[cur]), 4);
552 c->pid = ROAR_NET2HOST32(pid);
553 cur += 4;
554
555 memcpy(&pid, &(d[cur]), 4);
556 c->uid = ROAR_NET2HOST32(pid);
557 cur += 4;
558
559 memcpy(&pid, &(d[cur]), 4);
560 c->gid = ROAR_NET2HOST32(pid);
561 cur += 4;
562
563 if ( m->datalen >= cur+4 ) {
564  memcpy(&pid, &(d[cur]), 4);
565  c->proto = ROAR_NET2HOST32(pid);
566  cur += 4;
567 } else {
568  c->proto = ROAR_PROTO_NONE;
569 }
570
571 if ( m->datalen >= cur+4 ) {
572  memcpy(&pid, &(d[cur]), 4);
573  c->byteorder = ROAR_NET2HOST32(pid);
574  cur += 4;
575 } else {
576  c->byteorder = ROAR_BYTEORDER_UNKNOWN;
577 }
578
579 if ( m->datalen > cur ) {
580  len = m->datalen - cur;
581  if ( roar_nnode_from_blob(&(c->nnode), &(d[cur]), &len) == 0 ) {
582   cur += len;
583  } else {
584   if ( roar_nnode_new(&(c->nnode), ROAR_SOCKET_TYPE_UNKNOWN) == -1 )
585    return -1;
586  }
587 } else {
588  if ( roar_nnode_new(&(c->nnode), ROAR_SOCKET_TYPE_UNKNOWN) == -1 )
589   return -1;
590 }
591
592 return 0;
593}
594
595int roar_ctl_c2m      (struct roar_message * m, struct roar_client * c) {
596 return roar_ctl_c2m2(m, c, NULL);
597}
598int roar_ctl_m2c      (struct roar_message * m, struct roar_client * c) {
599 return roar_ctl_m2c2(m, c, NULL);
600}
601
602static struct {
603 int id;
604 const char * name;
605} _proto[] = {
606 {ROAR_PROTO_NONE,        "none"},
607 {ROAR_PROTO_ROARAUDIO,   "RoarAudio"},
608 {ROAR_PROTO_ESOUND,      "EsounD"},
609 {ROAR_PROTO_ESOUND,      "ESD"}, // alias
610 {ROAR_PROTO_AUTO,        "(auto)"},
611 {ROAR_PROTO_HTTP,        "http"},
612 {ROAR_PROTO_GOPHER,      "gopher"},
613 {ROAR_PROTO_ICY,         "ICY"},
614 {ROAR_PROTO_SIMPLE,      "Simple"},
615 {ROAR_PROTO_RSOUND,      "RSound"},
616 {ROAR_PROTO_RPLAY,       "RPlay"},
617 {ROAR_PROTO_IRC,         "IRC"},
618 {ROAR_PROTO_DCC,         "DCC"},
619 {ROAR_PROTO_ECHO,        "Echo"},
620 {ROAR_PROTO_DISCARD,     "Discard"},
621 {ROAR_PROTO_WHOIS,       "Whois"},
622 {ROAR_PROTO_FINGER,      "Finger"},
623 {ROAR_PROTO_QUOTE,       "quote"},
624 {ROAR_PROTO_DAYTIME,     "daytime"},
625 {ROAR_PROTO_GAME,        "game"},
626 {ROAR_PROTO_TELNET,      "telnet"},
627 {ROAR_PROTO_DHCP,        "dhcp"},
628 {ROAR_PROTO_SSH,         "ssh"},
629 {ROAR_PROTO_TIME,        "time"},
630 {ROAR_PROTO_RLOGIN,      "rlogin"},
631 {ROAR_PROTO_RPLD,        "rpld"},
632 {ROAR_PROTO_MPD,         "mpd"},
633 {-1, NULL}
634};
635
636int    roar_str2proto (const char * proto) {
637 size_t i;
638
639 for (i = 0; _proto[i].id != -1; i++)
640  if ( !strcasecmp(proto, _proto[i].name) )
641   return _proto[i].id;
642
643 roar_err_set(ROAR_ERROR_NOENT);
644 return -1;
645}
646
647const char * roar_proto2str (const int    proto) {
648 size_t i;
649
650 roar_err_set(ROAR_ERROR_NONE);
651
652 for (i = 0; _proto[i].id != -1; i++)
653  if ( proto == _proto[i].id )
654   return _proto[i].name;
655
656 roar_err_set(ROAR_ERROR_NOENT);
657 return "(unknown)";
658}
659
660int    roar_str2byteorder (const char * byteorder) {
661 if (        !strcasecmp(byteorder, "le")            || !strcasecmp(byteorder, "little") ||
662             !strcasecmp(byteorder, "little endian") || !strcasecmp(byteorder, "1234")   ) {
663  return ROAR_BYTEORDER_LE;
664 } else if ( !strcasecmp(byteorder, "be")            || !strcasecmp(byteorder, "big")    ||
665             !strcasecmp(byteorder, "big endian")    || !strcasecmp(byteorder, "4321")   ) {
666  return ROAR_BYTEORDER_BE;
667 } else if ( !strcasecmp(byteorder, "pdp")           ||
668             !strcasecmp(byteorder, "pdp endian") ) {
669  return ROAR_BYTEORDER_PDP;
670 } else if ( !strcasecmp(byteorder, "network")       ||
671             !strcasecmp(byteorder, "network byteorder") ) {
672  return ROAR_BYTEORDER_NETWORK;
673 }
674
675 roar_err_set(ROAR_ERROR_NOENT);
676 return -1;
677}
678
679const char * roar_byteorder2str (const int    byteorder) {
680 switch (byteorder) {
681  case ROAR_BYTEORDER_LE:      return "little endian"; break;
682  case ROAR_BYTEORDER_BE:      return "big endian";    break;
683  case ROAR_BYTEORDER_PDP:     return "pdp endian";    break;
684//  case ROAR_BYTEORDER_NETWORK: return "network";       break;
685  default:
686    return "(unknown)";
687 }
688}
689
690// grep '^#define ROAR_OT_' roaraudio/proto.h | cut -d' ' -f2 | sed 's/^\(ROAR_OT_\)\(.*\)$/ {\1\2, "\2"},/'
691static struct {
692 const int ot;
693 const char * name;
694} _libroar_ot[] = {
695 {ROAR_OT_CLIENT,   "client"},
696 {ROAR_OT_STREAM,   "stream"},
697 {ROAR_OT_SOURCE,   "source"},
698 {ROAR_OT_SAMPLE,   "sample"},
699 {ROAR_OT_OUTPUT,   "output"},
700 {ROAR_OT_MIXER,    "mixer"},
701 {ROAR_OT_BRIDGE,   "bridge"},
702 {ROAR_OT_LISTEN,   "listen"},
703 {ROAR_OT_ACTION,   "action"},
704 {ROAR_OT_MSGQUEUE, "msgqueue"},
705 {ROAR_OT_MSGBUS,   "msgbus"},
706 {-1, NULL}
707};
708
709int    roar_str2ot        (const char * ot) {
710 int i;
711
712 for (i = 0; _libroar_ot[i].ot != -1; i++)
713  if ( !strcasecmp(ot, _libroar_ot[i].name) )
714   return _libroar_ot[i].ot;
715
716 roar_err_set(ROAR_ERROR_NOENT);
717 return -1;
718}
719
720const char * roar_ot2str  (const int    ot) {
721 int i;
722
723 for (i = 0; _libroar_ot[i].ot != -1; i++)
724  if ( _libroar_ot[i].ot == ot )
725   return _libroar_ot[i].name;
726
727 roar_err_set(ROAR_ERROR_NOENT);
728 return NULL;
729}
730
731int roar_conv_volume (struct roar_mixer_settings * dst, struct roar_mixer_settings * src, int dstchans, int srcchans) {
732 struct roar_mixer_settings lsrc;
733 int i;
734 uint_least32_t s;
735
736 if ( dst == NULL || src == NULL ) {
737  roar_err_set(ROAR_ERROR_FAULT);
738  return -1;
739 }
740
741 if ( dstchans < 0 || srcchans < 0 ) {
742  roar_err_set(ROAR_ERROR_INVAL);
743  return -1;
744 }
745
746 if ( dstchans == srcchans ) {
747  if ( dst == src )
748   return 0;
749
750  memcpy(dst, src, sizeof(struct roar_mixer_settings));
751  return 0;
752 }
753
754 if ( dst == src ) {
755  memcpy(&lsrc, src, sizeof(lsrc));
756  src = &lsrc;
757 }
758
759 // sepcal handling for N->1:
760 if ( dstchans == 1 ) {
761  s = 0;
762
763  for (i = 0; i < srcchans; i++)
764   s += src->mixer[i];
765
766  dst->mixer[0] = s / srcchans;
767 } else {
768  switch (srcchans) {
769   case  1:
770     for (i = 0; i < dstchans; i++)
771      dst->mixer[i] = src->mixer[0];
772    break;
773   case 2:
774     switch (dstchans) {
775      case 3:
776        dst->mixer[0] = src->mixer[0];
777        dst->mixer[1] = src->mixer[1];
778        dst->mixer[2] = (src->mixer[0] + src->mixer[1]) / 2;
779       break;
780      case 4:
781        dst->mixer[0] = src->mixer[0];
782        dst->mixer[1] = src->mixer[1];
783        dst->mixer[2] = src->mixer[0];
784        dst->mixer[3] = src->mixer[1];
785       break;
786      case 5:
787        dst->mixer[0] = src->mixer[0];
788        dst->mixer[1] = src->mixer[1];
789        dst->mixer[2] = (src->mixer[0] + src->mixer[1]) / 2;
790        dst->mixer[3] = src->mixer[0];
791        dst->mixer[4] = src->mixer[1];
792       break;
793      case 6:
794        dst->mixer[0] = src->mixer[0];
795        dst->mixer[1] = src->mixer[1];
796        dst->mixer[2] = (src->mixer[0] + src->mixer[1]) / 2;
797        dst->mixer[3] = dst->mixer[2];
798        dst->mixer[4] = src->mixer[0];
799        dst->mixer[5] = src->mixer[1];
800       break;
801      default:
802        roar_err_set(ROAR_ERROR_NOTSUP);
803        return -1;
804       break;
805     }
806    break;
807   case 3:
808     switch (dstchans) {
809      case 2:
810        dst->mixer[0] = src->mixer[0];
811        dst->mixer[1] = src->mixer[1];
812       break;
813      case 4:
814        dst->mixer[0] = src->mixer[0];
815        dst->mixer[1] = src->mixer[1];
816        dst->mixer[2] = src->mixer[0];
817        dst->mixer[3] = src->mixer[1];
818       break;
819      case 5:
820        dst->mixer[0] = src->mixer[0];
821        dst->mixer[1] = src->mixer[1];
822        dst->mixer[2] = src->mixer[2];
823        dst->mixer[3] = src->mixer[0];
824        dst->mixer[4] = src->mixer[1];
825       break;
826      case 6:
827        dst->mixer[0] = src->mixer[0];
828        dst->mixer[1] = src->mixer[1];
829        dst->mixer[2] = src->mixer[2];
830        dst->mixer[3] = src->mixer[2];
831        dst->mixer[4] = src->mixer[0];
832        dst->mixer[5] = src->mixer[1];
833       break;
834      default:
835        roar_err_set(ROAR_ERROR_NOTSUP);
836        return -1;
837       break;
838     }
839    break;
840   case 4:
841     switch (dstchans) {
842      case 2:
843        dst->mixer[0] = (src->mixer[0] + src->mixer[2]) / 2;
844        dst->mixer[1] = (src->mixer[1] + src->mixer[3]) / 2;
845       break;
846      case 3:
847        dst->mixer[0] = (src->mixer[0] + src->mixer[2]) / 2;
848        dst->mixer[1] = (src->mixer[1] + src->mixer[3]) / 2;
849        dst->mixer[2] = (dst->mixer[0] + dst->mixer[1]) / 2;
850       break;
851      case 5:
852        dst->mixer[0] = src->mixer[0];
853        dst->mixer[1] = src->mixer[1];
854        dst->mixer[2] = (src->mixer[0] + src->mixer[2] + src->mixer[1] + src->mixer[3]) / 4;
855        dst->mixer[3] = src->mixer[2];
856        dst->mixer[4] = src->mixer[3];
857       break;
858      case 6:
859        dst->mixer[0] = src->mixer[0];
860        dst->mixer[1] = src->mixer[1];
861        dst->mixer[2] = (src->mixer[0] + src->mixer[2] + src->mixer[1] + src->mixer[3]) / 4;
862        dst->mixer[3] = dst->mixer[2];
863        dst->mixer[4] = src->mixer[2];
864        dst->mixer[5] = src->mixer[3];
865       break;
866      default:
867        roar_err_set(ROAR_ERROR_NOTSUP);
868        return -1;
869       break;
870     }
871    break;
872   case 5:
873     switch (dstchans) {
874      case 2:
875        dst->mixer[0] = (src->mixer[0] + src->mixer[3]) / 2;
876        dst->mixer[1] = (src->mixer[1] + src->mixer[4]) / 2;
877       break;
878      case 3:
879        dst->mixer[0] = (src->mixer[0] + src->mixer[3]) / 2;
880        dst->mixer[1] = (src->mixer[1] + src->mixer[4]) / 2;
881        dst->mixer[2] = src->mixer[2];
882       break;
883      case 4:
884        dst->mixer[0] = src->mixer[0];
885        dst->mixer[1] = src->mixer[1];
886        dst->mixer[2] = src->mixer[3];
887        dst->mixer[3] = src->mixer[4];
888       break;
889      case 6:
890        dst->mixer[0] = src->mixer[0];
891        dst->mixer[1] = src->mixer[1];
892        dst->mixer[2] = src->mixer[2];
893        dst->mixer[3] = src->mixer[2];
894        dst->mixer[4] = src->mixer[3];
895        dst->mixer[5] = src->mixer[4];
896       break;
897      default:
898        roar_err_set(ROAR_ERROR_NOTSUP);
899        return -1;
900       break;
901     }
902    break;
903   case 6:
904     switch (dstchans) {
905      case 2:
906        dst->mixer[0] = (src->mixer[0] + src->mixer[4]) / 2;
907        dst->mixer[1] = (src->mixer[1] + src->mixer[5]) / 2;
908       break;
909      case 3:
910        dst->mixer[0] = (src->mixer[0] + src->mixer[4]) / 2;
911        dst->mixer[1] = (src->mixer[1] + src->mixer[5]) / 2;
912        dst->mixer[2] = src->mixer[2];
913       break;
914      case 4:
915        dst->mixer[0] = src->mixer[0];
916        dst->mixer[1] = src->mixer[1];
917        dst->mixer[2] = src->mixer[4];
918        dst->mixer[3] = src->mixer[5];
919       break;
920      case 5:
921        dst->mixer[0] = src->mixer[0];
922        dst->mixer[1] = src->mixer[1];
923        dst->mixer[2] = src->mixer[2];
924        dst->mixer[3] = src->mixer[4];
925        dst->mixer[4] = src->mixer[5];
926       break;
927      default:
928        roar_err_set(ROAR_ERROR_NOTSUP);
929        return -1;
930       break;
931     }
932    break;
933   default:
934     roar_err_set(ROAR_ERROR_NOTSUP);
935     return -1;
936    break;
937  }
938 }
939
940 dst->scale   = src->scale;
941 dst->rpg_mul = src->rpg_mul;
942 dst->rpg_div = src->rpg_div;
943
944 return 0;
945}
946
947//ll
Note: See TracBrowser for help on using the repository browser.