Changeset 3846

Show
Ignore:
Timestamp:
09/12/06 17:40:38 (8 years ago)
Author:
piers
Message:

Reformatted. Added assert() after new rtp_init().

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • rat/trunk/mbus_engine.c

    r3828 r3846  
    11/* 
    2  * FILE:    mbus_engine.c 
    3  * AUTHORS: Colin Perkins 
    4  * MODIFICATIONS: Orion Hodson 
    5  * 
    6  * Copyright (c) 1998-2001 University College London 
    7  * All rights reserved. 
    8  */ 
     2* FILE:    mbus_engine.c 
     3* AUTHORS: Colin Perkins 
     4* MODIFICATIONS: Orion Hodson 
     5* 
     6* Copyright (c) 1998-2001 University College London 
     7* All rights reserved. 
     8*/ 
    99 
    1010#ifndef HIDE_SOURCE_STRINGS 
    1111static const char cvsid[] = 
    12         "$Id$"; 
     12"$Id$"; 
    1313#endif /* HIDE_SOURCE_STRINGS */ 
    1414 
     
    5858/* Tuple to associate string received with it's parsing fn */ 
    5959typedef struct { 
    60         const char   *rxname; 
    61         mbus_rx_proc  rxproc; 
     60        const char   *rxname; 
     61        mbus_rx_proc  rxproc; 
    6262} mbus_cmd_tuple; 
    6363 
     
    9898static void rx_tool_rat_silence(char *srce, char *args, session_t *sp) 
    9999{ 
    100         char *detector; 
     100        char *detector; 
    101101        struct mbus_parser      *mp; 
    102102 
     
    105105        mp = mbus_parse_init(args); 
    106106        if (mbus_parse_str(mp, &detector)) { 
    107                 mbus_decode_str(detector); 
     107                mbus_decode_str(detector); 
    108108                sp->silence_detection = sd_name_to_type(detector); 
    109                 debug_msg("detector:%s index %d (%s)\n", detector, sp->silence_detection, srce); 
     109                debug_msg("detector:%s index %d (%s)\n", detector, sp->silence_detection, srce); 
    110110        } else { 
    111111                debug_msg("mbus: usage \"tool.rat.silence <Auto|Manual|Off>\"\n"); 
     
    124124        if (mbus_parse_int(mp, &i)) { 
    125125                sp->manual_sd_thresh = i; 
    126                 manual_sd_set_thresh(sp->manual_sd, (uint16_t)i); 
    127                 debug_msg("Setting threshold: %d\n", i); 
     126                manual_sd_set_thresh(sp->manual_sd, (uint16_t)i); 
     127                debug_msg("Setting threshold: %d\n", i); 
    128128        } else { 
    129129                debug_msg("mbus: usage \"tool.rat.silence.threshold <int>\"\n"); 
     
    141141        mp = mbus_parse_init(args); 
    142142        if (mbus_parse_int(mp, &i)) { 
    143                 audio_device_register_change_render_3d(sp, i); 
     143                audio_device_register_change_render_3d(sp, i); 
    144144        } else { 
    145145                debug_msg("mbus: usage \"audio.3d.enabled <boolean>\"\n"); 
     
    151151rx_audio_3d_user_settings(char *srce, char *args, session_t *sp) 
    152152{ 
    153         pdb_entry_t             *p; 
    154         char                    *filter_name; 
    155         int                      filter_type, filter_length, azimuth, freq; 
     153        pdb_entry_t             *p; 
     154        char                    *filter_name; 
     155        int                      filter_type, filter_length, azimuth, freq; 
    156156        char                    *ss; 
    157         uint32_t                 ssrc; 
    158         struct mbus_parser      *mp; 
    159  
    160         UNUSED(srce); 
    161  
    162         mp = mbus_parse_init(args); 
     157        uint32_t                 ssrc; 
     158        struct mbus_parser      *mp; 
     159 
     160        UNUSED(srce); 
     161 
     162        mp = mbus_parse_init(args); 
    163163        if (mbus_parse_str(mp, &ss) && 
    164             mbus_parse_str(mp, &filter_name) && 
    165             mbus_parse_int(mp, &filter_length) && 
    166             mbus_parse_int(mp, &azimuth)) { 
    167  
    168                 mbus_decode_str(filter_name); 
    169                 ss = mbus_decode_str(ss); 
    170                 ssrc = strtoul(ss, 0, 16); 
    171  
    172                 if (pdb_item_get(sp->pdb, ssrc, &p)) { 
    173                         filter_type = render_3D_filter_get_by_name(filter_name); 
    174                         freq        = ts_get_freq(sp->cur_ts); 
    175                         if (p->render_3D_data == NULL) { 
    176                                 p->render_3D_data = render_3D_init(freq); 
    177                         } 
    178                         render_3D_set_parameters(p->render_3D_data, 
    179                                                  freq, 
    180                                                  azimuth, 
    181                                                  filter_type, 
    182                                                  filter_length); 
    183                 } else { 
    184                         debug_msg("Unknown source 0x%08lx\n", ssrc); 
    185                 } 
    186         } else { 
    187                 debug_msg("mbus: usage \"audio.3d.user.settings <cname> <filter name> <filter len> <azimuth>\"\n"); 
    188         } 
    189         mbus_parse_done(mp); 
     164                mbus_parse_str(mp, &filter_name) && 
     165                mbus_parse_int(mp, &filter_length) && 
     166                mbus_parse_int(mp, &azimuth)) { 
     167 
     168                        mbus_decode_str(filter_name); 
     169                        ss = mbus_decode_str(ss); 
     170                        ssrc = strtoul(ss, 0, 16); 
     171 
     172                        if (pdb_item_get(sp->pdb, ssrc, &p)) { 
     173                                filter_type = render_3D_filter_get_by_name(filter_name); 
     174                                freq        = ts_get_freq(sp->cur_ts); 
     175                                if (p->render_3D_data == NULL) { 
     176                                        p->render_3D_data = render_3D_init(freq); 
     177                                } 
     178                                render_3D_set_parameters(p->render_3D_data, 
     179                                        freq, 
     180                                        azimuth, 
     181                                        filter_type, 
     182                                        filter_length); 
     183                        } else { 
     184                                debug_msg("Unknown source 0x%08lx\n", ssrc); 
     185                        } 
     186                } else { 
     187                        debug_msg("mbus: usage \"audio.3d.user.settings <cname> <filter name> <filter len> <azimuth>\"\n"); 
     188                } 
     189                mbus_parse_done(mp); 
    190190} 
    191191 
     
    194194{ 
    195195        char                    *ss; 
    196         uint32_t                 ssrc; 
    197         struct mbus_parser      *mp; 
    198  
    199         UNUSED(srce); 
    200  
    201         mp = mbus_parse_init(args); 
     196        uint32_t                 ssrc; 
     197        struct mbus_parser      *mp; 
     198 
     199        UNUSED(srce); 
     200 
     201        mp = mbus_parse_init(args); 
    202202        if (mbus_parse_str(mp, &ss)) { 
    203203                ss   = mbus_decode_str(ss); 
    204                 ssrc = strtoul(ss, 0, 16); 
    205                 ui_send_audio_3d_settings(sp, sp->mbus_ui_addr, ssrc); 
    206         } 
    207         mbus_parse_done(mp); 
     204                ssrc = strtoul(ss, 0, 16); 
     205                ui_send_audio_3d_settings(sp, sp->mbus_ui_addr, ssrc); 
     206        } 
     207        mbus_parse_done(mp); 
    208208} 
    209209 
     
    265265        mp = mbus_parse_init(args); 
    266266        if (mbus_parse_int(mp, &i)) { 
    267                 if (i) { 
    268                         audio_loopback(sp->audio_device, 100); 
     267                if (i) { 
     268                        audio_loopback(sp->audio_device, 100); 
    269269                        sp->loopback_gain = 100; 
    270                 } else { 
    271                         audio_loopback(sp->audio_device, 0); 
     270                } else { 
     271                        audio_loopback(sp->audio_device, 0); 
    272272                        sp->loopback_gain = 0; 
    273                 } 
     273                } 
    274274        } else { 
    275275                debug_msg("mbus: usage \"tool.rat.loopback.gain <boolean>\"\n"); 
     
    288288        if (mbus_parse_int(mp, &i)) { 
    289289                sp->echo_suppress = i; 
    290                 if (sp->echo_suppress     == FALSE && 
    291                     sp->echo_tx_active    == TRUE  && 
    292                     tx_is_sending(sp->tb) == FALSE) { 
    293                         /* Suppressor has just been disabled,  transmitter  */ 
    294                         /* is in suppressed state and would otherwise be    */ 
    295                         /* active.  Therefore start it up now.              */ 
    296                         tx_start(sp->tb); 
    297                 } 
     290                if (sp->echo_suppress     == FALSE && 
     291                        sp->echo_tx_active    == TRUE  && 
     292                        tx_is_sending(sp->tb) == FALSE) { 
     293                                /* Suppressor has just been disabled,  transmitter  */ 
     294                                /* is in suppressed state and would otherwise be    */ 
     295                                /* active.  Therefore start it up now.              */ 
     296                                tx_start(sp->tb); 
     297                        } 
    298298        } else { 
    299299                debug_msg("mbus: usage \"tool.rat.echo.suppress <boolean>\"\n"); 
     
    311311        mp = mbus_parse_init(args); 
    312312        if (mbus_parse_int(mp, &i)) { 
    313                 assert(sp->channel_coder != NULL); 
    314                 channel_encoder_set_units_per_packet(sp->channel_coder, (uint16_t)i); 
     313                assert(sp->channel_coder != NULL); 
     314                channel_encoder_set_units_per_packet(sp->channel_coder, (uint16_t)i); 
    315315                ui_send_rate(sp, sp->mbus_ui_addr); 
    316316        } else { 
     
    330330        if (mbus_parse_int(mp, &i)) { 
    331331                if (i) { 
    332                         if (tx_is_sending(sp->tb)) { 
    333                                 tx_stop(sp->tb); 
    334                         } 
     332                        if (tx_is_sending(sp->tb)) { 
     333                                tx_stop(sp->tb); 
     334                        } 
    335335                } else { 
    336                         if (tx_is_sending(sp->tb) == FALSE) { 
    337                                 tx_start(sp->tb); 
    338                         } 
    339                 } 
    340                 /* Keep echo suppressor informed of change */ 
    341                 sp->echo_tx_active = !i; 
     336                        if (tx_is_sending(sp->tb) == FALSE) { 
     337                                tx_start(sp->tb); 
     338                        } 
     339                } 
     340                /* Keep echo suppressor informed of change */ 
     341                sp->echo_tx_active = !i; 
    342342                ui_send_audio_input_port(sp, sp->mbus_ui_addr); 
    343343                ui_send_audio_input_mute(sp, sp->mbus_ui_addr); 
     
    358358        mp = mbus_parse_init(args); 
    359359        if (mbus_parse_int(mp, &i) && 
    360             (i >= 0 && i <= 100)) { 
    361                 audio_set_igain(sp->audio_device, i); 
    362                 tx_igain_update(sp->tb); 
    363         } else { 
    364                 debug_msg("mbus: usage \"audio.input.gain <integer>\"\n"); 
    365         } 
    366         mbus_parse_done(mp); 
     360                (i >= 0 && i <= 100)) { 
     361                        audio_set_igain(sp->audio_device, i); 
     362                        tx_igain_update(sp->tb); 
     363                } else { 
     364                        debug_msg("mbus: usage \"audio.input.gain <integer>\"\n"); 
     365                } 
     366                mbus_parse_done(mp); 
    367367} 
    368368 
    369369static void rx_audio_input_port(char *srce, char *args, session_t *sp) 
    370370{ 
    371         const audio_port_details_t *apd = NULL; 
     371        const audio_port_details_t *apd = NULL; 
    372372        char                    *s; 
    373         int                      i, n, found; 
     373        int                      i, n, found; 
    374374        struct mbus_parser      *mp; 
    375375 
     
    379379        if (mbus_parse_str(mp, &s)) { 
    380380                s = mbus_decode_str(s); 
    381                 n = audio_get_iport_count(sp->audio_device); 
    382                 found = FALSE; 
    383                 for(i = 0; i < n; i++) { 
    384                         apd = audio_get_iport_details(sp->audio_device, i); 
    385                         if (!strcasecmp(s, apd->name)) { 
    386                                 found = TRUE; 
    387                                 break; 
    388                         } 
    389                 } 
    390                 if (found == FALSE) { 
    391                         debug_msg("%s does not match any port names\n", s); 
    392                         apd = audio_get_iport_details(sp->audio_device, 0); 
    393                 } 
    394                 audio_set_iport(sp->audio_device, apd->port); 
     381                n = audio_get_iport_count(sp->audio_device); 
     382                found = FALSE; 
     383                for(i = 0; i < n; i++) { 
     384                        apd = audio_get_iport_details(sp->audio_device, i); 
     385                        if (!strcasecmp(s, apd->name)) { 
     386                                found = TRUE; 
     387                                break; 
     388                        } 
     389                } 
     390                if (found == FALSE) { 
     391                        debug_msg("%s does not match any port names\n", s); 
     392                        apd = audio_get_iport_details(sp->audio_device, 0); 
     393                } 
     394                audio_set_iport(sp->audio_device, apd->port); 
    395395        } else { 
    396396                debug_msg("mbus: usage \"audio.input.port <port>\"\n"); 
     
    405405{ 
    406406        struct mbus_parser      *mp; 
    407         struct s_source         *s; 
     407        struct s_source         *s; 
    408408        int                      i, n; 
    409409 
     
    412412        mp = mbus_parse_init(args); 
    413413        if (mbus_parse_int(mp, &i)) { 
    414                 sp->playing_audio = !i; 
     414                sp->playing_audio = !i; 
    415415                ui_send_audio_output_port(sp, sp->mbus_ui_addr); 
    416                 n = (int)source_list_source_count(sp->active_sources); 
    417                 for (i = 0; i < n; i++) { 
    418                         s = source_list_get_source_no(sp->active_sources, i); 
    419                         ui_send_rtp_inactive(sp, sp->mbus_ui_addr, source_get_ssrc(s)); 
    420                         source_remove(sp->active_sources, s); 
    421                         /* revise source no's since we removed a source */ 
    422                         i--; 
    423                         n--; 
    424                 } 
     416                n = (int)source_list_source_count(sp->active_sources); 
     417                for (i = 0; i < n; i++) { 
     418                        s = source_list_get_source_no(sp->active_sources, i); 
     419                        ui_send_rtp_inactive(sp, sp->mbus_ui_addr, source_get_ssrc(s)); 
     420                        source_remove(sp->active_sources, s); 
     421                        /* revise source no's since we removed a source */ 
     422                        i--; 
     423                        n--; 
     424                } 
    425425        } else { 
    426426                debug_msg("mbus: usage \"audio.output.mute <boolean>\"\n"); 
     
    438438        mp = mbus_parse_init(args); 
    439439        if (mbus_parse_int(mp, &i) && 
    440             (i >= 0 && i <= 100)) { 
    441                 audio_set_ogain(sp->audio_device, i); 
    442         } else { 
    443                 debug_msg("mbus: usage \"audio.output.gain <integer>\"\n"); 
    444         } 
    445         mbus_parse_done(mp); 
     440                (i >= 0 && i <= 100)) { 
     441                        audio_set_ogain(sp->audio_device, i); 
     442                } else { 
     443                        debug_msg("mbus: usage \"audio.output.gain <integer>\"\n"); 
     444                } 
     445                mbus_parse_done(mp); 
    446446} 
    447447 
    448448static void rx_audio_output_port(char *srce, char *args, session_t *sp) 
    449449{ 
    450         const audio_port_details_t *apd = NULL; 
     450        const audio_port_details_t *apd = NULL; 
    451451        char *s; 
    452         int   i, n, found; 
     452        int   i, n, found; 
    453453        struct mbus_parser      *mp; 
    454454 
     
    458458        if (mbus_parse_str(mp, &s)) { 
    459459                s = mbus_decode_str(s); 
    460                 n     = audio_get_oport_count(sp->audio_device); 
    461                 found = FALSE; 
    462  
    463                 for(i = 0; i < n; i++) { 
    464                         apd = audio_get_oport_details(sp->audio_device, i); 
    465                         if (!strcasecmp(s, apd->name)) { 
    466                                 found = TRUE; 
    467                                 break; 
    468                         } 
    469                 } 
    470                 if (found == FALSE) { 
    471                         debug_msg("%s does not match any port names\n", s); 
    472                         apd = audio_get_oport_details(sp->audio_device, 0); 
    473                 } 
    474                 audio_set_oport(sp->audio_device, apd->port); 
     460                n     = audio_get_oport_count(sp->audio_device); 
     461                found = FALSE; 
     462 
     463                for(i = 0; i < n; i++) { 
     464                        apd = audio_get_oport_details(sp->audio_device, i); 
     465                        if (!strcasecmp(s, apd->name)) { 
     466                                found = TRUE; 
     467                                break; 
     468                        } 
     469                } 
     470                if (found == FALSE) { 
     471                        debug_msg("%s does not match any port names\n", s); 
     472                        apd = audio_get_oport_details(sp->audio_device, 0); 
     473                } 
     474                audio_set_oport(sp->audio_device, apd->port); 
    475475        } else { 
    476476                debug_msg("mbus: usage \"audio.output.port <port>\"\n"); 
     
    484484static void rx_audio_channel_repair(char *srce, char *args, session_t *sp) 
    485485{ 
    486         const repair_details_t *r; 
    487         uint16_t i, n; 
     486        const repair_details_t *r; 
     487        uint16_t i, n; 
    488488        char    *s; 
    489489        struct mbus_parser      *mp; 
     
    494494        if (mbus_parse_str(mp, &s)) { 
    495495                s = mbus_decode_str(s); 
    496                 if (strcasecmp(s, "first") == 0) { 
    497                         r = repair_get_details(0); 
    498                         sp->repair = r->id; 
    499                 } else { 
    500                         n = repair_get_count(); 
    501                         for(i = 0; i < n; i++) { 
    502                                 r = repair_get_details(i); 
    503                                 if (strcasecmp(r->name, s) == 0 || strcasecmp("first", s) == 0) { 
    504                                         sp->repair = r->id; 
    505                                         break; 
    506                                 } 
    507                         } 
    508                 } 
     496                if (strcasecmp(s, "first") == 0) { 
     497                        r = repair_get_details(0); 
     498                        sp->repair = r->id; 
     499                } else { 
     500                        n = repair_get_count(); 
     501                        for(i = 0; i < n; i++) { 
     502                                r = repair_get_details(i); 
     503                                if (strcasecmp(r->name, s) == 0 || strcasecmp("first", s) == 0) { 
     504                                        sp->repair = r->id; 
     505                                        break; 
     506                                } 
     507                        } 
     508                } 
    509509        } else { 
    510510                debug_msg("mbus: usage \"audio.channel.repair <repair>\"\n"); 
    511511        } 
    512512        mbus_parse_done(mp); 
    513         ui_send_audio_channel_repair(sp, sp->mbus_ui_addr); 
     513        ui_send_audio_channel_repair(sp, sp->mbus_ui_addr); 
    514514} 
    515515 
    516516static void rx_security_encryption_key(char *srce, char *args, session_t *sp) 
    517517{ 
    518         int      i; 
     518        int      i; 
    519519        char    *key; 
    520520        struct mbus_parser      *mp; 
     
    526526        if (mbus_parse_str(mp, &key)) { 
    527527                debug_msg("rx_security_encryption_key: key: %s\n",key); 
    528                 key = mbus_decode_str(key); 
    529                 for(i = 0; i < sp->rtp_session_count; i++) { 
     528                key = mbus_decode_str(key); 
     529                for(i = 0; i < sp->rtp_session_count; i++) { 
    530530                        if (strlen(key) == 0) { 
    531                                 rtp_set_encryption_key(sp->rtp_session[i], NULL); 
     531                                rtp_set_encryption_key(sp->rtp_session[i], NULL); 
    532532                                sp->encrkey = NULL; 
    533533                                ui_send_encryption_key(sp, sp->mbus_ui_addr); 
    534534                        } else { 
    535                                 rtp_set_encryption_key(sp->rtp_session[i], key); 
     535                                rtp_set_encryption_key(sp->rtp_session[i], key); 
    536536                                sp->encrkey = xstrdup(key); 
    537537                                ui_send_encryption_key(sp, sp->mbus_ui_addr); 
    538538                        } 
    539                 } 
     539                } 
    540540        } else { 
    541541                debug_msg("mbus: usage \"security.encryption.key <key>\"\n"); 
     
    547547{ 
    548548        UNUSED(srce); 
    549         UNUSED(args); 
     549        UNUSED(args); 
    550550 
    551551        if (sp->in_file != NULL) { 
     
    560560 
    561561        UNUSED(srce); 
    562         UNUSED(sp); 
     562        UNUSED(sp); 
    563563 
    564564        mp = mbus_parse_init(args); 
    565565        if (mbus_parse_str(mp, &file)) { 
    566                 mbus_decode_str(file); 
    567                 if (sp->local_file_player) { 
    568                         voxlet_destroy(&sp->local_file_player); 
    569                 } 
    570                 voxlet_create(&sp->local_file_player, sp->ms, sp->pdb, file); 
     566                mbus_decode_str(file); 
     567                if (sp->local_file_player) { 
     568                        voxlet_destroy(&sp->local_file_player); 
     569                } 
     570                voxlet_create(&sp->local_file_player, sp->ms, sp->pdb, file); 
    571571        } else { 
    572572                debug_msg("mbus: usage \"tool.rat.voxlet.play <filename>\"\n"); 
     
    633633static void rx_tool_rat_tone_start(char *srce, char *args, session_t *sp) 
    634634{ 
    635         int freq, amp; 
     635        int freq, amp; 
    636636        struct mbus_parser *mp; 
    637637 
    638         UNUSED(srce); 
    639  
    640         if (sp->tone_generator) { 
    641                 tonegen_destroy(&sp->tone_generator); 
    642         } 
    643  
    644         mp = mbus_parse_init(args); 
     638        UNUSED(srce); 
     639 
     640        if (sp->tone_generator) { 
     641                tonegen_destroy(&sp->tone_generator); 
     642        } 
     643 
     644        mp = mbus_parse_init(args); 
    645645        if (mbus_parse_int(mp, &freq) && 
    646             mbus_parse_int(mp, &amp)) { 
    647                 tonegen_create(&sp->tone_generator, sp->ms, sp->pdb, (uint16_t)freq, (uint16_t)amp); 
    648         } else { 
    649                 debug_msg("mbus: usage \"tool.rat.tone.start <freq> <amplitude>\"\n"); 
    650         } 
    651         mbus_parse_done(mp); 
     646                mbus_parse_int(mp, &amp)) { 
     647                        tonegen_create(&sp->tone_generator, sp->ms, sp->pdb, (uint16_t)freq, (uint16_t)amp); 
     648                } else { 
     649                        debug_msg("mbus: usage \"tool.rat.tone.start <freq> <amplitude>\"\n"); 
     650                } 
     651                mbus_parse_done(mp); 
    652652} 
    653653 
    654654static void rx_tool_rat_tone_stop(char *srce, char *args, session_t *sp) 
    655655{ 
    656         UNUSED(srce); 
    657         UNUSED(args); 
    658         if (sp->tone_generator) { 
    659                 tonegen_destroy(&sp->tone_generator); 
    660         } 
     656        UNUSED(srce); 
     657        UNUSED(args); 
     658        if (sp->tone_generator) { 
     659                tonegen_destroy(&sp->tone_generator); 
     660        } 
    661661} 
    662662 
     
    667667 
    668668        UNUSED(srce); 
    669         UNUSED(sp); 
     669        UNUSED(sp); 
    670670 
    671671        mp = mbus_parse_init(args); 
    672672        if (mbus_parse_str(mp, &file)) { 
    673                 mbus_decode_str(file); 
    674                 if (sp->in_file) snd_read_close(&sp->in_file); 
    675                 if (snd_read_open(&sp->in_file, file, NULL)) { 
    676                         debug_msg("Hooray opened %s\n",file); 
    677                 } 
     673                mbus_decode_str(file); 
     674                if (sp->in_file) snd_read_close(&sp->in_file); 
     675                if (snd_read_open(&sp->in_file, file, NULL)) { 
     676                        debug_msg("Hooray opened %s\n",file); 
     677                } 
    678678        } else { 
    679679                debug_msg("mbus: usage \"audio.file.play.open <filename>\"\n"); 
     
    681681        mbus_parse_done(mp); 
    682682 
    683         if (sp->in_file) { 
    684                 ui_send_audio_file_play_ready(sp, sp->mbus_ui_addr, file); 
    685         } 
     683        if (sp->in_file) { 
     684                ui_send_audio_file_play_ready(sp, sp->mbus_ui_addr, file); 
     685        } 
    686686} 
    687687 
    688688static void rx_audio_file_play_pause(char *srce, char *args, session_t *sp) 
    689689{ 
    690         int pause; 
    691         struct mbus_parser      *mp; 
    692  
    693         UNUSED(srce); 
    694  
    695         mp = mbus_parse_init(args); 
    696  
    697         if (mbus_parse_int(mp, &pause)) { 
    698                 if (sp->in_file) { 
    699                         if (pause) { 
    700                                 snd_pause(sp->in_file); 
    701                         } else { 
    702                                 snd_resume(sp->in_file); 
    703                         } 
    704                 } 
    705         } else { 
    706                 debug_msg("mbus: usage \"audio.file.play.pause <bool>\"\n"); 
    707         } 
    708         mbus_parse_done(mp); 
     690        int pause; 
     691        struct mbus_parser      *mp; 
     692 
     693        UNUSED(srce); 
     694 
     695        mp = mbus_parse_init(args); 
     696 
     697        if (mbus_parse_int(mp, &pause)) { 
     698                if (sp->in_file) { 
     699                        if (pause) { 
     700                                snd_pause(sp->in_file); 
     701                        } else { 
     702                                snd_resume(sp->in_file); 
     703                        } 
     704                } 
     705        } else { 
     706                debug_msg("mbus: usage \"audio.file.play.pause <bool>\"\n"); 
     707        } 
     708        mbus_parse_done(mp); 
    709709} 
    710710 
    711711static void rx_audio_file_play_live(char *srce, char *args, session_t *sp) 
    712712{ 
    713         /* This is a request to see if file we are playing is still valid */ 
    714         UNUSED(args); 
    715         UNUSED(srce); 
    716         ui_send_audio_file_alive(sp, sp->mbus_ui_addr, "play", (sp->in_file) ? 1 : 0); 
     713        /* This is a request to see if file we are playing is still valid */ 
     714        UNUSED(args); 
     715        UNUSED(srce); 
     716        ui_send_audio_file_alive(sp, sp->mbus_ui_addr, "play", (sp->in_file) ? 1 : 0); 
    717717} 
    718718 
     
    720720{ 
    721721        UNUSED(srce); 
    722         UNUSED(args); 
    723  
    724         if (sp->out_file != NULL) { 
     722        UNUSED(args); 
     723 
     724        if (sp->out_file != NULL) { 
    725725                snd_write_close(&sp->out_file); 
    726726        } 
     
    736736        mp = mbus_parse_init(args); 
    737737        if (mbus_parse_str(mp, &file)) { 
    738                 sndfile_fmt_t sf_fmt; 
    739                 const audio_format *ofmt; 
    740                 ofmt = audio_get_ofmt(sp->audio_device); 
    741                 mbus_decode_str(file); 
    742                 if (sp->out_file) snd_write_close(&sp->out_file); 
    743  
    744                 sf_fmt.encoding    = SNDFILE_ENCODING_L16; 
    745                 sf_fmt.sample_rate = (uint32_t)ofmt->sample_rate; 
    746                 sf_fmt.channels    = (uint16_t)ofmt->channels; 
     738                sndfile_fmt_t sf_fmt; 
     739                const audio_format *ofmt; 
     740                ofmt = audio_get_ofmt(sp->audio_device); 
     741                mbus_decode_str(file); 
     742                if (sp->out_file) snd_write_close(&sp->out_file); 
     743 
     744                sf_fmt.encoding    = SNDFILE_ENCODING_L16; 
     745                sf_fmt.sample_rate = (uint32_t)ofmt->sample_rate; 
     746                sf_fmt.channels    = (uint16_t)ofmt->channels; 
    747747#ifdef WIN32 
    748                 if (snd_write_open(&sp->out_file, file, "wav", &sf_fmt)) { 
    749                         debug_msg("Hooray opened %s\n",file); 
    750                 } 
     748                if (snd_write_open(&sp->out_file, file, "wav", &sf_fmt)) { 
     749                        debug_msg("Hooray opened %s\n",file); 
     750                } 
    751751#else 
    752                 if (snd_write_open(&sp->out_file, file, "au", &sf_fmt)) { 
    753                         debug_msg("Hooray opened %s\n",file); 
    754                 } 
     752                if (snd_write_open(&sp->out_file, file, "au", &sf_fmt)) { 
     753                        debug_msg("Hooray opened %s\n",file); 
     754                } 
    755755#endif /* WIN32 */ 
    756756        } else { 
     
    759759        mbus_parse_done(mp); 
    760760 
    761         if (sp->out_file) ui_send_audio_file_record_ready(sp, sp->mbus_ui_addr, file); 
     761        if (sp->out_file) ui_send_audio_file_record_ready(sp, sp->mbus_ui_addr, file); 
    762762} 
    763763 
    764764static void rx_audio_file_rec_pause(char *srce, char *args, session_t *sp) 
    765765{ 
    766         int pause; 
    767         struct mbus_parser      *mp; 
    768  
    769         UNUSED(srce); 
    770  
    771         mp = mbus_parse_init(args); 
    772  
    773         if (mbus_parse_int(mp, &pause)) { 
    774                 if (sp->out_file) { 
    775                         if (pause) { 
    776                                 snd_pause(sp->out_file); 
    777                         } else { 
    778                                 snd_resume(sp->out_file); 
    779                         } 
    780                 } 
    781         } else { 
    782                 debug_msg("mbus: usage \"audio.file.record.pause <bool>\"\n"); 
    783         } 
    784         mbus_parse_done(mp); 
     766        int pause; 
     767        struct mbus_parser      *mp; 
     768 
     769        UNUSED(srce); 
     770 
     771        mp = mbus_parse_init(args); 
     772 
     773        if (mbus_parse_int(mp, &pause)) { 
     774                if (sp->out_file) { 
     775                        if (pause) { 
     776                                snd_pause(sp->out_file); 
     777                        } else { 
     778                                snd_resume(sp->out_file); 
     779                        } 
     780                } 
     781        } else { 
     782                debug_msg("mbus: usage \"audio.file.record.pause <bool>\"\n"); 
     783        } 
     784        mbus_parse_done(mp); 
    785785} 
    786786 
    787787static void rx_audio_file_rec_live(char *srce, char *args, session_t *sp) 
    788788{ 
    789         /* This is a request to see if file we are recording is still valid */ 
    790         UNUSED(args); 
    791         UNUSED(srce); 
    792         ui_send_audio_file_alive(sp, sp->mbus_ui_addr, "record", (sp->out_file) ? 1 : 0); 
     789        /* This is a request to see if file we are recording is still valid */ 
     790        UNUSED(args); 
     791        UNUSED(srce); 
     792        ui_send_audio_file_alive(sp, sp->mbus_ui_addr, "record", (sp->out_file) ? 1 : 0); 
    793793} 
    794794 
     
    796796rx_audio_device(char *srce, char *args, session_t *sp) 
    797797{ 
    798         char    *s, dev_name[64], first_dev_name[64]; 
     798        char    *s, dev_name[64], first_dev_name[64]; 
    799799        struct mbus_parser      *mp; 
    800800 
     
    804804        if (mbus_parse_str(mp, &s)) { 
    805805                s = mbus_decode_str(s); 
    806                 purge_chars(s, "[]()"); 
    807                 if (s) { 
    808                         const audio_device_details_t *add = NULL; 
    809                         audio_desc_t           first_dev_desc = 0; 
    810                         uint32_t i, n, stop_at_first_device = FALSE; 
    811                         dev_name[0] = 0; 
    812                         first_dev_name[0] = 0; 
    813                         n = audio_get_device_count(); 
    814  
    815                         if (!strncasecmp("first", s, 5)) { 
    816                                 /* The ui may send first if the saved device is the null audio 
    817                                  * device so it starts up trying to play something. 
    818                                  */ 
    819                                 stop_at_first_device = TRUE; 
    820                         } 
    821  
    822                         for(i = 0; i < n; i++) { 
    823                                 /* Brackets are a problem so purge them */ 
    824                                 add = audio_get_device_details(i); 
    825                                 strncpy(dev_name, add->name, AUDIO_DEVICE_NAME_LENGTH); 
    826                                 purge_chars(dev_name, "[]()"); 
    827                                 if (first_dev_name[0] == 0) { 
    828                                         strncpy(first_dev_name, dev_name, AUDIO_DEVICE_NAME_LENGTH); 
    829                                         first_dev_desc = add->descriptor; 
    830                                 } 
    831  
    832                                 if (!strcmp(s, dev_name) | stop_at_first_device) { 
    833                                         break; 
    834                                 } 
    835                         } 
    836                         if (i < n) { 
    837                                 /* Found device looking for */ 
    838                                 audio_device_register_change_device(sp, add->descriptor); 
    839                         } else if (first_dev_name[0]) { 
    840                                 /* Have a fall back */ 
    841                                 audio_device_register_change_device(sp, first_dev_desc); 
    842                         } 
    843                 } 
     806                purge_chars(s, "[]()"); 
     807                if (s) { 
     808                        const audio_device_details_t *add = NULL; 
     809                        audio_desc_t           first_dev_desc = 0; 
     810                        uint32_t i, n, stop_at_first_device = FALSE; 
     811                        dev_name[0] = 0; 
     812                        first_dev_name[0] = 0; 
     813                        n = audio_get_device_count(); 
     814 
     815                        if (!strncasecmp("first", s, 5)) { 
     816                                /* The ui may send first if the saved device is the null audio 
     817                                * device so it starts up trying to play something. 
     818                                */ 
     819                                stop_at_first_device = TRUE; 
     820                        } 
     821 
     822                        for(i = 0; i < n; i++) { 
     823                                /* Brackets are a problem so purge them */ 
     824                                add = audio_get_device_details(i); 
     825                                strncpy(dev_name, add->name, AUDIO_DEVICE_NAME_LENGTH); 
     826                                purge_chars(dev_name, "[]()"); 
     827                                if (first_dev_name[0] == 0) { 
     828                                        strncpy(first_dev_name, dev_name, AUDIO_DEVICE_NAME_LENGTH); 
     829                                        first_dev_desc = add->descriptor; 
     830                                } 
     831 
     832                                if (!strcmp(s, dev_name) | stop_at_first_device) { 
     833                                        break; 
     834                                } 
     835                        } 
     836                        if (i < n) { 
     837                                /* Found device looking for */ 
     838                                audio_device_register_change_device(sp, add->descriptor); 
     839                        } else if (first_dev_name[0]) { 
     840                                /* Have a fall back */ 
     841                                audio_device_register_change_device(sp, first_dev_desc); 
     842                        } 
     843                } 
    844844        } else { 
    845845                debug_msg("mbus: usage \"audio.device <string>\"\n"); 
     
    859859static void rx_rtp_source_sdes(char *srce, char *args, session_t *sp, uint8_t type) 
    860860{ 
    861         char               *arg, *ss; 
    862         uint32_t           ssrc; 
     861        char               *arg, *ss; 
     862        uint32_t           ssrc; 
    863863        struct mbus_parser *mp; 
    864864        UNUSED(srce); 
     
    866866        mp = mbus_parse_init(args); 
    867867        if (mbus_parse_str(mp, &ss) && 
    868             mbus_parse_str(mp, &arg)) { 
    869                 uint32_t my_ssrc = rtp_my_ssrc(sp->rtp_session[0]); 
    870                 ss = mbus_decode_str(ss); 
    871                 if (isalpha((int)ss[0])) { 
    872                         /* 
    873                          * Allow alpha so people can do my_src, me, 
    874                          * local_user, whatever.  Let the mbus police 
    875                          * pick something sane. 
    876                          */ 
    877                         ssrc = my_ssrc; 
    878                 } else { 
    879                         ssrc = strtoul(ss, 0, 16); 
    880                 } 
    881                 if (ssrc == my_ssrc) { 
    882                         char *value; 
    883                         int i, vlen; 
    884                         value = mbus_decode_str(arg); 
    885                         vlen  = strlen(value); 
    886                         for (i = 0; i < sp->rtp_session_count; i++) { 
    887                                 rtp_set_sdes(sp->rtp_session[i], ssrc, type, value, vlen); 
    888                         } 
     868                mbus_parse_str(mp, &arg)) { 
     869                        uint32_t my_ssrc = rtp_my_ssrc(sp->rtp_session[0]); 
     870                        ss = mbus_decode_str(ss); 
     871                        if (isalpha((int)ss[0])) { 
     872                                /* 
     873                                * Allow alpha so people can do my_src, me, 
     874                                * local_user, whatever.  Let the mbus police 
     875                                * pick something sane. 
     876                                */ 
     877                                ssrc = my_ssrc; 
     878                        } else { 
     879                                ssrc = strtoul(ss, 0, 16); 
     880                        } 
     881                        if (ssrc == my_ssrc) { 
     882                                char *value; 
     883                                int i, vlen; 
     884                                value = mbus_decode_str(arg); 
     885                                vlen  = strlen(value); 
     886                                for (i = 0; i < sp->rtp_session_count; i++) { 
     887                                        rtp_set_sdes(sp->rtp_session[i], ssrc, type, value, vlen); 
     888                                } 
     889                        } else { 
     890                                debug_msg("mbus: ssrc %s (%08lx) != %08lx\n", ss, strtoul(ss, 0, 16), rtp_my_ssrc(sp->rtp_session[0])); 
     891                        } 
    889892                } else { 
    890                         debug_msg("mbus: ssrc %s (%08lx) != %08lx\n", ss, strtoul(ss, 0, 16), rtp_my_ssrc(sp->rtp_session[0])); 
    891                 } 
    892         } else { 
    893                 debug_msg("mbus: usage \"rtp_source_<sdes_item> <ssrc> <name>\"\n"); 
    894         } 
    895         mbus_parse_done(mp); 
     893                        debug_msg("mbus: usage \"rtp_source_<sdes_item> <ssrc> <name>\"\n"); 
     894                } 
     895                mbus_parse_done(mp); 
    896896} 
    897897 
     
    907907        ui_send_rtp_ssrc(sp, srce); 
    908908        pdb_get_first_id(sp->pdb, &ssrc); 
    909         my_ssrc = rtp_my_ssrc(sp->rtp_session[0]); 
     909        my_ssrc = rtp_my_ssrc(sp->rtp_session[0]); 
    910910 
    911911        do { 
     
    918918                ui_send_rtp_note(sp, srce, ssrc); 
    919919                ui_send_rtp_mute(sp, srce, ssrc); 
    920                 if (ssrc != my_ssrc) { 
    921                         if ((s = source_get_by_ssrc(sp->active_sources, ssrc)) != NULL) { 
    922                                 ui_send_rtp_active(sp, srce, ssrc); 
    923                         } else { 
    924                                 ui_send_rtp_inactive(sp, srce, ssrc); 
    925                         } 
    926                 } else { 
    927                         tx_update_ui(sp->tb); 
    928                 } 
     920                if (ssrc != my_ssrc) { 
     921                        if ((s = source_get_by_ssrc(sp->active_sources, ssrc)) != NULL) { 
     922                                ui_send_rtp_active(sp, srce, ssrc); 
     923                        } else { 
     924                                ui_send_rtp_inactive(sp, srce, ssrc); 
     925                        } 
     926                } else { 
     927                        tx_update_ui(sp->tb); 
     928                } 
    929929        } while (pdb_get_next_id(sp->pdb, ssrc, &ssrc)); 
    930930        ui_send_rtp_addr(sp, srce); 
     
    999999        int      rx_port, tx_port, ttl; 
    10001000        struct mbus_parser      *mp; 
    1001         char buf[50]; 
    1002         uint32_t           ssrc; 
     1001        char buf[50]; 
     1002        uint32_t           ssrc; 
    10031003 
    10041004        UNUSED(srce); 
     
    10101010        mbus_parse_int(mp, &ttl); 
    10111011        mbus_parse_done(mp); 
    1012         debug_msg("rx_rtp_addr: New Addr:%d,rx_port:%d,tx_port:%d,ttl:%d\n",addr, rx_port, tx_port, ttl); 
     1012        debug_msg("rx_rtp_addr: New Addr:%d,rx_port:%d,tx_port:%d,ttl:%d\n",addr, rx_port, tx_port, ttl); 
    10131013 
    10141014        if (sp->rtp_session_count) { 
    1015           /* Existing session present - delete and recreate with new params */ 
    1016           sp->rtp_session_count--; 
    1017           rx_audio_input_mute(srce, "1", sp); 
    1018           rtp_set_encryption_key(sp->rtp_session[0], NULL); 
    1019           sp->encrkey = NULL; 
    1020           ui_send_encryption_key(sp, sp->mbus_ui_addr); 
    1021           settings_save(sp); 
    1022           rtp_callback_exit(sp->rtp_session[sp->rtp_session_count]); 
    1023           /* Remove existing sources from DB and UI , then destory DB and RTP sess */ 
    1024           pdb_get_first_id(sp->pdb, &ssrc); 
    1025           do { 
    1026               struct s_source *s = source_get_by_ssrc(sp->active_sources, ssrc); 
    1027               if (s != NULL) { 
    1028                 source_remove(sp->active_sources, s); 
    1029               } 
    1030               ui_send_rtp_remove(sp, sp->mbus_ui_addr, ssrc); 
    1031           } while (pdb_get_next_id(sp->pdb, ssrc, &ssrc)); 
    1032           pdb_destroy(&sp->pdb); 
    1033           rtp_done(sp->rtp_session[sp->rtp_session_count]); 
    1034  
    1035           /* Perform rtp session re-creation */ 
    1036           sp->rtp_session[sp->rtp_session_count] = rtp_init(addr, (uint16_t)rx_port, (uint16_t)tx_port, ttl, 64000, rtp_callback_proc, NULL); 
    1037            
    1038           rtp_set_option(sp->rtp_session[sp->rtp_session_count], RTP_OPT_PROMISC, sp->rtp_promiscuous_mode); 
    1039           rtp_callback_init(sp->rtp_session[0], sp); 
    1040  
    1041           if(sp->rtp_session_count < sp->layers && sp->rtp_session_count > 0) { 
    1042                  rtp_set_my_ssrc(sp->rtp_session[sp->rtp_session_count], rtp_my_ssrc(sp->rtp_session[0])); 
    1043           } 
    1044           sp->rtp_session_count++; 
    1045           /* Load saved settings, and create the participant database... */ 
    1046           /* FIXME: probably needs updating for the transcoder so we can */ 
    1047           /*        have different saved settings for each domain.       */ 
    1048           /* FIXME: this gets the wrong device name for the transcoder.  */ 
    1049           if (pdb_create(&sp->pdb) == FALSE) { 
    1050                     debug_msg("Failed to re-create new participant database\n"); 
    1051                     abort(); 
    1052           } 
    1053           pdb_item_create(sp->pdb, (uint16_t)ts_get_freq(sp->cur_ts), rtp_my_ssrc(sp->rtp_session[0])); 
    1054           settings_load_late(sp); 
    1055           session_validate(sp); 
    1056  
    1057           // Update src in UI 
    1058           rx_rtp_query(srce, args, sp); 
    1059         } else { 
    1060           sp->rtp_session[sp->rtp_session_count] = rtp_init(addr, (uint16_t)rx_port, (uint16_t)tx_port, ttl, 64000, rtp_callback_proc, NULL); 
    1061            
    1062           rtp_set_option(sp->rtp_session[sp->rtp_session_count], RTP_OPT_PROMISC, sp->rtp_promiscuous_mode); 
    1063           rtp_callback_init(sp->rtp_session[0], sp); 
    1064  
    1065           if(sp->rtp_session_count < sp->layers && sp->rtp_session_count > 0) { 
    1066                  rtp_set_my_ssrc(sp->rtp_session[sp->rtp_session_count], rtp_my_ssrc(sp->rtp_session[0])); 
    1067           } 
    1068           sp->rtp_session_count++; 
    1069         } 
     1015                /* Existing session present - delete and recreate with new params */ 
     1016                sp->rtp_session_count--; 
     1017                rx_audio_input_mute(srce, "1", sp); 
     1018                rtp_set_encryption_key(sp->rtp_session[0], NULL); 
     1019                sp->encrkey = NULL; 
     1020                ui_send_encryption_key(sp, sp->mbus_ui_addr); 
     1021                settings_save(sp); 
     1022                rtp_callback_exit(sp->rtp_session[sp->rtp_session_count]); 
     1023                /* Remove existing sources from DB and UI , then destory DB and RTP sess */ 
     1024                pdb_get_first_id(sp->pdb, &ssrc); 
     1025                do { 
     1026                        struct s_source *s = source_get_by_ssrc(sp->active_sources, ssrc); 
     1027                        if (s != NULL) { 
     1028                                source_remove(sp->active_sources, s); 
     1029                        } 
     1030                        ui_send_rtp_remove(sp, sp->mbus_ui_addr, ssrc); 
     1031                } while (pdb_get_next_id(sp->pdb, ssrc, &ssrc)); 
     1032                pdb_destroy(&sp->pdb); 
     1033                rtp_done(sp->rtp_session[sp->rtp_session_count]); 
     1034 
     1035                /* Perform rtp session re-creation */ 
     1036                if (!(sp->rtp_session[sp->rtp_session_count] =  
     1037                        rtp_init(addr, (uint16_t)rx_port, (uint16_t)tx_port, ttl, 64000, rtp_callback_proc, NULL))) { 
     1038                                debug_msg("Failed to reinitialise rtp session - exiting"); 
     1039                                assert(sp->rtp_session[sp->rtp_session_count]); 
     1040                } 
     1041                rtp_set_option(sp->rtp_session[sp->rtp_session_count], RTP_OPT_PROMISC, sp->rtp_promiscuous_mode); 
     1042                rtp_callback_init(sp->rtp_session[0], sp); 
     1043 
     1044                if(sp->rtp_session_count < sp->layers && sp->rtp_session_count > 0) { 
     1045                        rtp_set_my_ssrc(sp->rtp_session[sp->rtp_session_count], rtp_my_ssrc(sp->rtp_session[0])); 
     1046                } 
     1047                sp->rtp_session_count++; 
     1048                /* Load saved settings, and create the participant database... */ 
     1049                /* FIXME: probably needs updating for the transcoder so we can */ 
     1050                /*        have different saved settings for each domain.       */ 
     1051                /* FIXME: this gets the wrong device name for the transcoder.  */ 
     1052                if (pdb_create(&sp->pdb) == FALSE) { 
     1053                        debug_msg("Failed to re-create new participant database\n"); 
     1054                        abort(); 
     1055                } 
     1056                pdb_item_create(sp->pdb, (uint16_t)ts_get_freq(sp->cur_ts), rtp_my_ssrc(sp->rtp_session[0])); 
     1057                settings_load_late(sp); 
     1058                session_validate(sp); 
     1059 
     1060                // Update src in UI 
     1061                rx_rtp_query(srce, args, sp); 
     1062        } else { 
     1063                sp->rtp_session[sp->rtp_session_count] = rtp_init(addr, (uint16_t)rx_port, (uint16_t)tx_port, ttl, 64000, rtp_callback_proc, NULL); 
     1064 
     1065                rtp_set_option(sp->rtp_session[sp->rtp_session_count], RTP_OPT_PROMISC, sp->rtp_promiscuous_mode); 
     1066                rtp_callback_init(sp->rtp_session[0], sp); 
     1067 
     1068                if(sp->rtp_session_count < sp->layers && sp->rtp_session_count > 0) { 
     1069                        rtp_set_my_ssrc(sp->rtp_session[sp->rtp_session_count], rtp_my_ssrc(sp->rtp_session[0])); 
     1070                } 
     1071                sp->rtp_session_count++; 
     1072        } 
    10701073} 
    10711074 
     
    11011104        pdb_entry_t     *pdbe; 
    11021105        char            *ssrc; 
    1103         double           g; 
     1106        double           g; 
    11041107        struct mbus_parser      *mp; 
    11051108 
     
    11091112        if (mbus_parse_str(mp, &ssrc) && mbus_parse_flt(mp, &g)) { 
    11101113                ssrc = mbus_decode_str(ssrc); 
    1111                 if (pdb_item_get(sp->pdb, strtoul(ssrc, 0, 16), &pdbe)) { 
    1112                         pdbe->gain = g; 
    1113                 } else { 
     1114                if (pdb_item_get(sp->pdb, strtoul(ssrc, 0, 16), &pdbe)) { 
     1115                        pdbe->gain = g; 
     1116                } else { 
    11141117                        debug_msg("Unknown source 0x%08lx\n", ssrc); 
    11151118                } 
     
    11341137{ 
    11351138        char    *short_name, *sfreq, *schan; 
    1136         int      freq, channels; 
    1137         codec_id_t cid, next_cid; 
     1139        int      freq, channels; 
     1140        codec_id_t cid, next_cid; 
    11381141        struct mbus_parser      *mp; 
    11391142 
     
    11421145        mp = mbus_parse_init(args); 
    11431146        if (mbus_parse_str(mp, &short_name) && 
    1144             mbus_parse_str(mp, &schan) && 
    1145             mbus_parse_str(mp, &sfreq)) { 
    1146                 mbus_decode_str(short_name); 
    1147                 mbus_decode_str(schan); 
    1148                 mbus_decode_str(sfreq); 
    1149                 mbus_parse_done(mp); 
    1150         } else { 
    1151                 debug_msg("mbus: usage \"tool.rat.codec <codec> <channels> <freq>\"\n"); 
    1152                 mbus_parse_done(mp); 
    1153                 return; 
    1154         } 
    1155  
    1156         if (strcasecmp(schan, "mono") == 0) { 
    1157                 channels = 1; 
    1158         } else if (strcasecmp(schan, "stereo") == 0) { 
    1159                 channels = 2; 
    1160         } else { 
    1161                 channels = 0; 
    1162         } 
    1163  
    1164         freq = string_to_freq(sfreq); 
    1165         assert(channels != 0); 
    1166         assert(freq     != 0); 
    1167         next_cid = codec_get_matching(short_name, (uint16_t)freq, (uint16_t)channels); 
    1168  
    1169         if (next_cid && codec_get_payload(next_cid) != 255) { 
    1170                 cid     = codec_get_by_payload ((u_char)sp->encodings[0]); 
    1171                 if (codec_audio_formats_compatible(next_cid, cid)) { 
    1172                         sp->encodings[0] = codec_get_payload(next_cid); 
    1173                         ui_send_audio_codec(sp, sp->mbus_ui_addr); 
    1174                 } else { 
    1175                         /* just register we want to make a change */ 
    1176                         audio_device_register_change_primary(sp, next_cid); 
    1177                 } 
    1178         } 
     1147                mbus_parse_str(mp, &schan) && 
     1148                mbus_parse_str(mp, &sfreq)) { 
     1149                        mbus_decode_str(short_name); 
     1150                        mbus_decode_str(schan); 
     1151                        mbus_decode_str(sfreq); 
     1152                        mbus_parse_done(mp); 
     1153                } else { 
     1154                        debug_msg("mbus: usage \"tool.rat.codec <codec> <channels> <freq>\"\n"); 
     1155                        mbus_parse_done(mp); 
     1156                        return; 
     1157                } 
     1158 
     1159                if (strcasecmp(schan, "mono") == 0) { 
     1160                        channels = 1; 
     1161                } else if (strcasecmp(schan, "stereo") == 0) { 
     1162                        channels = 2; 
     1163                } else { 
     1164                        channels = 0; 
     1165                } 
     1166 
     1167                freq = string_to_freq(sfreq); 
     1168                assert(channels != 0); 
     1169                assert(freq     != 0); 
     1170                next_cid = codec_get_matching(short_name, (uint16_t)freq, (uint16_t)channels); 
     1171 
     1172                if (next_cid && codec_get_payload(next_cid) != 255) { 
     1173                        cid     = codec_get_by_payload ((u_char)sp->encodings[0]); 
     1174                        if (codec_audio_formats_compatible(next_cid, cid)) { 
     1175                                sp->encodings[0] = codec_get_payload(next_cid); 
     1176                                ui_send_audio_codec(sp, sp->mbus_ui_addr); 
     1177                        } else { 
     1178                                /* just register we want to make a change */ 
     1179                                audio_device_register_change_primary(sp, next_cid); 
     1180                        } 
     1181                } 
    11791182} 
    11801183 
     
    11881191static void rx_tool_rat_playout_limit(char *srce, char *args, session_t *sp) 
    11891192{ 
    1190         int i; 
    1191         struct mbus_parser      *mp; 
    1192  
    1193         UNUSED(srce); 
    1194         mp = mbus_parse_init(args); 
    1195         if (mbus_parse_int(mp, &i) && (1 == i || 0 == i)) { 
    1196                 sp->limit_playout = i; 
    1197         } else { 
     1193        int i; 
     1194        struct mbus_parser      *mp; 
     1195 
     1196        UNUSED(srce); 
     1197        mp = mbus_parse_init(args); 
     1198        if (mbus_parse_int(mp, &i) && (1 == i || 0 == i)) { 
     1199                sp->limit_playout = i; 
     1200        } else { 
    11981201                debug_msg("mbus: usage \"tool.rat.playout.limit <bool>\"\n"); 
    11991202        } 
     
    12351238static void rx_tool_rat_payload_set(char *srce, char *args, session_t *sp) 
    12361239{ 
    1237         codec_id_t cid, cid_replacing; 
    1238         char *codec_long_name; 
    1239         int   i, new_pt; 
    1240         struct mbus_parser      *mp; 
    1241  
    1242         UNUSED(srce); 
    1243  
    1244         mp = mbus_parse_init(args); 
    1245  
    1246         if (mbus_parse_str(mp, &codec_long_name) && 
    1247             mbus_parse_int(mp, &new_pt)) { 
    1248                 mbus_decode_str(codec_long_name); 
    1249  
    1250                 if (payload_is_valid((u_char)new_pt) == FALSE || 
    1251                     new_pt < 0 || new_pt > 255) { 
    1252                         debug_msg("Invalid payload specified\n"); 
    1253                         mbus_parse_done(mp); 
    1254                         return; 
    1255                 } 
    1256  
    1257                 /* Don't allow payloads to be mapped to channel_coder payloads - it doesn't seem to work */ 
    1258                 if (channel_coder_exist_payload((uint8_t)new_pt)) { 
    1259                         debug_msg("Channel coder payload specified\n"); 
    1260                         mbus_parse_done(mp); 
    1261                         return; 
    1262                 } 
    1263  
    1264                 for(i = 0; i < sp->num_encodings; i++) { 
    1265                         if (new_pt == sp->encodings[i]) { 
    1266                                 debug_msg("Doh! Attempting to remap encoding %d codec.\n", i); 
    1267                                 mbus_parse_done(mp); 
    1268                                 return; 
    1269                         } 
    1270                 } 
    1271  
    1272                 cid_replacing = codec_get_by_payload((u_char)new_pt); 
    1273                 if (cid_replacing) { 
    1274                         const codec_format_t *cf; 
    1275                         cf = codec_get_format(cid_replacing); 
    1276                         assert(cf); 
    1277                         debug_msg("Codec map replacing %s\n", cf->long_name); 
    1278                         codec_unmap_payload(cid_replacing, (u_char)new_pt); 
    1279                         ui_send_codec_details(sp, sp->mbus_ui_addr, cid_replacing); 
    1280                 } 
    1281  
    1282                 cid = codec_get_by_name(codec_long_name); 
    1283                 if (cid && codec_map_payload(cid, (u_char)new_pt)) { 
    1284                         ui_send_codec_details(sp, sp->mbus_ui_addr, cid); 
    1285                         debug_msg("map %s %d succeeded.\n", codec_long_name, new_pt); 
    1286                 } else { 
    1287                         debug_msg("map %s %d failed.\n", codec_long_name, new_pt); 
    1288                 } 
    1289         } 
    1290         mbus_parse_done(mp); 
     1240        codec_id_t cid, cid_replacing; 
     1241        char *codec_long_name; 
     1242        int   i, new_pt; 
     1243        struct mbus_parser      *mp; 
     1244 
     1245        UNUSED(srce); 
     1246 
     1247        mp = mbus_parse_init(args); 
     1248 
     1249        if (mbus_parse_str(mp, &codec_long_name) && 
     1250                mbus_parse_int(mp, &new_pt)) { 
     1251                        mbus_decode_str(codec_long_name); 
     1252 
     1253                        if (payload_is_valid((u_char)new_pt) == FALSE || 
     1254                                new_pt < 0 || new_pt > 255) { 
     1255                                        debug_msg("Invalid payload specified\n"); 
     1256                                        mbus_parse_done(mp); 
     1257                                        return; 
     1258                                } 
     1259 
     1260                                /* Don't allow payloads to be mapped to channel_coder payloads - it doesn't seem to work */ 
     1261                                if (channel_coder_exist_payload((uint8_t)new_pt)) { 
     1262                                        debug_msg("Channel coder payload specified\n"); 
     1263                                        mbus_parse_done(mp); 
     1264                                        return; 
     1265                                } 
     1266 
     1267                                for(i = 0; i < sp->num_encodings; i++) { 
     1268                                        if (new_pt == sp->encodings[i]) { 
     1269                                                debug_msg("Doh! Attempting to remap encoding %d codec.\n", i); 
     1270                                                mbus_parse_done(mp); 
     1271                                                return; 
     1272                                        } 
     1273                                } 
     1274 
     1275                                cid_replacing = codec_get_by_payload((u_char)new_pt); 
     1276                                if (cid_replacing) { 
     1277                                        const codec_format_t *cf; 
     1278                                        cf = codec_get_format(cid_replacing); 
     1279                                        assert(cf); 
     1280                                        debug_msg("Codec map replacing %s\n", cf->long_name); 
     1281                                        codec_unmap_payload(cid_replacing, (u_char)new_pt); 
     1282                                        ui_send_codec_details(sp, sp->mbus_ui_addr, cid_replacing); 
     1283                                } 
     1284 
     1285                                cid = codec_get_by_name(codec_long_name); 
     1286                                if (cid && codec_map_payload(cid, (u_char)new_pt)) { 
     1287                                        ui_send_codec_details(sp, sp->mbus_ui_addr, cid); 
     1288                                        debug_msg("map %s %d succeeded.\n", codec_long_name, new_pt); 
     1289                                } else { 
     1290                                        debug_msg("map %s %d failed.\n", codec_long_name, new_pt); 
     1291                                } 
     1292                } 
     1293                mbus_parse_done(mp); 
    12911294} 
    12921295 
     
    12941297{ 
    12951298        UNUSED(args); 
    1296         ui_send_converter_list(sp, srce); 
     1299        ui_send_converter_list(sp, srce); 
    12971300} 
    12981301 
    12991302static void rx_tool_rat_converter(char *srce, char *args, session_t *sp) 
    13001303{ 
    1301         const converter_details_t *d = NULL; 
    1302         uint32_t             i, n; 
    1303         char               *name; 
     1304        const converter_details_t *d = NULL; 
     1305        uint32_t             i, n; 
     1306        char               *name; 
    13041307        struct mbus_parser      *mp; 
    13051308 
     
    13081311        mp = mbus_parse_init(args); 
    13091312        if (mbus_parse_str(mp, &name)) { 
    1310                 mbus_decode_str(name); 
    1311                 n = converter_get_count(); 
    1312                 for(i = 0; i < n; i++) { 
    1313                         d = converter_get_details(i); 
    1314                         if (0 == strcasecmp(d->name,name)) { 
    1315                                 break; 
    1316                         } 
    1317                 } 
    1318                 if (i == n) { 
    1319                         d = converter_get_details(0); 
    1320                 } 
    1321                 sp->converter = d->id; 
     1313                mbus_decode_str(name); 
     1314                n = converter_get_count(); 
     1315                for(i = 0; i < n; i++) { 
     1316                        d = converter_get_details(i); 
     1317                        if (0 == strcasecmp(d->name,name)) { 
     1318                                break; 
     1319                        } 
     1320                } 
     1321                if (i == n) { 
     1322                        d = converter_get_details(0); 
     1323                } 
     1324                sp->converter = d->id; 
    13221325        } else { 
    13231326                debug_msg("mbus: usage \"tool.rat.converter <name>\"\n"); 
    13241327        } 
    13251328        mbus_parse_done(mp); 
    1326         ui_send_converter(sp, sp->mbus_ui_addr); 
     1329        ui_send_converter(sp, sp->mbus_ui_addr); 
    13271330} 
    13281331 
    13291332/* set_red_parameters translates what mbus_receives into command 
    1330  * redundancy encoder understands. 
    1331  */ 
     1333* redundancy encoder understands. 
     1334*/ 
    13321335 
    13331336static void 
    13341337set_red_parameters(session_t *sp, char *sec_enc, int offset) 
    13351338{ 
    1336         const codec_format_t *pcf, *rcf; 
    1337         codec_id_t            pri_id, red_id; 
    1338         char *cmd; 
    1339         int   clen; 
    1340         assert(offset>0); 
    1341  
    1342         pri_id = codec_get_by_payload(sp->encodings[0]); 
    1343         pcf    = codec_get_format(pri_id); 
    1344         red_id = codec_get_matching(sec_enc, (uint32_t)pcf->format.sample_rate, (uint16_t)pcf->format.channels); 
    1345         if (!codec_id_is_valid(red_id)) { 
    1346                 debug_msg("Failed to get redundant codec requested (%s)\n", sec_enc); 
    1347                 red_id = pri_id;  /* Use same as primary */ 
    1348         } 
    1349         rcf = codec_get_format(red_id); 
    1350  
    1351         clen = 2 * (CODEC_LONG_NAME_LEN + 4); 
    1352         cmd  = (char*)xmalloc(clen); 
    1353         sprintf(cmd, "%s/%d/%s/%d", pcf->long_name, 0, rcf->long_name, offset); 
    1354  
    1355         xmemchk(); 
    1356         if (channel_encoder_set_parameters(sp->channel_coder, cmd) == 0) { 
    1357                 debug_msg("Red command failed: %s\n", cmd); 
    1358         } 
    1359         xmemchk(); 
    1360         xfree(cmd); 
    1361         /* Now tweak session parameters */ 
    1362         sp->num_encodings = 2; 
    1363         sp->encodings[1]  = codec_get_payload(red_id); 
     1339        const codec_format_t *pcf, *rcf; 
     1340        codec_id_t            pri_id, red_id; 
     1341        char *cmd; 
     1342        int   clen; 
     1343        assert(offset>0); 
     1344 
     1345        pri_id = codec_get_by_payload(sp->encodings[0]); 
     1346        pcf    = codec_get_format(pri_id); 
     1347        red_id = codec_get_matching(sec_enc, (uint32_t)pcf->format.sample_rate, (uint16_t)pcf->format.channels); 
     1348        if (!codec_id_is_valid(red_id)) { 
     1349                debug_msg("Failed to get redundant codec requested (%s)\n", sec_enc); 
     1350                red_id = pri_id;  /* Use same as primary */ 
     1351        } 
     1352        rcf = codec_get_format(red_id); 
     1353 
     1354        clen = 2 * (CODEC_LONG_NAME_LEN + 4); 
     1355        cmd  = (char*)xmalloc(clen); 
     1356        sprintf(cmd, "%s/%d/%s/%d", pcf->long_name, 0, rcf->long_name, offset); 
     1357 
     1358        xmemchk(); 
     1359        if (channel_encoder_set_parameters(sp->channel_coder, cmd) == 0) { 
     1360                debug_msg("Red command failed: %s\n", cmd); 
     1361        } 
     1362        xmemchk(); 
     1363        xfree(cmd); 
     1364        /* Now tweak session parameters */ 
     1365        sp->num_encodings = 2; 
     1366        sp->encodings[1]  = codec_get_payload(red_id); 
    13641367} 
    13651368 
     
    13681371set_layered_parameters(session_t *sp, char *sec_enc, char *schan, char *sfreq, int layerenc) 
    13691372{ 
    1370         const codec_format_t *pcf, *lcf; 
    1371         codec_id_t            pri_id, lay_id; 
    1372         char *cmd; 
    1373         int      freq, channels; 
    1374         int   clen; 
    1375         assert(layerenc>0); 
    1376  
    1377         if (strcasecmp(schan, "mono") == 0) { 
    1378                 channels = 1; 
    1379         } else if (strcasecmp(schan, "stereo") == 0) { 
    1380                 channels = 2; 
    1381         } else { 
    1382                 channels = 0; 
    1383         } 
    1384  
    1385         freq = string_to_freq(sfreq); 
    1386         pri_id = codec_get_by_payload(sp->encodings[0]); 
    1387         pcf    = codec_get_format(pri_id); 
    1388         lay_id = codec_get_matching(sec_enc, (uint16_t)freq, (uint16_t)channels); 
    1389         if(lay_id == 0) { 
    1390                 debug_msg("Can't find layered codec (%s) - need to change primary codec\n", sec_enc); 
    1391         } 
    1392         if (pri_id!=lay_id) { 
    1393                 /* This can happen if you change codec and select layering    * 
    1394                  * before pushing apply, so change the primary encoding here. */ 
    1395                 codec_id_t cid; 
    1396                 if (lay_id && codec_get_payload(lay_id) != 255) { 
    1397                         cid     = codec_get_by_payload ((u_char)sp->encodings[0]); 
    1398                         if (codec_audio_formats_compatible(lay_id, cid)) { 
    1399                                 sp->encodings[0] = codec_get_payload(lay_id); 
    1400                                 ui_send_audio_codec(sp, sp->mbus_ui_addr); 
    1401                         } else { 
    1402                                 /* just register we want to make a change */ 
    1403                                 audio_device_register_change_primary(sp, lay_id); 
    1404                         } 
    1405                 } 
    1406         } 
    1407         lcf = codec_get_format(lay_id); 
    1408  
    1409         if(layerenc<=MAX_LAYERS) { 
    1410                 if(layerenc > sp->rtp_session_count) { 
    1411                         debug_msg("%d is too many layers - ports not inited - forcing %d layers\n", layerenc, sp->rtp_session_count); 
     1373        const codec_format_t *pcf, *lcf; 
     1374        codec_id_t            pri_id, lay_id; 
     1375        char *cmd; 
     1376        int      freq, channels; 
     1377        int   clen; 
     1378        assert(layerenc>0); 
     1379 
     1380        if (strcasecmp(schan, "mono") == 0) { 
     1381                channels = 1; 
     1382        } else if (strcasecmp(schan, "stereo") == 0) { 
     1383                channels = 2; 
     1384        } else { 
     1385                channels = 0; 
     1386        } 
     1387 
     1388        freq = string_to_freq(sfreq); 
     1389        pri_id = codec_get_by_payload(sp->encodings[0]); 
     1390        pcf    = codec_get_format(pri_id); 
     1391        lay_id = codec_get_matching(sec_enc, (uint16_t)freq, (uint16_t)channels); 
     1392        if(lay_id == 0) { 
     1393                debug_msg("Can't find layered codec (%s) - need to change primary codec\n", sec_enc); 
     1394        } 
     1395        if (pri_id!=lay_id) { 
     1396                /* This can happen if you change codec and select layering    * 
     1397                * before pushing apply, so change the primary encoding here. */ 
     1398                codec_id_t cid; 
     1399                if (lay_id && codec_get_payload(lay_id) != 255) { 
     1400                        cid     = codec_get_by_payload ((u_char)sp->encodings[0]); 
     1401                        if (codec_audio_formats_compatible(lay_id, cid)) { 
     1402                                sp->encodings[0] = codec_get_payload(lay_id); 
     1403                                ui_send_audio_codec(sp, sp->mbus_ui_addr); 
     1404                        } else { 
     1405                                /* just register we want to make a change */ 
     1406                                audio_device_register_change_primary(sp, lay_id); 
     1407                        } 
     1408                } 
     1409        } 
     1410        lcf = codec_get_format(lay_id); 
     1411 
     1412        if(layerenc<=MAX_LAYERS) { 
     1413                if(layerenc > sp->rtp_session_count) { 
     1414                        debug_msg("%d is too many layers - ports not inited - forcing %d layers\n", layerenc, sp->rtp_session_count); 
    14121415                        layerenc = sp->rtp_session_count; 
    14131416                } 
    14141417        } 
    14151418 
    1416         clen = CODEC_LONG_NAME_LEN + 4; 
    1417         cmd  = (char*)xmalloc(clen); 
    1418         sprintf(cmd, "%s/%d", lcf->long_name, layerenc); 
    1419  
    1420         xmemchk(); 
    1421         if (channel_encoder_set_parameters(sp->channel_coder, cmd) == 0) { 
    1422                 debug_msg("Layered command failed: %s\n", cmd); 
    1423         } 
    1424         xmemchk(); 
    1425         xfree(cmd); 
    1426         /* Now tweak session parameters */ 
    1427         sp->layers = layerenc; 
    1428         sp->num_encodings = 1; 
     1419        clen = CODEC_LONG_NAME_LEN + 4; 
     1420        cmd  = (char*)xmalloc(clen); 
     1421        sprintf(cmd, "%s/%d", lcf->long_name, layerenc); 
     1422 
     1423        xmemchk(); 
     1424        if (channel_encoder_set_parameters(sp->channel_coder, cmd) == 0) { 
     1425                debug_msg("Layered command failed: %s\n", cmd); 
     1426        } 
     1427        xmemchk(); 
     1428        xfree(cmd); 
     1429        /* Now tweak session parameters */ 
     1430        sp->layers = layerenc; 
     1431        sp->num_encodings = 1; 
    14291432} 
    14301433 
    14311434/* This function is a bit nasty because it has to coerce what the 
    1432  * mbus gives us into something the channel coders understand.  In addition, 
    1433  * we assume we know what channel coders are which kind of defies point 
    1434  * 'generic' structure but that's probably because it's not generic enough. 
    1435  */ 
     1435* mbus gives us into something the channel coders understand.  In addition, 
     1436* we assume we know what channel coders are which kind of defies point 
     1437* 'generic' structure but that's probably because it's not generic enough. 
     1438*/ 
    14361439static void rx_audio_channel_coding(char *srce, char *args, session_t *sp) 
    14371440{ 
    1438         const cc_details_t *ccd; 
    1439         char        *coding, *sec_enc, *schan, *sfreq; 
    1440         int          offset, layerenc; 
    1441         uint32_t      i, n; 
    1442         uint16_t      upp; 
    1443         struct mbus_parser      *mp; 
    1444  
    1445         UNUSED(srce); 
    1446  
    1447         mp = mbus_parse_init(args); 
    1448         if (mbus_parse_str(mp, &coding)) { 
    1449                 mbus_decode_str(coding); 
    1450                 upp = channel_encoder_get_units_per_packet(sp->channel_coder); 
    1451                 n = channel_get_coder_count(); 
    1452                 for(i = 0; i < n; i++) { 
    1453                         ccd = channel_get_coder_details(i); 
    1454                         if (strncasecmp(ccd->name, coding, 3) == 0) { 
    1455                                 debug_msg("rx_audio_channel_coding: 0x%08x, %s\n", ccd->descriptor, &ccd->name); 
    1456                                 switch(tolower((int)ccd->name[0])) { //SV-XXX: NetBSD 
    1457                                 case 'n':   /* No channel coding */ 
    1458                                         sp->num_encodings = 1; 
    1459                                         sp->layers = 1; 
    1460                                         channel_encoder_destroy(&sp->channel_coder); 
    1461                                         channel_encoder_create(ccd->descriptor, &sp->channel_coder); 
    1462                                         channel_encoder_set_units_per_packet(sp->channel_coder, upp); 
    1463                                         break; 
    1464                                 case 'r':   /* Redundancy -> extra parameters */ 
    1465                                         if (mbus_parse_str(mp, &sec_enc) && 
    1466                                                 mbus_parse_int(mp, &offset)) { 
    1467                                                 mbus_decode_str(sec_enc); 
    1468                                                 sp->layers = 1; 
    1469                                                 channel_encoder_destroy(&sp->channel_coder); 
    1470                                                 channel_encoder_create(ccd->descriptor, &sp->channel_coder); 
    1471                                                 channel_encoder_set_units_per_packet(sp->channel_coder, upp); 
    1472                                                 set_red_parameters(sp, sec_enc, offset); 
    1473                                         } 
    1474                                         break; 
    1475                                 case 'l':       /*Layering */ 
    1476                                         if (mbus_parse_str(mp, &sec_enc) && 
    1477                                                 mbus_parse_str(mp, &schan) && 
    1478                                                 mbus_parse_str(mp, &sfreq) && 
    1479                                                 mbus_parse_int(mp, &layerenc)) { 
    1480                                                 mbus_decode_str(sec_enc); 
    1481                                                 mbus_decode_str(schan); 
    1482                                                 mbus_decode_str(sfreq); 
    1483                                                 channel_encoder_destroy(&sp->channel_coder); 
    1484                                                 channel_encoder_create(ccd->descriptor, &sp->channel_coder); 
    1485                                                 channel_encoder_set_units_per_packet(sp->channel_coder, upp); 
    1486                                                 set_layered_parameters(sp, sec_enc, schan, sfreq, layerenc); 
    1487                                         } 
    1488                                         break; 
    1489                                 } 
    1490                                 break; 
    1491                         } 
    1492                 } 
    1493         } 
    1494         mbus_parse_done(mp); 
     1441        const cc_details_t *ccd; 
     1442        char        *coding, *sec_enc, *schan, *sfreq; 
     1443        int          offset, layerenc; 
     1444        uint32_t      i, n; 
     1445        uint16_t      upp; 
     1446        struct mbus_parser      *mp; 
     1447 
     1448        UNUSED(srce); 
     1449 
     1450        mp = mbus_parse_init(args); 
     1451        if (mbus_parse_str(mp, &coding)) { 
     1452                mbus_decode_str(coding); 
     1453                upp = channel_encoder_get_units_per_packet(sp->channel_coder); 
     1454                n = channel_get_coder_count(); 
     1455                for(i = 0; i < n; i++) { 
     1456                        ccd = channel_get_coder_details(i); 
     1457                        if (strncasecmp(ccd->name, coding, 3) == 0) { 
     1458                                debug_msg("rx_audio_channel_coding: 0x%08x, %s\n", ccd->descriptor, &ccd->name); 
     1459                                switch(tolower((int)ccd->name[0])) { //SV-XXX: NetBSD 
     1460                                                                case 'n':   /* No channel coding */ 
     1461                                                                        sp->num_encodings = 1; 
     1462                                                                        sp->layers = 1; 
     1463                                                                        channel_encoder_destroy(&sp->channel_coder); 
     1464                                                                        channel_encoder_create(ccd->descriptor, &sp->channel_coder); 
     1465                                                                        channel_encoder_set_units_per_packet(sp->channel_coder, upp); 
     1466                                                                        break; 
     1467                                                                case 'r':   /* Redundancy -> extra parameters */ 
     1468                                                                        if (mbus_parse_str(mp, &sec_enc) && 
     1469                                                                                mbus_parse_int(mp, &offset)) { 
     1470                                                                                        mbus_decode_str(sec_enc); 
     1471                                                                                        sp->layers = 1; 
     1472                                                                                        channel_encoder_destroy(&sp->channel_coder); 
     1473                                                                                        channel_encoder_create(ccd->descriptor, &sp->channel_coder); 
     1474                                                                                        channel_encoder_set_units_per_packet(sp->channel_coder, upp); 
     1475                                                                                        set_red_parameters(sp, sec_enc, offset); 
     1476                                                                                } 
     1477                                                                                break; 
     1478                                                                case 'l':       /*Layering */ 
     1479                                                                        if (mbus_parse_str(mp, &sec_enc) && 
     1480                                                                                mbus_parse_str(mp, &schan) && 
     1481                                                                                mbus_parse_str(mp, &sfreq) && 
     1482                                                                                mbus_parse_int(mp, &layerenc)) { 
     1483                                                                                        mbus_decode_str(sec_enc); 
     1484                                                                                        mbus_decode_str(schan); 
     1485                                                                                        mbus_decode_str(sfreq); 
     1486                                                                                        channel_encoder_destroy(&sp->channel_coder); 
     1487                                                                                        channel_encoder_create(ccd->descriptor, &sp->channel_coder); 
     1488                                                                                        channel_encoder_set_units_per_packet(sp->channel_coder, upp); 
     1489                                                                                        set_layered_parameters(sp, sec_enc, schan, sfreq, layerenc); 
     1490                                                                                } 
     1491                                                                                break; 
     1492                                } 
     1493                                break; 
     1494                        } 
     1495                } 
     1496        } 
     1497        mbus_parse_done(mp); 
    14951498#ifdef DEBUG 
    1496         ccd = channel_get_coder_identity(sp->channel_coder); 
    1497         debug_msg("***** %s\n", ccd->name); 
     1499        ccd = channel_get_coder_identity(sp->channel_coder); 
     1500        debug_msg("***** %s\n", ccd->name); 
    14981501#endif /* DEBUG */ 
    14991502        ui_send_audio_channel_coding(sp, sp->mbus_ui_addr); 
     
    15091512        /* to implementing all that yet - please send in a patch! [csp]  */ 
    15101513        UNUSED(args); 
    1511         ui_send_repair_scheme_list(sp, srce); 
     1514        ui_send_repair_scheme_list(sp, srce); 
    15121515        ui_send_codec_list        (sp, srce); 
    1513         ui_send_converter_list    (sp, srce); 
    1514         ui_send_converter         (sp, sp->mbus_ui_addr); 
    1515         ui_send_lecture_mode      (sp, sp->mbus_ui_addr); 
    1516         ui_send_sampling_mode_list(sp, srce); 
     1516        ui_send_converter_list    (sp, srce); 
     1517        ui_send_converter         (sp, sp->mbus_ui_addr); 
     1518        ui_send_lecture_mode      (sp, sp->mbus_ui_addr); 
     1519        ui_send_sampling_mode_list(sp, srce); 
    15171520        ui_send_powermeter        (sp, srce); 
    15181521        ui_send_playout_bounds    (sp, srce); 
     
    15321535        UNUSED(srce); 
    15331536        UNUSED(sp); 
    1534         should_exit = TRUE; 
     1537        should_exit = TRUE; 
    15351538        debug_msg("Media engine got mbus.quit()\n"); 
    15361539} 
     
    16071610static void rx_tool_rat_layers(char *srce, char *args, session_t *sp) 
    16081611{ 
    1609         int      i; 
    1610         struct mbus_parser      *mp; 
    1611  
    1612         UNUSED(srce); 
    1613  
    1614         mp = mbus_parse_init(args); 
    1615         if (mbus_parse_int(mp, &i)) { 
    1616                 if(i>MAX_LAYERS) { 
    1617                        debug_msg("too many layers: max = %d\n", MAX_LAYERS); 
    1618                        sp->layers = MAX_LAYERS; 
    1619                 } else { 
    1620                        sp->layers = i; 
    1621                 } 
    1622         } else { 
    1623                 debug_msg("mbus: usage \"tool.rat.layers <integer>\"\n"); 
    1624         } 
    1625         mbus_parse_done(mp); 
     1612        int      i; 
     1613        struct mbus_parser      *mp; 
     1614 
     1615        UNUSED(srce); 
     1616 
     1617        mp = mbus_parse_init(args); 
     1618        if (mbus_parse_int(mp, &i)) { 
     1619                if(i>MAX_LAYERS) { 
     1620                        debug_msg("too many layers: max = %d\n", MAX_LAYERS); 
     1621                        sp->layers = MAX_LAYERS; 
     1622                } else { 
     1623                        sp->layers = i; 
     1624                } 
     1625        } else { 
     1626                debug_msg("mbus: usage \"tool.rat.layers <integer>\"\n"); 
     1627        } 
     1628        mbus_parse_done(mp); 
    16261629} 
    16271630 
     
    16371640static const mbus_cmd_tuple engine_cmds[] = { 
    16381641        { "tool.rat.logstats",                     rx_tool_rat_logstats }, 
    1639         { "tool.rat.tone.start",                   rx_tool_rat_tone_start }, 
    1640         { "tool.rat.tone.stop",                    rx_tool_rat_tone_stop }, 
     1642        { "tool.rat.tone.start",                   rx_tool_rat_tone_start }, 
     1643        { "tool.rat.tone.stop",                    rx_tool_rat_tone_stop }, 
    16411644        { "tool.rat.voxlet.play",                  rx_tool_rat_voxlet_play }, 
    1642         { "session.title",                         rx_session_title }, 
    1643         { "tool.rat.silence",                      rx_tool_rat_silence }, 
    1644         { "tool.rat.silence.threshold",            rx_tool_rat_silence_thresh }, 
    1645         { "tool.rat.lecture.mode",                 rx_tool_rat_lecture_mode }, 
    1646         { "audio.3d.enabled",                      rx_audio_3d_enable }, 
    1647         { "audio.3d.user.settings",                rx_audio_3d_user_settings }, 
    1648         { "audio.3d.user.settings.request",        rx_audio_3d_user_settings_req }, 
    1649         { "tool.rat.agc",                          rx_tool_rat_agc }, 
    1650         { "tool.rat.loopback.gain",                rx_tool_rat_loopback_gain }, 
    1651         { "tool.rat.echo.suppress",                rx_tool_rat_echo_suppress }, 
    1652         { "tool.rat.rate",                         rx_tool_rat_rate }, 
    1653         { "tool.rat.powermeter",                   rx_tool_rat_powermeter }, 
    1654         { "tool.rat.converters.request",           rx_tool_rat_converters_request }, 
    1655         { "tool.rat.converter",                    rx_tool_rat_converter }, 
    1656         { "tool.rat.settings",                     rx_tool_rat_settings }, 
    1657         { "tool.rat.codec",                        rx_tool_rat_codec }, 
    1658         { "tool.rat.codecs.request",               rx_tool_rat_codecs_request }, 
    1659         { "tool.rat.playout.limit",                rx_tool_rat_playout_limit }, 
    1660         { "tool.rat.playout.min",                  rx_tool_rat_playout_min }, 
    1661         { "tool.rat.playout.max",                  rx_tool_rat_playout_max }, 
    1662         { "tool.rat.payload.set",                  rx_tool_rat_payload_set }, 
     1645        { "session.title",                         rx_session_title }, 
     1646        { "tool.rat.silence",                      rx_tool_rat_silence }, 
     1647        { "tool.rat.silence.threshold",            rx_tool_rat_silence_thresh }, 
     1648        { "tool.rat.lecture.mode",                 rx_tool_rat_lecture_mode }, 
     1649        { "audio.3d.enabled",                      rx_audio_3d_enable }, 
     1650        { "audio.3d.user.settings",                rx_audio_3d_user_settings }, 
     1651        { "audio.3d.user.settings.request",        rx_audio_3d_user_settings_req }, 
     1652        { "tool.rat.agc",                          rx_tool_rat_agc }, 
     1653        { "tool.rat.loopback.gain",                rx_tool_rat_loopback_gain }, 
     1654        { "tool.rat.echo.suppress",                rx_tool_rat_echo_suppress }, 
     1655        { "tool.rat.rate",                         rx_tool_rat_rate }, 
     1656        { "tool.rat.powermeter",                   rx_tool_rat_powermeter }, 
     1657        { "tool.rat.converters.request",           rx_tool_rat_converters_request }, 
     1658        { "tool.rat.converter",                    rx_tool_rat_converter }, 
     1659        { "tool.rat.settings",                     rx_tool_rat_settings }, 
     1660        { "tool.rat.codec",                        rx_tool_rat_codec }, 
     1661        { "tool.rat.codecs.request",               rx_tool_rat_codecs_request }, 
     1662        { "tool.rat.playout.limit",                rx_tool_rat_playout_limit }, 
     1663        { "tool.rat.playout.min",                  rx_tool_rat_playout_min }, 
     1664        { "tool.rat.playout.max",                  rx_tool_rat_playout_max }, 
     1665        { "tool.rat.payload.set",                  rx_tool_rat_payload_set }, 
    16631666        { "tool.rat.ui.detach.request",            rx_tool_rat_ui_detach_request }, 
    16641667        { "tool.rat.filter.loopback",              rx_tool_rat_filter_loopback }, 
    16651668        { "tool.rat.layers",                       rx_tool_rat_layers }, 
    1666         { "audio.input.mute",                      rx_audio_input_mute }, 
    1667         { "audio.input.gain",                      rx_audio_input_gain }, 
    1668         { "audio.input.port",                      rx_audio_input_port }, 
    1669         { "audio.output.mute",                     rx_audio_output_mute }, 
    1670         { "audio.output.gain",                     rx_audio_output_gain }, 
    1671         { "audio.output.port",                     rx_audio_output_port }, 
    1672         { "audio.channel.coding",                  rx_audio_channel_coding }, 
    1673         { "audio.channel.repair",                  rx_audio_channel_repair }, 
    1674         { "audio.file.play.open",                  rx_audio_file_play_open }, 
    1675         { "audio.file.play.pause",                 rx_audio_file_play_pause }, 
    1676         { "audio.file.play.stop",                  rx_audio_file_play_stop }, 
    1677         { "audio.file.play.live",                  rx_audio_file_play_live }, 
    1678         { "audio.file.record.open",                rx_audio_file_rec_open }, 
    1679         { "audio.file.record.pause",               rx_audio_file_rec_pause }, 
    1680         { "audio.file.record.stop",                rx_audio_file_rec_stop }, 
    1681         { "audio.file.record.live",                rx_audio_file_rec_live }, 
    1682         { "audio.device",                          rx_audio_device }, 
    1683         { "audio.query",                           rx_audio_query }, 
    1684         { "security.encryption.key",               rx_security_encryption_key }, 
    1685         { "rtp.query",                             rx_rtp_query }, 
    1686         { "rtp.addr.query",                        rx_rtp_addr_query }, 
    1687         { "rtp.addr",                              rx_rtp_addr }, 
    1688         { "rtp.source.name",                       rx_rtp_source_name }, 
    1689         { "rtp.source.email",                      rx_rtp_source_email }, 
    1690         { "rtp.source.phone",                      rx_rtp_source_phone }, 
    1691         { "rtp.source.loc",                        rx_rtp_source_loc }, 
    1692         { "rtp.source.note",                       rx_rtp_source_note }, 
    1693         { "rtp.source.mute",                       rx_rtp_source_mute }, 
    1694         { "rtp.source.gain",                       rx_rtp_source_gain }, 
    1695         { "mbus.quit",                             rx_mbus_quit }, 
     1669        { "audio.input.mute",                      rx_audio_input_mute }, 
     1670        { "audio.input.gain",                      rx_audio_input_gain }, 
     1671        { "audio.input.port",                      rx_audio_input_port }, 
     1672        { "audio.output.mute",                     rx_audio_output_mute }, 
     1673        { "audio.output.gain",                     rx_audio_output_gain }, 
     1674        { "audio.output.port",                     rx_audio_output_port }, 
     1675        { "audio.channel.coding",                  rx_audio_channel_coding }, 
     1676        { "audio.channel.repair",                  rx_audio_channel_repair }, 
     1677        { "audio.file.play.open",                  rx_audio_file_play_open }, 
     1678        { "audio.file.play.pause",                 rx_audio_file_play_pause }, 
     1679        { "audio.file.play.stop",                  rx_audio_file_play_stop }, 
     1680        { "audio.file.play.live",                  rx_audio_file_play_live }, 
     1681        { "audio.file.record.open",                rx_audio_file_rec_open }, 
     1682        { "audio.file.record.pause",               rx_audio_file_rec_pause }, 
     1683        { "audio.file.record.stop",                rx_audio_file_rec_stop }, 
     1684        { "audio.file.record.live",                rx_audio_file_rec_live }, 
     1685        { "audio.device",                          rx_audio_device }, 
     1686        { "audio.query",                           rx_audio_query }, 
     1687        { "security.encryption.key",               rx_security_encryption_key }, 
     1688        { "rtp.query",                             rx_rtp_query }, 
     1689        { "rtp.addr.query",                        rx_rtp_addr_query }, 
     1690        { "rtp.addr",                              rx_rtp_addr }, 
     1691        { "rtp.source.name",                       rx_rtp_source_name }, 
     1692        { "rtp.source.email",                      rx_rtp_source_email }, 
     1693        { "rtp.source.phone",                      rx_rtp_source_phone }, 
     1694        { "rtp.source.loc",                        rx_rtp_source_loc }, 
     1695        { "rtp.source.note",                       rx_rtp_source_note }, 
     1696        { "rtp.source.mute",                       rx_rtp_source_mute }, 
     1697        { "rtp.source.gain",                       rx_rtp_source_gain }, 
     1698        { "mbus.quit",                             rx_mbus_quit }, 
    16961699        { "mbus.bye",                              rx_mbus_bye }, 
    1697         { "mbus.waiting",                          rx_mbus_waiting }, 
    1698         { "mbus.go",                               rx_mbus_go }, 
    1699         { "mbus.hello",                            rx_mbus_hello }, 
     1700        { "mbus.waiting",                          rx_mbus_waiting }, 
     1701        { "mbus.go",                               rx_mbus_go }, 
     1702        { "mbus.hello",                            rx_mbus_hello }, 
    17001703}; 
    17011704 
     
    17041707void mbus_engine_rx(char *srce, char *cmnd, char *args, void *data) 
    17051708{ 
    1706         uint32_t i; 
    1707  
    1708         for (i = 0; i < NUM_ENGINE_CMDS; i++) { 
     1709        uint32_t i; 
     1710 
     1711        for (i = 0; i < NUM_ENGINE_CMDS; i++) { 
    17091712                if (strcmp(engine_cmds[i].rxname, cmnd) == 0) { 
    1710                         engine_cmds[i].rxproc(srce, args, (session_t *) data); 
     1713                        engine_cmds[i].rxproc(srce, args, (session_t *) data); 
    17111714                        return; 
    17121715                }