root/rat/trunk/ui.c @ 2792

Revision 2792, 31.0 KB (checked in by ucacoxh, 15 years ago)

- Add loss reporting.
- Fixes for optimizer.

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