root/rat/trunk/ui.c @ 2765

Revision 2765, 30.9 KB (checked in by ucacoxh, 15 years ago)

- Consistency fixes for channel coder query functions.

  • 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: all
8 * updates are done via the conference bus.
9 *
10 * Copyright (c) 1995-99 University College London
11 * All rights reserved.
12 *
13 */
14
15#include "config_unix.h"
16#include "config_win32.h"
17#include "debug.h"
18#include "memory.h"
19#include "version.h"
20#include "codec_types.h"
21#include "codec_state.h"
22#include "codec.h"
23#include "session.h"
24#include "channel_types.h"
25#include "channel.h"
26#include "repair.h"
27#include "converter.h"
28#include "audio.h"
29#include "audio_fmt.h"
30#include "auddev.h"
31#include "mbus.h"
32#include "mbus_engine.h"
33#include "transmit.h"
34#include "pdb.h"
35#include "rtp.h"
36#include "mix.h"
37#include "ui.h"
38#include "timers.h"
39#include "render_3D.h"
40#include "source.h"
41#include "net.h"
42#include "util.h" /* purge_chars */
43
44static char *mbus_name_engine = NULL;
45static char *mbus_name_ui     = NULL;
46static char *mbus_name_video  = NULL;
47
48static void ui_info_update_sdes(session_t *sp, char *item, const char *val, u_int32 ssrc)
49{
50        char *arg;
51        if (val == NULL) {
52                val = "Unknown";
53        }
54        arg = mbus_encode_str(val);
55        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, TRUE, item, "\"%08lx\" %s", ssrc, arg);
56        xfree(arg);
57}
58
59void ui_info_update_cname(session_t *sp, u_int32 ssrc)
60{
61        const char *cname = rtp_get_sdes(sp->rtp_session[0], ssrc, RTCP_SDES_CNAME);
62        ui_info_update_sdes(sp, "rtp.source.cname", cname, ssrc);
63}
64
65void ui_info_update_name(session_t *sp, u_int32 ssrc)
66{
67        const char *name = rtp_get_sdes(sp->rtp_session[0], ssrc, RTCP_SDES_NAME);
68        ui_info_update_sdes(sp, "rtp.source.name", name, ssrc);
69}
70
71void ui_info_update_email(session_t *sp, u_int32 ssrc)
72{
73        const char *email = rtp_get_sdes(sp->rtp_session[0], ssrc, RTCP_SDES_EMAIL);
74        ui_info_update_sdes(sp, "rtp.source.email", email, ssrc);
75}
76
77void ui_info_update_phone(session_t *sp, u_int32 ssrc)
78{
79        const char *phone = rtp_get_sdes(sp->rtp_session[0], ssrc, RTCP_SDES_PHONE);
80        ui_info_update_sdes(sp, "rtp.source.phone", phone, ssrc);
81}
82
83void ui_info_update_loc(session_t *sp, u_int32 ssrc)
84{
85        const char *loc = rtp_get_sdes(sp->rtp_session[0], ssrc, RTCP_SDES_LOC);
86        ui_info_update_sdes(sp, "rtp.source.loc", loc, ssrc);
87}
88
89void ui_info_update_tool(session_t *sp, u_int32 ssrc)
90{
91        const char *tool = rtp_get_sdes(sp->rtp_session[0], ssrc, RTCP_SDES_TOOL);
92        ui_info_update_sdes(sp, "rtp.source.tool", tool, ssrc);
93}
94
95void ui_info_update_note(session_t *sp, u_int32 ssrc)
96{
97        const char *note = rtp_get_sdes(sp->rtp_session[0], ssrc, RTCP_SDES_NOTE);
98        ui_info_update_sdes(sp, "rtp.source.note", note, ssrc);
99}
100
101void 
102ui_info_gain(session_t *sp, u_int32 ssrc)
103{
104        pdb_entry_t *pdbe;
105        if (pdb_item_get(sp->pdb, ssrc, &pdbe)) {
106                mbus_qmsgf(sp->mbus_engine, mbus_name_ui, TRUE, "rtp.source.gain", "\"%08lx\" %.2f", pdbe->ssrc, pdbe->gain);
107        }
108}
109
110void
111ui_info_mute(session_t *sp, u_int32 ssrc)
112{
113        pdb_entry_t *pdbe;
114        if (pdb_item_get(sp->pdb, ssrc, &pdbe)) {
115                mbus_qmsgf(sp->mbus_engine, mbus_name_ui, TRUE, "rtp.source.mute", "\"%08lx\" %d", pdbe->ssrc, pdbe->mute);
116        }
117}
118
119void
120ui_info_remove(session_t *sp, u_int32 ssrc)
121{
122        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, TRUE, "rtp.source.remove", "\"%08lx\"", ssrc);
123}
124
125void
126ui_info_activate(session_t *sp, u_int32 ssrc)
127{
128        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, TRUE, "rtp.source.active", "\"%08lx\"", ssrc);
129}
130
131void
132ui_info_deactivate(session_t *sp, u_int32 ssrc)
133{
134        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, TRUE, "rtp.source.inactive", "\"%08lx\"", ssrc);
135}
136
137void
138ui_info_3d_settings(session_t *sp, u_int32 ssrc)
139{
140        char *filter_name;
141        int   azimuth, filter_type, filter_length;
142        pdb_entry_t *p;
143
144        if (pdb_item_get(sp->pdb, ssrc, &p) == FALSE) {
145                return;
146        }
147
148        if (p->render_3D_data == NULL) {
149                p->render_3D_data = render_3D_init(get_freq(sp->device_clock));
150        }
151
152        render_3D_get_parameters(p->render_3D_data, &azimuth, &filter_type, &filter_length);
153        filter_name = mbus_encode_str(render_3D_filter_get_name(filter_type));
154        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, TRUE, "tool.rat.3d.user.settings", "\"%08lx\" %s %d %d", ssrc, filter_name, filter_length, azimuth);
155        xfree(filter_name);
156}
157
158void
159ui_update_stats(session_t *sp, u_int32 ssrc)
160{
161        const rtcp_rr           *rr;
162        u_int32                  fract_lost, my_ssrc;
163        char                    *args, *mbes;
164        struct s_source         *src;
165        u_int32                  buffered, delay;
166        pdb_entry_t             *pdbe;
167
168        debug_msg("ui_update_stats (0x%08x)\n", ssrc);
169
170        if (pdb_item_get(sp->pdb, ssrc, &pdbe) == FALSE) {
171                debug_msg("ui_update_stats: pdb entry does not exist (0x%08x)\n", ssrc);
172                return;
173        }
174        pdbe->last_ui_update = sp->cur_ts;
175
176        if (pdbe->enc_fmt) {
177                mbes = mbus_encode_str(pdbe->enc_fmt);
178                args = (char *) xmalloc(strlen(mbes) + 12);
179                sprintf(args, "\"%08lx\" %s", pdbe->ssrc, mbes);
180                xfree(mbes);
181        } else {
182                args = (char *) xmalloc(19);
183                sprintf(args, "\"%08lx\" unknown", pdbe->ssrc);
184        }
185
186        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "rtp.source.codec", args, FALSE);
187
188        xfree(args);
189
190        src = source_get_by_ssrc(sp->active_sources, pdbe->ssrc);
191        if (src) {
192                buffered = ts_to_ms(source_get_audio_buffered(src, sp->cur_ts));
193                delay    = ts_to_ms(source_get_playout_delay(src));
194        } else {
195                buffered = 0;
196                delay    = 0;
197        }
198
199        debug_msg("buffer (%05d) calced (%05d)\n", buffered, delay);
200
201        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, FALSE, "tool.rat.audio.buffered", "\"%08lx\" %ld", pdbe->ssrc, buffered);
202        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, FALSE, "tool.rat.audio.delay", "\"%08lx\" %ld", pdbe->ssrc, delay);
203
204        my_ssrc = rtp_my_ssrc(sp->rtp_session[0]);
205        rr = rtp_get_rr(sp->rtp_session[0], pdbe->ssrc, my_ssrc);
206        if (rr != NULL) {
207                fract_lost = (rr->fract_lost * 100) >> 8;
208        } else {
209                fract_lost = 0;
210        }
211        ui_update_loss(sp, my_ssrc, pdbe->ssrc, fract_lost);
212        ui_update_reception(sp, pdbe->ssrc, pdbe->received, 0,
213                            pdbe->misordered, pdbe->duplicates,
214                            ts_to_ms(pdbe->jitter), 0);
215        ui_update_duration(sp, pdbe->ssrc, pdbe->inter_pkt_gap * 1000 / get_freq(pdbe->clock));
216}
217
218void
219ui_update_input_port(session_t *sp)
220{
221        const audio_port_details_t      *apd = NULL;
222        audio_port_t                     port;
223        char                            *mbes;
224        int                              i, n, found;
225       
226        port = audio_get_iport(sp->audio_device);
227
228        found = FALSE;
229        n = audio_get_iport_count(sp->audio_device);
230        for(i = 0; i < n; i++) {
231                apd = audio_get_iport_details(sp->audio_device, i);
232                if (apd->port == port) {
233                        found = TRUE;
234                        break;
235                }
236        }
237
238        if (found == FALSE) {
239                debug_msg("Port %d not found!\n", port);
240                apd = audio_get_iport_details(sp->audio_device, 0);
241        }
242
243        mbes = mbus_encode_str(apd->name);
244        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.input.port", mbes, TRUE);
245        xfree(mbes);
246
247        if (tx_is_sending(sp->tb)) {
248                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.input.mute", "0", TRUE);
249        } else {
250                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.input.mute", "1", TRUE);
251        }
252        ui_update_input_gain(sp);
253}
254
255void
256ui_update_output_port(session_t *sp)
257{
258        const audio_port_details_t      *apd = NULL;
259        audio_port_t                     port;
260        char                            *mbes;
261        int                              i, n, found;
262       
263        port = audio_get_oport(sp->audio_device);
264
265        found = FALSE;
266        n = audio_get_oport_count(sp->audio_device);
267        for(i = 0; i < n; i++) {
268                apd = audio_get_oport_details(sp->audio_device, i);
269                if (apd->port == port) {
270                        found = TRUE;
271                        break;
272                }
273        }
274
275        if (found == FALSE) {
276                debug_msg("Port %d not found!\n", port);
277                apd = audio_get_oport_details(sp->audio_device, 0);
278        }
279
280        mbes = mbus_encode_str(apd->name);
281
282        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.output.port", mbes, TRUE);
283        xfree(mbes);
284
285        if (sp->playing_audio) {
286                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.output.mute", "0", TRUE);
287        } else {
288                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.output.mute", "1", TRUE);
289        }
290        ui_update_output_gain(sp);
291}
292
293void
294ui_input_level(session_t *sp, int level)
295{
296        static int      ol;
297
298        assert(level>=0 && level <=100);
299
300        if (ol == level) {
301                return;
302        }
303
304        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, FALSE, "audio.input.powermeter", "%3d", level);
305        ol = level;
306}
307
308void
309ui_output_level(session_t *sp, int level)
310{
311        static int      ol;
312        assert(level>=0 && level <=100);
313
314        if (ol == level) {
315                return;
316        }
317
318        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, FALSE, "audio.output.powermeter", "%3d", level);
319        ol = level;
320}
321
322static void
323ui_repair(session_t *sp)
324{
325        const repair_details_t *d;
326        u_int16 i, n;
327        char    *mbes;
328
329        n = repair_get_count();
330        for (i = 0; i < n; i++) {
331                d = repair_get_details(i);
332                if (d->id == sp->repair) {
333                        mbes = mbus_encode_str(d->name);
334                        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.channel.repair", mbes, FALSE);
335                        xfree(mbes);
336                        break;
337                }
338        }
339}
340
341void
342ui_update_device_config(session_t *sp)
343{
344        char                     fmt_buf[64], *mbes;
345        const audio_format      *af;
346
347        af = audio_get_ifmt(sp->audio_device);
348        if (af && audio_format_name(af, fmt_buf, 64)) {
349                mbes = mbus_encode_str(fmt_buf);
350                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.format.in", mbes, TRUE);
351                xfree(mbes);
352        } else {
353                debug_msg("Could not get ifmt\n");
354        }
355}
356
357void
358ui_update_primary(session_t *sp)
359{
360        codec_id_t            pri_id;
361        const codec_format_t *pri_cf;
362        char *mbes;
363
364        pri_id = codec_get_by_payload(sp->encodings[0]);
365        pri_cf = codec_get_format(pri_id);
366        mbes = mbus_encode_str(pri_cf->short_name);
367        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.codec", mbes, FALSE);
368        xfree(mbes);
369}
370
371/*
372static void
373ui_update_interleaving(session_t *sp)
374{
375
376        int pt, isep, iu;
377        char buf[128], *sep=NULL, *units = NULL, *dummy;
378
379        pt = get_cc_pt(sp,"INTERLEAVER");
380        if (pt != -1) {
381                query_channel_coder(sp, pt, buf, 128);
382                dummy  = strtok(buf,"/");
383                units  = strtok(NULL,"/");
384                sep    = strtok(NULL,"/");
385        } else {
386                debug_msg("Could not find interleaving channel coder!\n");
387        }
388       
389        if (units != NULL && sep != NULL) {
390                iu   = atoi(units);
391                isep = atoi(sep);
392        } else {
393                iu   = 4;
394                isep = 4;
395        }
396
397        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, TRUE, "audio.channel.coding", "\"interleaved\" %d %d",iu, isep);
398
399        UNUSED(sp);
400}
401*/
402
403static void
404ui_update_redundancy(session_t *sp)
405{
406        const codec_format_t *scf;
407        codec_id_t            scid;
408        char *cmd, *out, *sec_enc, *sec_off, *mbes;
409       
410        int clen;
411
412        clen = 2 * (CODEC_LONG_NAME_LEN + 4) + 1;
413        cmd  = (char*)xmalloc(clen);
414
415        channel_encoder_get_parameters(sp->channel_coder, cmd, clen);
416       
417        sec_enc = (char *) strtok(cmd, "/");  /* ignore primary encoding   */
418        sec_enc = (char *) strtok(NULL, "/"); /* ignore primary offset     */
419        sec_enc = (char *) strtok(NULL, "/"); /* get secondary encoding    */
420        sec_off = (char *) strtok(NULL, "/"); /* get secondary offset      */
421
422        if (sec_enc == NULL || sec_off == NULL) {
423                goto redundancy_update_end;
424        }
425
426        scid    = codec_get_by_name(sec_enc);
427        if (!codec_id_is_valid(scid)) {
428                   goto redundancy_update_end;
429        }
430       
431        scf = codec_get_format(scid);
432        out = (char*)xmalloc(clen);
433
434        mbes = mbus_encode_str("redundancy");
435        sprintf(out, "%s ", mbes);
436        xfree(mbes);
437
438        mbes = mbus_encode_str(scf->short_name);
439        strcat(out, mbes);
440        xfree(mbes);
441
442        strcat(out, " ");
443        strcat(out, sec_off);
444        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.channel.coding", out, TRUE);
445        xfree(out);
446
447redundancy_update_end:
448        xfree(cmd);
449}
450
451static void
452ui_update_layering(session_t *sp)
453{
454        const codec_format_t *lcf;
455        codec_id_t            lcid;
456        char *cmd, *out, *sec_enc, *layerenc, *mbes;
457       
458        int clen;
459
460        clen = 2 * (CODEC_LONG_NAME_LEN + 4) + 1;
461        cmd  = (char*)xmalloc(clen);
462
463        channel_encoder_get_parameters(sp->channel_coder, cmd, clen);
464       
465        sec_enc = (char *) strtok(cmd, "/");
466        layerenc = (char *) strtok(NULL, "/");
467
468        if (sec_enc == NULL || layerenc == NULL) {
469                goto layering_update_end;
470        }
471
472        lcid    = codec_get_by_name(sec_enc);
473        if (!codec_id_is_valid(lcid)) {
474                   goto layering_update_end;
475        }
476       
477        lcf = codec_get_format(lcid);
478        out = (char*)xmalloc(clen);
479
480        mbes = mbus_encode_str("layering");
481        sprintf(out, "%s ", mbes);
482        xfree(mbes);
483
484        mbes = mbus_encode_str(lcf->short_name);
485        strcat(out, mbes);
486        xfree(mbes);
487
488        strcat(out, " ");
489        strcat(out, layerenc);
490        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.channel.coding", out, TRUE);
491        xfree(out);
492
493layering_update_end:
494        xfree(cmd);
495}
496
497void 
498ui_update_channel(session_t *sp)
499{
500        const cc_details_t *ccd;
501        char *mbes;
502
503        ccd = channel_get_coder_identity(sp->channel_coder);
504        switch(tolower(ccd->name[0])) {
505        case 'n':
506                mbes = mbus_encode_str("none");
507                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.channel.coding", mbes, TRUE);
508                xfree(mbes);
509                debug_msg("ui_update_channel: n\n");
510                break;
511        case 'r':
512                ui_update_redundancy(sp);
513                debug_msg("ui_update_channel: r\n");
514                break;
515        case 'l':
516                ui_update_layering(sp);
517                debug_msg("ui_update_channel: l\n");
518                break;
519        }
520        return;
521}
522
523void
524ui_update_input_gain(session_t *sp)
525{
526        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, TRUE, "audio.input.gain", "%3d", audio_get_igain(sp->audio_device));
527}
528
529void
530ui_update_output_gain(session_t *sp)
531{
532        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, TRUE, "audio.output.gain", "%3d", audio_get_ogain(sp->audio_device));
533}
534
535static void
536ui_update_3d_enabled(session_t *sp)
537{
538        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, TRUE, "tool.rat.3d.enabled", "%d", (sp->render_3d ? 1 : 0));
539}
540
541static void
542ui_input_ports(session_t *sp)
543{
544        const audio_port_details_t *apd;
545        char *mbes;
546        int i, n;
547       
548        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.input.ports.flush", "", TRUE);
549
550        n = audio_get_iport_count(sp->audio_device);
551        assert(n >= 1);
552
553        for(i = 0; i < n; i++) {
554                apd = audio_get_iport_details(sp->audio_device, i);
555                mbes = mbus_encode_str(apd->name);
556                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.input.ports.add", mbes, TRUE);
557                xfree(mbes);
558        }
559}
560
561static void
562ui_output_ports(session_t *sp)
563{
564        const audio_port_details_t *apd;
565        char *mbes;
566        int i, n;
567       
568        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.output.ports.flush", "", TRUE);
569
570        n = audio_get_oport_count(sp->audio_device);
571        assert(n >= 1);
572
573        for(i = 0; i < n; i++) {
574                apd = audio_get_oport_details(sp->audio_device, i);
575                mbes = mbus_encode_str(apd->name);
576                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.output.ports.add", mbes, TRUE);
577                xfree(mbes);
578        }
579}
580
581static void
582ui_devices(session_t *sp)
583{
584        const audio_device_details_t *add;
585        char *mbes, dev_name[AUDIO_DEVICE_NAME_LENGTH];
586        int i,nDev;
587
588        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.devices.flush", "", TRUE);
589        nDev = audio_get_device_count();
590
591        for(i = 0; i < nDev; i++) {
592                add  = audio_get_device_details(i);
593                strcpy(dev_name, add->name);
594                purge_chars(dev_name, "[]()");
595                mbes = mbus_encode_str(dev_name);
596                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.devices.add", mbes, TRUE);
597                xfree(mbes);
598        }
599}
600
601static void
602ui_device(session_t *sp)
603{
604        const audio_device_details_t *add;
605        char                         *mbes;
606        u_int32                       i, n;
607
608        n = audio_get_device_count();
609        for(i = 0; i < n; i++) {
610                add = audio_get_device_details(i);
611                if (sp->audio_device == add->descriptor) {
612                        break;
613                }
614        }
615
616        if (i != n) {
617                char dev_name[AUDIO_DEVICE_NAME_LENGTH];
618                strcpy(dev_name, add->name);
619                purge_chars(dev_name, "()[]");
620                mbes = mbus_encode_str(dev_name);
621                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.device", mbes, TRUE);
622                xfree(mbes);
623                ui_input_ports(sp);
624                ui_output_ports(sp);
625        }
626}
627
628static void
629ui_sampling_modes(session_t *sp)
630{
631        char    *mbes;
632        char    modes[255]="";
633        char    tmp[22];
634        u_int16 rate, channels, support, zap;
635       
636        for(rate = 8000; rate <=48000; rate += 8000) {
637                support = 0;
638                if (rate == 24000 || rate == 40000) continue;
639                for(channels = 1; channels <= 2; channels++) {
640                        if (audio_device_supports(sp->audio_device, rate, channels)) support += channels;
641                }
642                switch(support) {
643                case 3: sprintf(tmp, "%d-kHz,Mono,Stereo ", rate/1000); break;
644                case 2: sprintf(tmp, "%d-kHz,Stereo ", rate/1000);      break;
645                case 1: sprintf(tmp, "%d-kHz,Mono ", rate/1000);        break;
646                case 0: continue;
647                }
648                strcat(modes, tmp);
649        }
650
651        /* Remove trailing space */
652        zap = strlen(modes);
653        if (zap) {
654                zap -= 1;
655                modes[zap] = '\0';
656        }
657
658        mbes = mbus_encode_str(modes);
659        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.sampling.supported", mbes, TRUE);
660        xfree(mbes);
661}
662
663void
664ui_update(session_t *sp)
665{
666        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, TRUE, "tool.rat.rate", "%3d", channel_encoder_get_units_per_packet(sp->channel_coder));
667       
668        ui_devices(sp);
669        ui_device(sp);
670        ui_update_input_gain(sp);
671        ui_update_output_gain(sp);
672        ui_input_ports(sp);
673        ui_output_ports(sp);
674        ui_update_output_port(sp);
675        ui_update_input_port(sp);
676        ui_update_3d_enabled(sp);
677        ui_sampling_modes(sp);
678        ui_update_device_config(sp);
679        ui_update_primary(sp);
680        ui_update_channel(sp);
681        ui_repair(sp);
682}
683
684void
685ui_show_audio_busy(session_t *sp)
686{
687        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.disable.audio.ctls", "", TRUE);
688}
689
690void
691ui_hide_audio_busy(session_t *sp)
692{
693        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.enable.audio.ctls", "", TRUE);
694}
695
696void
697ui_update_lecture_mode(session_t *sp)
698{
699        /* Update the UI to reflect the lecture mode setting...*/
700        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, TRUE, "tool.rat.lecture.mode", "%1d", sp->lecture);
701}
702
703void
704ui_update_powermeters(session_t *sp, struct s_mix_info *ms, int elapsed_time)
705{
706        static u_int32 power_time = 0;
707
708        if (power_time > sp->meter_period) {
709                if (sp->meter && (ms != NULL)) {
710                        mix_update_ui(sp, ms);
711                }
712                if (tx_is_sending(sp->tb)) {
713                        tx_update_ui(sp->tb);
714                }
715                power_time = 0;
716        } else {
717                power_time += elapsed_time;
718        }
719}
720
721void
722ui_update_loss(session_t *sp, u_int32 srce, u_int32 dest, int loss)
723{
724        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, FALSE, "rtp.source.packet.loss", "\"%08lx\" \"%08lx\" %3d", srce, dest, loss);
725}
726
727void
728ui_update_reception(session_t *sp, u_int32 ssrc, u_int32 recv, u_int32 lost, u_int32 misordered, u_int32 duplicates, u_int32 jitter, int jit_tog)
729{
730        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, FALSE, "rtp.source.reception", "\"%08lx\" %6ld %6ld %6ld %6ld %6ld %6d",
731                  ssrc, recv, lost, misordered, duplicates, jitter, jit_tog);
732}
733
734void
735ui_update_duration(session_t *sp, u_int32 ssrc, int duration)
736{
737        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, FALSE, "rtp.source.packet.duration", "\"%08lx\" %3d", ssrc, duration);
738}
739
740void 
741ui_update_video_playout(session_t *sp, u_int32 ssrc, int playout)
742{
743        const char *cname = rtp_get_sdes(sp->rtp_session[0], ssrc, RTCP_SDES_CNAME);
744        char *arg = mbus_encode_str(cname);
745        mbus_qmsgf(sp->mbus_engine, mbus_name_video, FALSE, "rtp.source.cname",   "\"%08lx\" %s",   ssrc, arg);
746        mbus_qmsgf(sp->mbus_engine, mbus_name_video, FALSE, "rtp.source.playout", "\"%08lx\" %12d", ssrc, playout);
747        xfree(arg);
748}
749
750void
751ui_update_key(session_t *sp, char *key)
752{
753        char    *key_e;
754
755        key_e = mbus_encode_str(key);
756        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "security.encryption.key", key_e, TRUE);
757        xfree(key_e);
758}
759
760void
761ui_update_codec(session_t *sp, codec_id_t cid)
762{
763        char                    *caps, *long_name_e, *short_name_e, *pay_e, *descr_e;
764        int                      can_enc, can_dec, layers;
765        char                     pay[4];
766        u_char                   pt;
767        const codec_format_t    *cf;
768       
769        cf  = codec_get_format(cid);
770        assert(cf != NULL);
771
772        can_enc = codec_can_encode(cid);
773        can_dec = codec_can_decode(cid);
774
775        caps = NULL;
776        if (can_enc && can_dec) {
777                caps = mbus_encode_str("Encode and decode");
778        } else if (can_enc) {
779                caps = mbus_encode_str("Encode only");
780        } else if (can_dec) {
781                caps = mbus_encode_str("Decode only");
782        } else {
783                caps = mbus_encode_str("Not available");
784        }
785
786        pt = codec_get_payload(cid);
787        if (payload_is_valid(pt)) {
788                sprintf(pay, "%d", pt);
789        } else {
790                sprintf(pay, "-");
791        }
792        pay_e        = mbus_encode_str(pay);
793        long_name_e  = mbus_encode_str(cf->long_name);
794        short_name_e = mbus_encode_str(cf->short_name);
795        descr_e      = mbus_encode_str(cf->description);
796        layers       = codec_can_layer(cid);
797
798        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, TRUE,
799                   "tool.rat.codec.details",
800                   "%s %s %s %d %d %d %d %d %s %s %d",
801                   pay_e,
802                   long_name_e,
803                   short_name_e,
804                   cf->format.channels,
805                   cf->format.sample_rate,
806                   cf->format.bytes_per_block,
807                   cf->mean_per_packet_state_size,
808                   cf->mean_coded_frame_size,
809                   descr_e,
810                   caps,
811                   layers);
812        xfree(caps);
813        xfree(pay_e);
814        xfree(long_name_e);
815        xfree(short_name_e);
816        xfree(descr_e);
817}
818
819static void
820ui_codecs(session_t *sp)
821{
822        u_int32 nCodecs, iCodec;
823        codec_id_t cid;
824
825        nCodecs = codec_get_number_of_codecs();
826
827        for(iCodec = 0; iCodec < nCodecs; iCodec++) {
828                cid = codec_get_codec_number(iCodec);
829                if (cid) ui_update_codec(sp, cid);
830        }
831}
832
833void
834ui_update_playback_file(session_t *sp, char *name)
835{
836        char *mbes;
837        mbes = mbus_encode_str(name);
838        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.file.play.ready", mbes, TRUE);
839        xfree(mbes);
840}
841
842void
843ui_update_record_file(session_t *sp, char *name)
844{
845        char *mbes;
846        mbes = mbus_encode_str(name);
847        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.file.record.ready", mbes, TRUE);
848        xfree(mbes);
849}
850
851void
852ui_update_file_live(session_t *sp, char *mode, int valid)
853{
854        char cmd[32], arg[2];
855       
856        assert(!strcmp(mode, "play") || !strcmp(mode, "record"));
857       
858        sprintf(cmd, "audio.file.%s.alive", mode);
859        sprintf(arg, "%1d", valid);
860        mbus_qmsg(sp->mbus_engine, mbus_name_ui, cmd, arg, TRUE);
861}
862
863static void 
864ui_converters(session_t *sp)
865{
866        const converter_details_t *details;
867        char *mbes;
868        int i, cnt;
869
870        cnt = converter_get_count();
871
872        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.converters.flush", "", TRUE);
873
874        for (i = 0; i < cnt; i++) {
875                details = converter_get_details(i);
876                mbes = mbus_encode_str(details->name);
877                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.converters.add", mbes, TRUE);
878                xfree(mbes);
879        }
880}
881
882void
883ui_update_converter(session_t *sp)
884{
885        const converter_details_t *details;
886        char *mbes;
887        int i, cnt;
888
889        cnt = converter_get_count();
890
891        for(i = 0; i < cnt; i++) {
892                details = converter_get_details(i);
893                if (sp->converter == details->id) {
894                        mbes = mbus_encode_str(details->name);
895                        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.converter", mbes, TRUE);
896                        xfree(mbes);
897                        return;
898                }
899        }
900}
901
902static void
903ui_repair_schemes(session_t *sp)
904{
905        const repair_details_t *r;
906        char *mbes;
907        u_int16 i, n;
908       
909        n = repair_get_count();
910        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.repairs.flush", "", TRUE);
911
912        for(i = 0; i < n; i++) {
913                r = repair_get_details(i);
914                mbes = mbus_encode_str(r->name);
915                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.repairs.add", mbes, TRUE);
916                xfree(mbes);
917        }
918}
919
920void
921ui_update_repair(session_t *sp)
922{
923        const repair_details_t *r;
924        u_int16 i, n;
925        char *mbes;
926
927        n = repair_get_count();
928        for (i = 0; i < n; i++) {
929                r = repair_get_details(i);
930                if (sp->repair == i) {
931                        mbes = mbus_encode_str(r->name);
932                        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.repair", mbes, TRUE);
933                        xfree(mbes);
934                        return;
935                }
936        }
937        debug_msg("Repair not found\n");
938}
939
940void
941ui_controller_init(session_t *sp, char *name_engine, char *name_ui, char *name_video)
942{
943        char    my_ssrc[11];
944
945        mbus_name_engine = name_engine;
946        mbus_name_ui     = name_ui;
947        mbus_name_video  = name_video;
948
949        sprintf(my_ssrc, "\"%08lx\"", rtp_my_ssrc(sp->rtp_session[0]));
950        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "rtp.ssrc", my_ssrc, TRUE);
951}
952
953static void
954ui_title(session_t *sp)
955{
956        char    *addr, *title;
957
958        title = mbus_encode_str(sp->title);
959        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "session.title", title, TRUE);
960        xfree(title);
961
962        addr = mbus_encode_str(sp->asc_address[0]);
963        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, TRUE, "session.address", "%s %5d %3d", addr, sp->rx_rtp_port[0], sp->ttl);
964        xfree(addr);
965}
966
967/* ui_final_settings: so we here we load things that get broken
968 * because we open null audio device first, and it has limited no of
969 * input and output ports. 
970 */
971
972void
973ui_final_settings(session_t *sp)
974{
975        int i, n;
976        char *mbes;
977        const char *settings[] = {
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        };
985       
986        n = sizeof(settings)/sizeof(settings[0]);
987        for(i = 0; i < n; i++) {
988                mbes = mbus_encode_str(settings[i]);
989                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.load.setting", mbes, TRUE);
990                xfree(mbes);
991        }
992}
993
994static void
995ui_3d_options(session_t *sp)
996{
997        char args[256], tmp[5];
998        char *mbes;
999        int i, cnt;
1000
1001        args[0] = '\0';
1002        cnt = render_3D_filter_get_count();
1003        for(i = 0; i < cnt; i++) {
1004                strcat(args, render_3D_filter_get_name(i));
1005                if (i != cnt - 1) strcat(args, ",");
1006        }
1007
1008        mbes = mbus_encode_str(args);
1009        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.3d.filter.types", mbes, TRUE);
1010        xfree(mbes);
1011
1012        args[0] = '\0';
1013        cnt = render_3D_filter_get_lengths_count();
1014        for(i = 0; i < cnt; i++) {
1015                sprintf(tmp, "%d", render_3D_filter_get_length(i));
1016                strcat(args, tmp);
1017                if (i != cnt - 1) strcat(args, ",");
1018        }
1019       
1020        mbes = mbus_encode_str(args);
1021        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.3d.filter.lengths", mbes, TRUE);
1022        xfree(mbes);
1023
1024        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, TRUE, "tool.rat.3d.azimuth.min", "%d", render_3D_filter_get_lower_azimuth());
1025        mbus_qmsgf(sp->mbus_engine, mbus_name_ui, TRUE, "tool.rat.3d.azimuth.max", "%d", render_3D_filter_get_upper_azimuth());
1026}
1027
1028static void
1029ui_update_options(session_t *sp)
1030{
1031        if (sp->meter) {
1032                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.powermeter", "1", TRUE);
1033        } else {
1034                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.powermeter", "0", TRUE);
1035        }
1036        if (sp->sync_on) {
1037                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.sync", "1", TRUE);
1038        } else {
1039                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.sync", "0", TRUE);
1040        }
1041}
1042
1043void
1044ui_initial_settings(session_t *sp)
1045{
1046        u_int32 my_ssrc = rtp_my_ssrc(sp->rtp_session[0]);
1047        /* One off setting transfers / initialization */
1048        ui_sampling_modes(sp);                  network_process_mbus(sp);
1049        ui_converters(sp);                      network_process_mbus(sp);
1050        ui_repair_schemes(sp);                  network_process_mbus(sp);
1051        ui_codecs(sp);                          network_process_mbus(sp);
1052        ui_3d_options(sp);                      network_process_mbus(sp);
1053        ui_info_update_cname(sp, my_ssrc);      network_process_mbus(sp);
1054        ui_info_update_name(sp,  my_ssrc);      network_process_mbus(sp);
1055        ui_info_update_email(sp, my_ssrc);      network_process_mbus(sp);
1056        ui_info_update_phone(sp, my_ssrc);      network_process_mbus(sp);
1057        ui_info_update_loc(sp,   my_ssrc);      network_process_mbus(sp);
1058        ui_info_update_tool(sp,  my_ssrc);      network_process_mbus(sp);
1059        ui_title(sp);                           network_process_mbus(sp);
1060        ui_update_options(sp);                  network_process_mbus(sp);
1061#ifdef NDEF /* This is done by load_settings() now... */
1062        ui_load_settings(sp);                   network_process_mbus(sp);
1063#endif
1064}
1065
1066void 
1067ui_quit(session_t *sp)
1068{
1069        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "mbus.quit", "", TRUE);
1070}
Note: See TracBrowser for help on using the browser.