Changeset 2765

Show
Ignore:
Timestamp:
09/24/99 14:09:24 (15 years ago)
Author:
ucacoxh
Message:

- Consistency fixes for channel coder query functions.

Location:
rat/trunk
Files:
8 modified

Legend:

Unmodified
Added
Removed
  • rat/trunk/audio.c

    r2744 r2765  
    289289                if (sp->num_encodings > 1 &&  
    290290                    !codec_audio_formats_compatible(curr_config->primary, codec_get_by_payload(sp->encodings[1]))) { 
    291                         cc_details ccd; 
    292                         int null_idx; 
    293                          
     291                        const cc_details_t *ccd; 
    294292                        channel_encoder_destroy(&sp->channel_coder); 
    295                          
    296                         null_idx = channel_get_null_coder(); 
    297                         channel_get_coder_details(null_idx, &ccd); 
    298                          
    299                         channel_encoder_create(ccd.descriptor, &sp->channel_coder); 
     293                        ccd = channel_get_null_coder(); 
     294                        channel_encoder_create(ccd->descriptor, &sp->channel_coder); 
    300295                        sp->num_encodings = 1; 
    301296                } 
    302                 sp->render_3d     = curr_config->render_3d; 
     297                sp->render_3d = curr_config->render_3d; 
    303298        } else { 
    304299                debug_msg("audio device reconfigure - nothing to do.\n"); 
  • rat/trunk/channel.c

    r2648 r2765  
    2929 
    3030typedef struct { 
    31         char    name[CC_NAME_LENGTH]; 
     31        cc_details_t details; 
    3232        u_int8  pt; 
    3333        u_int8  layers; 
     
    7575#define CC_LAYERED_PT    125 
    7676 
     77#define CC_IDX_TO_ID(x) (((x)+1) | 0x0e00) 
     78#define CC_ID_TO_IDX(x) (((x)-1) & 0x000f) 
     79 
    7780static const channel_coder_t table[] = { 
    7881        /* The vanilla coder goes first. Update channel_get_null_coder 
    7982         * and channel_coder_get_by_payload if it moves. 
    8083         */ 
    81         {"None",      
    82          CC_VANILLA_PT, 
    83          1, 
    84          vanilla_encoder_create,  
    85          vanilla_encoder_destroy, 
    86          NULL,                   /* No parameters to set ...*/ 
    87          NULL,                   /* ... or get. */ 
    88          vanilla_encoder_reset, 
    89          vanilla_encoder_encode, 
    90          NULL, 
    91          NULL, 
    92          NULL, 
    93          vanilla_decoder_decode, 
    94          vanilla_decoder_peek, 
    95          vanilla_decoder_describe 
     84        { 
     85                { 
     86                        CC_IDX_TO_ID(0),  
     87                        "None" 
     88                }, 
     89                CC_VANILLA_PT, 
     90                1, 
     91                vanilla_encoder_create,  
     92                vanilla_encoder_destroy, 
     93                NULL,                   /* No parameters to set ...*/ 
     94                NULL,                   /* ... or get. */ 
     95                vanilla_encoder_reset, 
     96                vanilla_encoder_encode, 
     97                NULL, 
     98                NULL, 
     99                NULL, 
     100                vanilla_decoder_decode, 
     101                vanilla_decoder_peek, 
     102                vanilla_decoder_describe 
    96103        }, 
    97         {"Redundancy", 
    98          CC_REDUNDANCY_PT, 
    99          1, 
    100          redundancy_encoder_create, 
    101          redundancy_encoder_destroy, 
    102          redundancy_encoder_set_parameters, 
    103          redundancy_encoder_get_parameters, 
    104          redundancy_encoder_reset, 
    105          redundancy_encoder_encode, 
    106          NULL, 
    107          NULL, 
    108          NULL, 
    109          redundancy_decoder_decode, 
    110          redundancy_decoder_peek, 
    111          redundancy_decoder_describe 
     104        { 
     105                {  
     106                        CC_IDX_TO_ID(1),  
     107                        "Redundancy" 
     108                }, 
     109                CC_REDUNDANCY_PT, 
     110                1, 
     111                redundancy_encoder_create, 
     112                redundancy_encoder_destroy, 
     113                redundancy_encoder_set_parameters, 
     114                redundancy_encoder_get_parameters, 
     115                redundancy_encoder_reset, 
     116                redundancy_encoder_encode, 
     117                NULL, 
     118                NULL, 
     119                NULL, 
     120                redundancy_decoder_decode, 
     121                redundancy_decoder_peek, 
     122                redundancy_decoder_describe 
    112123        }, 
    113         {"Layering",  
    114          CC_LAYERED_PT, 
    115          LAY_MAX_LAYERS, 
    116          layered_encoder_create, 
    117          layered_encoder_destroy, 
    118          layered_encoder_set_parameters, 
    119          layered_encoder_get_parameters, 
    120          layered_encoder_reset, 
    121          layered_encoder_encode, 
    122          NULL, 
    123          NULL, 
    124          NULL, 
    125          layered_decoder_decode, 
    126          layered_decoder_peek, 
    127          layered_decoder_describe 
    128         }, 
     124        { 
     125                { 
     126                        CC_IDX_TO_ID(2), 
     127                        "Layering" 
     128                },  
     129                CC_LAYERED_PT, 
     130                LAY_MAX_LAYERS, 
     131                layered_encoder_create, 
     132                layered_encoder_destroy, 
     133                layered_encoder_set_parameters, 
     134                layered_encoder_get_parameters, 
     135                layered_encoder_reset, 
     136                layered_encoder_encode, 
     137                NULL, 
     138                NULL, 
     139                NULL, 
     140                layered_decoder_decode, 
     141                layered_decoder_peek, 
     142                layered_decoder_describe 
     143        } 
    129144}; 
    130145 
    131 #define CC_IDX_TO_ID(x) (((x)+1) | 0x0e00) 
    132 #define CC_ID_TO_IDX(x) (((x)-1) & 0x000f) 
    133  
    134146#define CC_NUM_CODERS (sizeof(table)/sizeof(table[0])) 
    135147 
    136 int 
     148u_int32 
    137149channel_get_coder_count() 
    138150{ 
     
    140152} 
    141153 
    142 int 
    143 channel_get_coder_details(int idx, cc_details *ccd) 
    144 { 
    145         if (idx >=  0 &&  
    146             idx < channel_get_coder_count()) { 
    147                 ccd->descriptor = CC_IDX_TO_ID(idx); 
    148                 strcpy(ccd->name, table[idx].name); 
    149                 return TRUE; 
    150         } 
    151         return FALSE; 
    152 } 
    153  
    154 int 
    155 channel_get_coder_identity(channel_state_t *cs, cc_details *ccd) 
    156 { 
    157         assert(cs != NULL); 
    158         assert(ccd != NULL); 
    159         ccd->descriptor = CC_IDX_TO_ID(cs->coder); 
    160         strcpy(ccd->name, table[cs->coder].name); 
    161         return TRUE; 
    162 } 
    163  
    164 int 
     154const cc_details_t* 
     155channel_get_coder_details(u_int32 idx) 
     156{ 
     157        if (idx < CC_NUM_CODERS) { 
     158                return &table[idx].details; 
     159        }  
     160        return NULL; 
     161} 
     162 
     163const cc_details_t* 
     164channel_get_coder_identity(channel_state_t *cs) 
     165{ 
     166        assert(cs->coder < CC_NUM_CODERS); 
     167        return &table[cs->coder].details; 
     168} 
     169 
     170const cc_details_t* 
    165171channel_get_null_coder(void) 
    166172{ 
    167         return 0; 
     173        return &table[0].details; 
    168174} 
    169175 
  • rat/trunk/channel.h

    r2648 r2765  
    2424 */ 
    2525 
    26 int       channel_get_coder_count   (void); 
    27 int       channel_get_coder_details (int idx, cc_details *ccd); 
    28 int      channel_get_null_coder    (void); 
     26u_int32             channel_get_coder_count   (void); 
     27const cc_details_t* channel_get_coder_details (u_int32 idx); 
     28const cc_details_t* channel_get_null_coder    (void); 
    2929 
    3030/* channel_get_coder_identity fills coder name and descriptor into ccd */ 
    31 int       channel_get_coder_identity(struct s_channel_state *cs, cc_details *ccd); 
     31const cc_details_t* channel_get_coder_identity(struct s_channel_state *cs); 
    3232 
    3333/* Don't use these two functions directly use macros channel_encoder_{create, destory, reset}, 
  • rat/trunk/channel_types.h

    r2381 r2765  
    2020 
    2121typedef struct { 
    22         cc_id_t descriptor; 
    23         char    name[CC_NAME_LENGTH]; 
    24 } cc_details; 
     22        cc_id_t    descriptor; 
     23        const char name[CC_NAME_LENGTH]; 
     24} cc_details_t; 
    2525 
    2626/* In and out unit types.  On input channel encoder takes a playout buffer 
  • rat/trunk/mbus_engine.c

    r2763 r2765  
    11241124static void rx_audio_channel_coding(char *srce, char *args, session_t *sp) 
    11251125{ 
    1126         cc_details   ccd; 
     1126        const cc_details_t *ccd; 
    11271127        char        *coding, *sec_enc, *schan, *sfreq; 
    1128         int          i, n, offset, layerenc; 
     1128        int          offset, layerenc; 
     1129        u_int32      i, n; 
    11291130        u_int16      upp; 
    11301131 
     
    11341135        if (mbus_parse_str(sp->mbus_engine, &coding)) { 
    11351136                mbus_decode_str(coding); 
    1136  
    11371137                upp = channel_encoder_get_units_per_packet(sp->channel_coder); 
    11381138                n = channel_get_coder_count(); 
    11391139                for(i = 0; i < n; i++) { 
    1140                         channel_get_coder_details(i, &ccd); 
    1141                         if (strncasecmp(ccd.name, coding, 3) == 0) { 
    1142                                 debug_msg("rx_audio_channel_coding: %d, %s\n", ccd.descriptor, &ccd.name); 
    1143                                 switch(tolower(ccd.name[0])) { 
     1140                        ccd = channel_get_coder_details(i); 
     1141                        if (strncasecmp(ccd->name, coding, 3) == 0) { 
     1142                                debug_msg("rx_audio_channel_coding: 0x%08x, %s\n", ccd->descriptor, &ccd->name); 
     1143                                switch(tolower(ccd->name[0])) { 
    11441144                                case 'n':   /* No channel coding */ 
    11451145                                        sp->num_encodings = 1; 
    11461146                                        sp->layers = 1; 
    11471147                                        channel_encoder_destroy(&sp->channel_coder); 
    1148                                         channel_encoder_create(ccd.descriptor, &sp->channel_coder); 
     1148                                        channel_encoder_create(ccd->descriptor, &sp->channel_coder); 
    11491149                                        channel_encoder_set_units_per_packet(sp->channel_coder, upp); 
    11501150                                        break; 
     
    11551155                                                sp->layers = 1; 
    11561156                                                channel_encoder_destroy(&sp->channel_coder); 
    1157                                                 channel_encoder_create(ccd.descriptor, &sp->channel_coder); 
     1157                                                channel_encoder_create(ccd->descriptor, &sp->channel_coder); 
    11581158                                                channel_encoder_set_units_per_packet(sp->channel_coder, upp); 
    11591159                                                set_red_parameters(sp, sec_enc, offset); 
     
    11691169                                                mbus_decode_str(sfreq); 
    11701170                                                channel_encoder_destroy(&sp->channel_coder); 
    1171                                                 channel_encoder_create(ccd.descriptor, &sp->channel_coder); 
     1171                                                channel_encoder_create(ccd->descriptor, &sp->channel_coder); 
    11721172                                                channel_encoder_set_units_per_packet(sp->channel_coder, upp); 
    11731173                                                set_layered_parameters(sp, sec_enc, schan, sfreq, layerenc); 
     
    11811181        mbus_parse_done(sp->mbus_engine); 
    11821182#ifdef DEBUG 
    1183         channel_get_coder_identity(sp->channel_coder, &ccd); 
    1184         debug_msg("***** %s\n", ccd.name); 
     1183        ccd = channel_get_coder_identity(sp->channel_coder); 
     1184        debug_msg("***** %s\n", ccd->name); 
    11851185#endif /* DEBUG */ 
    11861186        ui_update_channel(sp); 
  • rat/trunk/session.c

    r2756 r2765  
    7171        u_int32 i, j, n_codecs, n_channels; 
    7272        codec_id_t cid; 
    73         const codec_format_t *cf; 
     73        const codec_format_t *cf  = NULL; 
     74        const cc_details_t   *ccd = NULL; 
    7475        cc_id_t    ccid; 
    75         cc_details ccd; 
     76 
    7677        u_char pt; 
    7778 
     
    8586                        ccid = channel_coder_get_by_payload(pt); 
    8687                        for(j = 0; j < n_channels; j++) { 
    87                                 if ((int)j == channel_get_null_coder()) { 
     88                                ccd = channel_get_coder_details(j); 
     89                                if (ccd == channel_get_null_coder()) { 
    8890                                        continue; 
    8991                                } 
    90                                 channel_get_coder_details(j, &ccd); 
    91                                 if (ccd.descriptor == ccid) { 
    92                                         debug_msg("clash with %s %s payload (%d)\n", cf->long_name, ccd.name, pt); 
     92                                if (ccd->descriptor == ccid) { 
     93                                        debug_msg("clash with %s %s payload (%d)\n", cf->long_name, ccd->name, pt); 
    9394                                        return FALSE; 
    9495                                } 
     
    104105session_init(session_t *sp) 
    105106{ 
    106         codec_id_t            cid; 
    107         const codec_format_t *cf; 
    108         const converter_details_t *conv; 
    109         cc_details            ccd; 
    110         u_int8                i; 
     107        codec_id_t                cid; 
     108        const codec_format_t      *cf   = NULL; 
     109        const converter_details_t *conv = NULL; 
     110        const cc_details_t        *ccd  = NULL; 
     111        u_int8                     i; 
    111112 
    112113        memset(sp, 0, sizeof(session_t)); 
     
    122123        sp->num_encodings               = 1;                                    /* Number of encodings applied */ 
    123124 
    124         channel_get_coder_details(channel_get_null_coder(), &ccd); 
    125         channel_encoder_create(ccd.descriptor, &sp->channel_coder); 
     125        ccd = channel_get_null_coder(); 
     126        channel_encoder_create(ccd->descriptor, &sp->channel_coder); 
    126127 
    127128        conv                            = converter_get_details(0); 
     
    552553                        if ((strcmp(argv[i], "-f") == 0) && (argc > i+1)) { 
    553554                                codec_id_t primary_cid, secondary_cid; 
    554                                 cc_details ccd; 
     555                                const cc_details_t *ccd; 
    555556                                const char *primary_name, *secondary_name; 
    556557                                u_int16 upp, num_channel_coders, idx; 
     
    581582                                         */ 
    582583                                        upp = channel_encoder_get_units_per_packet(sp[s]->channel_coder); 
    583                                         num_channel_coders = channel_get_coder_count(); 
    584                                         for (idx = 0; idx < num_channel_coders; idx++) { 
    585                                                 channel_get_coder_details(idx, &ccd); 
    586                                                 if (tolower(ccd.name[0]) == 'n') { 
    587                                                         channel_encoder_destroy(&sp[s]->channel_coder); 
    588                                                         channel_encoder_create(ccd.descriptor, &sp[s]->channel_coder); 
    589                                                         channel_encoder_set_units_per_packet(sp[s]->channel_coder, upp); 
    590                                                         sp[s]->num_encodings = 1; 
    591                                                 } 
    592                                         } 
    593                                         continue; 
     584                                        ccd = channel_get_null_coder(); 
     585                                        channel_encoder_destroy(&sp[s]->channel_coder); 
     586                                        channel_encoder_create(ccd->descriptor, &sp[s]->channel_coder); 
     587                                        channel_encoder_set_units_per_packet(sp[s]->channel_coder, upp); 
    594588                                } 
    595589                                 
     
    612606                                num_channel_coders = channel_get_coder_count(); 
    613607                                for(idx = 0; idx < num_channel_coders; idx++) { 
    614                                         channel_get_coder_details(idx, &ccd); 
    615                                         if (tolower(ccd.name[0]) == 'r') { 
     608                                        ccd = channel_get_coder_details(idx); 
     609                                        /* Redundant channel coder is the only that begins with an 'r' */ 
     610                                        if (tolower(ccd->name[0]) == 'r') { 
    616611                                                char *cmd; 
    617612                                                channel_encoder_destroy(&sp[s]->channel_coder); 
    618                                                 channel_encoder_create(ccd.descriptor, &sp[s]->channel_coder); 
     613                                                channel_encoder_create(ccd->descriptor, &sp[s]->channel_coder); 
    619614                                                channel_encoder_set_units_per_packet(sp[s]->channel_coder, upp); 
    620615                                                cmd = (char*)xmalloc(2 * (CODEC_LONG_NAME_LEN + 4)); 
     
    632627                                        } 
    633628                                } 
    634  
    635629                        } 
    636630                } 
  • rat/trunk/settings.c

    r2763 r2765  
    358358{ 
    359359        char                            *name, *primary_codec, *port; 
    360         int                              i, freq, chan, n; 
    361         cc_details                       ccd; 
     360        int                              freq, chan; 
     361        u_int32                          i, n; 
     362        const cc_details_t              *ccd; 
    362363        const audio_device_details_t    *add = NULL; 
    363364        const audio_port_details_t      *apd = NULL; 
     
    393394 
    394395        port = setting_load_str("audioOutputPort", "Headphone"); 
    395         for(i = 0; i < audio_get_oport_count(sp->audio_device); i++) { 
     396        n    = audio_get_oport_count(sp->audio_device); 
     397        for(i = 0; i < n; i++) { 
    396398                apd = audio_get_oport_details(sp->audio_device, i); 
    397399                if (!strcasecmp(port, apd->name)) { 
     
    402404         
    403405        port = setting_load_str("audioInputPort", "Microphone"); 
    404         for(i = 0; i < audio_get_iport_count(sp->audio_device); i++) { 
     406        n    = audio_get_iport_count(sp->audio_device); 
     407        for(i = 0; i < n; i++) { 
    405408                apd = audio_get_iport_details(sp->audio_device, i); 
    406409                if (!strcasecmp(port, apd->name)) { 
     
    417420        n    = channel_get_coder_count(); 
    418421        for (i = 0; i < n; i++ ) { 
    419                 channel_get_coder_details(i, &ccd); 
    420                 if (strcmp(ccd.name, name) == 0) { 
    421                         channel_encoder_create(ccd.descriptor, &sp->channel_coder); 
     422                ccd = channel_get_coder_details(i); 
     423                if (strcmp(ccd->name, name) == 0) { 
     424                        channel_encoder_create(ccd->descriptor, &sp->channel_coder); 
    422425                        break; 
    423426                } 
     
    573576{ 
    574577        const codec_format_t            *pri_cf; 
    575         const audio_port_details_t      *iapd   = NULL; 
    576         const audio_port_details_t      *oapd   = NULL; 
    577         const audio_format              *af     = NULL; 
    578         const repair_details_t          *repair = NULL; 
     578        const audio_port_details_t      *iapd      = NULL; 
     579        const audio_port_details_t      *oapd      = NULL; 
     580        const audio_format              *af        = NULL; 
     581        const repair_details_t          *repair    = NULL; 
    579582        const converter_details_t       *converter = NULL; 
    580         const audio_device_details_t    *add    = NULL; 
     583        const audio_device_details_t    *add       = NULL; 
     584        const cc_details_t              *ccd       = NULL; 
    581585        codec_id_t                       pri_id; 
    582         cc_details                       cd; 
     586    
    583587        int                              cc_len; 
    584588        char                            *cc_param; 
     
    592596        cc_param = (char*) xmalloc(cc_len); 
    593597        channel_encoder_get_parameters(sp->channel_coder, cc_param, cc_len); 
    594         channel_get_coder_identity(sp->channel_coder, &cd); 
     598        ccd = channel_get_coder_identity(sp->channel_coder); 
    595599 
    596600        n = converter_get_count(); 
     
    651655                setting_save_str("audioPrimary",           pri_cf->short_name); 
    652656                /* If vanilla channel coder don't save audioChannelParameters - it's rubbish */ 
    653                 if (strcmp(cd.name, "Vanilla") == 0) { 
     657                if (strcmp(ccd->name, "Vanilla") == 0) { 
    654658                        setting_save_str("audioChannelParameters", cc_param); 
    655                 } 
    656                 else { 
     659                } else { 
    657660                        setting_save_str("audioChannelParameters", "None"); 
    658661                } 
     
    660663 
    661664        setting_save_int("audioUnits", channel_encoder_get_units_per_packet(sp->channel_coder)); 
    662         /* Don't save the layered channel coder - you need to start it from the command 
    663         line anyway */ 
    664         if (strcmp(cd.name, "Layering") == 0) { 
     665        /* Don't save the layered channel coder - you need to start it */ 
     666        /* from the command line anyway                                */ 
     667        if (strcmp(ccd->name, "Layering") == 0) { 
    665668                setting_save_str("audioChannelCoding", "Vanilla"); 
    666         } 
    667         else setting_save_str("audioChannelCoding",     cd.name); 
    668         setting_save_str("audioChannelCoding",     cd.name); 
     669        } else { 
     670                setting_save_str("audioChannelCoding", ccd->name); 
     671        } 
     672        setting_save_str("audioChannelCoding",     ccd->name); 
    669673        setting_save_str("audioRepair",            repair->name); 
    670674        setting_save_str("audioAutoConvert",       converter->name); 
  • rat/trunk/ui.c

    r2763 r2765  
    498498ui_update_channel(session_t *sp)  
    499499{ 
    500         cc_details cd; 
    501         char *mbes; 
    502  
    503         channel_get_coder_identity(sp->channel_coder, &cd); 
    504         switch(tolower(cd.name[0])) { 
     500        const cc_details_t *ccd; 
     501        char *mbes; 
     502 
     503        ccd = channel_get_coder_identity(sp->channel_coder); 
     504        switch(tolower(ccd->name[0])) { 
    505505        case 'n': 
    506506                mbes = mbus_encode_str("none");