Changeset 2234

Show
Ignore:
Timestamp:
02/18/99 14:11:06 (15 years ago)
Author:
ucaccsp
Message:

Remove support for multiple mbus channels. Note that the session struct has
changed, so you'll have to make clean.

Location:
rat/trunk
Files:
8 modified

Legend:

Unmodified
Added
Removed
  • rat/trunk/main.c

    r2231 r2234  
    121121        if (sp[0]->mode == AUDIO_TOOL) { 
    122122                sprintf(mbus_engine_addr, "(audio engine rat %lu)", (u_int32) getpid()); 
    123                 sp[0]->mbus_engine_base = mbus_init(0, mbus_engine_rx, NULL);  
    124                 mbus_addr(sp[0]->mbus_engine_base, mbus_engine_addr); 
    125                 if (sp[0]->mbus_channel == 0) { 
    126                         sp[0]->mbus_engine_conf = sp[0]->mbus_engine_base; 
    127                 } else { 
    128                         sp[0]->mbus_engine_conf = mbus_init((short)sp[0]->mbus_channel, mbus_engine_rx, NULL);  
    129                         mbus_addr(sp[0]->mbus_engine_conf, mbus_engine_addr); 
    130                 } 
     123                sp[0]->mbus_engine = mbus_init(0, mbus_engine_rx, NULL);  
     124                mbus_addr(sp[0]->mbus_engine, mbus_engine_addr); 
    131125 
    132126                if (sp[0]->ui_on) { 
    133127                        sprintf(mbus_ui_addr, "(audio ui rat %lu)", (u_int32) getpid()); 
    134                         sp[0]->mbus_ui_base = mbus_init(0, mbus_ui_rx, NULL); 
    135                         mbus_addr(sp[0]->mbus_ui_base, mbus_ui_addr); 
    136                         if (sp[0]->mbus_channel == 0) { 
    137                                 sp[0]->mbus_ui_conf = sp[0]->mbus_ui_base; 
    138                         } else { 
    139                                 sp[0]->mbus_ui_conf = mbus_init((short)sp[0]->mbus_channel, mbus_ui_rx, NULL); 
    140                                 mbus_addr(sp[0]->mbus_ui_conf, mbus_ui_addr); 
    141                         } 
     128                        sp[0]->mbus_ui = mbus_init(0, mbus_ui_rx, NULL); 
     129                        mbus_addr(sp[0]->mbus_ui, mbus_ui_addr); 
    142130                        tcl_init(sp[0], argc, argv, mbus_engine_addr); 
    143131                } else { 
     
    154142        do { 
    155143                network_process_mbus(sp[0]); 
    156                 mbus_heartbeat(sp[0]->mbus_engine_base, 1); 
     144                mbus_heartbeat(sp[0]->mbus_engine, 1); 
    157145                usleep(20000); 
    158146        } while (sp[0]->wait_on_startup); 
     
    273261                        if (sp[i]->ui_on) { 
    274262                                tcl_process_events(sp[i]); 
    275                                 mbus_send(sp[i]->mbus_ui_base); mbus_retransmit(sp[i]->mbus_ui_base); 
    276                                 mbus_send(sp[i]->mbus_ui_conf); mbus_retransmit(sp[i]->mbus_ui_conf); 
     263                                mbus_send(sp[i]->mbus_ui); mbus_retransmit(sp[i]->mbus_ui); 
    277264                        } 
    278                         mbus_retransmit(sp[i]->mbus_engine_base); 
    279                         mbus_retransmit(sp[i]->mbus_engine_conf); 
    280                         mbus_send(sp[i]->mbus_engine_base);  
    281                         mbus_send(sp[i]->mbus_engine_conf);  
    282                         mbus_recv(sp[i]->mbus_engine_base, (void *) sp[i]); 
    283                         mbus_recv(sp[i]->mbus_ui_base    , (void *) sp[i]); 
    284                         if (sp[i]->mbus_channel != 0) { 
    285                                 mbus_recv(sp[i]->mbus_engine_conf, (void *) sp[i]); 
    286                                 mbus_recv(sp[i]->mbus_ui_conf    , (void *) sp[i]); 
    287                         } 
    288                         mbus_heartbeat(sp[i]->mbus_engine_base, 10); 
     265                        mbus_retransmit(sp[i]->mbus_engine); 
     266                        mbus_send(sp[i]->mbus_engine);  
     267                        mbus_recv(sp[i]->mbus_engine, (void *) sp[i]); 
     268                        mbus_recv(sp[i]->mbus_ui    , (void *) sp[i]); 
     269                        mbus_heartbeat(sp[i]->mbus_engine, 10); 
    289270 
    290271                        /* wait for mbus messages - closing audio device 
     
    314295 
    315296        if (sp[0]->mode == AUDIO_TOOL) { 
    316                 if (sp[0]->mbus_engine_conf != sp[0]->mbus_engine_base) { 
    317                         mbus_exit(sp[0]->mbus_engine_conf); 
    318                 } 
    319                 mbus_exit(sp[0]->mbus_engine_base); 
    320  
     297                mbus_exit(sp[0]->mbus_engine); 
    321298                if (sp[0]->ui_on) { 
    322                         if (sp[0]->mbus_ui_base != sp[0]->mbus_ui_base) { 
    323                                 mbus_exit(sp[0]->mbus_ui_conf); 
    324                         } 
    325                         mbus_exit(sp[0]->mbus_ui_base); 
     299                        mbus_exit(sp[0]->mbus_ui); 
    326300                } 
    327301        } 
  • rat/trunk/mbus_engine.c

    r2220 r2234  
    103103        UNUSED(srce); 
    104104 
    105         mbus_parse_init(sp->mbus_engine_conf, args); 
    106         if (mbus_parse_int(sp->mbus_engine_conf, &i)) { 
     105        mbus_parse_init(sp->mbus_engine, args); 
     106        if (mbus_parse_int(sp->mbus_engine, &i)) { 
    107107                sp->meter = i; 
    108108                ui_input_level(sp, 0); 
     
    111111                printf("mbus: usage \"tool.rat.powermeter <boolean>\"\n"); 
    112112        } 
    113         mbus_parse_done(sp->mbus_engine_conf); 
     113        mbus_parse_done(sp->mbus_engine); 
    114114} 
    115115 
     
    120120        UNUSED(srce); 
    121121 
    122         mbus_parse_init(sp->mbus_engine_conf, args); 
    123         if (mbus_parse_int(sp->mbus_engine_conf, &i)) { 
     122        mbus_parse_init(sp->mbus_engine, args); 
     123        if (mbus_parse_int(sp->mbus_engine, &i)) { 
    124124                sp->detect_silence = i; 
    125125        } else { 
    126126                printf("mbus: usage \"tool.rat.silence <boolean>\"\n"); 
    127127        } 
    128         mbus_parse_done(sp->mbus_engine_conf); 
     128        mbus_parse_done(sp->mbus_engine); 
    129129} 
    130130 
     
    135135        UNUSED(srce); 
    136136 
    137         mbus_parse_init(sp->mbus_engine_conf, args); 
    138         if (mbus_parse_int(sp->mbus_engine_conf, &i)) { 
     137        mbus_parse_init(sp->mbus_engine, args); 
     138        if (mbus_parse_int(sp->mbus_engine, &i)) { 
    139139                sp->render_3d = (i ? 1 : 0); 
    140140        } else { 
    141141                printf("mbus: usage \"tool.rat.3d.enabled <boolean>\"\n"); 
    142142        } 
    143         mbus_parse_done(sp->mbus_engine_conf); 
     143        mbus_parse_done(sp->mbus_engine); 
    144144} 
    145145 
     
    152152        UNUSED(srce); 
    153153 
    154         mbus_parse_init(sp->mbus_engine_conf, args); 
    155         if (mbus_parse_str(sp->mbus_engine_conf, &cname) && 
    156             mbus_parse_str(sp->mbus_engine_conf, &filter_name) && 
    157             mbus_parse_int(sp->mbus_engine_conf, &filter_length) && 
    158             mbus_parse_int(sp->mbus_engine_conf, &azimuth)) { 
     154        mbus_parse_init(sp->mbus_engine, args); 
     155        if (mbus_parse_str(sp->mbus_engine, &cname) && 
     156            mbus_parse_str(sp->mbus_engine, &filter_name) && 
     157            mbus_parse_int(sp->mbus_engine, &filter_length) && 
     158            mbus_parse_int(sp->mbus_engine, &azimuth)) { 
    159159 
    160160                mbus_decode_str(cname); 
     
    173173                printf("mbus: usage \"tool.rat.3d.user.settings <cname> <filter name> <filter len> <azimuth>\"\n"); 
    174174        } 
    175         mbus_parse_done(sp->mbus_engine_conf); 
     175        mbus_parse_done(sp->mbus_engine); 
    176176} 
    177177 
     
    184184        UNUSED(srce); 
    185185 
    186         mbus_parse_init(sp->mbus_engine_conf, args); 
    187         if (mbus_parse_str(sp->mbus_engine_conf, &cname)) { 
     186        mbus_parse_init(sp->mbus_engine, args); 
     187        if (mbus_parse_str(sp->mbus_engine, &cname)) { 
    188188                mbus_decode_str(cname); 
    189189                e = rtcp_get_dbentry_by_cname(sp, cname); 
    190190        } 
    191         mbus_parse_done(sp->mbus_engine_conf); 
     191        mbus_parse_done(sp->mbus_engine); 
    192192 
    193193        if (e) { 
     
    204204        UNUSED(srce); 
    205205 
    206         mbus_parse_init(sp->mbus_engine_conf, args); 
    207         if (mbus_parse_int(sp->mbus_engine_conf, &i)) { 
     206        mbus_parse_init(sp->mbus_engine, args); 
     207        if (mbus_parse_int(sp->mbus_engine, &i)) { 
    208208                sp->lecture = i; 
    209209        } else { 
    210210                printf("mbus: usage \"tool.rat.lecture <boolean>\"\n"); 
    211211        } 
    212         mbus_parse_done(sp->mbus_engine_conf); 
     212        mbus_parse_done(sp->mbus_engine); 
    213213} 
    214214 
     
    219219        UNUSED(srce); 
    220220 
    221         mbus_parse_init(sp->mbus_engine_conf, args); 
    222         if (mbus_parse_int(sp->mbus_engine_conf, &i)) { 
    223                 if (sp->mbus_channel != 0) { 
    224                         sp->sync_on = i; 
    225                 } else { 
    226                         ui_update_sync(sp, FALSE); 
    227                 } 
     221        mbus_parse_init(sp->mbus_engine, args); 
     222        if (mbus_parse_int(sp->mbus_engine, &i)) { 
     223                sp->sync_on = i; 
    228224        } else { 
    229225                printf("mbus: usage \"tool.rat.sync <boolean>\"\n"); 
    230226        } 
    231         mbus_parse_done(sp->mbus_engine_conf); 
     227        mbus_parse_done(sp->mbus_engine); 
    232228} 
    233229 
     
    238234        UNUSED(srce); 
    239235 
    240         mbus_parse_init(sp->mbus_engine_conf, args); 
    241         if (mbus_parse_int(sp->mbus_engine_conf, &i)) { 
     236        mbus_parse_init(sp->mbus_engine, args); 
     237        if (mbus_parse_int(sp->mbus_engine, &i)) { 
    242238                sp->agc_on = i; 
    243239        } else { 
    244240                printf("mbus: usage \"tool.rat.agc <boolean>\"\n"); 
    245241        } 
    246         mbus_parse_done(sp->mbus_engine_conf); 
     242        mbus_parse_done(sp->mbus_engine); 
    247243} 
    248244 
     
    253249        UNUSED(srce); 
    254250 
    255         mbus_parse_init(sp->mbus_engine_conf, args); 
    256         if (mbus_parse_int(sp->mbus_engine_conf, &i)) { 
     251        mbus_parse_init(sp->mbus_engine, args); 
     252        if (mbus_parse_int(sp->mbus_engine, &i)) { 
    257253                if (i) { 
    258254                        audio_loopback(sp->audio_device, 100); 
     
    263259                printf("mbus: usage \"tool.rat.audio.loopback <boolean>\"\n"); 
    264260        } 
    265         mbus_parse_done(sp->mbus_engine_conf); 
     261        mbus_parse_done(sp->mbus_engine); 
    266262} 
    267263 
     
    272268        UNUSED(srce); 
    273269 
    274         mbus_parse_init(sp->mbus_engine_conf, args); 
    275         if (mbus_parse_int(sp->mbus_engine_conf, &i)) { 
     270        mbus_parse_init(sp->mbus_engine, args); 
     271        if (mbus_parse_int(sp->mbus_engine, &i)) { 
    276272                sp->echo_suppress = i; 
    277273                if (sp->echo_suppress) { 
     
    281277                printf("mbus: usage \"tool.rat.echo.suppress <boolean>\"\n"); 
    282278        } 
    283         mbus_parse_done(sp->mbus_engine_conf); 
     279        mbus_parse_done(sp->mbus_engine); 
    284280} 
    285281 
     
    290286        UNUSED(srce); 
    291287 
    292         mbus_parse_init(sp->mbus_engine_conf, args); 
    293         if (mbus_parse_int(sp->mbus_engine_conf, &i)) { 
     288        mbus_parse_init(sp->mbus_engine, args); 
     289        if (mbus_parse_int(sp->mbus_engine, &i)) { 
    294290                assert(sp->channel_coder != NULL); 
    295291                channel_encoder_set_units_per_packet(sp->channel_coder, (u_int16)i); 
     
    297293                printf("mbus: usage \"tool.rat.rate <integer>\"\n"); 
    298294        } 
    299         mbus_parse_done(sp->mbus_engine_conf); 
     295        mbus_parse_done(sp->mbus_engine); 
    300296} 
    301297 
     
    306302        UNUSED(srce); 
    307303 
    308         mbus_parse_init(sp->mbus_engine_conf, args); 
    309         if (mbus_parse_int(sp->mbus_engine_conf, &i)) { 
     304        mbus_parse_init(sp->mbus_engine, args); 
     305        if (mbus_parse_int(sp->mbus_engine, &i)) { 
    310306                if (i) { 
    311307                        if (tx_is_sending(sp->tb)) { 
     
    322318                printf("mbus: usage \"audio.input.mute <boolean>\"\n"); 
    323319        } 
    324         mbus_parse_done(sp->mbus_engine_conf); 
     320        mbus_parse_done(sp->mbus_engine); 
    325321} 
    326322 
     
    331327        UNUSED(srce); 
    332328 
    333         mbus_parse_init(sp->mbus_engine_conf, args); 
    334         if (mbus_parse_int(sp->mbus_engine_conf, &i)) { 
     329        mbus_parse_init(sp->mbus_engine, args); 
     330        if (mbus_parse_int(sp->mbus_engine, &i)) { 
    335331                sp->input_gain = i; 
    336332                audio_set_gain(sp->audio_device, sp->input_gain); 
     
    339335                printf("mbus: usage \"audio.input.gain <integer>\"\n"); 
    340336        } 
    341         mbus_parse_done(sp->mbus_engine_conf); 
     337        mbus_parse_done(sp->mbus_engine); 
    342338} 
    343339 
     
    348344        UNUSED(srce); 
    349345 
    350         mbus_parse_init(sp->mbus_engine_conf, args); 
    351         if (mbus_parse_str(sp->mbus_engine_conf, &s)) { 
     346        mbus_parse_init(sp->mbus_engine, args); 
     347        if (mbus_parse_str(sp->mbus_engine, &s)) { 
    352348                s = mbus_decode_str(s); 
    353349                if (strcmp(s, "microphone") == 0) { 
     
    366362                debug_msg("mbus: usage \"audio.input.port <port>\"\n"); 
    367363        } 
    368         mbus_parse_done(sp->mbus_engine_conf); 
     364        mbus_parse_done(sp->mbus_engine); 
    369365} 
    370366 
     
    375371        UNUSED(srce); 
    376372 
    377         mbus_parse_init(sp->mbus_engine_conf, args); 
    378         if (mbus_parse_int(sp->mbus_engine_conf, &i)) { 
     373        mbus_parse_init(sp->mbus_engine, args); 
     374        if (mbus_parse_int(sp->mbus_engine, &i)) { 
    379375                sp->playing_audio = !i;  
    380376                ui_update_output_port(sp); 
     
    382378                printf("mbus: usage \"audio.output.mute <boolean>\"\n"); 
    383379        } 
    384         mbus_parse_done(sp->mbus_engine_conf); 
     380        mbus_parse_done(sp->mbus_engine); 
    385381} 
    386382 
     
    391387        UNUSED(srce); 
    392388 
    393         mbus_parse_init(sp->mbus_engine_conf, args); 
    394         if (mbus_parse_int(sp->mbus_engine_conf, &i)) { 
     389        mbus_parse_init(sp->mbus_engine, args); 
     390        if (mbus_parse_int(sp->mbus_engine, &i)) { 
    395391                sp->output_gain = i; 
    396392                audio_set_volume(sp->audio_device, sp->output_gain); 
     
    398394                printf("mbus: usage \"audio.output.gain <integer>\"\n"); 
    399395        } 
    400         mbus_parse_done(sp->mbus_engine_conf); 
     396        mbus_parse_done(sp->mbus_engine); 
    401397} 
    402398 
     
    407403        UNUSED(srce); 
    408404 
    409         mbus_parse_init(sp->mbus_engine_conf, args); 
    410         if (mbus_parse_str(sp->mbus_engine_conf, &s)) { 
     405        mbus_parse_init(sp->mbus_engine, args); 
     406        if (mbus_parse_str(sp->mbus_engine, &s)) { 
    411407                s = mbus_decode_str(s); 
    412408                if (strcmp(s, "speaker") == 0) { 
     
    422418                printf("mbus: usage \"audio.output.port <port>\"\n"); 
    423419        } 
    424         mbus_parse_done(sp->mbus_engine_conf); 
     420        mbus_parse_done(sp->mbus_engine); 
    425421        sp->output_mode = audio_get_oport(sp->audio_device); 
    426422        ui_update_output_port(sp); 
     
    433429        UNUSED(srce); 
    434430 
    435         mbus_parse_init(sp->mbus_engine_conf, args); 
    436         if (mbus_parse_str(sp->mbus_engine_conf, &s)) { 
     431        mbus_parse_init(sp->mbus_engine, args); 
     432        if (mbus_parse_str(sp->mbus_engine, &s)) { 
    437433                s = mbus_decode_str(s); 
    438434                sp->repair = repair_get_by_name(s); 
     
    440436                printf("mbus: usage \"audio.channel.repair <repair>\"\n"); 
    441437        } 
    442         mbus_parse_done(sp->mbus_engine_conf); 
     438        mbus_parse_done(sp->mbus_engine); 
    443439} 
    444440 
     
    450446        UNUSED(srce); 
    451447 
    452         mbus_parse_init(sp->mbus_engine_conf, args); 
    453         if (mbus_parse_str(sp->mbus_engine_conf, &key)) { 
     448        mbus_parse_init(sp->mbus_engine, args); 
     449        if (mbus_parse_str(sp->mbus_engine, &key)) { 
    454450                Set_Key(mbus_decode_str(key)); 
    455451        } else { 
    456452                printf("mbus: usage \"security.encryption.key <key>\"\n"); 
    457453        } 
    458         mbus_parse_done(sp->mbus_engine_conf); 
     454        mbus_parse_done(sp->mbus_engine); 
    459455} 
    460456 
     
    476472        UNUSED(sp); 
    477473 
    478         mbus_parse_init(sp->mbus_engine_conf, args); 
    479         if (mbus_parse_str(sp->mbus_engine_conf, &file)) { 
     474        mbus_parse_init(sp->mbus_engine, args); 
     475        if (mbus_parse_str(sp->mbus_engine, &file)) { 
    480476                mbus_decode_str(file); 
    481477                if (sp->in_file) snd_read_close(&sp->in_file); 
     
    486482                printf("mbus: usage \"audio.file.play.open <filename>\"\n"); 
    487483        } 
    488         mbus_parse_done(sp->mbus_engine_conf); 
     484        mbus_parse_done(sp->mbus_engine); 
    489485 
    490486        if (sp->in_file) ui_update_playback_file(sp, file); 
     
    498494        UNUSED(srce); 
    499495 
    500         mbus_parse_init(sp->mbus_engine_conf, args); 
    501  
    502         if (mbus_parse_int(sp->mbus_engine_conf, &pause)) { 
     496        mbus_parse_init(sp->mbus_engine, args); 
     497 
     498        if (mbus_parse_int(sp->mbus_engine, &pause)) { 
    503499                if (sp->in_file) { 
    504500                        if (pause) { 
     
    511507                printf("mbus: usage \"audio.file.play.pause <bool>\"\n");         
    512508        } 
    513         mbus_parse_done(sp->mbus_engine_conf); 
     509        mbus_parse_done(sp->mbus_engine); 
    514510} 
    515511 
     
    539535        UNUSED(srce); 
    540536 
    541         mbus_parse_init(sp->mbus_engine_conf, args); 
    542         if (mbus_parse_str(sp->mbus_engine_conf, &file)) { 
     537        mbus_parse_init(sp->mbus_engine, args); 
     538        if (mbus_parse_str(sp->mbus_engine, &file)) { 
    543539                const audio_format *ofmt; 
    544540                ofmt = audio_get_ofmt(sp->audio_device); 
     
    552548                printf("mbus: usage \"audio.file.record.open <filename>\"\n"); 
    553549        } 
    554         mbus_parse_done(sp->mbus_engine_conf); 
     550        mbus_parse_done(sp->mbus_engine); 
    555551         
    556552        if (sp->out_file) ui_update_record_file(sp, file); 
     
    563559        UNUSED(srce); 
    564560 
    565         mbus_parse_init(sp->mbus_engine_conf, args); 
    566  
    567         if (mbus_parse_int(sp->mbus_engine_conf, &pause)) { 
     561        mbus_parse_init(sp->mbus_engine, args); 
     562 
     563        if (mbus_parse_int(sp->mbus_engine, &pause)) { 
    568564                if (sp->out_file) { 
    569565                        if (pause) { 
     
    576572                printf("mbus: usage \"audio.file.record.pause <bool>\"\n");         
    577573        } 
    578         mbus_parse_done(sp->mbus_engine_conf); 
     574        mbus_parse_done(sp->mbus_engine); 
    579575} 
    580576 
     
    596592        UNUSED(srce); 
    597593 
    598         mbus_parse_init(sp->mbus_engine_conf, args); 
    599         if (mbus_parse_str(sp->mbus_engine_conf, &s)) { 
     594        mbus_parse_init(sp->mbus_engine, args); 
     595        if (mbus_parse_str(sp->mbus_engine, &s)) { 
    600596                s = mbus_decode_str(s); 
    601597                purge_chars(s, "[]()"); 
     
    625621                printf("mbus: usage \"audio.device <string>\"\n"); 
    626622        } 
    627         mbus_parse_done(sp->mbus_engine_conf); 
     623        mbus_parse_done(sp->mbus_engine); 
    628624         
    629625        sp->next_selected_device = next_device; 
     
    636632        UNUSED(srce); 
    637633 
    638         mbus_parse_init(sp->mbus_engine_conf, args); 
    639         if (mbus_parse_str(sp->mbus_engine_conf, &cname) && (strcmp(mbus_decode_str(cname), sp->db->my_dbe->sentry->cname) == 0) && mbus_parse_str(sp->mbus_engine_conf, &arg)) { 
     634        mbus_parse_init(sp->mbus_engine, args); 
     635        if (mbus_parse_str(sp->mbus_engine, &cname) && (strcmp(mbus_decode_str(cname), sp->db->my_dbe->sentry->cname) == 0) && mbus_parse_str(sp->mbus_engine, &arg)) { 
    640636                rtcp_set_attribute(sp, RTCP_SDES_NAME,  mbus_decode_str(arg)); 
    641637        } else { 
    642638                printf("mbus: usage \"rtp_source_name <cname> <name>\"\n"); 
    643639        } 
    644         mbus_parse_done(sp->mbus_engine_conf); 
     640        mbus_parse_done(sp->mbus_engine); 
    645641} 
    646642 
     
    651647        UNUSED(srce); 
    652648 
    653         mbus_parse_init(sp->mbus_engine_conf, args); 
    654         if (mbus_parse_str(sp->mbus_engine_conf, &cname) && (strcmp(mbus_decode_str(cname), sp->db->my_dbe->sentry->cname) == 0) && mbus_parse_str(sp->mbus_engine_conf, &arg)) { 
     649        mbus_parse_init(sp->mbus_engine, args); 
     650        if (mbus_parse_str(sp->mbus_engine, &cname) && (strcmp(mbus_decode_str(cname), sp->db->my_dbe->sentry->cname) == 0) && mbus_parse_str(sp->mbus_engine, &arg)) { 
    655651                rtcp_set_attribute(sp, RTCP_SDES_EMAIL,  mbus_decode_str(arg)); 
    656652        } else { 
    657653                printf("mbus: usage \"rtp_source_email <cname> <email>\"\n"); 
    658654        } 
    659         mbus_parse_done(sp->mbus_engine_conf); 
     655        mbus_parse_done(sp->mbus_engine); 
    660656} 
    661657 
     
    666662        UNUSED(srce); 
    667663 
    668         mbus_parse_init(sp->mbus_engine_conf, args); 
    669         if (mbus_parse_str(sp->mbus_engine_conf, &cname) && (strcmp(mbus_decode_str(cname), sp->db->my_dbe->sentry->cname) == 0) && mbus_parse_str(sp->mbus_engine_conf, &arg)) { 
     664        mbus_parse_init(sp->mbus_engine, args); 
     665        if (mbus_parse_str(sp->mbus_engine, &cname) && (strcmp(mbus_decode_str(cname), sp->db->my_dbe->sentry->cname) == 0) && mbus_parse_str(sp->mbus_engine, &arg)) { 
    670666                rtcp_set_attribute(sp, RTCP_SDES_PHONE,  mbus_decode_str(arg)); 
    671667        } else { 
    672668                printf("mbus: usage \"rtp_source_phone <cname> <phone>\"\n"); 
    673669        } 
    674         mbus_parse_done(sp->mbus_engine_conf); 
     670        mbus_parse_done(sp->mbus_engine); 
    675671} 
    676672 
     
    681677        UNUSED(srce); 
    682678 
    683         mbus_parse_init(sp->mbus_engine_conf, args); 
    684         if (mbus_parse_str(sp->mbus_engine_conf, &cname) && (strcmp(mbus_decode_str(cname), sp->db->my_dbe->sentry->cname) == 0) && mbus_parse_str(sp->mbus_engine_conf, &arg)) { 
     679        mbus_parse_init(sp->mbus_engine, args); 
     680        if (mbus_parse_str(sp->mbus_engine, &cname) && (strcmp(mbus_decode_str(cname), sp->db->my_dbe->sentry->cname) == 0) && mbus_parse_str(sp->mbus_engine, &arg)) { 
    685681                rtcp_set_attribute(sp, RTCP_SDES_LOC,  mbus_decode_str(arg)); 
    686682        } else { 
    687683                printf("mbus: usage \"rtp_source_loc <cname> <loc>\"\n"); 
    688684        } 
    689         mbus_parse_done(sp->mbus_engine_conf); 
     685        mbus_parse_done(sp->mbus_engine); 
    690686} 
    691687 
     
    698694        UNUSED(srce); 
    699695 
    700         mbus_parse_init(sp->mbus_engine_conf, args); 
    701         if (mbus_parse_str(sp->mbus_engine_conf, &cname) && mbus_parse_int(sp->mbus_engine_conf, &i)) { 
     696        mbus_parse_init(sp->mbus_engine, args); 
     697        if (mbus_parse_str(sp->mbus_engine, &cname) && mbus_parse_int(sp->mbus_engine, &i)) { 
    702698                mbus_decode_str(cname); 
    703699                e = rtcp_get_dbentry_by_cname(sp, cname); 
     
    709705                printf("mbus: usage \"rtp_source_mute <cname> <bool>\"\n"); 
    710706        } 
    711         mbus_parse_done(sp->mbus_engine_conf); 
     707        mbus_parse_done(sp->mbus_engine); 
    712708} 
    713709 
     
    721717        UNUSED(srce); 
    722718 
    723         mbus_parse_init(sp->mbus_engine_conf, args); 
    724         if (mbus_parse_str(sp->mbus_engine_conf, &cname) && mbus_parse_int(sp->mbus_engine_conf, &playout)) { 
     719        mbus_parse_init(sp->mbus_engine, args); 
     720        if (mbus_parse_str(sp->mbus_engine, &cname) && mbus_parse_int(sp->mbus_engine, &playout)) { 
    725721                for (e = sp->db->ssrc_db; e != NULL; e = e->next) { 
    726722                        if (strcmp(e->sentry->cname, mbus_decode_str(cname)) == 0) break; 
     
    731727                printf("mbus: usage \"rtp_source_playout <cname> <playout>\"\n"); 
    732728        } 
    733         mbus_parse_done(sp->mbus_engine_conf); 
     729        mbus_parse_done(sp->mbus_engine); 
    734730} 
    735731 
     
    744740        UNUSED(srce); 
    745741 
    746         mbus_parse_init(sp->mbus_engine_conf, args); 
    747         if (mbus_parse_str(sp->mbus_engine_conf, &short_name) && 
    748             mbus_parse_str(sp->mbus_engine_conf, &schan) && 
    749             mbus_parse_str(sp->mbus_engine_conf, &sfreq)) { 
     742        mbus_parse_init(sp->mbus_engine, args); 
     743        if (mbus_parse_str(sp->mbus_engine, &short_name) && 
     744            mbus_parse_str(sp->mbus_engine, &schan) && 
     745            mbus_parse_str(sp->mbus_engine, &sfreq)) { 
    750746                mbus_decode_str(short_name); 
    751747                mbus_decode_str(schan); 
    752748                mbus_decode_str(sfreq); 
    753                 mbus_parse_done(sp->mbus_engine_conf); 
     749                mbus_parse_done(sp->mbus_engine); 
    754750        } else { 
    755751                printf("mbus: usage \"audio.codec <codec> <freq> <channels>\"\n"); 
    756                 mbus_parse_done(sp->mbus_engine_conf); 
     752                mbus_parse_done(sp->mbus_engine); 
    757753                return; 
    758754        } 
     
    797793 
    798794        freq = channels = 0; 
    799         mbus_parse_init(sp->mbus_engine_conf, args); 
    800         if (mbus_parse_str(sp->mbus_engine_conf, &sfreq) &&  
    801             mbus_parse_str(sp->mbus_engine_conf, &schan)) { 
     795        mbus_parse_init(sp->mbus_engine, args); 
     796        if (mbus_parse_str(sp->mbus_engine, &sfreq) &&  
     797            mbus_parse_str(sp->mbus_engine, &schan)) { 
    802798                mbus_decode_str(sfreq); 
    803799                mbus_decode_str(schan); 
     
    817813        } 
    818814         
    819         mbus_parse_done(sp->mbus_engine_conf); 
     815        mbus_parse_done(sp->mbus_engine); 
    820816} 
    821817 
     
    825821 
    826822        UNUSED(srce); 
    827         mbus_parse_init(sp->mbus_engine_conf, args); 
    828         if (mbus_parse_int(sp->mbus_engine_conf, &i) && (1 == i || 0 == i)) { 
     823        mbus_parse_init(sp->mbus_engine, args); 
     824        if (mbus_parse_int(sp->mbus_engine, &i) && (1 == i || 0 == i)) { 
    829825                sp->limit_playout = i; 
    830826        } else { 
    831827                printf("mbus: usage \"tool.rat.playout.limit <bool>\"\n"); 
    832828        } 
    833         mbus_parse_done(sp->mbus_engine_conf); 
     829        mbus_parse_done(sp->mbus_engine); 
    834830} 
    835831 
     
    840836        UNUSED(srce); 
    841837 
    842         mbus_parse_init(sp->mbus_engine_conf, args); 
    843         if (mbus_parse_int(sp->mbus_engine_conf, &i)) { 
     838        mbus_parse_init(sp->mbus_engine, args); 
     839        if (mbus_parse_int(sp->mbus_engine, &i)) { 
    844840                sp->min_playout = i; 
    845841        } else { 
    846842                printf("mbus: usage \"tool.rat.playout.min <integer>\"\n"); 
    847843        } 
    848         mbus_parse_done(sp->mbus_engine_conf); 
     844        mbus_parse_done(sp->mbus_engine); 
    849845} 
    850846 
     
    855851        UNUSED(srce); 
    856852 
    857         mbus_parse_init(sp->mbus_engine_conf, args); 
    858         if (mbus_parse_int(sp->mbus_engine_conf, &i)) { 
     853        mbus_parse_init(sp->mbus_engine, args); 
     854        if (mbus_parse_int(sp->mbus_engine, &i)) { 
    859855                sp->max_playout = i; 
    860856        } else { 
    861857                printf("mbus: usage \"tool.rat.playout.max <integer>\"\n"); 
    862858        } 
    863         mbus_parse_done(sp->mbus_engine_conf); 
     859        mbus_parse_done(sp->mbus_engine); 
    864860} 
    865861 
     
    872868        UNUSED(srce); 
    873869 
    874         mbus_parse_init(sp->mbus_engine_conf, args); 
    875         if (mbus_parse_str(sp->mbus_engine_conf, &name)) { 
     870        mbus_parse_init(sp->mbus_engine, args); 
     871        if (mbus_parse_str(sp->mbus_engine, &name)) { 
    876872                mbus_decode_str(name); 
    877873                n = converter_get_count(); 
     
    886882                printf("mbus: usage \"tool.rat.converter <name>\"\n"); 
    887883        } 
    888         mbus_parse_done(sp->mbus_engine_conf); 
     884        mbus_parse_done(sp->mbus_engine); 
    889885} 
    890886 
     
    893889        UNUSED(srce); 
    894890 
    895         mbus_parse_init(sp->mbus_engine_conf, args); 
    896         mbus_parse_done(sp->mbus_engine_conf); 
     891        mbus_parse_init(sp->mbus_engine, args); 
     892        mbus_parse_done(sp->mbus_engine); 
    897893        ui_update_channel(sp); 
    898894} 
  • rat/trunk/net.c

    r2202 r2234  
    155155        int     rc; 
    156156        do { 
    157                 mbus_send(sp->mbus_ui_base); 
    158                 rc  = mbus_recv(sp->mbus_engine_base, (void *) sp);  
    159                 mbus_send(sp->mbus_engine_base); 
    160                 rc |= mbus_recv(sp->mbus_ui_base    , (void *) sp);  
    161                 if (sp->mbus_channel != 0) { 
    162                         mbus_send(sp->mbus_ui_conf); 
    163                         rc |= mbus_recv(sp->mbus_engine_conf, (void *) sp);  
    164                         mbus_send(sp->mbus_engine_conf); 
    165                         rc |= mbus_recv(sp->mbus_ui_conf    , (void *) sp);  
    166                 } 
     157                mbus_send(sp->mbus_ui); 
     158                rc  = mbus_recv(sp->mbus_engine, (void *) sp);  
     159                mbus_send(sp->mbus_engine); 
     160                rc |= mbus_recv(sp->mbus_ui, (void *) sp);  
    167161        } while (rc); 
    168162} 
  • rat/trunk/rtcp_db.c

    r2208 r2234  
    338338                if (dbptr->ssrc == ssrc) { 
    339339                        struct s_source *s; 
    340                         s = source_get_by_rtcp_dbentry(sp->active_sources,  
    341                                                        dbptr); 
    342                         if (s) source_remove(sp->active_sources, s); 
     340                        s = source_get_by_rtcp_dbentry(sp->active_sources, dbptr); 
     341                        if (s != NULL) { 
     342                                source_remove(sp->active_sources, s); 
     343                        } 
    343344                        ui_info_remove(sp, dbptr); 
    344345                        *pprev = dbptr->next; 
  • rat/trunk/session.c

    r2220 r2234  
    126126        sp->rtp_seq                     = lrand48() & 0xffff; 
    127127        sp->speakers_active             = NULL; 
    128         sp->mbus_engine_base            = NULL; 
    129         sp->mbus_engine_conf            = NULL; 
    130         sp->mbus_ui_base                = NULL; 
    131         sp->mbus_ui_conf                = NULL; 
    132         sp->mbus_channel                = 0; 
     128        sp->mbus_engine                 = NULL; 
     129        sp->mbus_ui                     = NULL; 
    133130        sp->min_playout                 = 0; 
    134131        sp->max_playout                 = 1000; 
     
    193190                        if ((strcmp(argv[i], "-C") == 0) && (argc > i+1)) { 
    194191                                strncpy(sp[s]->title, argv[i+1], SESSION_TITLE_LEN); 
    195                                 i++; 
    196                         } 
    197                         if ((strcmp(argv[i], "-mbus") == 0) && (argc > i+1)) { 
    198                                 sp[s]->mbus_channel = atoi(argv[i + 1]); 
    199192                                i++; 
    200193                        } 
     
    374367                        } 
    375368                        if (strcmp(argv[i], "-sync") == 0) { 
    376                                 if (sp[s]->mbus_channel != 0) { 
    377                                         sp[s]->sync_on = TRUE; 
    378                                 } else { 
    379                                         printf("Lip-sync can only be used if an mbus channel is specified\n"); 
    380                                         usage(); 
    381                                 } 
     369                                sp[s]->sync_on = TRUE; 
    382370                        } 
    383371                        if ((strcmp(argv[i], "-agc") == 0) && (argc > i+1)) { 
  • rat/trunk/session.h

    r2219 r2234  
    130130        u_int32          last_depart_ts; 
    131131        struct s_speaker_table  *speakers_active; 
    132         struct mbus     *mbus_engine_base; 
    133         struct mbus     *mbus_engine_conf; 
    134         struct mbus     *mbus_ui_base; 
    135         struct mbus     *mbus_ui_conf; 
    136         int              mbus_channel; 
     132        struct mbus     *mbus_engine; 
     133        struct mbus     *mbus_ui; 
    137134        int              wait_on_startup; 
    138135} session_struct; 
  • rat/trunk/tcltk.c

    r2161 r2234  
    9090        } 
    9191 
    92         mbus_qmsg(sp->mbus_ui_conf, engine_addr, argv[2], argv[3], strcmp(argv[1], "R") == 0); 
     92        mbus_qmsg(sp->mbus_ui, engine_addr, argv[2], argv[3], strcmp(argv[1], "R") == 0); 
    9393        return TCL_OK; 
    9494} 
  • rat/trunk/ui.c

    r2231 r2234  
    9797         
    9898        sprintf(args, "%s %s", cname, name); 
    99         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.name", args, TRUE); 
     99        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "rtp.source.name", args, TRUE); 
    100100        xfree(cname); 
    101101        xfree(name); 
     
    111111         
    112112        cname = mbus_encode_str(e->sentry->cname); 
    113         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.exists", cname, TRUE); 
     113        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "rtp.source.exists", cname, TRUE); 
    114114        xfree(cname); 
    115115} 
     
    126126        args = (char*)xmalloc(strlen(cname) + strlen(arg) + 2); 
    127127        sprintf(args, "%s %s", cname, arg); 
    128         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.email", args, TRUE); 
     128        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "rtp.source.email", args, TRUE); 
    129129        xfree(cname); 
    130130        xfree(arg); 
     
    143143        args = (char*)xmalloc(strlen(cname) + strlen(arg) + 2); 
    144144        sprintf(args, "%s %s", cname, arg); 
    145         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.phone", args, TRUE); 
     145        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "rtp.source.phone", args, TRUE); 
    146146        xfree(cname); 
    147147        xfree(arg); 
     
    160160        args = (char*)xmalloc(strlen(cname) + strlen(arg) + 2); 
    161161        sprintf(args, "%s %s", cname, arg); 
    162         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.loc", args, TRUE); 
     162        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "rtp.source.loc", args, TRUE); 
    163163        xfree(cname); 
    164164        xfree(arg); 
     
    173173        char *args = (char*)xmalloc(strlen(cname) + strlen(arg) + 2); 
    174174        sprintf(args, "%s %s", cname, arg); 
    175         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.tool", args, TRUE); 
     175        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "rtp.source.tool", args, TRUE); 
    176176        xfree(cname); 
    177177        xfree(arg); 
     
    186186        char *args = (char*)xmalloc(strlen(cname) + strlen(arg) + 2); 
    187187        sprintf(args, "%s %s", cname, arg); 
    188         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.note", args, TRUE); 
     188        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "rtp.source.note", args, TRUE); 
    189189        xfree(cname); 
    190190        xfree(arg); 
     
    198198        char *args = (char*)xmalloc(strlen(cname) + 4); 
    199199        sprintf(args, "%s %2d", cname, e->mute); 
    200         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.mute", args, TRUE); 
     200        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "rtp.source.mute", args, TRUE); 
    201201        xfree(cname); 
    202202        xfree(args); 
     
    211211         
    212212        cname = mbus_encode_str(e->sentry->cname); 
    213         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.remove", cname, TRUE); 
     213        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "rtp.source.remove", cname, TRUE); 
    214214        xfree(cname); 
    215215} 
     
    223223         
    224224        cname = mbus_encode_str(e->sentry->cname); 
    225         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.active", cname, FALSE); 
     225        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "rtp.source.active", cname, FALSE); 
    226226        xfree(cname); 
    227227} 
     
    235235         
    236236        cname = mbus_encode_str(e->sentry->cname); 
    237         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.inactive", cname, FALSE); 
     237        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "rtp.source.inactive", cname, FALSE); 
    238238        xfree(cname); 
    239239} 
     
    254254        msg = (char*)xmalloc(strlen(cname) + strlen(filter_name) + 10); 
    255255        sprintf(msg, "%s %s %d %d", cname, filter_name, filter_length, azimuth); 
    256         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.3d.user.settings", msg, TRUE); 
     256        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.3d.user.settings", msg, TRUE); 
    257257        xfree(cname); 
    258258        xfree(filter_name); 
     
    290290        } 
    291291 
    292         mbus_qmsg(sp->mbus_engine_base,  
     292        mbus_qmsg(sp->mbus_engine,  
    293293                  mbus_name_ui,  
    294294                  "rtp.source.codec",  
     
    317317                their_cname,  
    318318                buffered); 
    319         mbus_qmsg(sp->mbus_engine_base,  
     319        mbus_qmsg(sp->mbus_engine,  
    320320                  mbus_name_ui,  
    321321                  "tool.rat.audio.buffered",  
     
    327327                their_cname,  
    328328                delay); 
    329         mbus_qmsg(sp->mbus_engine_base,  
     329        mbus_qmsg(sp->mbus_engine,  
    330330                  mbus_name_ui,  
    331331                  "tool.rat.audio.delay",  
     
    338338                their_cname,  
    339339                (e->lost_frac * 100) >> 8); 
    340         mbus_qmsg(sp->mbus_engine_base,  
     340        mbus_qmsg(sp->mbus_engine,  
    341341                  mbus_name_ui,  
    342342                  "rtp.source.packet.loss",  
     
    354354        switch (sp->input_mode) { 
    355355        case AUDIO_MICROPHONE: 
    356                 mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.input.port", "\"microphone\"", TRUE); 
     356                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.input.port", "\"microphone\"", TRUE); 
    357357                break; 
    358358        case AUDIO_LINE_IN: 
    359                 mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.input.port", "\"line_in\"", TRUE); 
     359                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.input.port", "\"line_in\"", TRUE); 
    360360                break;   
    361361        case AUDIO_CD: 
    362                 mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.input.port", "\"cd\"", TRUE); 
     362                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.input.port", "\"cd\"", TRUE); 
    363363                break; 
    364364        default: 
     
    367367        } 
    368368        if (tx_is_sending(sp->tb)) { 
    369                 mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.input.mute", "0", TRUE); 
     369                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.input.mute", "0", TRUE); 
    370370        } else { 
    371                 mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.input.mute", "1", TRUE); 
     371                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.input.mute", "1", TRUE); 
    372372        } 
    373373} 
     
    378378        switch (sp->output_mode) { 
    379379        case AUDIO_SPEAKER: 
    380                 mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.output.port", "speaker", TRUE); 
     380                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.output.port", "speaker", TRUE); 
    381381                break; 
    382382        case AUDIO_HEADPHONE: 
    383                 mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.output.port", "headphone", TRUE); 
     383                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.output.port", "headphone", TRUE); 
    384384                break; 
    385385        case AUDIO_LINE_OUT: 
    386                 mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.output.port", "line_out", TRUE); 
     386                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.output.port", "line_out", TRUE); 
    387387                break; 
    388388        default: 
     
    391391        } 
    392392        if (sp->playing_audio) { 
    393                 mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.output.mute", "0", TRUE); 
     393                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.output.mute", "0", TRUE); 
    394394        } else { 
    395                 mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.output.mute", "1", TRUE); 
     395                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.output.mute", "1", TRUE); 
    396396        } 
    397397} 
     
    410410 
    411411        sprintf(args, "%3d", level); 
    412         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.input.powermeter", args, FALSE); 
     412        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.input.powermeter", args, FALSE); 
    413413        ol = level; 
    414414} 
     
    426426 
    427427        sprintf(args, "%3d", level); 
    428         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.output.powermeter", args, FALSE); 
     428        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.output.powermeter", args, FALSE); 
    429429        ol = level; 
    430430} 
     
    436436 
    437437        mbes = mbus_encode_str(repair_get_name((u_int16)sp->repair)); 
    438         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.channel.repair", mbes, FALSE); 
     438        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.channel.repair", mbes, FALSE); 
    439439        xfree(mbes); 
    440440} 
     
    449449        if (af && audio_format_name(af, fmt_buf, 64)) { 
    450450                mbes = mbus_encode_str(fmt_buf); 
    451                 mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.format.in", mbes, TRUE); 
     451                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.format.in", mbes, TRUE); 
    452452                xfree(mbes); 
    453453        } else { 
     
    458458        if (af && audio_format_name(af, fmt_buf, 64)) { 
    459459                mbes = mbus_encode_str(fmt_buf); 
    460                 mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.format.out", mbes, TRUE); 
     460                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.format.out", mbes, TRUE); 
    461461                xfree(mbes); 
    462462        } else { 
     
    475475        pri_cf = codec_get_format(pri_id); 
    476476        mbes = mbus_encode_str(pri_cf->short_name); 
    477         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.codec", mbes, FALSE); 
     477        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.codec", mbes, FALSE); 
    478478        xfree(mbes); 
    479479} 
     
    506506 
    507507        sprintf(args,"\"interleaved\" %d %d",iu, isep); 
    508         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.channel.coding", args, TRUE);         
     508        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.channel.coding", args, TRUE);         
    509509 
    510510        UNUSED(sp); 
     
    557557        sprintf(args,"\"redundant\" %s %2d", codec_name, ioff); 
    558558        assert(strlen(args) < (strlen(codec_name) + 16)); 
    559         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.channel.coding", args, TRUE); 
     559        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.channel.coding", args, TRUE); 
    560560        xfree(codec_name); 
    561561        xfree(args); 
     
    569569        cc_coder_t *ccp; 
    570570        */ 
    571         mbus_qmsg(sp->mbus_engine_base,  
     571        mbus_qmsg(sp->mbus_engine,  
    572572                  mbus_name_ui,  
    573573                  "audio.channel.coding", "\"none\"", TRUE); 
     
    575575        ccp = get_channel_coder(sp->cc_encoding); 
    576576        if (strcmp(ccp->name, "VANILLA") == 0) { 
    577                 mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.channel.coding", "\"none\"", TRUE); 
     577                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.channel.coding", "\"none\"", TRUE); 
    578578        } else if (strcmp(ccp->name, "REDUNDANCY") == 0) { 
    579579                ui_update_redundancy(sp); 
     
    594594        sprintf(args, "%3d", audio_get_gain(sp->audio_device));  
    595595        assert(strlen(args) < 4); 
    596         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.input.gain", args, TRUE); 
     596        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.input.gain", args, TRUE); 
    597597} 
    598598 
     
    604604        sprintf(args, "%3d", audio_get_volume(sp->audio_device));  
    605605        assert(strlen(args) < 4); 
    606         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.output.gain", args, TRUE); 
     606        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.output.gain", args, TRUE); 
    607607} 
    608608 
     
    612612        char args[2]; 
    613613        sprintf(args, "%d", (sp->render_3d ? 1 : 0)); 
    614         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.3d.enabled", args, TRUE); 
     614        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.3d.enabled", args, TRUE); 
    615615} 
    616616 
     
    635635 
    636636        mbes = mbus_encode_str(buf); 
    637         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.devices", mbes, TRUE); 
     637        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.devices", mbes, TRUE); 
    638638        xfree(mbes); 
    639639} 
     
    657657        if (cur_dev) { 
    658658                mbes = mbus_encode_str(cur_dev); 
    659                 mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.device", mbes, TRUE); 
     659                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.device", mbes, TRUE); 
    660660                xfree(mbes); 
    661661        } 
     
    695695 
    696696        mbes = mbus_encode_str(modes); 
    697         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.sampling.supported", mbes, TRUE); 
     697        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.sampling.supported", mbes, TRUE); 
    698698        xfree(mbes); 
    699699} 
     
    712712                done=1; 
    713713        } else { 
    714                 sprintf(args, "%3d", sp->output_gain); mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.output.gain", args, TRUE); 
     714                sprintf(args, "%3d", sp->output_gain); mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.output.gain", args, TRUE); 
    715715                assert(strlen(args) < 4); 
    716                 sprintf(args, "%3d", sp->input_gain ); mbus_qmsg(sp->mbus_engine_base, mbus_name_ui,  "audio.input.gain", args, TRUE); 
     716                sprintf(args, "%3d", sp->input_gain ); mbus_qmsg(sp->mbus_engine, mbus_name_ui,  "audio.input.gain", args, TRUE); 
    717717                assert(strlen(args) < 4); 
    718718        } 
     
    720720        sprintf(args, "%3d", channel_encoder_get_units_per_packet(sp->channel_coder)); 
    721721        assert(strlen(args) < 4); 
    722         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.rate", args, TRUE); 
     722        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.rate", args, TRUE); 
    723723 
    724724        ui_update_output_port(sp); 
     
    738738ui_show_audio_busy(session_struct *sp) 
    739739{ 
    740         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.disable.audio.ctls", "", TRUE); 
     740        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.disable.audio.ctls", "", TRUE); 
    741741} 
    742742 
     
    744744ui_hide_audio_busy(session_struct *sp) 
    745745{ 
    746         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.enable.audio.ctls", "", TRUE); 
     746        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.enable.audio.ctls", "", TRUE); 
    747747} 
    748748 
     
    753753        char    args[2]; 
    754754        sprintf(args, "%1d", sp->lecture); 
    755         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.lecture.mode", args, TRUE); 
     755        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.lecture.mode", args, TRUE); 
    756756} 
    757757 
     
    787787        args   = (char *) xmalloc(strlen(srce_e) + strlen(dest_e) + 6); 
    788788        sprintf(args, "%s %s %3d", srce_e, dest_e, loss); 
    789         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.packet.loss", args, FALSE); 
     789        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "rtp.source.packet.loss", args, FALSE); 
    790790        xfree(args); 
    791791        xfree(srce_e); 
     
    805805        args = (char *) xmalloc(strlen(cname_e) + 88); 
    806806        sprintf(args, "%s %6ld %6ld %6ld %6ld %6ld %6d", cname_e, recv, lost, misordered, duplicates, jitter, jit_tog); 
    807         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.reception", args, FALSE); 
     807        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "rtp.source.reception", args, FALSE); 
    808808        xfree(args); 
    809809        xfree(cname_e); 
     
    821821 
    822822        sprintf(args, "%s %3d", cname_e, duration); 
    823         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.source.packet.duration", args, FALSE); 
     823        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "rtp.source.packet.duration", args, FALSE); 
    824824        xfree(args); 
    825825        xfree(cname_e); 
     
    837837 
    838838        sprintf(args, "%s %12d", cname_e, playout); 
    839         mbus_qmsg(sp->mbus_engine_base, mbus_name_video, "source_playout", args, FALSE); 
     839        mbus_qmsg(sp->mbus_engine, mbus_name_video, "source_playout", args, FALSE); 
    840840        xfree(args); 
    841841        xfree(cname_e); 
     
    846846{ 
    847847        if (sync) { 
    848                 mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.sync", "1", TRUE); 
     848                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.sync", "1", TRUE); 
    849849        } else { 
    850                 mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.sync", "0", TRUE); 
     850                mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.sync", "0", TRUE); 
    851851        } 
    852852} 
     
    855855ui_update_key(session_struct *sp, char *key) 
    856856{ 
    857         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "security.encryption.key", key, TRUE); 
     857        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "security.encryption.key", key, TRUE); 
    858858} 
    859859 
     
    956956        ui_get_codecs(pt, args, 256, TRUE); 
    957957        mbes = mbus_encode_str(args); 
    958         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.codec.supported", mbes, TRUE); 
     958        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.codec.supported", mbes, TRUE); 
    959959        xfree(mbes); 
    960960        ui_get_codecs(pt, args, 256, FALSE); 
    961961        mbes = mbus_encode_str(args); 
    962         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.redundancy.supported", mbes, TRUE); 
     962        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.redundancy.supported", mbes, TRUE); 
    963963        xfree(mbes); 
    964964} 
     
    969969        char *mbes; 
    970970        mbes = mbus_encode_str(name); 
    971         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.file.play.ready", mbes, TRUE);  
     971        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.file.play.ready", mbes, TRUE);  
    972972        xfree(mbes); 
    973973} 
     
    978978        char *mbes; 
    979979        mbes = mbus_encode_str(name); 
    980         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.file.record.ready", mbes, TRUE);  
     980        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "audio.file.record.ready", mbes, TRUE);  
    981981        xfree(mbes); 
    982982} 
     
    991991        sprintf(cmd, "audio.file.%s.alive", mode); 
    992992        sprintf(arg, "%1d", valid);  
    993         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, cmd, arg, TRUE); 
     993        mbus_qmsg(sp->mbus_engine, mbus_name_ui, cmd, arg, TRUE); 
    994994} 
    995995 
     
    10121012         
    10131013        mbes = mbus_encode_str(buf); 
    1014         mbus_qmsg(sp->mbus_engine_base,  
     1014        mbus_qmsg(sp->mbus_engine,  
    10151015                  mbus_name_ui,  
    10161016                  "tool.rat.converter.supported",  
     
    10341034         
    10351035        mbes = mbus_encode_str(buf); 
    1036         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.repair.supported", mbes, TRUE); 
     1036        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.repair.supported", mbes, TRUE); 
    10371037        xfree(mbes); 
    10381038} 
     
    10481048 
    10491049        my_cname = mbus_encode_str(cname); 
    1050         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "rtp.cname", my_cname, TRUE); 
     1050        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "rtp.cname", my_cname, TRUE); 
    10511051        xfree(my_cname); 
    10521052} 
     
    10581058 
    10591059        title = mbus_encode_str(sp->title); 
    1060         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "session.title", title, TRUE); 
     1060        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "session.title", title, TRUE); 
    10611061        xfree(title); 
    10621062 
     
    10641064        args = (char *) xmalloc(strlen(addr) + 11); 
    10651065        sprintf(args, "%s %5d %3d", addr, sp->rtp_port, sp->ttl); 
    1066         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "session.address", args, TRUE); 
     1066        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "session.address", args, TRUE); 
    10671067        xfree(args); 
    10681068        xfree(addr); 
     
    10721072ui_load_settings(session_struct *sp) 
    10731073{ 
    1074         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.load.settings", "", TRUE); 
     1074        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "tool.rat.load.settings", "", TRUE); 
    10751075} 
    10761076 
     
    10901090 
    10911091        mbes = mbus_encode_str(args); 
    1092         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui,  
     1092        mbus_qmsg(sp->mbus_engine, mbus_name_ui,  
    10931093                  "tool.rat.3d.filter.types", mbes, TRUE); 
    10941094        xfree(mbes); 
     
    11031103         
    11041104        mbes = mbus_encode_str(args); 
    1105         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui,  
     1105        mbus_qmsg(sp->mbus_engine, mbus_name_ui,  
    11061106                  "tool.rat.3d.filter.lengths",  
    11071107                  mbes, TRUE); 
     
    11091109 
    11101110        sprintf(args, "%d", render_3D_filter_get_lower_azimuth()); 
    1111         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui,  
     1111        mbus_qmsg(sp->mbus_engine, mbus_name_ui,  
    11121112                  "tool.rat.3d.azimuth.min", args, TRUE); 
    11131113 
    11141114        sprintf(args, "%d", render_3D_filter_get_upper_azimuth()); 
    1115         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui,  
     1115        mbus_qmsg(sp->mbus_engine, mbus_name_ui,  
    11161116                  "tool.rat.3d.azimuth.max", args, TRUE); 
    11171117} 
     
    11351135ui_quit(session_struct *sp) 
    11361136{ 
    1137         mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "mbus.quit", "", TRUE); 
    1138 } 
     1137        mbus_qmsg(sp->mbus_engine, mbus_name_ui, "mbus.quit", "", TRUE); 
     1138}