source: roaraudio/libroar/ctl.c @ 5148:73d76a74be61

Last change on this file since 5148:73d76a74be61 was 5148:73d76a74be61, checked in by phi, 13 years ago

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