Projects for Final Engineering Students
1.1 MOTIVATION OF THE PROJECT
1.2 LITERATURE SURVEY
2. HARDWARE & SOFTWARE SPECIFICATION
4. DESIGN DETAIL
4.1 TOOLS USED
4.2 BLOCK DIAGRAM
5.1.1 USER INTERFACE
5.1.2 CAPTURING THE MEDIA
5.1.3 PROCESSING THE MEDIA
5.1.4 TRANSMISSION OF THE MEDIA
The project “Video Conference Over Intranet Using RTP” is a
software package to make a conferencing facility between two or more computers
connected over a Network.
Video Conferencing deals with the way people communicate and several
conferences takes place between them through computers. For this purpose several
software packages were available to conduct conference over internet. But not many
packages available for video conferencing over intranet. This project aims at
developing a software package for making video conference by using java media
framework, swings for graphical user interface applications, jdbc and MS-Access
database for information storage.
Videoconferencing needs a web cam and microphone through which
transmission of audio and video were possible in locally connected networks.
By simply install the package different group of peoples can make Video
Conference simultaneously over the Network. Here Text,Audio,Video are
transmitted and shared for this conference in a controlled way.
The video conference over Network is conducted by enabling the delivery of
dynamic interactive Media content across the Network.
To send or receive a live media and conduct a conference over a Network,We
need to receive and transmit the media frames in real time.
1.1 Motivation of the Project:
Problems in Existing System:
There are a variety of softwares existing for Video conferencing over
Internet, but not so for Intranet. Some product for Intranet exists but not well
known. Most of the systems do not provide proper authentication. No proper
hierarchy is maintained.The existing systems are not suitable for official use in
an Organization.Some existing systems like net-meeting can be used only in
Our package overcomes all the drawbacks in the existing system.since it
was developed in Java and hence remains portable across operating system and
provides interoperability across network of different operating systems. Proper
authentication is provided.It is using Real Time Transport Protocol (RTP) which is
of Internet standard and hence the system is flexible and future enhancements can be
provided with less cost and easy maintenance.
1.2 LITERATURE SURVEY
In this project media frames are transmitted in real-time. Hence, java
media framework 2.1.1 is used . Swing (for GUI Applications), jdbc3.0 and MS
Access database are used in this project.
Overview of Swings
The user interface is designed using Java Swing.The main reason behind
using swing is that they are more flexible and has more features than
AWT.Moreover AWT is a depreciated API.Hence it is adviseable to use swing.
Swing is a set of classes that provides more powerful and flexible
components than are not possible with the AWT.In addition to the familiar
components, such as buttons, checkboxes, and labels, swings supplies exciting
additons,including tabbed panes, scroll panes, trees and tables. Even familiar
components such as buttons have more capabilities in swing.
Unlike AWT components, Swing components are not implemented by
platform specific code. Instead, they are written entirely in java and therefore, are
platform independent. The term lightweight is used to describe such elements.
Fundamental to swing is the JApplet class, which extends Applet.
Overview of JMF2.1.1
Using java media framework we can contact with different types of media
devices. It contains lot of classes for transmission of media frames. It contains in-
built classes for creating players and processors . The JMF-RTP can be used for
transmission of the media.It has classes for processing the media and
Generating Live Audio/Video Data
JMF shows you how to create a custom PushBufferDataSource, which is
new to JMF2.1.1. A PushBufferDataSource contains streams of type
PushBufferStream. Such a stream typically generates audio/video data that is
organized as frames, rather than a continuous stream of bytes. So each Buffer object
carries an entire frame of video or a good sized chunk of audio (anywhere between
say 25 millisecs to 2 seconds worth). The data can be in a compressed or
uncompressed format. The stream needs to advertise the Format of its data through
the getFormat method.
2.HARDWARE AND SOFTWARE SPECIFICATION
Processor - Pentium II and above
Hard disk - minimum 100 MB of Free Space
RAM - 128 MB
Capture Devices - Webcam , Headphone and Speakers
Platform : Java
OS : Windows 2000/NT/XP
GUI : Swing
Database : MS Access
Media Package : JMF 2.1.1
Protocol : RTP
The project follows proper authentication features and permits access
in a controlled manner.
It deals with adding users to the database and assigning the roles for
the users and deleting users from the database.
The first step is the login where the username and password are checked and
provides access if the details are found to be valid.It also checks for the role of the
user and makes sure that access is provided accordingly.
STARTING THE CONFERENCE:
When the user presses the start button and enter the conference a chat
session is created where all the users who are logged in can have text chat.The list of
users who are logged in are displayed in a list box.A button will be provided for
adding users to the conference.Another button will be provided for removing users
from the conference.
Java media framework uses RTP to transmit the media. The data
thatone user want to send to another user can be sent at an instance with accuracy.
Two or more users are also able to chat and interact over an issue, and these
transmission is performed using the JMF-RTP API.
Using jmf to capture audio:
JMF uses multicasting for sending, receiving and controlling of audio.JMF
Processor captures the voice/audio and sent it over the network. JMF supports
various formats like .wav,.au,.aiff,.rmf etc.,.We are using .rtp format which is
platform independent and fits to any operating system.
Using JMF to capture video:
JMF API supports .mpeg, .avi formats for receiving of video over locally
connected networks. It uses multicasting for receiving media frames and
transmitting media frames. Codecs are provided by JMFAPI for compressing and
decompressing frames and storing it in database. Video frames are transmitted in
4.1 TOOLS USED
Java was conceived by James Gosling, Patrick Naughton, Chris Wrath, Ed
Frank and Mike Sheridan and SUN Micro Systems Incorporation in 1991. It took
18 months to develop the first working version. This language was initially called
"OAK", but was renamed "JAVA" in 1995. Before the initial implementation of
OAK in 1992 and the public announcement of Java in 1995, many more contributed
to the design and evolution of the language.
Java is a powerful but lean object oriented programming language. It has
generated a lot of excitement because it makes it possible to program for Internet by
creating applets, programs that can be embedded in web page.
The context of an applet is limited only by one's imagination. For example,
an applet can be animated with sound, an interactive game or a ticker tape with
constantly updated stock prices. Applets can be just little decoration to liven up web
page, or they can be serious applications like word processors or spreadsheet.
But Java is more than a programming language for writing applets. It is being
used more and more for writing standalone applications as well. It is becoming so
popular that many people believe it will become standard language for both general
purpose and Internet programming.
Java has added garbage collection, multi threading and security capabilities.
The result is that Java is actually a platform and easy to use.
Java is actually a platform consisting of three components:
1. Java programming language
2. Java library of classes and interfaces
3. Java virtual machine
FEATURES OF JAVA
Object-oriented programming is at the core of java. In fact, all
java programs are object-oriented
As we know, all computer programs consist of two elements: code and
data. Furthermore, a program can be conceptually organized around its code or
around its data. That is, some programs are written around "what is happening" and
other is written around "who is being affected”. These are the two paradigms that
govern how a program is constructed.
A class is a combination of similar type. The combination of both data and
the code of an object can be made a user defined data type with the help of a class.
A class defines shapes and behaviors of an object and data. In class has been
defined we can create any number of object belonging to that class. A said already
classes are user defined data types and behave likes the built in types of
An essential element of object -oriented programming is abstraction. Humans
manage complexity through abstraction. For example, people do not think of a car
as a set of tens of thousands of individual parts. They think of it as a well -defined
object with its own unique behavior. The point is that you manage the complexity of
car (or any other complex system) through the use of hierarchical abstraction.
Hierarchical abstraction of complex system can also be applied to computer
program .The data from a traditional process-oriented program can be transformed
by abstraction into its component object. A sequence of process steps can became a
collection of messages between these object. Thus each of this object describes its
own unique behavior.
The java programming language and environment is designed to solve a
number of problem in modern programming practice
Data abstraction is an act of representing essential features without
including the background details and explanations.
Encapsulation is the mechanism that binds together code and data it
manipulates, and keeps both safe from outside interference and misuse. It is the
protective wrapper that prevents the code and data being accessed by other code
from outside. Access to the code and data inside the wrapper is tightly controlled
through a well-defined interface,.
In java the basis of encapsulation is class. A class defines the structure
and behaviour that will be shared by a set of objects. Objects are reffered as
instances of a class.
Data Encapsulation is one of the most striking features of java.
Encapsulation is the wrapping up of data and functions into a single unit called
class. The wrapped defines the behavior and protects the code and data from being
arbitrarily accessed by the outside world and only those functions, which are
wrapped in the class, can access it. This type of insulation of data from direct
access by the program is called 'Data hiding'.
Inheritance is the process by which objects of a class can acquire the
properties of objects of another class i.e. in java the concept of inheritance provides
idea of reusability providing the means of adding additional features to an existing
class without modifying it. This is possible by
deriving a new class from the existing on thus the newly created class will have the
combined features of both the parent and the child classes.
Polymorphism means the ability to take more than one form i.e. one
object, many shapes. Polymorphism plays an important role in allowing objects
having different internal structure to share the same external interface. This states a
general class if operations may be accessed in the same manner ever though,
specific actions with each operation may differ.
Polymorphism is a feature that allows one interface to be used
for a general class of actions. This helps to reduce complexity by allowing the same
interface to be used to specify a general class of action. It is the compilers job to
select the specific action as it applies to each situation.
The advantages of Java are:
THE BYTE CODE
The key that allows java to solve both the security and the portability
problems is that the output of a java compiler is not executable code. There, it is
byte code. Byte code is a highly optimized set of instructions designed to be
executed by the java run-time system, which is called java virtual machine (JVM).
Translating a java program into byte code helps makes it much easier to
run a program in a wide variety of environments. The reason is straightforward:
only the JVM needs to be implemented for each flat form. Once the run-time
package exists for a given system, any java program can run on it. Remember
although the details of the JVM will differ from platform to platform, all interpret
the same java byte code. If a java program were compiled to native code, then
different versions of the same program would have to exist for each type of CPU
connected to the Internet. This is, of course, not a feasible solution. Thus, the
interpretation of byte code is the easiest way to create truly portable programs.
Binding refers the linking of a procedure call to the code to be executed in
response to the call. Dynamic binding means that the code associated with a given
procedure call is not known until the time of the call at the run time.Dynamic
binding is closely associated with the concepts of polymorphic depends on the
dynamic type of that reference.
PACKAGES AND INTERFACES
Java allows to groups classes in a collection called packages. Packages are
convenient way of organizing the classes and libraries. Packages can be nested. A
number of classes having same kind of behavior can be grouped under a package.
Packages are imported into the required java programs using the import
keyword. Interfaces provide a mechanism that allows unrelated classes to implement
the same set of methods. An interface is a collection of method prototypes and
constant values that is free from dependency on a specific class. Interfaces are
implemented by using the implements keyword.
INTRODUCTION TO API
Application programming interface (API) forms the heart of any java
program. These API's are defined in corresponding java packages and are imported
to the program. Some of the packages available in java that are used in this projest
Java. Lang -includes all language libraries
Java.awt -includes AWT libraries, such as windows,
scrollbars, etc., for GUI applications
Java. Applet -includes API for applet programming
Java.io -includes all libraries required for input-
output (io) applications.
Java.net -includes networking API's.
Java.util -includes general API's like vector, stack etc.
4.1.2 Java Database Connectivity (JDBC)
The Java Database Connectivity (JDBC) is a standard java extension for data
access that allows Java programmers to code to a unified relational database API.
By using JDBC, java programmer can represent database connections; issue SQL
statements, process database results, implemented by a JDBC Drive, an adapter that
known how to talk to a particular database in a proprietary way. JDBC is similar to
the Open Database Connectivity (ODBC) standard.
JDBC is a java database connectivity API that is a part of the Java
Enterprise APIs .It is used to integrate relational database with java programs. It
defines a set of API objects and methods to interact with the underlying database.
JDBC provides database access via Java that is independent of both the platform
and the database whose system the application runs on.
A java program first opens a connection to a database, makes a statement
object and retrieves the results as well as information about the
result sets. As a part of JDBC, a driver is also provided to access ODBC data
sources from JDBC. This driver is called the JDBC-ODBC bridge . It is
implemented as the JdbcOdbc.class and a native library to access the ODBC
As JDBC is close to ODBC in design, the ODBC bridge is a thin layer
over JDBC. Internally, this driver maps JDBC methods to ODBC calls and, thus, intracts
with any available ODBC driver. The advantage of this bridge is that now JDBC has the
capability to access almost all database, as ODBC drivers are widely available. The JDBC-
ODBC bridge allows JDBC driver to be used as ODBC drivers by converting JDBC
method calls into ODBC function calls.
JFC 1.2 consists of five major packages:
• Pluggable Look-and-Feel (PL&F)
• Drag and Drop
Swing components allow for efficient graphical user interface (GUI)
development. Swing components are a collection of lightweight visual components.
They contain replacements for the basic heavyweight AWT components as well as
complex user-interface components such as trees and tables.
Swing components contain a pluggable look-and-feel, abbreviated as
PL&F or plaf. This allows the same application to run with a native look-and-feel on
different platforms. For example, when running on a Windows platform, the
application will look like an application written specifically for the Windows-based
computer. The same application, when run on an Apple Macintosh computer, looks
like it was written specifically for the Macintosh. When the application is run on a
UNIX workstation, it looks like a UNIX application, and so on for any platform to
which the JVM has been ported.
Another use of the PL&F is to have an application behave the same on any
platform on which it is executed. The JFC contains operating system-neutral look-
and-feels that allow an application to present the same look-and-feel independent of
the operating system where it executes. This capability can reduce the learning
curve for users of applications running in a heterogeneous computer environment.
As a developer, you are not limited to the PL&F shipped with the JFC.
You can develop your own look-and-feel that can be used by any JFC application.
An organization may want to develop its own to give applications a consistent look-
and-feel for use on all its hardware platforms.
Unlike their AWT equivalents, Swing components do not contain peers.
Swing components are 100% pure Java and were designed to allow for mixing
AWT heavyweight and Swing lightweight components in an application. However,
in practice this has proven problematic. Whenever possible you should use all
Swing components and components derived from them.
The major difference between lightweight and heavyweight components is
that a lightweight component can have transparent pixels while a heavyweight
component is always opaque. By taking advantage of transparent pixels, a
lightweight component can appear to be non-rectangular, while a heavyweight
component must always be rectangular. A mouse event occurring in a lightweight
component falls through to its parent component, while a mouse event in a
heavyweight component does not propagate through to its parent component. When
a lightweight component overlaps a heavyweight component, the heavyweight
component is always drawn on top of the lightweight component, regardless of the
relative z-order of the two components.
Swing is an extension for the AWT, not a replacement. The root of the
majority of the Swing hierarchy is the JComponent class. This class is an extension
of the AWT Container class. Thus the necessity of the AWT classes, even when
using Swing components. For example, the AWT button or label classes are not
When there are equivalent classes in each toolkit for a particular UI
component, the Swing version should be used bcause awt is a depreciared API. The
JFC contains many complex components, such as a tree and table, that simply are
not available in the AWT.
The Swing component toolkit consists of over 250 pure Java classes
and 75 interfaces contained in more than 10 packages. They are used to build
lightweight user interfaces. Swing consists of non-user-interface (non-UI) classes as
well as the more familiar user-interface (UI) classes. The UI classes, such as buttons
and labels, create visible components that applications can display on screen, and
they can be combined to create a complete graphical user interface. The Swing UI
components descend from the JComponent class, and all begin with the capital letter
Swing packages that are typically used by developers when building
GUIs are listed, and briefly explained.Swing are not added in the awt package.They
are added in a package javax.swing.
The Swing Package: javax.swing
This is the largest of the Swing packages consisting of approximately 100 classes
and 25 interfaces. The majority of the UI classes (the "J" classes) are contained in
this package. The exceptions are JTableHeader, implemented in the
javax.swing.table package, and JTextComponent, implemented in the
javax.swing.text package. Both of these packages are described shortly.
The Basic Package: javax.swing.plaf.basic
The Basic package contains classes that define the default look-and-feel of Swing
components. By extending these classes, components with a customized PL&F can
The Border Package: javax.swing.border
The Border package contains the Border interface and nine classes that implement
this interface. Typically classes in this package are not instantiated directly; instead,
instances are obtained via methods in the BorderFactory class contained in the
javax.swing package.Classes in this package can be extended to create a specialized
The Event Package: javax.swing.event
The Event package defines events specific to Swing components. There are
approximately 25 Swing-specific events. The events themselves and their associated
Listener interfaces are defined in this package. Swing events are used by the various
data models contained in the JFC.
The Multipackage: javax.swing.plaf.multi
The Multipackage consists of multiplexing UI classes. These allow Swing
components to have UIs provided by multiple user-interface factories.
The Java Accessibility API provides the framework for JFC applications to interact
with assistive technologies. A properly written JFC application can be executed by
assistive technologies such as Braille terminals and screen readers just as easily as it
is run on conventional computers.
The Accessibility Package: javax.accessibility
The Accessibility package consists of eight interfaces and five classes. It contains
the Accessible interface that is the main interface for the JFC Accessibility package.
Any accessible component must implement this interface.
4.1.4 MICROSOFT ACCESS:
Microsoft Access has changed the image of desktop databases from
specialist applications used by dedicated professionals to standard business
productivity applications used by a wide range of users. More and more developers
are building easy-to-use business solutions on, or have integrated them with,
desktop applications on users' desktops.
Microsoft Access has built a tradition of innovation by making historically
difficult database technology accessible to general business users. Whether users are
connected by a LAN, the Internet, or not at all, Microsoft Access ensures that the
benefits of using a database can be quickly realized. With its integrated
technologies, Microsoft Access is designed to make it easy for all users to find
answers, share timely information, and build faster solutions.
At the same time, Microsoft Access has a powerful database engine and a
robust programming language, making it suitable for many types of complex
4.1.5 THE JMF
JMF is JAVA MEDIA FRAMEWORK . It is Fundamentally an
API for handling audio and video. Java Media Framework (JMF) provides a unified
architecture and messaging protocol for managing the acquisition, processing, and
delivery of time-based media data. JMF is designed to support most standard media
content types, such as AIFF, AU, AVI, GSM, MIDI, MPEG, QuickTime, RMF, and
By exploiting the advantages of the Java platform, JMF delivers
the promise of "Write Once, Run AnywhereTM" to developers who want to use
media such as audio and video in their Java programs. JMF provides a common
cross-platform Java API for accessing underlying media frameworks. JMF
implementations can leverage the capabilities of the underlying operating system,
while developers can easily create portable Java programs that feature time-based
media by writing to the JMF API.
The Java™ Media Framework API (JMF) enables audio, video and
other time-based media to be added to Java applications and applets. This optional
package, which can capture, playback, stream and transcode multiple media formats,
extends the multimedia capabilities on the J2SETM platform, and gives multimedia
developers a powerful toolkit to develop scalable, cross-platform technology.
FUNCTIONS OF JMF
Multiple content types and formats
Local or streaming media
Applets and Applications
Applications such as:
o AV conferencing
o True platform independent multi-media apps.
• Mobile and embedded devices (e.g., mobile phones)
Structure of the API
The version of JMF(2.1.1) that is used for this project consists of 209
classes (85 Interfaces).It is Split into 11 packages among which the following
packages are used in this project:
javax.media: The main, top-level, package comprising most of the classes and
also most of the important ones such as Time, Manager, Processor, and Player.
javax.media.control: A package comprised of 18 Interfaces defining the different
types of controls. Examples include FrameRateControl and FormatControl.
javax.media.format: An important package of 10 classes (one of which is an
exception) defining the different Formats that JMF is capable of processing.
Examples of the classes include AudioFormat and H263Format.
javax.media.protocol: An important package of 25 classes (15 being interfaces)
providing support for communication with datasources and capture devices.
Amongst the important classes included in this package are DataSource and
javax.media.renderer: A package of two interfaces defining a renderer (for video
javax.media.rtp: The top-level of the 3 packages dealing with RTP (Real-time
Transport Protocol) it comprises 26 classes (most interfaces) dealing with streaming
content with RTP.
javax.media.rtp.event: A package of 23 events that may result when using RTP.
javax.media.rtp.rtcp: A package of 5 classes (4 being interfaces) defining usage
of RTCP (RTP Control Protocol) within the JMF.
javax.media.util: A package of two highly useful classes: BufferToImage and
ImageToBuffer for converting between JMF buffers and AWT Images.
The classes that play major roles in this project used for creating
players,processing media and many more are:
Centralised creation of Players, Processors, DataSources and
* Playback (rendering) of time-based media Processor
* Processing (transcoding etc.) of time-based media
* Representation of time-based media arriving from a particular
source with a particular protocol
* Needed to create Players, Processors, etc.
* Means of “sinking” (e.g., saving to a file) time-based media
* Specification of the “location” of media.
• AudioFormat: Information about an audio format including sampling rate and
• CaptureDevice: Interface defining behaviour that all capture devices (e.g.,
cameras) must possess.
• CaptureDeviceInfo: Information about a particular capture device, including
the formats supported.
• CaptureDeviceManager: Manager aware of all the capture devices on the
system and capable of providing information about them or, for example, a
list that support a particular format.
• Clock: Interface defining JMF’s fundamental time model. Key classes such
as Players and Processors implement this Interface.
• Codec: Interface supporting the processing of media data in one format into
• Controller: Interface built on Clock and which defines the 5 states of stopped
time (see following section on time).
• ControllerListener: Interface defining a listener for Controller generated
events. As Controllers include Players and Processors this is a vital Interface
which is implemented somewhere in just about every JMF program.
• Controls: An interface specifying a means of obtaining a Control for an
• DataSink: Interface for accepting data and “rendering” it to some source such
as a file.
• DataSource: Class providing a simple protocol for managing media arriving
from a particular source (e.g., a file).
Further Key Classes
• FileTypeDescriptor: Defines the different content type (architectures)
• Format: An abstraction of the format of a media object without all the
encoding specific details.
• Manager: Central manager or access point for obtaining resources such as
Players, Processors, DataSources and DataSinks.
• MediaEvent: Parent event class for all media events (e.g., ControllerEvent).
• MediaLocator: Means of specifying the location of media content. Used in
the creation of Players and data sources and sinks.
• Multiplexer: A processing unit that accepts multiple input tracks and
interleaves them to produce a single output container format.
• Participant: A participant in an RTP session: a sender or receiver.
• PlugIn: An Interface defining a generic plug-in that processes media data in
• Processor: An extension to the Player Interface, the Processor defines an
object capable of processing and controlling a media object.
• PullDataSource: A media source from which the data must be pulled (e.g., a
• PushDataSource: A media source from which the data is streaming (e.g., an
• Time: An object that defines time to nanosecond precision.
• TimeBase: A constantly ticking source of time.
VideoFormat: Format information about video data including
Real time environment which is similar to the working of a JMF
Recording, processing, and presenting time-based media.
JMF uses this same basic model. A data source encapsulates the media
stream much like a video tape and a player provides processing and control
mechanisms similar to a VCR. Playing and capturing audio and video with JMF
requires the appropriate input and output devices such as microphones, cameras,
speakers, and monitors.
MANAGERS IN JMF:
Handles the construction of Players, Processors, DataSources, and
DataSinks. This level of indirection allows new implementations to be integrated
seamlessly with JMF. From the client perspective, these objects are always created
the same way whether the requested object is constructed from a default
implementation or a custom one.
Maintains a registry of available capture devices and generates capture
device info object.
Maintains a registry of packages that contain JMF classes, such as custom
Players, Processors, DataSources, and DataSinks.
Maintains a registry of available JMF plug-in processing components,
such as Multiplexers, Demultiplexers, Codecs, Effects, and Renderers.
To write programs based on JMF, you'll need to use the Manager create
methods to construct the Players, Processors, DataSources, and DataSinks for your
application. If you're capturing media data from an input device, you'll use the
CaptureDeviceManager to find out what devices are available and access
information about them. If you're interested in controlling what processing is
performed on the data, you might also query the PlugInManager to determine what
plug-ins have been registered.
An object for rendering (playing) and controlling (e.g., stopping,
changing rate of play) a media object.
A Player processes an input stream of media data and renders it at a precise
time. A DataSource is used to deliver the input media-stream to the Player.The
rendering destination depends on the type of media being presented.
JMF player model.
A Player does not provide any control over the processing that it performs
or how it renders the media data.
Player supports standardized user control and relaxes some of the
operational restrictions imposed by Clock and Controller.
A Player can be in one of six states. The Clock interface defines the two
primary states: Stopped and Started. To facilitate resource management,
Controller breaks the Stopped state down into five standby states:
Unrealized, Realizing, Realized, Prefetching, and Prefetched.
In normal operation, a Player steps through each state until it reaches the
A Player in the Unrealized state has been instantiated, but does not yet know
anything about its media. When a media Player is first created, it is Unrealized.
When realize is called, a Player moves from the Unrealized state into the
Realizing state. A Realizing Player is in the process of determining its resource
requirements. During realization, a Player acquires the resources that it only needs
to acquire once. These might include rendering resources other than exclusive-use
resources. (Exclusive-use resources are limited resources such as particular
hardware devices that can only be used by one Player at a time; such resources are
acquired during Prefetching.) A Realizing Player often downloads assets over the
• When a Player finishes Realizing, it moves into the Realized
state. A Realized Player knows what resources it needs and
information about the type of media it is to present. Because a
Realized Player knows how to render its data, it can provide
visual components and controls. Its connections to other objects
in the system are in place, but it does not own any resources
that would prevent another Player from starting.
• When prefetch is called, a Player moves from the Realized state into
the Prefetching state. A Prefetching Player is preparing to present its
media. During this phase, the Player preloads its media data, obtains
exclusive-use resources, and does whatever else it needs to do to
prepare itself to play. Prefetching might have to recur if a Player
object's media presentation is repositioned, or if a change in the Player
object's rate requires that additional buffers be acquired or alternate
processing take place.
• When a Player finishes Prefetching, it moves into the Prefetched
state. A Prefetched Player is ready to be started.
• Calling start puts a Player into the Started state. A Started
Player object's time-base time and media time are mapped and
its clock is running, though the Player might be waiting for a
particular time to begin presenting its media data.
4.1.6 REAL TIME TRANSPORT PROTOCOL
To send or receive a live media broadcast or conduct a video conference over
the Internet or Intranet, you need to be able to receive and transmit media streams in
RTP provides end-to-end network delivery services for the transmission of real-
time data. RTP is network and transport-protocol independent, though it is often
used over UDP.
RTP can be used over both unicast and multicast network services. Over a
unicast network service, separate copies of the data are sent from the source to each
destination. Over a multicast network service, the data is sent from the source only
once and the network is responsible for transmitting the data to multiple locations.
Multicasting is more efficient for many multimedia applications, such as video
conferences. The standard Internet Protocol (IP) supports multicasting.
RTP enables you to identify the type of data being transmitted, determine what
order the packets of data should be presented in, and synchronize media streams
from different sources.
While RTP does not provide any mechanism to ensure timely delivery or provide
other quality of service guarantees, it is augmented by a control protocol (RTCP)
that enables you to monitor the quality of the data distribution. RTCP also provides
control and identification mechanisms for RTP transmissions.
If quality of service is essential for a particular application, RTP can be
used over a resource reservation protocol that provides connection-oriented services.
RTP Data Handling
Data is transferred between the session manager and a Player or Processor
using the Buffer object. Therefore, all DataSources created by the Processor with an
RTP-specific format are buffer DataSources. Similarly, all DataSources created by
the session manager and handed over to the Manager for Player creation are buffer
All RTP-specific data uses an RTP-specific format encoding as defined in
the AudioFormat and VideoFormat classes. For example, gsm RTP encapsulated
packets have the encoding set to AudioFormat.GSM_RTP, while jpeg-encoded
video formats have the encoding set to VideoFormat.JPEG_RTP.
AudioFormat defines four standard RTP-specific encoding strings:
public static final String ULAW_RTP = "JAUDIO_G711_ULAW/rtp";
public static final String DVI_RTP = "dvi/rtp";
public static final String G723_RTP = "g723/rtp";
public static final String GSM_RTP = "gsm/rtp";
VideoFormat defines three standard RTP-specific encoding strings:
public static final String JPEG_RTP = "jpeg/rtp";
public static final String H261_RTP = "h261/rtp";
public static final String H263_RTP = "h263/rtp";
Buffers that have an RTP-specific encoding might have a non-null header
defined in javax.media.rtp.RTPHeader. Payload-specific headers are not part of the
RTPHeader. Instead, payload headers are part of the data object in the Buffers
transferred between the Player or Processor and the session manager. The packet's
actual RTP header is also included as part of the Buffer object's data. The Buffer
object's offset points to the end of this header.
For packets received from the network by the SessionManager, all available fields
from the RTP Header (as defined in RFC 1890) are translated to appropriate fields
in the Buffer object: timestamp and sequence number. The marker bit from the RTP
header is sent over as flags on the Buffer object, which you can access by calling the
Buffer getFlags method. The flag used to indicate the marker bit is
Buffer.FLAG_RTP_MARKER. If there is an extension header, it is sent over in the
header of be Buffer, which is a RTPHeader object. The format of the Buffer is set to
All source streams streamed out on RTP DataSources have their content
descriptor set to an empty content descriptor of "" and their format set to the
appropriate RTP-specific format and encoding. To be able to intercept or
depacketize this data, plug-in codecs must advertise this format as one of their input
For packets being sent over the network, the Processor's format must be set
to one of the RTP-specific formats (encodings). The plug-in codec must advertise
this format as one of its supported output formats. All Buffer objects passed to the
SessionManager through the DataSource sent to createSendStream must have an
RTP applications are often divided into those that need to be able to receive
data from the network (RTP Clients) and those that need to be able to transmit data
across the network (RTP Servers). Some applications do both--for example,
conferencing applications capture and transmit data at the same time that they're
receiving data from the network.
Receiving Media Streams From the Network
Being able to receive RTP streams is necessary for several types of applications.
• Conferencing applications need to be able to receive a media stream from an
RTP session and render it on the console.
• A telephone answering machine application needs to be able to receive a
media stream from an RTP session and store it in a file.
• An application that records a conversation or conference must be able to
receive a media stream from an RTP session and both render it on the console
and store it in a file.
Transmitting Media Streams Across the Network
RTP server applications transmit captured or stored media streams across
For example, in a conferencing application, a media stream might be
captured from a video camera and sent out on one or more RTP sessions. The media
streams might be encoded in multiple media formats and sent out on several RTP
sessions for conferencing with heterogeneous receivers. Multiparty conferencing
could be implemented without IP multicast by using multiple unicast RTP sessions
THE JMF RTP API
JMF enables the playback and transmission of RTP streams through the APIs
defined in the javax.media.rtp, javax.media.rtp.event, and javax.media.rtp.rtcp
packages. JMF can be extended to support additional RTP-specific formats and
dynamic payloads through the standard JMF plug-in mechanism.
Similarly, you can use the RTP APIs to transmit captured or stored
media streams across the network. Outgoing RTP streams can originate from a file
or a capture device. The outgoing streams can also be played locally, saved to a file,
We can implement a video conferencing application that captures live audio
and video and transmits it across the network using a separate RTP session for each
The JMF RTP APIs are designed to work seamlessly with the capture,
presentation, and processing capabilities of JMF. Players and processors are used to
present and manipulate RTP media streams just like any other media content. You
can transmit media streams that have been captured from a local capture device
using a capture DataSource or that have been stored to a file using a DataSink.
Similarly, JMF can be extended to support additional RTP formats and payloads
through the standard plug-in mechanism.
High-level JMF RTP architecture.
In JMF, a SessionManager is used to coordinate an RTP session. The
session manager keeps track of the session participants and the streams that are
The session manager maintains the state of the session as viewed from the
local participant. In effect, a session manager is a local representation of a
distributed entity, the RTP session. The session manager also handles the RTCP
control channel, and supports RTCP for both senders and receivers.
The SessionManager interface defines methods that enable an application to
initialize and start participating in a session, remove individual streams created by
the application, and close the entire session.
4.2 BLOCK DIAGRAM
This Project Video Conferencing over Intranet has four modules.The
four modules are listed below:
1. USER INTERFACE
2. CAPTURING THE MEDIA
3. PROCESSING THE MEDIA
4. TRANSMISSION OF THE MEDIA
The user interface is designed using Java Swing. The main screen is a
frame .It has a menubar.The menuitem login and close will only be enabled in the
beginning.When the application starts the connection is established with the
The login screen has two labels named username and password and a text
field and password field for getting the respective values from the user and two
buttons OK and CANCEL.The user interface is very user-friendly.The entered
values are validated before storing to the database.After entering the details if the
user clicks “ok” then the checkuser function(Boolean) is called.The checkuser
function compares the values got from the user with the details in the userdata
table.If the values match with any of the record,then it returns value true else false.If
checkuser function returns value true, then access will be granted.
If the user is an administrator then he can add new users to the
database,change details about existing user and also delete a user from the database.
The userdata table has four fields
The admin user can add new user to the data base.When the details about
the new user are entered first the data is validated .Then the value is checked with
the database if the userid already exists then a message is displayed saying that the
userid already exists.If not then the values are added to the database.
Whenever user starts the conference ,that user has to enter his details
in a dialogbox that appears before the conference screen.This will be stored in the
database and can be used for future reference.
CAPTURING THE MEDIA
In this project JMF is used to capture media data from the capture device
which is the web-camera in this case. Captured media data is used to create a
datasource which can be played using a player .
First we have to locate the capture device that we want to use by querying
the CaptureDeviceManager. Then get the CaptureDeviceInfo object for the device.
Get a MediaLocator from the CaptureDeviceInfo object and use it to create a
DataSource.But since we know what capture device we are going to use we need not
follow the above mentioned steps . Then a Processor is created using the
DataSource. The processor is then stared to begin the capture process.
Accessing Capture Devices
The web-camera that we want to use is accessed through the
CaptureDeviceManager. The CaptureDeviceManager is the central registry for all of
the capture devices available to JMF. We can get a list of the available capture
devices by calling the CaptureDeviceManager.getDeviceList method.
Each device is represented by a CaptureDeviceInfo object. To get the
CaptureDeviceInfo object for a particular device, you call
CaptureDeviceInfo deviceInfo =
The conference screen has two list boxes,one for displaying the list of users
who are currently logged in.The other list box for the users whom we add to our
conference.A button add is provided to add a user to our conference.Once we have
added a user to our conference , the conference initiator will get the audio and video
of that user.If the user wants to attend the conference he/she has to add the one who
has called for the conference.
PROCESSING THE MEDIA:
The next step in the project is processing the captured media.The captured
media may be of any format. JMF-RTP API supports all major audio and video
formats.The format used in this project is .rtp format which is supported by ths RTP.
To receive notification of format changes from a Controller, the
ControllerListener interface is implemented and it listens for FormatChangeEvents.
The exact media format of an object is represented by a Format object.
The format itself carries no encoding-specific parameters or global timing
information, it describes the format's encoding name and the type of data the format
requires. An AudioFormat describes the attributes specific to an audio format,
such as sample rate, bits per sample, and number of channels. A VideoFormat
encapsulates information relevant to video data.
Format is set by using the setFormat method :
setFormat( new Format(Format,Hz,bits(8 or 16),mono or stereo(1or 0))
The captured stream is converted into packetized .rtp format .The audio and
video streams are captured separately and processed separately.
TRANSMISSION OF THE MEDIA:
Media is transmitted over the network using JMF and JMF-RTP. We
may want to transmit media from one computer to another. Or we may want to
broadcast a live feed to an intranet. The source of the media can be a file, live
capture using a capture device or any other source supported by JMF.In this project
the source is the live streaming media from the web-cam.
The wrapper classes, VideoTransmit and AVTransmit, are programmed
such that it takes media input from a source(ie) the web-cam and the speakers
connected to our system and transmit the media to a destination multicast ip address
in the .rtp format .
The RTP API implementation included in JMF will transmit the media using
the RTP protocol.
The VideoTransmit program transmits only video regardless of the input
source. It always transcodes the media to JPEG/RTP for transmission. It uses the
RTP DataSink API to transmit the media. AVTransmit will transmit all available
media tracks from the input. It will use the specified RTP format for each track. It
then uses the RTP SessionManager API for the transmission.
The project now works in an Intranet .In future it has to be implemented in
the internet.Recording facility must be added to the project.A player capable of
playing the recorded conference must also be added as a tool .More controls have to
be added to the system so that it’s performance is improved.
More security features have to be added to the system when it is to be
implemented in the Internet.
In future white board facility must be added to the system to make it more
attractive and useful.Screen grabing feature must also be added to the system.
Applications of Video Conferencing:
Interaction with Experts:
Students are able to get answers to questions from experts who, because of
time and distance, would otherwise be inaccessible.
Learn about differences:
Students are able to interact with other students and adults who may be
very different from themselves.
Addresses different Learning Styles:
It can include media such as video clips, animations, audio and graphics.
This first hand learning is especially good for visual learners.
You will find that students are much more willing to do the research when
they know that they will be presenting it to other classes. Most students enjoy using
the new technology.
Students are learning from a primary source rather than a textbook.
• Presentation and Speaking Skills
• Communication and Management Skills
• Questioning Skills