Changeset 2058

Timestamp:

10/22/98 16:32:04 (15 years ago)

Author:

ucaccsp

Message:

Remove tool.rat.redundancy and tool.rat.interleaving, and merge their
functions into audio.channel.coding

Location:

rat/trunk

Files:

• README.mbus (modified) (1 diff)
• audio.c (modified) (1 diff)
• mbus_engine.c (modified) (7 diffs)
• session.c (modified) (3 diffs)
• ui.c (modified) (5 diffs)
• ui.h (modified) (1 diff)
• ui_audiotool.tcl (modified) (4 diffs)

rat/trunk/README.mbus

@@ -180 +180 @@
         Used in the initialisation process.
 
-tool.rat.interleaving
 tool.rat.codec
 tool.rat.codec.supported
-tool.rat.redundancy
 tool.rat.redundancy.supported
 
         Control which codecs are used for transmission. Should be replaced
-        by audio.channel.coding, audio.channel.repair, etc.
+        by audio.channel.coding, etc.
 
 tool.rat.converter

rat/trunk/audio.c

@@ -376 +376 @@
                 channel_set_coder(sp, sp->encodings[0]);
         }
-
-        ui_update(sp);
 }
 

rat/trunk/mbus_engine.c

@@ -696 +696 @@
 }
 
-static void
-rx_tool_rat_interleaving(char *srce, char *args, session_struct *sp)
-{
-        int units, separation, cc_pt;
-        char config[80];
-
-        UNUSED(srce);
-        
-        mbus_parse_init(sp->mbus_engine_conf, args);
-        if (mbus_parse_int(sp->mbus_engine_conf, &units) &&
-            mbus_parse_int(sp->mbus_engine_conf, &separation)) {
-                cc_pt        = get_cc_pt(sp,"INTERLEAVER");
-                sprintf(config, "%d/%d", units, separation);
-                debug_msg("config %s\n", config);
-                config_channel_coder(sp, cc_pt, config);
-        } else {
-                printf("mbus: usage \"tool.rat.interleaving <codec> <separation in units>\"\n");
-        }
-        mbus_parse_done(sp->mbus_engine_conf);
-        ui_update_interleaving(sp);
-}
-
-static codec_t*
-validate_redundant_codec(codec_t *primary, codec_t *redundant) 
-{
-        assert(primary != NULL);
-        
-        if ((redundant == NULL) ||                       /* passed junk */
-            (!codec_compatible(primary, redundant)) ||   /* passed incompatible codec */
-            (redundant->unit_len > primary->unit_len)) { /* passed higher bandwidth codec */
-                return primary;
-        }
-        return redundant;
-}
-
-static void 
-rx_tool_rat_redundancy(char *srce, char *args, session_struct *sp)
-{
-        char    *codec;
-        int      offset, cc_pt, rpt;
-        char     config[80];
-        codec_t *rcp, *pcp;
-
-        UNUSED(srce);
-
-        mbus_parse_init(sp->mbus_engine_conf, args);
-        if (mbus_parse_str(sp->mbus_engine_conf, &codec) && 
-            mbus_parse_int(sp->mbus_engine_conf, &offset)) {
-                if (offset<=0) offset = 0;;
-                pcp = get_codec_by_pt(sp->encodings[0]);
-                rpt = codec_matching(mbus_decode_str(codec), pcp->freq, pcp->channels);
-                if (rpt != -1) {
-                        rcp = get_codec_by_pt(rpt);
-                } else {
-                        /* Specified secondary codec doesn't exist. Make it the same */
-                        /* as the primary, and hope that's a sensible choice.        */
-                        rcp = pcp;
-                }
-                assert(rcp != NULL);
-                /* Check redundancy makes sense... */
-                rcp = validate_redundant_codec(pcp,rcp);
-                sprintf(config,"%s/0/%s/%d", pcp->name, rcp->name, offset);
-                debug_msg("Configuring redundancy %s\n", config);
-                cc_pt = get_cc_pt(sp,"REDUNDANCY");
-                config_channel_coder(sp, cc_pt, config);
-        } else {
-                printf("mbus: usage \"tool.rat.redundancy <codec> <offset in units>\"\n");
-        }                
-        mbus_parse_done(sp->mbus_engine_conf);
-        ui_update_redundancy(sp);
-}
-
 static void 
 rx_tool_rat_codec(char *srce, char *args, session_struct *sp)
@@ -813 +741 @@
                         sp->encodings[0] = pt;
                         ui_update_primary(sp);
-                        ui_update_redundancy(sp);
                 } else {
                         /* just register we want to make a change */
@@ -919 +846 @@
 }
 
+static codec_t*
+validate_redundant_codec(codec_t *primary, codec_t *redundant) 
+{
+        assert(primary != NULL);
+        
+        if ((redundant == NULL) ||                       /* passed junk */
+            (!codec_compatible(primary, redundant)) ||   /* passed incompatible codec */
+            (redundant->unit_len > primary->unit_len)) { /* passed higher bandwidth codec */
+                return primary;
+        }
+        return redundant;
+}
+
 static void rx_audio_channel_coding(char *srce, char *args, session_struct *sp)
 {
-        char *channel;
+        char    *channel, *codec;
+        int      units, separation, cc_pt, offset, rpt;
+        char     config[80];
+        codec_t *rcp, *pcp;
 
         UNUSED(srce);
@@ -932 +875 @@
                 } else if (strcmp(channel, "redundant") == 0) {
                         channel_set_coder(sp, get_cc_pt(sp, "REDUNDANCY"));
+                        if (mbus_parse_str(sp->mbus_engine_conf, &codec) && mbus_parse_int(sp->mbus_engine_conf, &offset)) {
+                                if (offset<=0) offset = 0;;
+                                pcp = get_codec_by_pt(sp->encodings[0]);
+                                rpt = codec_matching(mbus_decode_str(codec), pcp->freq, pcp->channels);
+                                if (rpt != -1) {
+                                        rcp = get_codec_by_pt(rpt);
+                                } else {
+                                        /* Specified secondary codec doesn't exist. Make it the same */
+                                        /* as the primary, and hope that's a sensible choice.        */
+                                        rcp = pcp;
+                                }
+                                assert(rcp != NULL);
+                                /* Check redundancy makes sense... */
+                                rcp = validate_redundant_codec(pcp,rcp);
+                                sprintf(config,"%s/0/%s/%d", pcp->name, rcp->name, offset);
+                                debug_msg("Configuring redundancy %s\n", config);
+                                cc_pt = get_cc_pt(sp,"REDUNDANCY");
+                                config_channel_coder(sp, cc_pt, config);
+                        } else {
+                                printf("mbus: usage \"audio.channel.coding \"redundant\" <codec> <offset in units>\"\n");
+                        }                
                 } else if (strcmp(channel, "interleaved") == 0) {
-                        channel_set_coder(sp, get_cc_pt(sp, "INTERLEAVER"));
+                        cc_pt = get_cc_pt(sp,"INTERLEAVER");
+                        channel_set_coder(sp, cc_pt);
+                        if (mbus_parse_int(sp->mbus_engine_conf, &units) && mbus_parse_int(sp->mbus_engine_conf, &separation)) {
+                                sprintf(config, "%d/%d", units, separation);
+                                config_channel_coder(sp, cc_pt, config);
+                        } else {
+                                printf("mbus: usage \"audio.channel.coding \"interleaved\" <units> <separation>\"\n");
+                        }
                 } else {
                         debug_msg("scheme %s not recognized\n", channel);
@@ -942 +913 @@
         }
         mbus_parse_done(sp->mbus_engine_conf);
+        ui_update_channel(sp);
 }
 
@@ -999 +971 @@
         "tool.rat.converter",
         "tool.rat.settings",
-        "tool.rat.interleaving",
-        "tool.rat.redundancy",
         "tool.rat.codec",
         "tool.rat.sampling",
@@ -1052 +1022 @@
         rx_tool_rat_converter,
         rx_tool_rat_settings,
-        rx_tool_rat_interleaving,
-        rx_tool_rat_redundancy,
         rx_tool_rat_codec,
         rx_tool_rat_sampling,

rat/trunk/session.c

@@ -409 +409 @@
                                         config_channel_coder(sp[s], pt, argv[i+1]);
                                         channel_set_coder(sp[s], pt);
-                                        ui_update_interleaving(sp[s]);
+                                        ui_update_channel(sp[s]);
                                 } else {
                                         printf("Can't determine interleaver payload type\n");
@@ -426 +426 @@
                                 config_channel_coder(sp[s], pt, cfg);
                                 channel_set_coder(sp[s], pt);
+                                ui_update_primary(sp[s]);
                                 ui_update_channel(sp[s]);
-                                ui_update_primary(sp[s]);
-                                ui_update_redundancy(sp[s]);
                                 i++;
                         }
@@ -484 +483 @@
                                 }
                                 ui_update_primary(sp[s]);
-                                ui_update_redundancy(sp[s]);
                                 ui_update_channel(sp[s]);
                                 i++;

rat/trunk/ui.c

@@ -382 +382 @@
 
 void
-ui_update_interleaving(session_struct *sp)
-{
-        int pt, isep, iu;
-        char buf[128], *sep=NULL, *units = NULL, *dummy, args[80];
-
-        pt = get_cc_pt(sp,"INTERLEAVER");
-        if (pt != -1) {
-                query_channel_coder(sp, pt, buf, 128);
-                dummy  = strtok(buf,"/");
-                units  = strtok(NULL,"/");
-                sep    = strtok(NULL,"/");
-        } else {
-                debug_msg("Could not find interleaving channel coder!\n");
-        }
-        
-        if (units != NULL && sep != NULL) {
-                iu   = atoi(units);
-                isep = atoi(sep);
-        } else {
-                iu   = 4;
-                isep = 4;
-        }
-
-        sprintf(args,"%d %d",iu, isep);
-        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.interleaving", args, TRUE);        
-}
-
-void
 ui_update_frequency(session_struct *sp)
 {
@@ -457 +429 @@
 }
 
-void
+static void
+ui_update_interleaving(session_struct *sp)
+{
+        int pt, isep, iu;
+        char buf[128], *sep=NULL, *units = NULL, *dummy, args[80];
+
+        pt = get_cc_pt(sp,"INTERLEAVER");
+        if (pt != -1) {
+                query_channel_coder(sp, pt, buf, 128);
+                dummy  = strtok(buf,"/");
+                units  = strtok(NULL,"/");
+                sep    = strtok(NULL,"/");
+        } else {
+                debug_msg("Could not find interleaving channel coder!\n");
+        }
+        
+        if (units != NULL && sep != NULL) {
+                iu   = atoi(units);
+                isep = atoi(sep);
+        } else {
+                iu   = 4;
+                isep = 4;
+        }
+
+        sprintf(args,"\"interleaved\" %d %d",iu, isep);
+        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.channel.coding", args, TRUE);        
+}
+
+static void
 ui_update_redundancy(session_struct *sp)
 {
@@ -495 +495 @@
         codec_name = mbus_encode_str(codec_name);
 
-        args = (char *) xmalloc(strlen(codec_name) + 4);
-        sprintf(args,"%s %2d", codec_name, ioff);
-        assert(strlen(args) < (strlen(codec_name) + 4));
-        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "tool.rat.redundancy", args, TRUE);
+        args = (char *) xmalloc(strlen(codec_name) + 16);
+        sprintf(args,"\"redundant\" %s %2d", codec_name, ioff);
+        assert(strlen(args) < (strlen(codec_name) + 16));
+        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.channel.coding", args, TRUE);
         xfree(codec_name);
         xfree(args);
@@ -507 +507 @@
 {
         cc_coder_t *ccp;
-        char       *mbes = NULL;
 
         ccp = get_channel_coder(sp->cc_encoding);
-        assert(ccp != NULL);
-        switch(ccp->name[0]) {
-        case 'V':
-                mbes = mbus_encode_str("none");
-                break;
-        case 'R':
-                mbes = mbus_encode_str("redundant");
-                break;
-        case 'I':
-                mbes = mbus_encode_str("interleaved");
-                break;
-        default:
-                debug_msg("Channel coding failed mapping.\n");
-                return;
-        }
-
-        mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.channel.coding", mbes, TRUE);
-        if (mbes) xfree(mbes);
+        if (strcmp(ccp->name, "VANILLA") == 0) {
+                mbus_qmsg(sp->mbus_engine_base, mbus_name_ui, "audio.channel.coding", "\"none\"", TRUE);
+        } else if (strcmp(ccp->name, "REDUNDANCY") == 0) {
+                ui_update_redundancy(sp);
+        } else if (strcmp(ccp->name, "INTERLEAVER") == 0) {
+                ui_update_interleaving(sp);
+        } else {
+                debug_msg("Channel coding failed mapping (%s)\n", ccp->name);
+                abort();
+        }
 }
 
@@ -618 +609 @@
         ui_update_channels(sp);
         ui_update_primary(sp);
-        ui_update_redundancy(sp);
-        ui_update_interleaving(sp);
         ui_update_channel(sp);
         ui_repair(sp);

rat/trunk/ui.h

@@ -69 +69 @@
 void    ui_update_output_port(struct session_tag *sp);
 void    ui_update_primary(struct session_tag *sp);
-void    ui_update_redundancy(struct session_tag *sp);
-void    ui_update_interleaving(struct session_tag *sp);
 void    ui_update_channel(struct session_tag *sp) ;
 void    ui_update_powermeters(struct session_tag *sp, struct s_mix_info *ms, int elapsed_time);

rat/trunk/ui_audiotool.tcl

@@ -159 +159 @@
                 tool.rat.codec                  {eval mbus_recv_tool.rat.codec $args}
                 tool.rat.rate                   {eval mbus_recv_tool.rat.rate $args}
-                tool.rat.redundancy             {eval mbus_recv_tool.rat.redundancy $args}
-                tool.rat.interleaving           {eval mbus_recv_tool.rat.interleaving $args}
                 tool.rat.externalise            {eval mbus_recv_tool.rat.externalise $args}
                 tool.rat.lecture.mode           {eval mbus_recv_tool.rat.lecture.mode $args}
@@ -372 +370 @@
 }
 
-proc mbus_recv_tool.rat.redundancy {new_codec new_off} {
-    global secenc red_off
-    set secenc  $new_codec
-    set red_off $new_off
-}
-
-proc mbus_recv_tool.rat.interleaving {units separation} {
-    global int_units int_gap
-    set int_units $units
-    set int_gap $separation
-}
-
-proc mbus_recv_audio.channel.coding {channel} {
-    global channel_var
+proc mbus_recv_audio.channel.coding {channel args} {
+    global channel_var secenc red_off int_units int_gap
     set channel_var $channel
+    switch $channel {
+        redundant {
+                set secenc  [lindex $args 0]
+                set red_off [lindex $args 1]
+        }
+        interleaved {
+                set int_units [lindex $args 0]
+                set int_gap   [lindex $args 1]
+        }
+    }
 }
 
@@ -1476 +1472 @@
     global meter_var sync_var gain volume input_port output_port 
     global in_mute_var out_mute_var channels freq key key_var
-        global audio_device
+    global audio_device
 
     set my_cname_enc [mbus_encode_str $my_cname]
@@ -1488 +1484 @@
     mbus_send "R" "tool.rat.codec"      "[mbus_encode_str $prenc] [mbus_encode_str $channels] [mbus_encode_str $freq]"
     mbus_send "R" "tool.rat.rate"         $upp
-    mbus_send "R" "tool.rat.redundancy"   "[mbus_encode_str $secenc] $red_off"
-    mbus_send "R" "tool.rat.interleaving" "$int_gap $int_units"
-
-    # channel.code announcement  MUST go after config of channel coders communicated
-    mbus_send "R" "audio.channel.coding" [mbus_encode_str $channel_var]
+
+    switch $channel_var {
+        none        {mbus_send "R" "audio.channel.coding" "[mbus_encode_str $channel_var]"}
+        redundant   {mbus_send "R" "audio.channel.coding" "[mbus_encode_str $channel_var] [mbus_encode_str $secenc] $red_off"}
+        interleaved {mbus_send "R" "audio.channel.coding" "[mbus_encode_str $channel_var] $int_gap $int_units"}
+        *           {error "unknown channel coding scheme $channel_var"}
+    }
 
     mbus_send "R" "tool.rat.silence"       $silence_var