Changeset 3374

Show
Ignore:
Timestamp:
04/19/00 01:33:48 (14 years ago)
Author:
ucaccsp
Message:

- Change the session struct to be a two element array in main_engine.c
- Change all references to sp-> into sp[0]-> in main() of the media

engine

- A few trivial changes to the initialization sequence, in support

of the transcoder. There are a number of things which will hinder
this:

  • mbus_rendezvous_waiting() and mbus_rendezvous_go() are incompatible with another mbus needing to run in parallel.
  • some parts of the code are non-reentrant (i.e. use static variables) and will have to be fixed

it's probably not too bad, though. All are wrapped in #ifdef
IS_TRANSCODER, for now.

Location:
rat/trunk
Files:
4 modified

Legend:

Unmodified
Added
Removed
  • rat/trunk/MODS

    r3372 r3374  
    12781278        * Released 17 April 2000. 
    12791279 
    1280 v4.2.3  -  
     1280v4.2.3  - Change the session struct to be a two element array in main_engine.c 
     1281        - Change all references to sp-> into sp[0]-> in main() of the media engine 
     1282        - A few trivial changes to the initialization sequence, in support 
     1283          of the transcoder. There are a number of things which will hinder 
     1284          this: 
     1285                - mbus_rendezvous_waiting() and mbus_rendezvous_go() are 
     1286                  incompatible with another mbus needing to run in parallel. 
     1287                - some parts of the code are non-reentrant (i.e. use static 
     1288                  variables) and will have to be fixed 
     1289          it's probably not too bad, though. All are wrapped in #ifdef 
     1290          IS_TRANSCODER, for now. 
    12811291 
    12821292 
  • rat/trunk/auddev.c

    r3239 r3374  
    3030#include "auddev_sparc.h" 
    3131#include "auddev_win32.h" 
     32#include "auddev_trans.h" 
    3233 
    3334typedef struct { 
     
    7374} audio_if_t; 
    7475 
    75  
    7676audio_if_t audio_if_table[] = { 
     77#ifdef IS_TRANSCODER 
     78        { 
     79                trans_audio_init, 
     80                NULL,  
     81                trans_audio_device_count, 
     82                trans_audio_device_name, 
     83                trans_audio_open, 
     84                trans_audio_close, 
     85                trans_audio_drain, 
     86                trans_audio_duplex, 
     87                trans_audio_read, 
     88                trans_audio_write, 
     89                trans_audio_non_block, 
     90                trans_audio_block, 
     91                trans_audio_set_igain, 
     92                trans_audio_get_igain, 
     93                trans_audio_set_ogain, 
     94                trans_audio_get_ogain, 
     95                trans_audio_loopback, 
     96                trans_audio_oport_set, 
     97                trans_audio_oport_get, 
     98                trans_audio_oport_details, 
     99                trans_audio_oport_count, 
     100                trans_audio_iport_set, 
     101                trans_audio_iport_get, 
     102                trans_audio_iport_details, 
     103                trans_audio_iport_count, 
     104                trans_audio_is_ready, 
     105                trans_audio_wait_for, 
     106                trans_audio_supports 
     107        } 
     108#else /* IS_TRANSCODER */ 
    77109#ifdef HAVE_SGI_AUDIO 
    78110        { 
     
    202234                alsa_audio_supports 
    203235        }, 
    204  
    205236#endif /* HAVE_ALSA_AUDIO */ 
    206237#ifdef HAVE_OSS_AUDIO 
     
    235266                oss_audio_supports 
    236267        }, 
    237  
    238268#endif /* HAVE_OSS_AUDIO */ 
    239269#ifdef WIN32 
     
    269299        }, 
    270300#endif /* WIN32 */ 
    271  
    272301#ifdef HAVE_LUIGI_AUDIO 
    273302        { 
     
    368397                null_audio_supports 
    369398        } 
     399#endif /* IS_TRANSCODER */ 
    370400}; 
    371401 
     
    462492        } 
    463493 
     494        debug_msg("Device %d is not active\n", (int) ad); 
    464495        return -1; 
    465496} 
     
    500531        dev_idx   = active_devices; 
    501532 
    502         assert(get_active_device_index(ad) == -1); 
    503533        assert(audio_if_table[iface].audio_if_open); 
    504534 
     
    11401170                        dev_details[k].name       = xstrdup(audio_if_table[i].audio_if_dev_name(j)); 
    11411171                        dev_details[k].descriptor = AIF_MAKE_DESC(i, j); 
     1172                        debug_msg("Added \"%s\" to audio device table\n", dev_details[k].name); 
    11421173                        k++; 
    11431174                } 
  • rat/trunk/auddev_trans.c

    r3173 r3374  
    88/*                                                                           */ 
    99/*****************************************************************************/ 
     10 
     11#ifndef HIDE_SOURCE_STRINGS 
     12static const char cvsid[] =  
     13        "$Id$"; 
     14#endif /* HIDE_SOURCE_STRINGS */ 
    1015 
    1116#include "config_unix.h" 
     
    5257        int i; 
    5358 
     59        debug_msg("Open transcoder audio device\n"); 
     60 
    5461        ad = mapAudioDescToDeviceID(ad); 
    5562        assert(ad >= 0); 
     
    8794        unsigned int i; 
    8895 
     96        debug_msg("Initialize transcoder audio device\n"); 
    8997        af.bits_per_sample = 16; 
    9098        af.bytes_per_block = 320; 
     
    115123 */ 
    116124  
    117 #ifndef HIDE_SOURCE_STRINGS 
    118 static const char cvsid[] =  
    119         "$Id$"; 
    120 #endif /* HIDE_SOURCE_STRINGS */ 
    121125void 
    122126trans_audio_close(audio_desc_t ad) 
    123127{ 
     128        debug_msg("Close transcoder audio device\n"); 
    124129        ad = mapAudioDescToDeviceID(ad); 
    125130        if (bufdev[ad].audio_fd > 0) 
  • rat/trunk/main_engine.c

    r3366 r3374  
    121121        uint32_t         rtp_time = 0; 
    122122        int              seed, elapsed_time, alc = 0, scnt = 0; 
    123         session_t       *sp; 
     123        session_t       *sp[2]; 
    124124        struct timeval   time; 
    125125        struct timeval   timeout; 
    126         uint8_t          j; 
     126        uint8_t          i, j; 
     127#ifdef IS_TRANSCODER 
     128        int              num_sessions = 2; 
     129#else  
     130        int              num_sessions = 1; 
     131#endif 
    127132 
    128133        appname = get_appname(argv[0]); 
     
    146151 
    147152        /* Initialize the session structure, and all session specific data */ 
    148         sp = (session_t *) xmalloc(sizeof(session_t)); 
    149         session_init(sp); 
    150         audio_device_get_safe_config(&sp->new_config); 
    151         audio_device_reconfigure(sp); 
    152         assert(audio_device_is_open(sp->audio_device)); 
    153  
    154         /* Initialise our mbus interface... once this is done we can talk to our controller */ 
    155         sp->mbus_engine_addr = (char *) xmalloc(strlen(MBUS_ADDR_ENGINE) + 10); 
    156         sprintf(sp->mbus_engine_addr, MBUS_ADDR_ENGINE, (unsigned long) ppid); 
    157         sp->mbus_engine      = mbus_init(mbus_engine_rx, mbus_error_handler, sp->mbus_engine_addr); 
    158         if (sp->mbus_engine == NULL) { 
    159                 fatal_error(appname, "Could not initialize Mbus: Is multicast enabled?"); 
    160                 return FALSE; 
    161         } 
     153        for (i = 0; i < num_sessions; i++) { 
     154                debug_msg("Initializing session %d\n", i); 
     155                sp[i] = (session_t *) xmalloc(sizeof(session_t)); 
     156                session_init(sp[i]); 
     157                audio_device_get_safe_config(&sp[i]->new_config); 
     158                audio_device_reconfigure(sp[i]); 
     159                assert(audio_device_is_open(sp[i]->audio_device)); 
     160 
     161                /* Initialise our mbus interface... once this is done we can talk to our controller */ 
     162                sp[i]->mbus_engine_addr = (char *) xmalloc(strlen(MBUS_ADDR_ENGINE) + 10); 
     163                sprintf(sp[i]->mbus_engine_addr, MBUS_ADDR_ENGINE, (unsigned long) ppid); 
     164                sp[i]->mbus_engine      = mbus_init(mbus_engine_rx, mbus_error_handler, sp[i]->mbus_engine_addr); 
     165                if (sp[i]->mbus_engine == NULL) { 
     166                        fatal_error(appname, "Could not initialize Mbus: Is multicast enabled?"); 
     167                        return FALSE; 
     168                } 
     169        } 
    162170 
    163171        /* Next, we signal to the controller that we are ready to go. It should be sending  */ 
     
    165173        /* passed on startup. We respond with mbus.go(foo) sent reliably to the controller. */ 
    166174        debug_msg("Waiting for mbus.waiting(%s) from controller...\n", token); 
    167         mbus_rendezvous_go(sp->mbus_engine, token, (void *) sp); 
     175        mbus_rendezvous_go(sp[0]->mbus_engine, token, (void *) sp[0]); 
    168176        debug_msg("...got it\n"); 
    169177 
     
    171179        /* a successful rendezvous with it. It will now send us configuration commands. */ 
    172180        debug_msg("Waiting for mbus.go(%s) from controller...\n", token); 
    173         mbus_rendezvous_waiting(sp->mbus_engine, c_addr, token, (void *) sp); 
     181        mbus_rendezvous_waiting(sp[0]->mbus_engine, c_addr, token, (void *) sp[0]); 
    174182        debug_msg("...got it\n"); 
    175         assert(sp->rtp_session[0] != NULL); 
    176  
    177         settings_load_early(sp); 
    178         if (pdb_create(&sp->pdb) == FALSE) { 
     183        assert(sp[0]->rtp_session[0] != NULL); 
     184 
     185        settings_load_early(sp[0]); 
     186        if (pdb_create(&sp[0]->pdb) == FALSE) { 
    179187                debug_msg("Failed to create persistent database\n"); 
    180188                abort(); 
    181189        } 
    182         pdb_item_create(sp->pdb, (uint16_t)ts_get_freq(sp->cur_ts), rtp_my_ssrc(sp->rtp_session[0]));  
    183         settings_load_late(sp); 
    184  
    185         session_validate(sp); 
     190        pdb_item_create(sp[0]->pdb, (uint16_t)ts_get_freq(sp[0]->cur_ts), rtp_my_ssrc(sp[0]->rtp_session[0]));  
     191        settings_load_late(sp[0]); 
     192 
     193        session_validate(sp[0]); 
    186194        xmemchk(); 
    187195        xdoneinit(); 
     
    192200 
    193201                /* Process audio */ 
    194                 elapsed_time = audio_rw_process(sp, sp, sp->ms); 
    195  
    196                 if (tx_is_sending(sp->tb)) { 
    197                         tx_process_audio(sp->tb); 
    198                         tx_send(sp->tb); 
     202                elapsed_time = audio_rw_process(sp[0], sp[0], sp[0]->ms); 
     203 
     204                if (tx_is_sending(sp[0]->tb)) { 
     205                        tx_process_audio(sp[0]->tb); 
     206                        tx_send(sp[0]->tb); 
    199207                } 
    200208 
     
    202210                timeout.tv_sec  = 0; 
    203211                timeout.tv_usec = 0; 
    204                 for (j = 0; j < sp->rtp_session_count; j++) { 
     212                for (j = 0; j < sp[0]->rtp_session_count; j++) { 
    205213                        /* FIXME: The should take an RTP format timestamp! */ 
    206                         rtp_time = tx_get_rtp_time(sp); 
    207                         while(rtp_recv(sp->rtp_session[j], &timeout, rtp_time)); 
    208                         rtp_send_ctrl(sp->rtp_session[j], rtp_time, NULL); 
    209                         rtp_update(sp->rtp_session[j]); 
     214                        rtp_time = tx_get_rtp_time(sp[0]); 
     215                        while(rtp_recv(sp[0]->rtp_session[j], &timeout, rtp_time)); 
     216                        rtp_send_ctrl(sp[0]->rtp_session[j], rtp_time, NULL); 
     217                        rtp_update(sp[0]->rtp_session[j]); 
    210218                } 
    211219 
     
    213221                timeout.tv_sec  = 0; 
    214222                timeout.tv_usec = 0; 
    215                 mbus_recv(sp->mbus_engine, (void *) sp, &timeout); 
    216                 mbus_heartbeat(sp->mbus_engine, 1); 
    217                 mbus_retransmit(sp->mbus_engine); 
    218                 mbus_send(sp->mbus_engine);  
    219  
    220                 if (tx_is_sending(sp->tb)) { 
    221                         tx_process_audio(sp->tb); 
    222                         tx_send(sp->tb); 
     223                mbus_recv(sp[0]->mbus_engine, (void *) sp[0], &timeout); 
     224                mbus_heartbeat(sp[0]->mbus_engine, 1); 
     225                mbus_retransmit(sp[0]->mbus_engine); 
     226                mbus_send(sp[0]->mbus_engine);  
     227 
     228                if (tx_is_sending(sp[0]->tb)) { 
     229                        tx_process_audio(sp[0]->tb); 
     230                        tx_send(sp[0]->tb); 
    223231                } 
    224232 
    225233                /* Process and mix active sources */ 
    226                 if (sp->playing_audio) { 
     234                if (sp[0]->playing_audio) { 
    227235                        struct s_source *s; 
    228236                        int              sidx; 
    229237                        ts_t             cush_ts; 
    230238 
    231                         session_validate(sp); 
    232                         cush_ts = ts_map32(ts_get_freq(sp->cur_ts), cushion_get_size(sp->cushion)); 
    233                         cush_ts = ts_add(sp->cur_ts, cush_ts); 
    234                         scnt = (int)source_list_source_count(sp->active_sources); 
     239                        session_validate(sp[0]); 
     240                        cush_ts = ts_map32(ts_get_freq(sp[0]->cur_ts), cushion_get_size(sp[0]->cushion)); 
     241                        cush_ts = ts_add(sp[0]->cur_ts, cush_ts); 
     242                        scnt = (int)source_list_source_count(sp[0]->active_sources); 
    235243                        for(sidx = 0; sidx < scnt; sidx++) { 
    236                                 s = source_list_get_source_no(sp->active_sources, sidx); 
    237                                 if (source_relevant(s, sp->cur_ts)) { 
     244                                s = source_list_get_source_no(sp[0]->active_sources, sidx); 
     245                                if (source_relevant(s, sp[0]->cur_ts)) { 
    238246                                        pdb_entry_t *e; 
    239247                                        ts_t         two_secs, delta; 
    240248                                        source_check_buffering(s); 
    241                                         source_process(sp, s, sp->ms, sp->render_3d, sp->repair, sp->cur_ts, cush_ts); 
     249                                        source_process(sp[0], s, sp[0]->ms, sp[0]->render_3d, sp[0]->repair, sp[0]->cur_ts, cush_ts); 
    242250                                        source_audit(s); 
    243251                                        /* Check for UI update necessary, updating once per 2 secs */ 
    244                                         pdb_item_get(sp->pdb, source_get_ssrc(s), &e); 
    245                                         delta    = ts_sub(sp->cur_ts, e->last_ui_update); 
     252                                        pdb_item_get(sp[0]->pdb, source_get_ssrc(s), &e); 
     253                                        delta    = ts_sub(sp[0]->cur_ts, e->last_ui_update); 
    246254                                        two_secs = ts_map32(8000, 16000); 
    247255                                        if (ts_gt(delta, two_secs)) { 
    248                                                 ui_send_stats(sp, sp->mbus_ui_addr, e->ssrc); 
    249                                                 e->last_ui_update = sp->cur_ts; 
     256                                                ui_send_stats(sp[0], sp[0]->mbus_ui_addr, e->ssrc); 
     257                                                e->last_ui_update = sp[0]->cur_ts; 
    250258                                        } 
    251259                                } else { 
     
    253261                                        uint32_t ssrc; 
    254262                                        ssrc = source_get_ssrc(s); 
    255                                         ui_send_rtp_inactive(sp, sp->mbus_ui_addr, ssrc); 
    256                                         source_remove(sp->active_sources, s); 
     263                                        ui_send_rtp_inactive(sp[0], sp[0]->mbus_ui_addr, ssrc); 
     264                                        source_remove(sp[0]->active_sources, s); 
    257265                                        sidx--; 
    258266                                        scnt--; 
     
    260268                        } 
    261269                        /* Play local file if playing */ 
    262                         if (sp->local_file_player) { 
    263                                 if (voxlet_play(sp->local_file_player, sp->cur_ts, cush_ts) == FALSE) { 
    264                                         voxlet_destroy(&sp->local_file_player); 
     270                        if (sp[0]->local_file_player) { 
     271                                if (voxlet_play(sp[0]->local_file_player, sp[0]->cur_ts, cush_ts) == FALSE) { 
     272                                        voxlet_destroy(&sp[0]->local_file_player); 
    265273                                } 
    266274                        } 
    267275                        /* Play loopback tone if present */ 
    268                         if (sp->tone_generator) { 
    269                                 tonegen_play(sp->tone_generator, sp->cur_ts, cush_ts); 
     276                        if (sp[0]->tone_generator) { 
     277                                tonegen_play(sp[0]->tone_generator, sp[0]->cur_ts, cush_ts); 
    270278                        } 
    271279                } else { 
    272280                        /* Destroy localfile player if not playing audio */ 
    273                         if (sp->local_file_player) { 
    274                                 voxlet_destroy(&sp->local_file_player); 
     281                        if (sp[0]->local_file_player) { 
     282                                voxlet_destroy(&sp[0]->local_file_player); 
    275283                        } 
    276284                } 
     
    278286                /* Echo Suppression - cut off transmitter when receiving     */ 
    279287                /* audio, enable when stop receiving.                        */ 
    280                 session_validate(sp); 
    281                 if (sp->echo_suppress) { 
     288                session_validate(sp[0]); 
     289                if (sp[0]->echo_suppress) { 
    282290                        if (scnt > 0) { 
    283                                 if (tx_is_sending(sp->tb)) { 
    284                                         tx_stop(sp->tb); 
    285                                         sp->echo_tx_active = TRUE; 
     291                                if (tx_is_sending(sp[0]->tb)) { 
     292                                        tx_stop(sp[0]->tb); 
     293                                        sp[0]->echo_tx_active = TRUE; 
    286294                                        debug_msg("Echo suppressor (disabling tx)\n"); 
    287295                                } 
    288                         } else if (sp->echo_tx_active) { 
     296                        } else if (sp[0]->echo_tx_active) { 
    289297                                /* Transmitter was stopped because we were   */ 
    290298                                /* playing out audio.  Restart it.           */ 
    291                                 if (tx_is_sending(sp->tb) == FALSE) { 
    292                                         tx_start(sp->tb); 
     299                                if (tx_is_sending(sp[0]->tb) == FALSE) { 
     300                                        tx_start(sp[0]->tb); 
    293301                                        debug_msg("Echo suppressor (enabling tx)\n"); 
    294302                                } 
    295                                 sp->echo_tx_active = FALSE; 
     303                                sp[0]->echo_tx_active = FALSE; 
    296304                        } 
    297305                } 
    298306                /* Lecture Mode */ 
    299307                if ((alc % 50) == 0) { 
    300                         if (!sp->lecture && tx_is_sending(sp->tb) && sp->auto_lecture != 0) { 
     308                        if (!sp[0]->lecture && tx_is_sending(sp[0]->tb) && sp[0]->auto_lecture != 0) { 
    301309                                gettimeofday(&time, NULL); 
    302                                 if (time.tv_sec - sp->auto_lecture > 120) { 
    303                                         sp->auto_lecture = 0; 
     310                                if (time.tv_sec - sp[0]->auto_lecture > 120) { 
     311                                        sp[0]->auto_lecture = 0; 
    304312                                        debug_msg("Dummy lecture mode\n"); 
    305313                                } 
     
    307315                } 
    308316 
    309                 if (sp->ui_on) { 
     317                if (sp[0]->ui_on) { 
    310318                        /* We have a user interface... do any periodic updates needed. */ 
    311                         if (sp->audio_device && elapsed_time != 0) { 
    312                                 ui_send_periodic_updates(sp, sp->mbus_ui_addr, elapsed_time); 
     319                        if (sp[0]->audio_device && elapsed_time != 0) { 
     320                                ui_send_periodic_updates(sp[0], sp[0]->mbus_ui_addr, elapsed_time); 
    313321                        } 
    314322                } else { 
    315323                        /* We don't yet have a user interface... send out a message soliciting one... */ 
    316324                        if ((alc % 25) == 0) { 
    317                                 mbus_qmsgf(sp->mbus_engine, "()", FALSE, "mbus.waiting", "\"rat-ui-requested\""); 
     325                                mbus_qmsgf(sp[0]->mbus_engine, "()", FALSE, "mbus.waiting", "\"rat-ui-requested\""); 
    318326                        } 
    319327                } 
    320                 if (sp->new_config != NULL) { 
     328                if (sp[0]->new_config != NULL) { 
    321329                        /* wait for mbus messages - closing audio device    */ 
    322330                        /* can timeout unprocessed messages as some drivers */ 
    323331                        /* pause to drain before closing.                   */ 
    324                         network_process_mbus(sp); 
    325                         if (audio_device_reconfigure(sp)) { 
    326                                 int saved_playing_audio = sp->playing_audio; 
     332                        network_process_mbus(sp[0]); 
     333                        if (audio_device_reconfigure(sp[0])) { 
     334                                int saved_playing_audio = sp[0]->playing_audio; 
    327335                                /* Device reconfig takes a second or two, discard 
    328336                                 * data that has arrived during this time 
    329337                                 */ 
    330                                 sp->playing_audio = 0; 
     338                                sp[0]->playing_audio = 0; 
    331339                                timeout.tv_sec  = 0; 
    332340                                timeout.tv_usec = 0; 
    333                                 for (j = 0; j < sp->rtp_session_count; j++) { 
    334                                         while(rtp_recv(sp->rtp_session[j], &timeout, rtp_time)); 
     341                                for (j = 0; j < sp[0]->rtp_session_count; j++) { 
     342                                        while(rtp_recv(sp[0]->rtp_session[j], &timeout, rtp_time)); 
    335343                                } 
    336                                 sp->playing_audio = saved_playing_audio; 
     344                                sp[0]->playing_audio = saved_playing_audio; 
    337345                                /* Device reconfigured so decode paths of all sources */ 
    338346                                /* are misconfigured. Delete the source, and incoming */ 
    339347                                /* data will drive the correct new path.              */ 
    340                                 source_list_clear(sp->active_sources); 
    341                                 ui_send_audio_update(sp, sp->mbus_ui_addr); 
    342                                 if (sp->local_file_player) { 
    343                                         voxlet_destroy(&sp->local_file_player); 
     348                                source_list_clear(sp[0]->active_sources); 
     349                                ui_send_audio_update(sp[0], sp[0]->mbus_ui_addr); 
     350                                if (sp[0]->local_file_player) { 
     351                                        voxlet_destroy(&sp[0]->local_file_player); 
    344352                                } 
    345353                        } 
     
    347355                 
    348356                /* Choke CPU usage */ 
    349                 if (!audio_is_ready(sp->audio_device)) { 
    350                         audio_wait_for(sp->audio_device, 50); 
     357                if (!audio_is_ready(sp[0]->audio_device)) { 
     358                        audio_wait_for(sp[0]->audio_device, 50); 
    351359                } 
    352360 
    353361                /* Check controller is still alive */ 
    354                 if (mbus_addr_valid(sp->mbus_engine, c_addr) == FALSE) { 
     362                if (mbus_addr_valid(sp[0]->mbus_engine, c_addr) == FALSE) { 
    355363                        should_exit = TRUE; 
    356364                        debug_msg("Controller address is no longer valid.  Assuming it exited\n"); 
     
    358366 
    359367                /* Debugging sanity check of the session... */ 
    360                 session_validate(sp); 
     368                session_validate(sp[0]); 
    361369                /* ...and check that nothing has trashed memory too badly! */ 
    362370                xmemchk(); 
    363371        } 
    364372 
    365         settings_save(sp); 
    366         tx_stop(sp->tb); 
    367  
    368         for (j = 0; j < sp->rtp_session_count; j++) { 
    369                 rtp_send_bye(sp->rtp_session[j]); 
    370                 rtp_done(sp->rtp_session[j]); 
    371                 rtp_callback_exit(sp->rtp_session[j]); 
     373        settings_save(sp[0]); 
     374        tx_stop(sp[0]->tb); 
     375 
     376        for (j = 0; j < sp[0]->rtp_session_count; j++) { 
     377                rtp_send_bye(sp[0]->rtp_session[j]); 
     378                rtp_done(sp[0]->rtp_session[j]); 
     379                rtp_callback_exit(sp[0]->rtp_session[j]); 
    372380        } 
    373381 
    374382        /* Inform other processes that we're about to quit... */ 
    375         mbus_qmsgf(sp->mbus_engine, "()", FALSE, "mbus.bye", ""); 
    376         mbus_send(sp->mbus_engine); 
     383        mbus_qmsgf(sp[0]->mbus_engine, "()", FALSE, "mbus.bye", ""); 
     384        mbus_send(sp[0]->mbus_engine); 
    377385 
    378386        /* Free audio device and clean up */ 
    379         audio_device_release(sp, sp->audio_device); 
     387        audio_device_release(sp[0], sp[0]->audio_device); 
    380388        audio_free_interfaces(); 
    381389         
    382         if (mbus_addr_valid(sp->mbus_engine, c_addr)) { 
     390        if (mbus_addr_valid(sp[0]->mbus_engine, c_addr)) { 
    383391                do { 
    384392                        struct timeval   timeout; 
    385                         mbus_send(sp->mbus_engine);  
     393                        mbus_send(sp[0]->mbus_engine);  
    386394                        /* At this stage we no longer care about acks for messages */ 
    387                         /* mbus_retransmit(sp->mbus_engine); */ 
     395                        /* mbus_retransmit(sp[0]->mbus_engine); */ 
    388396                        timeout.tv_sec  = 0; 
    389397                        timeout.tv_usec = 20000; 
    390                         mbus_recv(sp->mbus_engine, sp, &timeout); 
    391                 } while (!mbus_sent_all(sp->mbus_engine) && mbus_shutdown_error == FALSE); 
     398                        mbus_recv(sp[0]->mbus_engine, sp[0], &timeout); 
     399                } while (!mbus_sent_all(sp[0]->mbus_engine) && mbus_shutdown_error == FALSE); 
    392400        } 
    393401         
    394         mbus_exit(sp->mbus_engine); 
    395  
    396         session_validate(sp); 
    397         session_exit(sp); 
     402        mbus_exit(sp[0]->mbus_engine); 
     403 
     404        session_validate(sp[0]); 
     405        session_exit(sp[0]); 
    398406         
    399407        converters_free();