root/rat/trunk/mbus_engine.c @ 2058

Revision 2058, 30.0 KB (checked in by ucaccsp, 16 years ago)

Remove tool.rat.redundancy and tool.rat.interleaving, and merge their
functions into audio.channel.coding

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/*
2 * FILE:    mbus_engine.c
3 * AUTHORS: Colin Perkins
4 * MODIFICATIONS: Orion Hodson
5 *
6 * Copyright (c) 1998 University College London
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, is permitted, for non-commercial use only, provided
11 * that the following conditions are met:
12 * 1. Redistributions of source code must retain the above copyright
13 *    notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 *    notice, this list of conditions and the following disclaimer in the
16 *    documentation and/or other materials provided with the distribution.
17 * 3. All advertising materials mentioning features or use of this software
18 *    must display the following acknowledgement:
19 *      This product includes software developed by the Computer Science
20 *      Department at University College London
21 * 4. Neither the name of the University nor of the Department may be used
22 *    to endorse or promote products derived from this software without
23 *    specific prior written permission.
24 * Use of this software for commercial purposes is explicitly forbidden
25 * unless prior written permission is obtained from the authors.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
28 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
31 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 * SUCH DAMAGE.
38 */
39
40#include "config_unix.h"
41#include "config_win32.h"
42#include "assert.h"
43#include "debug.h"
44#include "mbus_engine.h"
45#include "mbus_ui.h"
46#include "mbus.h"
47#include "ui.h"
48#include "net_udp.h"
49#include "net.h"
50#include "transmit.h"
51#include "audio.h"
52#include "codec.h"
53#include "channel.h"
54#include "receive.h"
55#include "convert.h"
56#include "rtcp_pckt.h"
57#include "rtcp_db.h"
58#include "repair.h"
59#include "crypt.h"
60#include "session.h"
61#include "sndfile.h"
62#include "timers.h"
63#include "util.h"
64
65extern int should_exit;
66
67static void rx_tool_rat_toggle_input_port(char *srce, char *args, session_struct *sp)
68{
69        UNUSED(srce);
70
71        if ((strlen(args) != 1) || (args[0] != ' ')) {
72                printf("mbus: tool.rat.toggle.input.port does not require parameters\n");
73                return;
74        }
75
76        audio_next_iport(sp->audio_device);
77        sp->input_mode = audio_get_iport(sp->audio_device);
78        ui_update_input_port(sp);
79}
80
81static void rx_tool_rat_toggle_output_port(char *srce, char *args, session_struct *sp)
82{
83        UNUSED(srce);
84
85        if ((strlen(args) != 1) || (args[0] != ' ')) {
86                printf("mbus: tool.rat.toggle.output.port does not require parameters\n");
87                return;
88        }
89
90        audio_next_oport(sp->audio_device);
91        sp->output_mode = audio_get_oport(sp->audio_device);
92        ui_update_output_port(sp);
93}
94
95static void rx_tool_rat_get_audio(char *srce, char *args, session_struct *sp)
96{
97        UNUSED(srce);
98
99        if ((strlen(args) != 1) || (args[0] != ' ')) {
100                printf("mbus: get_audio does not require parameters\n");
101                return;
102        }
103
104        if (sp->audio_device) {
105                /* We already have the device! */
106                return;
107        }
108
109        if (audio_device_take(sp) == FALSE) {
110                /* Request device using the mbus... */
111        }
112}
113
114static void rx_tool_rat_powermeter(char *srce, char *args, session_struct *sp)
115{
116        int i;
117
118        UNUSED(srce);
119
120        mbus_parse_init(sp->mbus_engine_conf, args);
121        if (mbus_parse_int(sp->mbus_engine_conf, &i)) {
122                sp->meter = i;
123                ui_input_level(sp, 0);
124                ui_output_level(sp, 0);
125        } else {
126                printf("mbus: usage \"tool.rat.powermeter <boolean>\"\n");
127        }
128        mbus_parse_done(sp->mbus_engine_conf);
129}
130
131static void rx_tool_rat_silence(char *srce, char *args, session_struct *sp)
132{
133        int i;
134
135        UNUSED(srce);
136
137        mbus_parse_init(sp->mbus_engine_conf, args);
138        if (mbus_parse_int(sp->mbus_engine_conf, &i)) {
139                sp->detect_silence = i;
140        } else {
141                printf("mbus: usage \"tool.rat.silence <boolean>\"\n");
142        }
143        mbus_parse_done(sp->mbus_engine_conf);
144}
145
146static void rx_tool_rat_externalise(char *srce, char *args, session_struct *sp)
147{
148        int i;
149
150        UNUSED(srce);
151
152        mbus_parse_init(sp->mbus_engine_conf, args);
153        if (mbus_parse_int(sp->mbus_engine_conf, &i)) {
154                sp->externalise_audio = i;
155        } else {
156                printf("mbus: usage \"tool.rat.externalise <boolean>\"\n");
157        }
158        mbus_parse_done(sp->mbus_engine_conf);
159}
160
161static void rx_tool_rat_lecture(char *srce, char *args, session_struct *sp)
162{
163        int i;
164
165        UNUSED(srce);
166
167        mbus_parse_init(sp->mbus_engine_conf, args);
168        if (mbus_parse_int(sp->mbus_engine_conf, &i)) {
169                sp->lecture = i;
170        } else {
171                printf("mbus: usage \"tool.rat.lecture <boolean>\"\n");
172        }
173        mbus_parse_done(sp->mbus_engine_conf);
174}
175
176static void rx_tool_rat_sync(char *srce, char *args, session_struct *sp)
177{
178        int i;
179
180        UNUSED(srce);
181
182        mbus_parse_init(sp->mbus_engine_conf, args);
183        if (mbus_parse_int(sp->mbus_engine_conf, &i)) {
184                if (sp->mbus_channel != 0) {
185                        sp->sync_on = i;
186                } else {
187                        ui_update_sync(sp, FALSE);
188                }
189        } else {
190                printf("mbus: usage \"tool.rat.sync <boolean>\"\n");
191        }
192        mbus_parse_done(sp->mbus_engine_conf);
193}
194
195static void rx_tool_rat_agc(char *srce, char *args, session_struct *sp)
196{
197        int i;
198
199        UNUSED(srce);
200
201        mbus_parse_init(sp->mbus_engine_conf, args);
202        if (mbus_parse_int(sp->mbus_engine_conf, &i)) {
203                sp->agc_on = i;
204        } else {
205                printf("mbus: usage \"tool.rat.agc <boolean>\"\n");
206        }
207        mbus_parse_done(sp->mbus_engine_conf);
208}
209
210static void rx_tool_rat_audio_loopback(char *srce, char *args, session_struct *sp)
211{
212        int i;
213
214        UNUSED(srce);
215
216        mbus_parse_init(sp->mbus_engine_conf, args);
217        if (mbus_parse_int(sp->mbus_engine_conf, &i)) {
218                if (i) {
219                        audio_loopback(sp->audio_device, 100);
220                } else {
221                        audio_loopback(sp->audio_device, 0);
222                }
223        } else {
224                printf("mbus: usage \"tool.rat.audio.loopback <boolean>\"\n");
225        }
226        mbus_parse_done(sp->mbus_engine_conf);
227}
228
229static void rx_tool_rat_echo_suppress(char *srce, char *args, session_struct *sp)
230{
231        int i;
232
233        UNUSED(srce);
234
235        mbus_parse_init(sp->mbus_engine_conf, args);
236        if (mbus_parse_int(sp->mbus_engine_conf, &i)) {
237                sp->echo_suppress = i;
238                if (sp->echo_suppress) {
239                        playout_buffers_destroy(sp, &sp->playout_buf_list);
240                }
241        } else {
242                printf("mbus: usage \"tool.rat.echo.suppress <boolean>\"\n");
243        }
244        mbus_parse_done(sp->mbus_engine_conf);
245}
246
247static void rx_tool_rat_rate(char *srce, char *args, session_struct *sp)
248{
249        int      i;
250
251        UNUSED(srce);
252
253        mbus_parse_init(sp->mbus_engine_conf, args);
254        if (mbus_parse_int(sp->mbus_engine_conf, &i)) {
255                collator_set_units(sp->collator, i);
256        } else {
257                printf("mbus: usage \"tool.rat.rate <integer>\"\n");
258        }
259        mbus_parse_done(sp->mbus_engine_conf);
260}
261
262static void rx_audio_input_mute(char *srce, char *args, session_struct *sp)
263{
264        int i;
265
266        UNUSED(srce);
267
268        mbus_parse_init(sp->mbus_engine_conf, args);
269        if (mbus_parse_int(sp->mbus_engine_conf, &i)) {
270                if (i) {
271                        tx_stop(sp);
272                } else {
273                        tx_start(sp);
274                }
275                sp->echo_was_sending = i;
276                ui_update_input_port(sp);
277        } else {
278                printf("mbus: usage \"audio.input.mute <boolean>\"\n");
279        }
280        mbus_parse_done(sp->mbus_engine_conf);
281}
282
283static void rx_audio_input_gain(char *srce, char *args, session_struct *sp)
284{
285        int   i;
286
287        UNUSED(srce);
288
289        mbus_parse_init(sp->mbus_engine_conf, args);
290        if (mbus_parse_int(sp->mbus_engine_conf, &i)) {
291                sp->input_gain = i;
292                if (sp->audio_device) {
293                        audio_set_gain(sp->audio_device, sp->input_gain);
294                        tx_igain_update(sp);
295                }
296        } else {
297                printf("mbus: usage \"audio.input.gain <integer>\"\n");
298        }
299        mbus_parse_done(sp->mbus_engine_conf);
300}
301
302static void rx_audio_input_port(char *srce, char *args, session_struct *sp)
303{
304        char    *s;
305
306        UNUSED(srce);
307
308        mbus_parse_init(sp->mbus_engine_conf, args);
309        if (mbus_parse_str(sp->mbus_engine_conf, &s)) {
310                s = mbus_decode_str(s);
311                if (strcmp(s, "microphone") == 0) {
312                        audio_set_iport(sp->audio_device, AUDIO_MICROPHONE);
313                }
314                if (strcmp(s, "cd") == 0) {
315                        audio_set_iport(sp->audio_device, AUDIO_CD);
316                }
317                if (strcmp(s, "line_in") == 0) {
318                        audio_set_iport(sp->audio_device, AUDIO_LINE_IN);
319                }
320        } else {
321                printf("mbus: usage \"audio.input.port <port>\"\n");
322        }
323        mbus_parse_done(sp->mbus_engine_conf);
324        sp->input_mode = audio_get_iport(sp->audio_device);
325        ui_update_input_port(sp);
326}
327
328static void rx_audio_output_mute(char *srce, char *args, session_struct *sp)
329{
330        int i;
331
332        UNUSED(srce);
333
334        mbus_parse_init(sp->mbus_engine_conf, args);
335        if (mbus_parse_int(sp->mbus_engine_conf, &i)) {
336                sp->playing_audio = !i;
337                ui_update_output_port(sp);
338        } else {
339                printf("mbus: usage \"audio.output.mute <boolean>\"\n");
340        }
341        mbus_parse_done(sp->mbus_engine_conf);
342}
343
344static void rx_audio_output_gain(char *srce, char *args, session_struct *sp)
345{
346        int   i;
347
348        UNUSED(srce);
349
350        mbus_parse_init(sp->mbus_engine_conf, args);
351        if (mbus_parse_int(sp->mbus_engine_conf, &i)) {
352                sp->output_gain = i;
353                audio_set_volume(sp->audio_device, sp->output_gain);
354        } else {
355                printf("mbus: usage \"audio.output.gain <integer>\"\n");
356        }
357        mbus_parse_done(sp->mbus_engine_conf);
358}
359
360static void rx_audio_output_port(char *srce, char *args, session_struct *sp)
361{
362        char    *s;
363
364        UNUSED(srce);
365
366        mbus_parse_init(sp->mbus_engine_conf, args);
367        if (mbus_parse_str(sp->mbus_engine_conf, &s)) {
368                s = mbus_decode_str(s);
369                if (strcmp(s, "speaker") == 0) {
370                        audio_set_oport(sp->audio_device, AUDIO_SPEAKER);
371                }
372                if (strcmp(s, "headphone") == 0) {
373                        audio_set_oport(sp->audio_device, AUDIO_HEADPHONE);
374                }
375                if (strcmp(s, "line_out") == 0) {
376                        audio_set_oport(sp->audio_device, AUDIO_LINE_OUT);
377                }
378        } else {
379                printf("mbus: usage \"audio.output.port <port>\"\n");
380        }
381        mbus_parse_done(sp->mbus_engine_conf);
382        sp->output_mode = audio_get_oport(sp->audio_device);
383        ui_update_output_port(sp);
384}
385
386static void rx_audio_channel_repair(char *srce, char *args, session_struct *sp)
387{
388        char    *s;
389
390        UNUSED(srce);
391
392        mbus_parse_init(sp->mbus_engine_conf, args);
393        if (mbus_parse_str(sp->mbus_engine_conf, &s)) {
394                s = mbus_decode_str(s);
395                if (strcmp(s, "none") == 0) {
396                        sp->repair = REPAIR_NONE;
397                } else if (strcmp(s, "repetition") == 0) {
398                        sp->repair = REPAIR_REPEAT;
399                } else if (strcmp(s, "pattern-match") == 0) {
400                        sp->repair = REPAIR_PATTERN_MATCH;
401                } else {
402                        debug_msg("Repair scheme %s unknown\n", s);
403                        abort();
404                }
405        } else {
406                printf("mbus: usage \"audio.channel.repair none|repetition|pattern-match\"\n");
407        }
408        mbus_parse_done(sp->mbus_engine_conf);
409}
410
411static void rx_security_encryption_key(char *srce, char *args, session_struct *sp)
412{
413        char    *key;
414
415        UNUSED(sp);
416        UNUSED(srce);
417
418        mbus_parse_init(sp->mbus_engine_conf, args);
419        if (mbus_parse_str(sp->mbus_engine_conf, &key)) {
420                Set_Key(mbus_decode_str(key));
421        } else {
422                printf("mbus: usage \"security.encryption.key <key>\"\n");
423        }
424        mbus_parse_done(sp->mbus_engine_conf);
425}
426
427static void rx_audio_file_play_stop(char *srce, char *args, session_struct *sp)
428{
429        UNUSED(srce);
430        UNUSED(args);
431
432        if (sp->in_file != NULL) {
433                snd_read_close(&sp->in_file);
434        }
435}
436
437static void rx_audio_file_play_open(char *srce, char *args, session_struct *sp)
438{
439        char    *file;
440
441        UNUSED(srce);
442        UNUSED(sp);
443
444        mbus_parse_init(sp->mbus_engine_conf, args);
445        if (mbus_parse_str(sp->mbus_engine_conf, &file)) {
446                mbus_decode_str(file);
447                if (sp->in_file) snd_read_close(&sp->in_file);
448                if (snd_read_open(&sp->in_file, file)) {
449                        debug_msg("Hooray opened %s\n",file);
450                }
451        } else {
452                printf("mbus: usage \"audio.file.play.open <filename>\"\n");
453        }
454        mbus_parse_done(sp->mbus_engine_conf);
455
456        if (sp->in_file) ui_update_playback_file(sp, file);
457
458}
459
460static void rx_audio_file_play_pause(char *srce, char *args, session_struct *sp)
461{
462        int pause;
463
464        UNUSED(srce);
465
466        mbus_parse_init(sp->mbus_engine_conf, args);
467
468        if (mbus_parse_int(sp->mbus_engine_conf, &pause)) {
469                if (sp->in_file) {
470                        if (pause) {
471                                snd_pause(sp->in_file);
472                        } else {
473                                snd_resume(sp->in_file);
474                        }
475                }
476        } else {
477                printf("mbus: usage \"audio.file.play.pause <bool>\"\n");       
478        }
479        mbus_parse_done(sp->mbus_engine_conf);
480}
481
482
483static void rx_audio_file_play_live(char *srce, char *args, session_struct *sp)
484{
485        /* This is a request to see if file we are playing is still valid */
486        UNUSED(args);
487        UNUSED(srce);
488        ui_update_file_live(sp, "play", (sp->in_file) ? 1 : 0);
489}
490
491static void rx_audio_file_rec_stop(char *srce, char *args, session_struct *sp)
492{
493        UNUSED(srce);
494        UNUSED(args);
495
496        if (sp->out_file != NULL) {
497                snd_write_close(&sp->out_file);
498        }
499}
500
501static void rx_audio_file_rec_open(char *srce, char *args, session_struct *sp)
502{
503        char    *file;
504
505        UNUSED(srce);
506
507        mbus_parse_init(sp->mbus_engine_conf, args);
508        if (mbus_parse_str(sp->mbus_engine_conf, &file)) {
509                mbus_decode_str(file);
510                if (sp->out_file) snd_write_close(&sp->out_file);
511                if (snd_write_open(&sp->out_file, file, (u_int16)get_freq(sp->device_clock), (u_int16)audio_get_channels(sp->audio_device))) {
512                        debug_msg("Hooray opened %s\n",file);
513                }
514        } else {
515                printf("mbus: usage \"audio.file.record.open <filename>\"\n");
516        }
517        mbus_parse_done(sp->mbus_engine_conf);
518       
519        if (sp->out_file) ui_update_record_file(sp, file);
520}
521
522static void rx_audio_file_rec_pause(char *srce, char *args, session_struct *sp)
523{
524        int pause;
525
526        UNUSED(srce);
527
528        mbus_parse_init(sp->mbus_engine_conf, args);
529
530        if (mbus_parse_int(sp->mbus_engine_conf, &pause)) {
531                if (sp->out_file) {
532                        if (pause) {
533                                snd_pause(sp->out_file);
534                        } else {
535                                snd_resume(sp->out_file);
536                        }
537                }
538        } else {
539                printf("mbus: usage \"audio.file.record.pause <bool>\"\n");       
540        }
541        mbus_parse_done(sp->mbus_engine_conf);
542}
543
544static void rx_audio_file_rec_live(char *srce, char *args, session_struct *sp)
545{
546        /* This is a request to see if file we are recording is still valid */
547        UNUSED(args);
548        UNUSED(srce);
549        debug_msg("%d\n", sp->out_file ? 1 : 0);
550        ui_update_file_live(sp, "record", (sp->out_file) ? 1 : 0);
551}
552
553static void 
554rx_audio_device(char *srce, char *args, session_struct *sp)
555{
556        char    *s, dev_name[32];
557        int next_device;
558
559        UNUSED(srce);
560
561        mbus_parse_init(sp->mbus_engine_conf, args);
562        if (mbus_parse_str(sp->mbus_engine_conf, &s)) {
563                s = mbus_decode_str(s);
564                purge_chars(s, "[]()");
565                next_device = -1;
566                if (s) {
567                        int i, n;
568                        n = audio_get_number_of_interfaces();
569                        for(i = 0; i < n; i++) {
570                                /* Brackets are a problem so purge them */
571                                strncpy(dev_name, audio_get_interface_name(i), 31);
572                                purge_chars(dev_name, "[]()");
573                                if (!strcmp(s, dev_name)) {
574                                        next_device = i;
575                                        break;
576                                }
577                        }
578                }
579                       
580                debug_msg("Next audio device: %s (%d).\n", s, next_device);
581                /* We should close audio device, transmitter, etc
582                 * Then find corresponding audio interface, select it,
583                 * and re-open the device.
584                 */
585        } else {
586                printf("mbus: usage \"audio.device <string>\"\n");
587        }
588        mbus_parse_done(sp->mbus_engine_conf);
589       
590        sp->next_selected_device = next_device;
591}
592
593static void rx_rtp_source_name(char *srce, char *args, session_struct *sp)
594{
595        char    *arg, *cname;
596
597        UNUSED(srce);
598
599        mbus_parse_init(sp->mbus_engine_conf, args);
600        if (mbus_parse_str(sp->mbus_engine_conf, &cname) && (strcmp(mbus_decode_str(cname), sp->db->my_dbe->sentry->cname) == 0) && mbus_parse_str(sp->mbus_engine_conf, &arg)) {
601                rtcp_set_attribute(sp, RTCP_SDES_NAME,  mbus_decode_str(arg));
602        } else {
603                printf("mbus: usage \"rtp_source_name <cname> <name>\"\n");
604        }
605        mbus_parse_done(sp->mbus_engine_conf);
606}
607
608static void rx_rtp_source_email(char *srce, char *args, session_struct *sp)
609{
610        char    *arg, *cname;
611
612        UNUSED(srce);
613
614        mbus_parse_init(sp->mbus_engine_conf, args);
615        if (mbus_parse_str(sp->mbus_engine_conf, &cname) && (strcmp(mbus_decode_str(cname), sp->db->my_dbe->sentry->cname) == 0) && mbus_parse_str(sp->mbus_engine_conf, &arg)) {
616                rtcp_set_attribute(sp, RTCP_SDES_EMAIL,  mbus_decode_str(arg));
617        } else {
618                printf("mbus: usage \"rtp_source_email <cname> <email>\"\n");
619        }
620        mbus_parse_done(sp->mbus_engine_conf);
621}
622
623static void rx_rtp_source_phone(char *srce, char *args, session_struct *sp)
624{
625        char    *arg, *cname;
626
627        UNUSED(srce);
628
629        mbus_parse_init(sp->mbus_engine_conf, args);
630        if (mbus_parse_str(sp->mbus_engine_conf, &cname) && (strcmp(mbus_decode_str(cname), sp->db->my_dbe->sentry->cname) == 0) && mbus_parse_str(sp->mbus_engine_conf, &arg)) {
631                rtcp_set_attribute(sp, RTCP_SDES_PHONE,  mbus_decode_str(arg));
632        } else {
633                printf("mbus: usage \"rtp_source_phone <cname> <phone>\"\n");
634        }
635        mbus_parse_done(sp->mbus_engine_conf);
636}
637
638static void rx_rtp_source_loc(char *srce, char *args, session_struct *sp)
639{
640        char    *arg, *cname;
641
642        UNUSED(srce);
643
644        mbus_parse_init(sp->mbus_engine_conf, args);
645        if (mbus_parse_str(sp->mbus_engine_conf, &cname) && (strcmp(mbus_decode_str(cname), sp->db->my_dbe->sentry->cname) == 0) && mbus_parse_str(sp->mbus_engine_conf, &arg)) {
646                rtcp_set_attribute(sp, RTCP_SDES_LOC,  mbus_decode_str(arg));
647        } else {
648                printf("mbus: usage \"rtp_source_loc <cname> <loc>\"\n");
649        }
650        mbus_parse_done(sp->mbus_engine_conf);
651}
652
653static void rx_rtp_source_mute(char *srce, char *args, session_struct *sp)
654{
655        rtcp_dbentry    *e;
656        char            *cname;
657        int              i;
658
659        UNUSED(srce);
660
661        mbus_parse_init(sp->mbus_engine_conf, args);
662        if (mbus_parse_str(sp->mbus_engine_conf, &cname) && mbus_parse_int(sp->mbus_engine_conf, &i)) {
663                mbus_decode_str(cname);
664                for (e = sp->db->ssrc_db; e != NULL; e = e->next) {
665                        if (strcmp(e->sentry->cname, cname) == 0) {     
666                                e->mute = i;
667                                ui_info_mute(sp, e);
668                        }
669                }
670        } else {
671                printf("mbus: usage \"rtp_source_mute <cname> <bool>\"\n");
672        }
673        mbus_parse_done(sp->mbus_engine_conf);
674}
675
676
677static void rx_rtp_source_playout(char *srce, char *args, session_struct *sp)
678{
679        rtcp_dbentry    *e;
680        char            *cname;
681        int              playout;
682
683        UNUSED(srce);
684
685        mbus_parse_init(sp->mbus_engine_conf, args);
686        if (mbus_parse_str(sp->mbus_engine_conf, &cname) && mbus_parse_int(sp->mbus_engine_conf, &playout)) {
687                for (e = sp->db->ssrc_db; e != NULL; e = e->next) {
688                        if (strcmp(e->sentry->cname, mbus_decode_str(cname)) == 0) break;
689                }
690                e->video_playout_received = TRUE;
691                e->video_playout = playout;
692        } else {
693                printf("mbus: usage \"rtp_source_playout <cname> <playout>\"\n");
694        }
695        mbus_parse_done(sp->mbus_engine_conf);
696}
697
698static void 
699rx_tool_rat_codec(char *srce, char *args, session_struct *sp)
700{
701        static int virgin = 1;
702        char    *short_name, *sfreq, *schan;
703        int      pt, freq, channels;
704        codec_t *next_cp, *cp;
705
706        UNUSED(srce);
707
708        pt = -1;
709        next_cp = NULL;
710
711        mbus_parse_init(sp->mbus_engine_conf, args);
712        if (mbus_parse_str(sp->mbus_engine_conf, &short_name) &&
713            mbus_parse_str(sp->mbus_engine_conf, &schan) &&
714            mbus_parse_str(sp->mbus_engine_conf, &sfreq)) {
715                mbus_decode_str(short_name);
716                mbus_decode_str(schan);
717                mbus_decode_str(sfreq);
718                mbus_parse_done(sp->mbus_engine_conf);
719        } else {
720                printf("mbus: usage \"audio.codec <codec> <freq> <channels>\"\n");
721                mbus_parse_done(sp->mbus_engine_conf);
722                return;
723        }
724
725        if (strcasecmp(schan, "mono") == 0) {
726                channels = 1;
727        } else if (strcasecmp(schan, "stereo") == 0) {
728                channels = 2;
729        } else {
730                channels = 0;
731        }
732
733        freq = atoi(sfreq) * 1000;
734
735        if (-1 != (pt = codec_matching(short_name, freq, channels))) {
736                next_cp = get_codec_by_pt(pt);
737                cp      = get_codec_by_pt(sp->encodings[0]);
738                assert(next_cp != NULL);
739                assert(cp      != NULL);
740                if (codec_compatible(next_cp, cp)) {
741                        sp->encodings[0] = pt;
742                        ui_update_primary(sp);
743                } else {
744                        /* just register we want to make a change */
745                        sp->next_encoding = pt;
746                        if (virgin) {
747                                audio_device_reconfigure(sp);
748                                virgin = 0;
749                        }
750                }
751        }
752}
753
754static void 
755rx_tool_rat_sampling(char *srce, char *args, session_struct *sp)
756{
757        int channels, freq, pt;
758        char *sfreq, *schan;
759
760        UNUSED(srce);
761        UNUSED(sp);
762
763        freq = channels = 0;
764        mbus_parse_init(sp->mbus_engine_conf, args);
765        if (mbus_parse_str(sp->mbus_engine_conf, &sfreq) &&
766            mbus_parse_str(sp->mbus_engine_conf, &schan)) {
767                mbus_decode_str(sfreq);
768                mbus_decode_str(schan);
769                if (strcasecmp(schan, "mono") == 0) {
770                        channels = 1;
771                } else if (strcasecmp(schan, "stereo") == 0) {
772                        channels = 2;
773                }
774                freq = atoi(sfreq) * 1000;
775        }
776
777        pt = codec_first_with(freq, channels);
778        if (pt != -1) {
779                ui_codecs(sp, pt);
780        } else {
781                printf("mbus: usage \"tool.rat.sampling <freq> <channels>\"\n");
782        }
783       
784        mbus_parse_done(sp->mbus_engine_conf);
785}
786
787static void rx_tool_rat_playout_limit(char *srce, char *args, session_struct *sp)
788{
789        int i;
790
791        UNUSED(srce);
792        mbus_parse_init(sp->mbus_engine_conf, args);
793        if (mbus_parse_int(sp->mbus_engine_conf, &i) && (1 == i || 0 == i)) {
794                sp->limit_playout = i;
795        } else {
796                printf("mbus: usage \"tool.rat.playout.limit <bool>\"\n");
797        }
798        mbus_parse_done(sp->mbus_engine_conf);
799}
800
801static void rx_tool_rat_playout_min(char *srce, char *args, session_struct *sp)
802{
803        int      i;
804
805        UNUSED(srce);
806
807        mbus_parse_init(sp->mbus_engine_conf, args);
808        if (mbus_parse_int(sp->mbus_engine_conf, &i)) {
809                sp->min_playout = i;
810        } else {
811                printf("mbus: usage \"tool.rat.playout.min <integer>\"\n");
812        }
813        mbus_parse_done(sp->mbus_engine_conf);
814}
815
816static void rx_tool_rat_playout_max(char *srce, char *args, session_struct *sp)
817{
818        int      i;
819
820        UNUSED(srce);
821
822        mbus_parse_init(sp->mbus_engine_conf, args);
823        if (mbus_parse_int(sp->mbus_engine_conf, &i)) {
824                sp->max_playout = i;
825        } else {
826                printf("mbus: usage \"tool.rat.playout.max <integer>\"\n");
827        }
828        mbus_parse_done(sp->mbus_engine_conf);
829}
830
831static void rx_tool_rat_converter(char *srce, char *args, session_struct *sp)
832{
833        char *name;
834       
835        UNUSED(srce);
836
837        mbus_parse_init(sp->mbus_engine_conf, args);
838        if (mbus_parse_str(sp->mbus_engine_conf, &name)) {
839                mbus_decode_str(name);
840                sp->converter = converter_get_byname(name);
841                assert(sp->converter);
842        } else {
843                printf("mbus: usage \"tool.rat.converter <name>\"\n");
844        }
845        mbus_parse_done(sp->mbus_engine_conf);
846}
847
848static codec_t*
849validate_redundant_codec(codec_t *primary, codec_t *redundant)
850{
851        assert(primary != NULL);
852       
853        if ((redundant == NULL) ||                       /* passed junk */
854            (!codec_compatible(primary, redundant)) ||   /* passed incompatible codec */
855            (redundant->unit_len > primary->unit_len)) { /* passed higher bandwidth codec */
856                return primary;
857        }
858        return redundant;
859}
860
861static void rx_audio_channel_coding(char *srce, char *args, session_struct *sp)
862{
863        char    *channel, *codec;
864        int      units, separation, cc_pt, offset, rpt;
865        char     config[80];
866        codec_t *rcp, *pcp;
867
868        UNUSED(srce);
869
870        mbus_parse_init(sp->mbus_engine_conf, args);
871        if (mbus_parse_str(sp->mbus_engine_conf, &channel)) {
872                channel = mbus_decode_str(channel);
873                if (strcmp(channel, "none") == 0) {
874                        channel_set_coder(sp, get_cc_pt(sp, "VANILLA"));
875                } else if (strcmp(channel, "redundant") == 0) {
876                        channel_set_coder(sp, get_cc_pt(sp, "REDUNDANCY"));
877                        if (mbus_parse_str(sp->mbus_engine_conf, &codec) && mbus_parse_int(sp->mbus_engine_conf, &offset)) {
878                                if (offset<=0) offset = 0;;
879                                pcp = get_codec_by_pt(sp->encodings[0]);
880                                rpt = codec_matching(mbus_decode_str(codec), pcp->freq, pcp->channels);
881                                if (rpt != -1) {
882                                        rcp = get_codec_by_pt(rpt);
883                                } else {
884                                        /* Specified secondary codec doesn't exist. Make it the same */
885                                        /* as the primary, and hope that's a sensible choice.        */
886                                        rcp = pcp;
887                                }
888                                assert(rcp != NULL);
889                                /* Check redundancy makes sense... */
890                                rcp = validate_redundant_codec(pcp,rcp);
891                                sprintf(config,"%s/0/%s/%d", pcp->name, rcp->name, offset);
892                                debug_msg("Configuring redundancy %s\n", config);
893                                cc_pt = get_cc_pt(sp,"REDUNDANCY");
894                                config_channel_coder(sp, cc_pt, config);
895                        } else {
896                                printf("mbus: usage \"audio.channel.coding \"redundant\" <codec> <offset in units>\"\n");
897                        }               
898                } else if (strcmp(channel, "interleaved") == 0) {
899                        cc_pt = get_cc_pt(sp,"INTERLEAVER");
900                        channel_set_coder(sp, cc_pt);
901                        if (mbus_parse_int(sp->mbus_engine_conf, &units) && mbus_parse_int(sp->mbus_engine_conf, &separation)) {
902                                sprintf(config, "%d/%d", units, separation);
903                                config_channel_coder(sp, cc_pt, config);
904                        } else {
905                                printf("mbus: usage \"audio.channel.coding \"interleaved\" <units> <separation>\"\n");
906                        }
907                } else {
908                        debug_msg("scheme %s not recognized\n", channel);
909                        abort();
910                }
911        } else {
912                printf("mbus: usage \"audio.channel.coding <scheme>\"\n");
913        }
914        mbus_parse_done(sp->mbus_engine_conf);
915        ui_update_channel(sp);
916}
917
918static void rx_tool_rat_settings(char *srce, char *args, session_struct *sp)
919{
920        UNUSED(args);
921        UNUSED(srce);
922        ui_update(sp);
923}
924
925static void rx_mbus_quit(char *srce, char *args, session_struct *sp)
926{
927        UNUSED(args);
928        UNUSED(srce);
929        UNUSED(sp);
930        ui_quit(sp);
931        should_exit = TRUE;
932}
933
934static void rx_mbus_waiting(char *srce, char *args, session_struct *sp)
935{
936        UNUSED(srce);
937        UNUSED(args);
938        UNUSED(sp);
939}
940
941static void rx_mbus_go(char *srce, char *args, session_struct *sp)
942{
943        UNUSED(srce);
944        UNUSED(args);
945        sp->wait_on_startup = FALSE;
946}
947
948static void rx_mbus_hello(char *srce, char *args, session_struct *sp)
949{
950        /* Ignore "hello" messages... */
951        UNUSED(args);
952        UNUSED(srce);
953        UNUSED(sp);
954}
955
956/* Note: These next two arrays MUST be in the same order! */
957
958const char *rx_cmnd[] = {
959        "tool.rat.get_audio",             
960        "tool.rat.toggle.input.port",
961        "tool.rat.toggle.output.port",
962        "tool.rat.silence",
963        "tool.rat.lecture",
964        "tool.rat.externalise",
965        "tool.rat.agc",
966        "tool.rat.loopback",
967        "tool.rat.echo.suppress",
968        "tool.rat.sync",       
969        "tool.rat.rate",         
970        "tool.rat.powermeter",
971        "tool.rat.converter",
972        "tool.rat.settings",
973        "tool.rat.codec",
974        "tool.rat.sampling",
975        "tool.rat.playout.limit",
976        "tool.rat.playout.min",           
977        "tool.rat.playout.max",           
978        "audio.input.mute",
979        "audio.input.gain",
980        "audio.input.port",
981        "audio.output.mute",
982        "audio.output.gain",
983        "audio.output.port",
984        "audio.channel.coding",
985        "audio.channel.repair",
986        "audio.file.play.open",   
987        "audio.file.play.pause",
988        "audio.file.play.stop",
989        "audio.file.play.live",
990        "audio.file.record.open",
991        "audio.file.record.pause",
992        "audio.file.record.stop",
993        "audio.file.record.live",
994        "audio.device",
995        "security.encryption.key",             
996        "rtp.source.name",
997        "rtp.source.email",
998        "rtp.source.phone",       
999        "rtp.source.loc",
1000        "rtp.source.mute",
1001        "rtp.source.playout",
1002        "mbus.quit",
1003        "mbus.waiting",
1004        "mbus.go",
1005        "mbus.hello",             
1006        ""
1007};
1008
1009static void (*rx_func[])(char *srce, char *args, session_struct *sp) = {
1010        rx_tool_rat_get_audio,                 
1011        rx_tool_rat_toggle_input_port,
1012        rx_tool_rat_toggle_output_port,
1013        rx_tool_rat_silence,
1014        rx_tool_rat_lecture,
1015        rx_tool_rat_externalise,
1016        rx_tool_rat_agc,
1017        rx_tool_rat_audio_loopback,
1018        rx_tool_rat_echo_suppress,
1019        rx_tool_rat_sync,
1020        rx_tool_rat_rate,             
1021        rx_tool_rat_powermeter,
1022        rx_tool_rat_converter,
1023        rx_tool_rat_settings,
1024        rx_tool_rat_codec,
1025        rx_tool_rat_sampling,
1026        rx_tool_rat_playout_limit,
1027        rx_tool_rat_playout_min,
1028        rx_tool_rat_playout_max,               
1029        rx_audio_input_mute,
1030        rx_audio_input_gain,
1031        rx_audio_input_port,
1032        rx_audio_output_mute,
1033        rx_audio_output_gain,
1034        rx_audio_output_port,
1035        rx_audio_channel_coding,
1036        rx_audio_channel_repair,
1037        rx_audio_file_play_open,       
1038        rx_audio_file_play_pause,
1039        rx_audio_file_play_stop,               
1040        rx_audio_file_play_live,
1041        rx_audio_file_rec_open,
1042        rx_audio_file_rec_pause,
1043        rx_audio_file_rec_stop,
1044        rx_audio_file_rec_live,
1045        rx_audio_device,
1046        rx_security_encryption_key,
1047        rx_rtp_source_name,
1048        rx_rtp_source_email,
1049        rx_rtp_source_phone,           
1050        rx_rtp_source_loc,
1051        rx_rtp_source_mute,
1052        rx_rtp_source_playout,
1053        rx_mbus_quit,
1054        rx_mbus_waiting,
1055        rx_mbus_go,
1056        rx_mbus_hello,
1057        NULL
1058};
1059
1060void mbus_engine_rx(char *srce, char *cmnd, char *args, void *data)
1061{
1062        int i;
1063
1064        debug_msg("%s (%s)\n", cmnd, args);
1065        for (i=0; strlen(rx_cmnd[i]) != 0; i++) {
1066                if (strcmp(rx_cmnd[i], cmnd) == 0) {
1067                        rx_func[i](srce, args, (session_struct *) data);
1068                        return;
1069                }
1070        }
1071        debug_msg("Unknown mbus command: %s (%s)\n", cmnd, args);
1072#ifndef NDEBUG
1073        abort();
1074#endif
1075}
Note: See TracBrowser for help on using the browser.