root/rat/trunk/ui.c @ 2056

Revision 2056, 27.0 KB (checked in by ucaccsp, 16 years ago)

Update parameters to the audio.channel.* commands. This probably requires
that you remove your ~/.RTPdefaults file or else rat will crash on startup
the first time.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/*
2 * FILE:    ui_control.c
3 * PROGRAM: RAT
4 * AUTHOR:  Isidor Kouvelas + Colin Perkins + Orion Hodson
5 *     
6 * This file contains routines which update the user interface. There is no
7 * direct connection between the user interface and the media engine now, all
8 * updates are done via the conference bus.
9 *
10 * Copyright (c) 1995-98 University College London
11 * All rights reserved.
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, is permitted, for non-commercial use only, provided
15 * that the following conditions are met:
16 * 1. Redistributions of source code must retain the above copyright
17 *    notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 *    notice, this list of conditions and the following disclaimer in the
20 *    documentation and/or other materials provided with the distribution.
21 * 3. All advertising materials mentioning features or use of this software
22 *    must display the following acknowledgement:
23 *      This product includes software developed by the Computer Science
24 *      Department at University College London
25 * 4. Neither the name of the University nor of the Department may be used
26 *    to endorse or promote products derived from this software without
27 *    specific prior written permission.
28 * Use of this software for commercial purposes is explicitly forbidden
29 * unless prior written permission is obtained from the authors.
30 *
31 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
32 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
33 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
34 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
35 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
39 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
40 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
41 * SUCH DAMAGE.
42 */
43
44#include "config_unix.h"
45#include "config_win32.h"
46#include "assert.h"
47#include "debug.h"
48#include "memory.h"
49#include "version.h"
50#include "session.h"
51#include "crypt.h"
52#include "rtcp_pckt.h"
53#include "rtcp_db.h"
54#include "repair.h"
55#include "receive.h"
56#include "codec.h"
57#include "convert.h"
58#include "audio.h"
59#include "mbus.h"
60#include "mbus_engine.h"
61#include "channel.h"
62#include "mix.h"
63#include "transmit.h"
64#include "ui.h"
65#include "timers.h"
66
67static char *mbus_name_engine = NULL;
68static char *mbus_name_ui     = NULL;
69static char *mbus_name_video  = NULL;
70
71/*
72 * Update the on screen information for the given participant
73 *
74 * Note: We must be careful, since the Mbus code uses the CNAME
75 *       for communication with the UI. In a few cases we have
76 *       valid state for a participant (ie: we've received an
77 *       RTCP packet for that SSRC), but do NOT know their CNAME.
78 *       (For example, if the first packet we receive from a source
79 *       is an RTCP BYE piggybacked with an empty RR). In those
80 *       cases, we just ignore the request and send nothing to the
81 *       UI. [csp]
82 */
83
84void
85ui_info_update_name(session_struct *sp, rtcp_dbentry *e)
86{
87        char *cname, *name, *args;
88
89        if (e->sentry->cname == NULL) return;
90
91        cname = mbus_encode_str(e->sentry->cname);
92        name  = mbus_encode_str(e->sentry->name);
93        args = (char*)xmalloc(strlen(cname) + strlen(name) + 2);
94       
95        sprintf(args, "%s %s", cname, name);
96        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.name", args, TRUE);
97        xfree(cname);
98        xfree(name);
99        xfree(args);
100}
101
102void
103ui_info_update_cname(session_struct *sp, rtcp_dbentry *e)
104{
105        char *cname;
106       
107        if (e->sentry->cname == NULL) return;
108       
109        cname = mbus_encode_str(e->sentry->cname);
110        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.exists", cname, TRUE);
111        xfree(cname);
112}
113
114void
115ui_info_update_email(session_struct *sp, rtcp_dbentry *e)
116{
117        char *cname, *arg, *args;
118
119        if (e->sentry->cname == NULL) return;
120
121        cname = mbus_encode_str(e->sentry->cname);
122        arg   = mbus_encode_str(e->sentry->email);
123        args = (char*)xmalloc(strlen(cname) + strlen(arg) + 2);
124        sprintf(args, "%s %s", cname, arg);
125        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.email", args, TRUE);
126        xfree(cname);
127        xfree(arg);
128        xfree(args);
129}
130
131void
132ui_info_update_phone(session_struct *sp, rtcp_dbentry *e)
133{
134        char *cname, *arg, *args;
135
136        if (e->sentry->cname == NULL) return;
137
138        cname = mbus_encode_str(e->sentry->cname);
139        arg   = mbus_encode_str(e->sentry->phone);
140        args = (char*)xmalloc(strlen(cname) + strlen(arg) + 2);
141        sprintf(args, "%s %s", cname, arg);
142        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.phone", args, TRUE);
143        xfree(cname);
144        xfree(arg);
145        xfree(args);
146}
147
148void
149ui_info_update_loc(session_struct *sp, rtcp_dbentry *e)
150{
151        char *cname, *arg, *args;
152
153        if (e->sentry->cname == NULL) return;
154
155        cname = mbus_encode_str(e->sentry->cname);
156        arg   = mbus_encode_str(e->sentry->loc);
157        args = (char*)xmalloc(strlen(cname) + strlen(arg) + 2);
158        sprintf(args, "%s %s", cname, arg);
159        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.loc", args, TRUE);
160        xfree(cname);
161        xfree(arg);
162        xfree(args);
163}
164
165void
166ui_info_update_tool(session_struct *sp, rtcp_dbentry *e)
167{
168        char *cname = mbus_encode_str(e->sentry->cname);
169        char *arg   = mbus_encode_str(e->sentry->tool);
170        char *args = (char*)xmalloc(strlen(cname) + strlen(arg) + 2);
171        sprintf(args, "%s %s", cname, arg);
172        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.tool", args, TRUE);
173        xfree(cname);
174        xfree(arg);
175        xfree(args);
176}
177
178void
179ui_info_update_note(session_struct *sp, rtcp_dbentry *e)
180{
181        char *cname = mbus_encode_str(e->sentry->cname);
182        char *arg   = mbus_encode_str(e->sentry->note);
183        char *args = (char*)xmalloc(strlen(cname) + strlen(arg) + 2);
184        sprintf(args, "%s %s", cname, arg);
185        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.note", args, TRUE);
186        xfree(cname);
187        xfree(arg);
188        xfree(args);
189}
190
191void
192ui_info_mute(session_struct *sp, rtcp_dbentry *e)
193{
194        char *cname = mbus_encode_str(e->sentry->cname);
195        char *args = (char*)xmalloc(strlen(cname) + 4);
196        sprintf(args, "%s %2d", cname, e->mute);
197        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.mute", args, TRUE);
198        xfree(cname);
199        xfree(args);
200}
201
202void
203ui_info_remove(session_struct *sp, rtcp_dbentry *e)
204{
205        char *cname;
206       
207        if (e->sentry->cname == NULL) return;
208       
209        cname = mbus_encode_str(e->sentry->cname);
210        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.remove", cname, TRUE);
211        xfree(cname);
212}
213
214void
215ui_info_activate(session_struct *sp, rtcp_dbentry *e)
216{
217        char *cname;
218       
219        if (e->sentry->cname == NULL) return;
220       
221        cname = mbus_encode_str(e->sentry->cname);
222        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.active", cname, FALSE);
223        xfree(cname);
224}
225
226void
227ui_info_deactivate(session_struct *sp, rtcp_dbentry *e)
228{
229        char *cname;
230
231        if (e->sentry->cname == NULL) return;
232       
233        cname = mbus_encode_str(e->sentry->cname);
234        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.inactive", cname, FALSE);
235        xfree(cname);
236}
237
238void
239ui_update_stats(session_struct *sp, rtcp_dbentry *e)
240{
241        char    *my_cname, *their_cname, *args, *mbes;
242        codec_t *pcp;
243
244        if (sp->db->my_dbe->sentry == NULL || sp->db->my_dbe->sentry->cname == NULL) {
245                debug_msg("Warning sentry or name == NULL\n");
246                return;
247        }
248
249        if (e->sentry->cname == NULL) {
250                return;
251        }
252
253        my_cname    = mbus_encode_str(sp->db->my_dbe->sentry->cname);
254        their_cname = mbus_encode_str(e->sentry->cname);
255
256        if (e->enc_fmt) {
257                pcp  = get_codec_by_pt(e->enc);
258                mbes = mbus_encode_str(pcp->short_name);
259                args = (char *) xmalloc(strlen(their_cname) + strlen(mbes) + 2);
260                sprintf(args, "%s %s", their_cname, mbes);
261        } else {
262                args = (char *) xmalloc(strlen(their_cname) + 7 + 2);
263                sprintf(args, "%s unknown", their_cname);
264        }
265        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.codec", args, FALSE);
266        xfree(args);
267
268        /* args size is for source.packet.loss, tool.rat.audio.buffered size always less */
269        args = (char *) xmalloc(strlen(their_cname) + strlen(my_cname) + 11);
270       
271        sprintf(args, "%s %ld", their_cname, playout_buffer_duration(sp->playout_buf_list, e));
272        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.audio.buffered", args, FALSE);
273
274        sprintf(args, "%s %s %8ld", my_cname, their_cname, (e->lost_frac * 100) >> 8);
275        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.packet.loss", args, FALSE);
276
277        xfree(my_cname);
278        xfree(their_cname);
279        xfree(args);
280}
281
282void
283ui_update_input_port(session_struct *sp)
284{
285        switch (sp->input_mode) {
286        case AUDIO_MICROPHONE:
287                mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.input.port", "microphone", TRUE);
288                break;
289        case AUDIO_LINE_IN:
290                mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.input.port", "line_in", TRUE);
291                break
292        case AUDIO_CD:
293                mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.input.port", "cd", TRUE);
294                break;
295        default:
296                fprintf(stderr, "Invalid input port!\n");
297                return ;
298        }
299        if (sp->sending_audio) {
300                mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.input.mute", "0", TRUE);
301        } else {
302                mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.input.mute", "1", TRUE);
303        }
304}
305
306void
307ui_update_output_port(session_struct *sp)
308{
309        switch (sp->output_mode) {
310        case AUDIO_SPEAKER:
311                mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.output.port", "speaker", TRUE);
312                break;
313        case AUDIO_HEADPHONE:
314                mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.output.port", "headphone", TRUE);
315                break;
316        case AUDIO_LINE_OUT:
317                mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.output.port", "line_out", TRUE);
318                break;
319        default:
320                fprintf(stderr, "Invalid output port!\n");
321                return;
322        }
323        if (sp->playing_audio) {
324                mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.output.mute", "0", TRUE);
325        } else {
326                mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.output.mute", "1", TRUE);
327        }
328}
329
330void
331ui_input_level(session_struct *sp, int level)
332{
333        static int      ol;
334        char            args[4];
335
336        assert(level>=0 && level <=100);
337
338        if (ol == level) {
339                return;
340        }
341
342        sprintf(args, "%3d", level);
343        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.input.powermeter", args, FALSE);
344        ol = level;
345}
346
347void
348ui_output_level(session_struct *sp, int level)
349{
350        static int      ol;
351        char            args[4];
352        assert(level>=0 && level <=100);
353
354        if (ol == level) {
355                return;
356        }
357
358        sprintf(args, "%3d", level);
359        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.output.powermeter", args, FALSE);
360        ol = level;
361}
362
363static void
364ui_repair(session_struct *sp)
365{
366        char    *repair = NULL;
367
368        switch(sp->repair) {
369        case REPAIR_NONE:
370                repair = mbus_encode_str("none");
371                break;
372        case REPAIR_REPEAT:
373                repair = mbus_encode_str("repetition");
374                break;
375        case REPAIR_PATTERN_MATCH:
376                repair = mbus_encode_str("pattern-match");
377                break;
378        }
379        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.channel.repair", repair, FALSE);
380        xfree(repair);
381}
382
383void
384ui_update_interleaving(session_struct *sp)
385{
386        int pt, isep, iu;
387        char buf[128], *sep=NULL, *units = NULL, *dummy, args[80];
388
389        pt = get_cc_pt(sp,"INTERLEAVER");
390        if (pt != -1) {
391                query_channel_coder(sp, pt, buf, 128);
392                dummy  = strtok(buf,"/");
393                units  = strtok(NULL,"/");
394                sep    = strtok(NULL,"/");
395        } else {
396                debug_msg("Could not find interleaving channel coder!\n");
397        }
398       
399        if (units != NULL && sep != NULL) {
400                iu   = atoi(units);
401                isep = atoi(sep);
402        } else {
403                iu   = 4;
404                isep = 4;
405        }
406
407        sprintf(args,"%d %d",iu, isep);
408        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.interleaving", args, TRUE);       
409}
410
411void
412ui_update_frequency(session_struct *sp)
413{
414        codec_t *pcp;
415        char     args[7], *mbes;
416
417        pcp = get_codec_by_pt(sp->encodings[0]);
418        sprintf(args, "%d-kHz", pcp->freq/1000);
419        assert(strlen(args) < 7);
420        mbes = mbus_encode_str(args);
421        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.frequency", mbes, FALSE);
422        xfree(mbes);
423}
424
425void
426ui_update_channels(session_struct *sp)
427{
428        codec_t *pcp;
429        char    *mbes;
430       
431        pcp = get_codec_by_pt(sp->encodings[0]);
432        switch(pcp->channels) {
433        case 1:
434                mbes = mbus_encode_str("Mono");
435                break;
436        case 2:
437                mbes = mbus_encode_str("Stereo");
438                break;
439        default:
440                debug_msg("UI not ready for %d channels\n", pcp->channels);
441                return;
442        }
443        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.channels", mbes, FALSE);
444        xfree(mbes);
445}       
446
447void
448ui_update_primary(session_struct *sp)
449{
450        codec_t *pcp;
451        char *mbes;
452
453        pcp = get_codec_by_pt(sp->encodings[0]);
454        mbes = mbus_encode_str(pcp->short_name);
455        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.codec", mbes, FALSE);
456        xfree(mbes);
457}
458
459void
460ui_update_redundancy(session_struct *sp)
461{
462        int  pt;
463        int  ioff;
464        char buf[128]= "", *codec_name=NULL, *offset=NULL, *dummy, *args;
465
466        pt = get_cc_pt(sp,"REDUNDANCY");
467        if (pt != -1) {
468                codec_t *cp;
469                query_channel_coder(sp, pt, buf, 128);
470                if (strlen(buf)) {
471                        dummy  = strtok(buf,"/");
472                        dummy  = strtok(NULL,"/");
473                        codec_name  = strtok(NULL,"/");
474                        /* redundant coder returns long name convert to short*/
475                        if (codec_name) {
476                                cp         = get_codec_by_name(codec_name);
477                                assert(cp);
478                                codec_name = cp->short_name;
479                        }
480                        offset = strtok(NULL,"/");
481                }
482        } else {
483                debug_msg("Could not find redundant channel coder!\n");
484        }
485
486        if (codec_name != NULL && offset != NULL) {
487                ioff  = atoi(offset);
488        } else {
489                codec_t *pcp;
490                pcp   = get_codec_by_pt(sp->encodings[0]);
491                codec_name = pcp->short_name;
492                ioff  = 1;
493        }
494
495        codec_name = mbus_encode_str(codec_name);
496
497        args = (char *) xmalloc(strlen(codec_name) + 4);
498        sprintf(args,"%s %2d", codec_name, ioff);
499        assert(strlen(args) < (strlen(codec_name) + 4));
500        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.redundancy", args, TRUE);
501        xfree(codec_name);
502        xfree(args);
503}
504
505void 
506ui_update_channel(session_struct *sp)
507{
508        cc_coder_t *ccp;
509        char       *mbes = NULL;
510
511        ccp = get_channel_coder(sp->cc_encoding);
512        assert(ccp != NULL);
513        switch(ccp->name[0]) {
514        case 'V':
515                mbes = mbus_encode_str("none");
516                break;
517        case 'R':
518                mbes = mbus_encode_str("redundant");
519                break;
520        case 'I':
521                mbes = mbus_encode_str("interleaved");
522                break;
523        default:
524                debug_msg("Channel coding failed mapping.\n");
525                return;
526        }
527
528        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.channel.coding", mbes, TRUE);
529        if (mbes) xfree(mbes);
530}
531
532void
533ui_update_input_gain(session_struct *sp)
534{
535        char    args[4];
536
537        sprintf(args, "%3d", audio_get_gain(sp->audio_device));
538        assert(strlen(args) < 4);
539        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.input.gain", args, TRUE);
540}
541
542void
543ui_update_output_gain(session_struct *sp)
544{
545        char    args[4];
546
547        sprintf(args, "%3d", audio_get_volume(sp->audio_device));
548        assert(strlen(args) < 4);
549        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.output.gain", args, TRUE);
550}
551
552static void
553ui_devices(session_struct *sp)
554{
555        int i,nDev;
556        char buf[255] = "", *this_dev, *mbes;
557       
558        nDev = audio_get_number_of_interfaces();
559        for(i = 0; i < nDev; i++) {
560                this_dev = audio_get_interface_name(i);
561                if (this_dev) {
562                        strcat(buf, this_dev);
563                        strcat(buf, ",");
564                }
565        }
566        i = strlen(buf);
567        if (i != 0) buf[i-1] = '\0';
568
569        mbes = mbus_encode_str(buf);
570        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.devices", mbes, TRUE);
571        xfree(mbes);
572}
573
574static void
575ui_device(session_struct *sp)
576{
577        char *mbes, *cur_dev;
578        cur_dev = audio_get_interface_name(audio_get_interface());
579
580        if (cur_dev) {
581                mbes = mbus_encode_str(cur_dev);
582                mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.device", mbes, TRUE);
583                xfree(mbes);
584        }
585}
586
587void
588ui_update(session_struct *sp)
589{
590        static   int    done=0;
591        char            args[4];
592
593        /*XXX solaris seems to give a different volume back to what we   */
594        /*    actually set.  So don't even ask if it's not the first time*/
595        if (done==0) {
596                ui_update_input_gain(sp);
597                ui_update_output_gain(sp);
598                done=1;
599        } else {
600                sprintf(args, "%3d", sp->output_gain); mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.output.gain", args, TRUE);
601                assert(strlen(args) < 4);
602                sprintf(args, "%3d", sp->input_gain ); mbus_qmsg(sp->mbus_engine_base, mbus_name_ui,  "audio.input.gain", args, TRUE);
603                assert(strlen(args) < 4);
604        }
605
606        sprintf(args, "%3d", collator_get_units(sp->collator));
607        assert(strlen(args) < 4);
608        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.rate", args, TRUE);
609
610        ui_update_output_port(sp);
611        ui_update_input_port(sp);
612        ui_codecs(sp, sp->encodings[0]);
613        ui_devices(sp);
614        ui_device(sp);
615        ui_sampling_modes(sp);
616        ui_converters(sp);
617        ui_update_frequency(sp);
618        ui_update_channels(sp);
619        ui_update_primary(sp);
620        ui_update_redundancy(sp);
621        ui_update_interleaving(sp);
622        ui_update_channel(sp);
623        ui_repair(sp);
624}
625
626void
627ui_show_audio_busy(session_struct *sp)
628{
629        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.disable.audio.ctls", "", TRUE);
630}
631
632void
633ui_hide_audio_busy(session_struct *sp)
634{
635        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.enable.audio.ctls", "", TRUE);
636}
637
638
639void
640ui_update_lecture_mode(session_struct *sp)
641{
642        /* Update the UI to reflect the lecture mode setting...*/
643        char    args[2];
644        sprintf(args, "%1d", sp->lecture);
645        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.lecture.mode", args, TRUE);
646}
647
648void
649ui_update_powermeters(session_struct *sp, struct s_mix_info *ms, int elapsed_time)
650{
651        static u_int32 power_time = 0;
652
653        if (power_time > sp->meter_period) {
654                if (sp->meter && (ms != NULL)) {
655                        mix_update_ui(sp, ms);
656                }
657                if (sp->sending_audio) {
658                        tx_update_ui(sp);
659                }
660                power_time = 0;
661        } else {
662                power_time += elapsed_time;
663        }
664}
665
666void
667ui_update_loss(session_struct *sp, char *srce, char *dest, int loss)
668{
669        char    *srce_e, *dest_e, *args;
670
671        if ((srce == NULL) || (dest == NULL)) {
672                return;
673        }
674
675        srce_e = mbus_encode_str(srce);
676        dest_e = mbus_encode_str(dest);
677        args   = (char *) xmalloc(strlen(srce_e) + strlen(dest_e) + 6);
678        sprintf(args, "%s %s %3d", srce_e, dest_e, loss);
679        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.packet.loss", args, FALSE);
680        xfree(args);
681        xfree(srce_e);
682        xfree(dest_e);
683}
684
685void
686ui_update_reception(session_struct *sp, char *cname, u_int32 recv, u_int32 lost, u_int32 misordered, u_int32 duplicates, u_int32 jitter, int jit_tog)
687{
688        char    *cname_e, *args;
689
690        if (cname == NULL) return;
691
692        cname_e = mbus_encode_str(cname);
693
694        /* I hate this function! */
695        args = (char *) xmalloc(strlen(cname_e) + 88);
696        sprintf(args, "%s %6ld %6ld %6ld %6ld %6ld %6d", cname_e, recv, lost, misordered, duplicates, jitter, jit_tog);
697        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.reception", args, FALSE);
698        xfree(args);
699        xfree(cname_e);
700}
701
702void
703ui_update_duration(session_struct *sp, char *cname, int duration)
704{
705        char    *cname_e, *args;
706
707        if (cname == NULL) return;
708
709        cname_e = mbus_encode_str(cname);
710        args    = (char *) xmalloc(5 + strlen(cname_e));
711
712        sprintf(args, "%s %3d", cname_e, duration);
713        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.packet.duration", args, FALSE);
714        xfree(args);
715        xfree(cname_e);
716}
717
718void 
719ui_update_video_playout(session_struct *sp, char *cname, int playout)
720{
721        char    *cname_e, *args;
722
723        if (cname == NULL) return;
724
725        cname_e = mbus_encode_str(cname);
726        args    = (char *) xmalloc(14 + strlen(cname_e));
727
728        sprintf(args, "%s %12d", cname_e, playout);
729        mbus_qmsg(sp->mbus_engine_base, mbus_name_video, "source_playout", args, FALSE);
730        xfree(args);
731        xfree(cname_e);
732}
733
734void   
735ui_update_sync(session_struct *sp, int sync)
736{
737        if (sync) {
738                mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.sync", "1", TRUE);
739        } else {
740                mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.sync", "0", TRUE);
741        }
742}
743
744void
745ui_update_key(session_struct *sp, char *key)
746{
747        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "security.encryption.key", key, TRUE);
748}
749
750static int
751codec_bw_cmp(const void *a, const void *b)
752{
753        int bwa, bwb;
754        bwa = (*((codec_t**)a))->max_unit_sz;
755        bwb = (*((codec_t**)b))->max_unit_sz;
756        if (bwa<bwb) {
757                return 1;
758        } else if (bwa>bwb) {
759                return -1;
760        }
761        return 0;
762}
763
764static char *
765ui_get_codecs(int pt, char *buf, unsigned int buf_len, int loose)
766{
767        codec_t *codec[10],*sel;
768        u_int32  i,nc, cnt;
769        char *bp = buf;
770       
771        cnt = get_codec_count();
772        sel = get_codec_by_pt(pt);
773       
774        for (nc = i = 0; i< cnt ; i++) {
775                codec[nc] = get_codec_by_index(i);
776                if (codec[nc] != NULL && codec[nc]->encode != NULL) {
777                        if (loose == TRUE && codec_loosely_compatible(sel,codec[nc])) {
778                                /* Picking out primary codecs, i.e. not bothered
779                                 * about sample size and block sizes matching.
780                                 */
781                                nc++;
782                                assert(nc<10);
783                        } else if (codec_compatible(sel, codec[nc])) {
784                                /* Picking out redundant codecs where we are
785                                 * fussed about sample and block size matching.
786                                 */
787                                nc++;
788                                assert(nc<10);
789                        }
790                }
791        }
792       
793        /* sort by bw as this makes handling of acceptable redundant codecs easier in ui */
794        qsort(codec,nc,sizeof(codec_t*),codec_bw_cmp);
795        for(i=0;i<nc && strlen(buf) + strlen(codec[i]->short_name) < buf_len;i++) {
796                sprintf(bp, "%s ", codec[i]->short_name);
797                bp += strlen(codec[i]->short_name) + 1;
798        }
799
800        if (i != nc) {
801                debug_msg("Ran out of buffer space.\n");
802        }
803       
804        if (bp != buf) *(bp-1) = 0;
805        return buf;
806}
807
808void
809ui_update_playback_file(session_struct *sp, char *name)
810{
811        char *mbes;
812        mbes = mbus_encode_str(name);
813        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.file.play.ready", mbes, TRUE);
814        xfree(mbes);
815}
816
817void
818ui_update_record_file(session_struct *sp, char *name)
819{
820        char *mbes;
821        mbes = mbus_encode_str(name);
822        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.file.record.ready", mbes, TRUE);
823        xfree(mbes);
824}
825
826void
827ui_update_file_live(session_struct *sp, char *mode, int valid)
828{
829        char cmd[32], arg[2];
830       
831        assert(!strcmp(mode, "play") || !strcmp(mode, "record"));
832       
833        sprintf(cmd, "audio.file.%s.alive", mode);
834        sprintf(arg, "%1d", valid);
835        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, cmd, arg, TRUE);
836}
837
838void 
839ui_codecs(session_struct *sp, int pt)
840{
841        char    args[256], *mbes;       /* Hope that's big enough... :-) */
842
843        ui_get_codecs(pt, args, 256, TRUE);
844        mbes = mbus_encode_str(args);
845        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.codec.supported", mbes, TRUE);
846        xfree(mbes);
847        ui_get_codecs(pt, args, 256, FALSE);
848        mbes = mbus_encode_str(args);
849        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.redundancy.supported", mbes, TRUE);
850        xfree(mbes);
851}
852
853void 
854ui_converters(session_struct *sp)
855{
856        char buf[255], *mbes;
857        if (converter_get_names(buf, 255)) {
858                mbes = mbus_encode_str(buf);
859                mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.converter.supported", mbes, TRUE);
860                xfree(mbes);
861        }
862}
863
864void
865ui_sampling_modes(session_struct *sp)
866{
867        char    *mbes;
868        char    modes[255]="";
869        char    tmp[22];
870        u_int16 rate, channels, support, zap;
871       
872        for(rate = 8000; rate <=48000; rate += 8000) {
873                support = 0;
874                for(channels = 1; channels <= 2; channels++) {
875                        if (audio_device_supports(sp->audio_device, rate, channels)) support += channels;
876                }
877                switch(support) {
878                case 3: sprintf(tmp, "%d-kHz,Mono,Stereo ", rate/1000); break;
879                case 2: sprintf(tmp, "%d-kHz,Stereo ", rate/1000);      break;
880                case 1: sprintf(tmp, "%d-kHz,Mono ", rate/1000);        break;
881                case 0: continue;
882                }
883                strcat(modes, tmp);
884        }
885
886        debug_msg("Sampling modes: %s\n", modes);
887
888        /* Remove trailing space */
889        zap = strlen(modes);
890        if (zap) {
891                zap -= 1;
892                modes[zap] = '\0';
893        }
894
895        mbes = mbus_encode_str(modes);
896        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.sampling.supported", mbes, TRUE);
897        xfree(mbes);
898}
899
900void
901ui_controller_init(session_struct *sp, char *cname, char *name_engine, char *name_ui, char *name_video)
902{
903        char    *my_cname;
904
905        mbus_name_engine = name_engine;
906        mbus_name_ui     = name_ui;
907        mbus_name_video  = name_video;
908
909        my_cname = mbus_encode_str(cname);
910        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.cname", my_cname, TRUE);
911        xfree(my_cname);
912}
913
914void
915ui_title(session_struct *sp)
916{
917        char    *addr, *args, *title;
918
919        title = mbus_encode_str(sp->title);
920        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "session.title", title, TRUE);
921        xfree(title);
922
923        addr = mbus_encode_str(sp->asc_address);
924        args = (char *) xmalloc(strlen(addr) + 11);
925        sprintf(args, "%s %5d %3d", addr, sp->rtp_port, sp->ttl);
926        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "session.address", args, TRUE);
927        xfree(args);
928        xfree(addr);
929}
930
931void
932ui_load_settings(session_struct *sp)
933{
934        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.load.settings", "", TRUE);
935}
936
937void 
938ui_quit(session_struct *sp)
939{
940        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "mbus.quit", "", TRUE);
941}
942
943
944
Note: See TracBrowser for help on using the browser.