source: roaraudio/libroar/ctl.c @ 5462:4aa873706b47

Last change on this file since 5462:4aa873706b47 was 5462:4aa873706b47, checked in by phi, 12 years ago

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