[Documentation].doc.doc

Projects for Final Engineering Students

VIDEO CONFERENCINGOVER

INTRANET

CONTENTS

1. INTRODUCTION

1.1 MOTIVATION OF THE PROJECT 1.2 LITERATURE SURVEY

2. HARDWARE & SOFTWARE SPECIFICATION

3. METHODOLOGY

4. DESIGN DETAIL 4.1 TOOLS USED 4.2 BLOCK DIAGRAM

5. IMPLEMENTATION 5.1 MODULES 5.1.1 USER INTERFACE 5.1.2 CAPTURING THE MEDIA 5.1.3 PROCESSING THE MEDIA 5.1.4 TRANSMISSION OF THE MEDIA

6. FUTURE ENHANCEMENTS

7. APPLICATION

8. CONCLUSION

9. SOURCE CODE

10. TESTING

11. I/O DETAILS

12. REFERENCE

1. INTRODUCTION

1.INTRODUCTION

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

windows platform.

Proposed System:

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

converting,compressing media.

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

2.HARDWARE AND SOFTWARE SPECIFICATION

HARDWARE REQUIRMENTS

Processor - Pentium II and above

Hard disk - minimum 100 MB of Free Space

RAM - 128 MB

Capture Devices - Webcam , Headphone and Speakers

SOFTWARE REQUIREMENTS:

Platform : Java

OS : Windows 2000/NT/XP

GUI : Swing

Database : MS Access

Media Package : JMF 2.1.1

Protocol : RTP

3.METHODOLOG

Y

3. Methodology:

The project follows proper authentication features and permits access

in a controlled manner.

USER MANAGEMENT:

It deals with adding users to the database and assigning the roles for

the users and deleting users from the database.

AUTHENTICATION:

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

frames/second.

4.DESIGN

DETAILS

4.1 TOOLS USED

4.1.1 JAVA

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 OVERVIEW

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 PROGRAMING

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.

Classes

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

programming language.

Data Abstraction

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

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

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

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:

Simple

Object-Oriented

Robust

Multithreaded

Portable

Secure

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.

DYNAMIC BINDING

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

are:

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

driver.

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.

4.1.3 SWING

JFC 1.2 consists of five major packages:

Swing

Pluggable Look-and-Feel (PL&F)

Drag and Drop

Accessibility

2D

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

extended.

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.

Packages

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

J.

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

be developed.

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

border.

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.

Accessibility

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

database applications.

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

WAV.

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

       Media handling:

o     Play

o     Capture

o     Transmission

o     Processing

       Decode

       Encode

       Transcode

       (De)Multiplex

       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

CaptureDevice.

     javax.media.renderer: A package of two interfaces defining a renderer (for video

content).

     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.

Key Classes

     The classes that play major roles in this project used for creating players,processing media and many more are:

   Manager

     Centralised creation of Players, Processors, DataSources and DataSinks

       Player

*     Playback (rendering) of time-based media Processor

*     Processing (transcoding etc.) of time-based media

       DataSource

*     Representation of time-based media arriving from a particular source with a particular protocol

*     Needed to create Players, Processors, etc.

       DataSink

*     Means of “sinking” (e.g., saving to a file) time-based media

       MediaLocator.

* Specification of the “location” of media.

AudioFormat: Information about an audio format including sampling rate and

quantisation level.

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

(typically) another.

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

object.

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)

supported.

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

some manner.

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

file).

PushDataSource: A media source from which the data is streaming (e.g., an

RTP session).

Time: An object that defines time to nanosecond precision.

TimeBase: A constantly ticking source of time.

VideoFormat: Format information about video data including

High-Level Architecture

Real time environment which is similar to the working of a JMF

Player.

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:

Manager

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.

CaptureDeviceManager

Maintains a registry of available capture devices and generates capture

device info object.

PackageManager

Maintains a registry of packages that contain JMF classes, such as custom

Players, Processors, DataSources, and DataSinks.

PlugInManager

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.

Player

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.

Player States

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.

Player states.

In normal operation, a Player steps through each state until it reaches the

Started state:

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

network.

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

RTP Architecture

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

real-time.

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 architecture.

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 Services

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

DataSources.

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

AudioFormat.GSM_RTP.

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

formats.

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-specific format.

RTP Applications

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.

For example:

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

the network.

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,

or both.

RTP transmission.

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

media type.

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.

Session Manager

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

being transmitted.

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

SYSTEM DIAGRAM:

FLOW DIAGRAM:

5.IMPLEMENTATION

5.1MODULES:

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

MODULE 1

USER INTERFACE:

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

database.

LOGIN: 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.

ADMIN USER:

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

1.userid

2.username

3.password

4.role

ADD/EDIT USER:

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.

CONFERENCE USERS:

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.

MODULE 2

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

CaptureDeviceManager.getDevice:

CaptureDeviceInfo deviceInfo =

CaptureDeviceManager.getDevice("deviceName");

CONFERENCE WORKING:

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.

MODULE 3

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.

MODULE 4:

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.

6.FUTURE ENHANCEMENT

S

FUTURE ENHANCEMENTS:

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.

7.APPLICATION

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.

Increases Motivation:

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.

Better Retention:

Students are learning from a primary source rather than a textbook.

Improve Skills:

Presentation and Speaking Skills

Communication and Management Skills

Questioning Skills

8.CONCLUSION

CONCLUSION

This project has been successfully developed using the standard software

development strategies that is followed in the Industry. I hope that this system

would help the VIDEO CONFERENCING APPLICATION users fulfill their

requirements and vendors able to satisfy their customers.

This project has been developed by our sincere effort.This project has so

many useful features, unlike the existing system which is very much restricted in its

operation. Of course even some limitations also exist. According to the specified

functionality, it will work in a proper manner.

Application point of view,Besides various Video Conference applications,the

project software shall be recommended to implement as communication software in

the corporate offices.In that case ,the user will have lot of advantages such as easy

and economical communication and maximum utilization of employees

timings ,Also be noted that by this setup,the telephone connection,given to each

employees through exchange shall be free for getting external calls.

• Home • Forum-Help • Mail Box & Other Services • Bookmark (Ctrl + D) • Contact Us • Sitemap •                                  ©2005 -07 ITAcumens

                A Free Resource Sharing Place For Engineers.