The Java programming language and the Java runtime environment have been developed by Sun
Microsystems, Inc. Gosling and McGilton, who were involved in the development of Java,
claim in their Java white paper [GM95] that Java
is a simple, object-oriented, distributed, interpreted, robust, secure, architecture
neutral, portable, high-performance, multithreaded, and dynamic language. In comparison to other
programming languages, they position Java in the middle between high-level and portable
but slow scripting languages such as TCL on the one hand, and low level and fast but
non-portable and unreliable compiled languages such as C++ on the other hand.
For the purpose of implementing an object-oriented multimedia data stream transmission
architecture, the portability, architecture neutrality, object orientation, multithreading, and
distribution of Java seem especially advantageous.
Java includes two possibilities of executing bytecoded Java programmes. One method is to distribute
the Java bytecode via the World Wide Web by integrating the bytecoded programmes as
Java applets in HTML pages. It is then the task of the displaying WWW browsers to
start a Java bytecode interpreter for running the applet. This mode of operation is very suitable
in case the presented architecture is used as a base for a multimedia chat system, for example.
However, the security managers incorporated in the Java interpreters of current
WWW browsers limit the network access of Java applets in a very restrictive way:
applets are only permitted to connect back to the WWW server they were downloaded
from. However, distributed multimedia applications, such as for example conferencing
systems, must be able to exchange data with partners on hosts residing on hosts all over
the network.
Consequently, the applet mechanism must be reject. Instead, I employed the other method of
running Java programmes: the Java interpreter executes the bytecode as a stand-alone
Java application, which does not incur any security-related limitations.
As a drawback of the application solution, the bytecode must be installed manually
like any normal piece of software, and cannot be downloaded dynamically over a network by means
of the applet mechanism.
Because I wanted to preserve the portability offered by Java, I refrained from writing any native C or C++ code, but relied on ``pure'' Java only. This decision was made with a potential applet implementation in mind, because the applet mechanism does not include the downloading of natively implemented C code, because this is extremely unfavourable from the security viewpoint. Consequently, the implementation is entirely built on the class packages provided with Sun's Java Development Kit (JDK), version 1.0.2.
To achieve modularity and expandability, I made intensive use of Java's interface
construct. Interfaces define a type hierarchy. Classes that declare that they conform to a
particular type must provide an implementation of the methods defined by the type's
interface definition.
For similar reasons, I structured the classes of the architecture using Java's package
concept. The top-level package name is mmstream; the subpackages are:
mmstream.util
mmstream.address
mmstream.connection and mmstream.connection.ip
mmstream.protocols and mmstream.protocols.rtp
mmstream.source
mmstream.config and mmstream.session
mmstream.stream
mmstream.consumer and mmstream.producer
mmstream.apps