Application Installation

In order to configure HRN, Mbus, RAT and VIC is needed.

1. Mbus
• Before installation of Mbus, you need to read Mbus documentation; Requirement Draft, Transport Draft and Semantics Draft
• To install Mbus, download java-mbus-beta7.tgz
• compilation
• After uncompressing the zip file, set up the path of javac file. If you don't have jdk1.2.2 and uses jdk1.3, you have to install it first because Mbus supports jdk1.2.2.
• In order to use Mbus, .mbus configuration file at $HOME is needed.
• mbus needs cryptix encryption algorithms(Cryptix JCE and Cryptix 3)
• jce package from www.cryptix.org
• Download cryptix-jce-20000905-snap.zip
• Copy .jar files you got from the zip file into $(JDKHOME)/jre/lib/ext and $(JDKHOME)/lib/ext
• It requires java.security file modification
• add  security.provider.2=cryptix.provider.Cryptix to $(JDKHOME)/jre/lib/security/java.security file
• Update PATH and CLASSPATH variables to find out these files for example $HOME/.profile
• modification for HRN
• To add some commands for HRN, MessageBus.java and SimpleTransportLayer.java was modified.
• Even if the Mbus is updated, if you overwrite these files, you can use HRN commands for RAT and VIC.

2.  RAT
• Download rat-4.2.10.tar.gz
• When you uncompress and extract files,  you can get several directories.
• common directory
  • It contains Common multimedia library for Mbus communication
  • You have to modify common/rtp.c like this
  • in init_opt
  • Change rtp_setopt(session, RTP_OPT_WEAK_VALIDATION, TRUE);  
  • to rtp_setopt(session, RTP_OPT_WEAK_VALIDATION, FALSE);
  • so that RAT won't wait for RTCP to play sound out
  • ./configure
  • make
•  tcl-8.0 directory
• ./configure
• make
• make install
• tk-8.0 compilation
  • ./configure
  • make
  • make install
• rat directory
  • ./configure
  • make
  • make install

   

3. VIC
• Download vic.2.8ucl-1.1.3.tar.gz
• In order to install VIC, first you need to set up opi files for a video device. The OPI API provides a mechanism for accessing card specific capabilities in a platform independent way, and serves as the framework for producing platform and hardware independent applications.
• Uncompress opi files
• This files is needed for compilation of VIC i.e. opi.h and opi_c.h
• Copy include files ($(OPIHOME)/rt/MMACopi/reloc/MMACopi/include/opi.h, opi_c.h), header files and source file to VIC directory.
• Update environment variable to lib directory
• OPIHOME=$(OPI)/rt/MMACopi/reloc/MMACopi
  • $(OPI) is the installation directory of opi
• PATH=...:$OPIHOME/rt/MMACopi/reloc/MMACopi/bin:$PATH
• export PATH
• LD_LIBRARY_PATH=$OPIHOME/rt/MMACopi/reloc/MMACopi/lib:$LD_LIBRARY_PATH
• export LD_LIBRARY_PATH
• export OPIHOME
• overwrite Makefile for video card to that of Makefile of vic.
• VIC compilation
  • ./configure
  • make
  • make install
• Modification for HRN
• In order to get bps, fps and rtp information, I added some code in
• $(VIC)/net/mbus_engine.cpp and $(VIC)/net/mbus_engine.h
• mbus_engine.h
• For "tool.vic.codec.bps" Mbus command. When VIC receives this command, it sets its bandwidth to the received argument.

        void rx_video_codec_bps(char *srce, char *args, MBusHandler *mb);

• For "tool.vic.codec.fps" Mbus command. When VIC receives this command, it sets its frame rates to the received argument.

        void rx_video_codec_fps(char *srce, char *args, MBusHandler *mb);

• For "rtp.query" Mbus command. When VIC receives this command, it returns the information such as source/destination IP-address, port number, tool information etc.

        void rx_rtp_query(char *srce, char *args, MBusHandler *mb);

• For "audio.query" Mbus command. When VIC receives this command, it returns the information such as frame rate, its bandwidth.

        void rx_video_query(char *srce, char *args, MBusHandler *mb);

• For change video codec, "video.codec" Mbus command can be used.

        void rx_video_codec(char *srce, char *args, MBusHandler *mb);

• mbus_engine.cpp
• When mbus routine handler receives these kinds of commands, it dispatchs the proper routines.

        static struct mbus_cmnd_to_func  mbus_cmnd_to_func_table[] = {

          {"rtp.source.playout",          &MBusEngine::rx_source_playout},

          {"rtp.source.cname",            &MBusEngine::rx_source_cname},

          {"rtp.source.active",           &MBusEngine::rx_source_active},

          {"audio.output.powermeter",     &MBusEngine::rx_powermeter},

          {"audio.input.powermeter",      &MBusEngine::rx_powermeter},

          {"mbus.hello",                  &MBusEngine::rx_mbus_hello},

          {"rtp.query",                   &MBusEngine::rx_rtp_query},

          {"video.query",                 &MBusEngine::rx_video_query},

          {"tool.vic.codec",              &MBusEngine::rx_video_codec},

          {"tool.vic.codec.bps",          &MBusEngine::rx_video_codec_bps},

          {"tool.vic.codec.fps",          &MBusEngine::rx_video_codec_fps},

          {NULL,NULL}

        };

 

• Each function calls the correspondent functions in ui-ctrlmenu.tcl.

// This is for rtp.query command

void MBusEngine::rx_rtp_query(char *srce, char *args, MBusHandler *mb)

{

  Tcl& tcl = Tcl::instance();

  // This is for rtp.tool.source

  tcl.evalf("rtp_source_tool {%s}", srce);

  char *tool = strdup(tcl.result());

  mb->send(srce, "rtp.source.tool", tool, 0);

  // This is for rtp.addr

  tcl.evalf("rtp_addr {%s}", srce);

  char *addr = strdup(tcl.result());

  mb->send(srce, "rtp.addr", addr, 0);

}

// for video.query command

void MBusEngine::rx_video_query(char *srce, char *args, MBusHandler *mb)

{

  Tcl& tcl = Tcl::instance();

  // This is for rtp.tool.source

  tcl.evalf("video_bps {%s}", srce);

  char *bps = strdup(tcl.result());

  mb->send(srce, "tool.vic.codec.bps", bps, 0);

}

// for video.codec command

void MBusEngine::rx_video_codec(char *srce, char *args, MBusHandler *mb)

{

  struct mbus_parser *mp;

  char *codec;

  mp = mbus_parse_init(args);

  mbus_parse_done(mp);

}

// for tool.vic.codec.bps command

void MBusEngine::rx_video_codec_bps(char *srce, char *args, MBusHandler *mb)

{

  struct mbus_parser *mp;

  char *bandwidth;

  char *bps;

  mp = mbus_parse_init(args);

  if(mbus_parse_str(mp, &bps)) {

    bandwidth = strdup(mbus_decode_str(bps));

    Tcl::instance().evalf("adapt_bps {%s}", bandwidth);

  }

  mbus_parse_done(mp);

}

// for tool.vic.codec.fps command

void MBusEngine::rx_video_codec_fps(char *srce, char *args, MBusHandler *mb)

{

  struct mbus_parser *mp;

  char *framerate;

  char *fps;

  mp = mbus_parse_init(args);

  if(mbus_parse_str(mp, &fps)) {

        framerate = strdup(mbus_decode_str(fps));

    Tcl::instance().evalf("adapt_fps {%s}", framerate);

  }

  mbus_parse_done(mp);

}

• ui_ctrlmenu.tcl

 

• In order to process the Mbus commands, the tcl routines was added.

 

        # To process rtp.addr command

        # It returns ip-address and port number

proc rtp_addr value {

  set ret ""

  global V

  set net $V(data-net)

  append ret [$net addr] " " [$net port] " " [$net ttl]

  return $ret

}

        # To process tool.vic.codec.fps command

        # It gets frame rate information

proc video_bps value {

  set ret [.menu.cb.frame.right.bps.scale get]

  return $ret

}

        # To process tool.vic.codec.bps command

        # It gets bandwidth information

proc adapt_bps value {

  .menu.cb.frame.right.bps.scale set $value

  set_bps .menu.cb.frame.right.bps.value $value

}

        # To process tool.vic.codec.fps command

        # It sets frame rate information

proc adapt_fps value {

  .menu.cb.frame.right.fps.scale set $value

  set_fps .menu.cb.frame.right.fps.value $value

}

        # To process tool.vic.codec.bps command

        # It sets bandwidth information

proc set_bps { w value } {

  if [have grabber] {

     grabber bps $value

     session data-bandwidth $value

  }

  $w configure -text "$value kbps"

}

        # To process tool.vic.codec.fps command

        # It sets frame rate information

proc set_fps { w value } {

  grabber fps $value

  $w configure -text "$value fps"

}

4. HRN

• make hrn
• make jni
• in Solaris, to use raw socket with router_alert option
• make jnil
• in Linux, to use raw socket with router_alert option

Run

• java [dstIPAddress] [dstPort]
• default dstPort is 20000
• If you want to execute at ind.cs.columbia.edu as a sender agent to a receiver agent at bourbone
• java HrnMain 192.168.4.11
• If you want to execute at bourbon.cs.columbia.edu as a sender agent to a receiver agent at ind
• java HrnMain 192.168.3.11
• Instructions for HrnMain

KyungTae Kim (kk521@columbia.edu)