SUMIT New

Streaming Video Using RTP and RTSP 1
STREAMING VIDEO USING RTP AND RTSP

DESIGN DOCUMENT
Submitted by:
Shivangi Harit (1238)

M.Sc.(Informatics) 4th Sem
Institute of Informatics & Communication
UNIVERSITY OF DELHI ,SOUTH CAMPUS
( 2009- 11)
ACKNOWLEDGEMENT
This project has been a learning ground for all of us, not only in terms of
learning new aspects of things we were already acknowledged with, not
only in terms of learning new techniques of getting things done, but also in
the terms of working as a team and working towards a common objective,
and seeing it perform.
We would like to take this opportunity to extend our heartfelt
acknowledgements and regards, to our guide and coordinator, in this regard
and others, Mr. Rajat Budhiraja, under whose guidance and mentoring, we
were able to accomplish the task and the objectives, we initially began
with. The project would not have been possible without the support
provided to us, in terms of infrastructure, and other amenities, by the
campus and its members. We would also like to thank them for the support
and the faith, they invested in us.
We also wish to express our delight, in working with our fine batch of
classmates, with whom you can always find some light moments during
the project.
We also wish to thank each other, for being so supportive a team member and seeing
the project completed, in whatever objectives, that were envisioned in the very
beginning.
CERTIFICATE
This is to certify that the project titled "Streaming Video Using RTP
& RTSP" submitted by:
Santanu Pal(1237)
Shivangi Harit(1238)
Shoikat Das(1239)
Sumit Kr. Baberwal(1240)
in partial fulfillment of the requirement of the degree of M. Sc. Informatics

is a record of bona-fide work carried out by them under my supervision
and guidance.
Dated April 8, 2011

Mr. Rajat Budhiraja
Institute of Informatics & Communication
University of Delhi South Campus
TABLE OF CONTENTS
1. Objective……………………………………. 5
2. Abstract…………………………………….. 6
3. List of Figures……………………………….. 7
4. List of Abbreviations……………………….. 7
5. Requirements……………………………….. 8
6. Code………………….……………………. 13
6.1. Protocols Implemented..........……… 14
6.2. Classes……………………………… 19
6.3. Client……………………………….. 21
6.4. Server………………………………. 23
7. Database Requirements……………………. 25
8. Data Flow Diagrams..……………………… 26
9. State Diagram………………………………. 30
10. Designing Modules………………………. 31
11. FCAPS……………………………… . . . . 58
12. How we implemented FCAPS……….……… 61
13. Screenshots……………………………… 62
14. Future Scope………….…………………...64
15. Conclusions………………………………..65
16. References………………………………….66
1. OBJECTIVE
In this project, we are developing a STREAMING

VIDEO SERVER AND CLIENT which would help
user to view videos without actually downloading it
to user-end. The client can view the database
videos actually transferring the data to his end.
we will implement a streaming video server and

client that communicate using the Real-Time
Streaming Protocol (RTSP) and send data using the
Real-time Transfer Protocol (RTP). We are going to
implement the RTSP protocol in the client and
implement the RTP packetization in the server, using java .
2. ABSTRACT
In this project, we will implement a streaming video server and client that communicate
using the Real-Time Streaming Protocol (RTSP) and send data using the Real-time
Transfer Protocol (RTP). We are going to implement the RTSP protocol in the client and
implement the RTP packetization in the server, using Java. The server streams a video
which has been encoded into a proprietary MJPEG file format. This format stores the
video as concatenated JPEG-encoded images, with each image being preceded by a 5-
Byte header which indicates the bit size of the image. The server parses the bit stream of
the MJPEG file to extract the JPEG images on the fly. The server sends the images to the
client at periodic intervals. The client then displays the individual JPEG images as they
arrive from the server.
3. List of Figures
Figure 1: Our Interface…………………………...

Figure 2: Length of Packet Header………………
Figure 3: Level 0 DFD………...…………………
Figure 4: Level 1 DFD………...…………………
Figure 5: Level 2 DFDs………...…………………
Figure 6: State Diagram………………………….
Figure 7: Modules and their relations…………….
Figure 8: Description of Modules……………….
4. List of Abbreviations
RTP: Real-time Transfer Protocol

RTSP: Real- Time Streaming Protocol
JPEG: Joint Photographic Experts Group
MJPEG: Motion JPEG
G.U.I.: Graphical User Interface
TCP: Transmission Control
Protocol IP: Internet Protocol
UDP: User Datagram Protocol
SQL: Structure Query Language
PT: Payload Type field
SSRC: Synchronization Source (telephony, real-
time control protocol)
CSRC: Contributing Source
5. REQUIREMENTS
5.1. Hardware:
 INTEL PENTIUM-IV Processor
 At least 128 MB RAM
 Microprocessor-486 or above
5.2. Software:
 JAVA (jdk 1.6)
 MS Windows Platform
 JAVA SWING
5.3. User Interface:

The user could interact with the software easily as it has very good
G.U.I. (Graphical User Interface). The user has to just perform
clicking events on the functionalities which he has to use.
5.4. Tools and Technology Used:

 Swing (Java)
Swing is a widget toolkit for Java. It is part of Sun
Microsystems' Java Foundation Classes (JFC) — an API for
providing a graphical user interface (GUI) for Java programs.
Swing was developed to provide a more sophisticated set of
GUI components than the earlier Abstract Window Toolkit.
Swing provides a native look and feel that emulates the look
and feel of several platforms, and also supports a pluggable
look and feel that allows applications to have a look and feel
unrelated to the underlying platform. Swing is built on top of
AWT and is entirely written in Java, using AWT’s lightweight component
support. In particular, unlike AWT, t he architecture of Swing components makes
it easy to customize both their appearance and behavior. Components from AWT
and Swing can be mixed, allowing you to add
Swing support to existing AWT-based programs. For

example, swing components such as JSlider, JButton and
JCheckbox could be used in the same program with standard
AWT labels, textfields and scrollbars. You could subclass the
existing Swing UI, model, or change listener classes without
having to reinvent the entire implementation. Swing also has
the ability to replace these objects on-the-fly.
Anatomy of an Application GUI
GUI Internal Structure
• Socket Programming
In computing, network programming, essentially identical to socket programming
or client-server programming, involves
writing computer programs that communicate with other

programs across a computer network. The program or
process initiating the communication is called a client
process, and the program waiting for the communication to
be initiated is the server process. The client and server
processes together form a distributed system. The
communication between the client and server process may
either be connection-oriented (such as an established TCP
virtual circuit or session), or connectionless (based on UDP
datagrams).
Sockets are usually implemented by an API library such as

Berkeley sockets, first introduced in 1983. Most
implementations are based on Berkeley sockets, for example
Winsock introduced 1991. Other socket API implementations
exist, such as the STREAMS-based Transport Layer
Interface (TLI).
These are examples of functions or methods typically provided by the API library:
 socket() creates a new socket of a certain socket type,

identified by an integer number, and allocates system
resources to it.
 bind() is typically used on the server side, and
associates a socket with a socket address structure, i.e.
a specified local port number and IP address.
 listen() is used on the server side, and causes a bound
TCP socket to enter listening state.
 connect() is used on the client side, and assigns a free
local port number to a socket. In case of a TCP socket, it
causes an attempt to establish a new TCP connection.
 accept() is used on the server side. It accepts a received
incoming attempt to create a new TCP connection from
the remote client, and creates a new socket associated
with the socket address pair of this connection.
 send() and recv(), or write() and read(), or recvfrom()
and sendto(), are used for sending and receiving data
to/from a remote socket.
 close() causes the system to release resources allocated
to a socket. In case of TCP, the connection is
terminated.
 TCP/IP/UDP Networking
The TCP/IP model, or Internet Protocol Suite, describes a set
of general design guidelines and implementations of specific
networking protocols to enable computers to communicate
over a network. TCP/IP provides end-to-end connectivity
specifying how data should be formatted, addressed,
transmitted, routed and received at the destination. Protocols
exist for a variety of different types of communication
services between computers.
TCP/IP is generally described as having four abstraction

layers. Starting from the lowest level, following are the four
layers:
Link Layer
Internet Layer
Transport Layer
Application Layer
User Datagram Protocol is a connectionless datagram

protocol. Like IP, it is a best effort, "unreliable" protocol.
Reliability is addressed through error detection using a weak
checksum algorithm. UDP is typically used for applications
such as streaming media (audio, video, Voice over IP etc)
where on-time arrival is more important than reliability, or
for simple query/response applications like DNS lookups,
where the overhead of setting up a reliable connection is
disproportionately large. Real-time Transport Protocol (RTP)
is a datagram protocol that is designed for real-time data such
as streaming audio and video.
TCP and UDP are used to carry an assortment of higher-level
applications. The appropriate transport protocol is chosen
based on the higher-layer protocol application. For example,
the File Transfer Protocol expects a reliable connection, but
the Network File System (NFS) assumes that the subordinate
Remote Procedure Call protocol, not transport, will guarantee
reliable transfer. Other applications, such as VoIP, can
tolerate some loss of packets, but not the reordering or delay
that could be caused by retransmission.
The applications at any given network address are distinguished by their TCP or
UDP port. By convention certain well known ports are associated with specific
applications.
Transport Service Requirements of Common Apps
5.5. Front End:

Java (Programming Language)
5.6. Back End:

SQL
6. CODE
We will implement a streaming video server and client that communicate using the Real-
Time Streaming Protocol (RTSP) and send data using the Real-time Transfer Protocol
(RTP), using Java.
We will implement the RTSP protocol and RTSP de-packetization

in the client and implement the RTSP protocol and RTP
packetization in the server.
6.1. PROTOCOLS IMPLEMENTED

6.1.1. RTP (Real-Time Transport Protocol)
Tool Used: Swing
The Real-time Transport Protocol (RTP) defines a standardized

packet format for delivering audio and video over the Internet.
RTP is used extensively in communication and entertainment
systems that involve streaming media, such as telephony, video
teleconference applications and web-based push to talk features.
For these it carries media streams controlled by H.323, MGCP,
Megaco, SCCP, or Session Initiation Protocol (SIP) signaling
protocols, making it one of the technical foundations of the Voice
over IP industry.
RTP is usually used in conjunction with the RTP Control Protocol (RTCP). While RTP
carries the media streams (e.g., audio and video) or out-of-band events signaling (DTMF
in separate payload type), RTCP is used to monitor transmission statistics and quality
of service (QoS) information. When both protocols are used in

conjunction, RTP is usually originated and received on even port
numbers, whereas RTCP uses the next higher odd port number.
 Protocol components
The RTP specification describes two sub-protocols:
The data transfer protocol, which deals with the transfer of real-
time multimedia data. Information provided by this protocol
include timestamps (for synchronization), sequence numbers
(for packet loss detection) and the payload format which
indicates the encoded format of the data.
The Real Time Control Protocol (RTCP) is used to specify

Quality of Service (QOS) feedback and synchronization
between the media streams. The bandwidth of RTCP traffic
compared to RTP is small, typically around 5%.
 Sessions
An RTP Session is established for each multimedia stream. A

session consists of an IP address with a pair of ports for RTP
and RTCP. For example, audio and video streams will have
separate RTP sessions, enabling a receiver to deselect a
particular stream.[9] The ports which form a session are
negotiated using other protocols such as RTSP (using SDP in
the setup method) and SIP. According to the specification, an
RTP port should be even and the RTCP port is the next higher
odd port number. RTP and RTCP typically use unprivileged
UDP ports (1024 to 65535),but may use other transport
protocols (most notably, SCTP and DCCP) as well, as the
protocol design is transport independent.
6.1.1. RTSP (Real Time Streaming Protocol)
The Real Time Streaming Protocol (RTSP) is a network control

protocol designed for use in entertainment and communications
systems to control streaming media servers. The protocol is used to
establish and control media sessions between end points. Clients of
media servers issue VCR-like commands, such as play and pause,
to facilitate real-time control of playback of media files from the
server.
The transmission of streaming data itself is not a task of the RTSP

protocol. Most RTSP servers use the Real-time Transport Protocol
(RTP) for media stream delivery, however some vendors
implement proprietary transport protocols. The RTSP server from
RealNetworks, for example, also features RealNetworks'
proprietary RDT stream transport.
 Protocol directives
The RTSP protocol has similarities to HTTP, but RTSP adds

new requests. While HTTP is stateless, RTSP is a stateful
protocol. A session identifier is used to keep track of sessions
when needed; thus, no permanent TCP connection is required.
RTSP messages are sent from client to server, although some
exceptions exist where the server will send to the client.
Presented here are the basic RTSP requests. Some typical HTTP
requests, like the OPTIONS request, are also available. The
default transport layer port number is 554.
OPTIONS
An OPTIONS request returns the request types the server will

accept.
DESCRIBE
A DESCRIBE request includes an RTSP URL (rtsp://...), and

the type of reply data that can be handled. The default port for
the RTSP protocol is 554 for both UDP and TCP transports.
This reply includes the presentation description, typically in
Session Description Protocol (SDP) format. Among other
things, the presentation description lists the media streams
controlled with the aggregate URL. In the typical case, there is
one media stream each for audio and video.
SETUP
A SETUP request specifies how a single media stream must be transported. This must
be done before a PLAY request is sent. The request contains the media stream URL
and a transport specifier. This specifier typically includes a local port for receiving
RTP data (audio or video), and another for RTCP data (meta information). The server
reply usually confirms the chosen parameters, and fills in the missing parts, such as
the
server's chosen ports. Each media stream must be configured

using SETUP before an aggregate play request may be sent.
PLAY
A PLAY request will cause one or all media streams to be

played. Play requests can be stacked by sending multiple PLAY
requests. The URL may be the aggregate URL (to play all
media streams), or a single media stream URL (to play only that
stream). A range can be specified. If no range is specified, the
stream is played from the beginning and plays to the end, or, if
the stream is paused, it is resumed at the point it was paused.
PAUSE
A PAUSE request temporarily halts one or all media streams, so

it can later be resumed with a PLAY request. The request
contains an aggregate or media stream URL. When to pause can
be specified with a range parameter. The range parameter can be
left out to pause immediately.
RECORD
The RECORD request can be used to send a stream to the

server for storage.
TEARDOWN
A TEARDOWN request is used to terminate the session. It stops all media streams
and frees all session related data on the server.
Protocol stack for multimedia services
6.2. CLASSES
Our code implements the RTSP protocol in the client as well as server and implements
the RTP packetization in the server and
RTP de-packetization in the client, using Java (Programming

Language).
There are 4 classes in our code.
1. Client
2. Server
3. RTPpacket
4. VideoStream
6.2.1. Client
This class implements the client and the user interface which we
use to send RTSP commands and which is used to display the
video. Below is what the interface look like. Here, we implement
the actions that are taken when the buttons (Setup, Play, Pause, and
Teardown) are pressed.
6.2.2. Server
This class implements the server which responds to the RTSP
requests and streams back the video. Here, we implement the
RTSP interaction and the server calls routines in the RTPpacket
class to packetize the video data.
6.2.3. RTPpacket
This class is used to handle the RTP packets. It has separate
routines for handling the received packets at the client side. The
first constructor of this class implements RTP-packetization of the
video data. The second constructor is used by the client to de-
packetize the data.
6.2.4. VideoStream
This class is used to read video data from the file on disk.
6.3. CLIENT
Our first task is to implement the RTSP on the client side. To do
this, we will be defining the functions that are called when the user
clicks on the buttons in the user interface. For each button in the
interface there is a handler function in the code. We will
implement the following actions in each handler function.
When the client starts, it also opens the RTSP socket to the server.
This socket is used for sending all RTSP requests.
SETUP
 Create a socket for receiving RTP data and set the timeout on
the socket to 5 milliseconds.
 Send SETUP request to server. We need to insert the
Transport header in which we specify the port for the RTP data
socket we have created.
 Read reply from server and parse the Session header in the
response to get the session ID.
PLAY
 Send PLAY request. We need to insert the Session header

and use the session ID returned in the SETUP response. We do not
put the Transport header in this request.
 Read server's response.
PAUSE
 Send PAUSE request. We insert the Session header and use
the session ID returned in the SETUP response. We do not put the
Transport header in this request.
• Read server's response.
TEARDOWN
 Send TEARDOWN request. We insert the Session header

and use the session ID returned in the SETUP response. We do not
put the Transport header in this request.
 Read server's response.
It is appropriate to send TEARDOWN when user clicks on the stop-button, because

The TEARDOWN request stops the stream delivery for the given URI, freeing the
resources associated with it. If the URI is the presentation URI for this presentation,
any RTSP session identifier associated with the session is no longer valid. Unless all
transport parameters are defined by the session description, a SETUP request has to
be issued before the session can be played again.
As per our designed code, the interface will resemble the

following, taking in account the general Windows display:
Fig. 1
6.4. SERVER
On the server we will implement the packetization of the video data into RTP packets.
For this we will creat the packet, set the fields in the packet header, and copy the payload
(i.e., one video frame) into the packet.
When the server receives the PLAY-request from the client, it

starts a timer which is triggered every 100 ms. At these times the
server will read one video frame from the file and send it to the
client. The server creates an RTPpacket-object which is the RTP-
encapsulation of the video frame.
The server calls the first constructor of the class RTPpacket to

perform the encapsulation. Following are the tasks at server’s end:
(the letters in parenthesis refer to the fields in the RTP packet
format below)
1. Set the RTP-version field (V). This will be set to 2.
2. Set padding (P), extension (X), number of contributing
sources (CC), and marker (M) fields. These are all set to zero in
our project.
3. Set payload type field (PT). In this project we use MJPEG
and the type for that is 26.
4. Set the sequence number. The server gives this the sequence
number as the Framenb argument to the constructor.
5. Set the timestamp. The server gives this number as
the Time argument to the constructor.
6. Set the source identifier (SSRC). This field identifies the
server. Any integer value can be taken.
Because we have no other contributing sources (field CC == 0), the CSRC-field does not
exist. The length of the packet header is therefore 12 bytes, or the first three lines from
the diagram below.
Fig.2
The diagram is in the network byte order (also known as big-

endian). The Java Virtual Machine uses the same byte order.
7. DATABASE REQUIREMENTS
MJPEG (Motion JPEG) format files.
The server streams a video which has been encoded into a proprietary MJPEG file
format. This format stores the video as concatenated JPEG-encoded images, with each
image being preceded by a 5-Byte header which indicates the bit size of the image. The
server parses the bitstream of the MJPEG file to extract the JPEG images on the fly. The
server sends the images to the client at periodic intervals. The client then displays the
individual JPEG images as they arrive from the server.
8. DATA FLOW DIAGRAMS
8.1. Level 0
Fig. 3
8.2. Level 1
Fig. 4
8.3. Level 3
8.3.1. Setup
Fig. 5.1
8.3.2. Play
Fig. 5.2
8.3.3. Pause
Fig. 5.3
8.3.4. Teardown
Fig. 5.4
9. STATE DIAGRAM
Fig. 6
10. DESIGNING MODULES
 Module 1: Client
 Module 2: Server
 Module 3: RTPpacket
 Module 4: VideoStream
10.1: Modules and their relations:
Fig. 7
Description of Modules:
Module 1: Client
Fig. 8.1
Module 2: Server
Fig. 8.2
Module 3: RTPpacket
Fig. 8.3
Module 4: VideoStream
Fig. 8.4
CODE:-
Server.java
import java.io.*;
import java.net.*;
import java.awt.*;
import java.util.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.Timer;
public class Server extends JFrame implements ActionListener {

DatagramSocket RTPsocket;
DatagramPacket senddp;
InetAddress ClientIPAddr;
int RTP_dest_port = 0;
//Layout JLabel
label;
int imagenb = 0;
VideoStream video;
static int MJPEG_TYPE = 26;
static int FRAME_PERIOD = 100;
static int VIDEO_LENGTH = 500;
Timer timer;
byte[] buf;
final static int INIT = 0;
final static int READY = 1;
final static int PLAYING = 2;
final static int SETUP = 3;

final static int PLAY = 4;
final static int PAUSE = 5;
final static int TEARDOWN = 6;
static int state;

Socket RTSPsocket;
static BufferedReader RTSPBufferedReader;
static BufferedWriter RTSPBufferedWriter;
static String VideoFileName;
static int RTSP_ID =
123456; int RTSPSeqNb = 0;
final static String CRLF = "\r\n";
public Server(){
super("Server");
timer = new Timer(FRAME_PERIOD, this);
timer.setInitialDelay(0);
timer.setCoalesce(true);
buf = new byte[15000];
addWindowListener(new WindowAdapter() { public void

windowClosing(WindowEvent e) { timer.stop();
System.exit(0);
}
};
label = new JLabel("Send frame # ", JLabel.CENTER);

getContentPane().add(label, BorderLayout.CENTER);
}
public static void main(String args[]) throws Exception

{
Server theServer = new Server();
theServer.pack();
theServer.setVisible(true);
int RTSPport = 25000;
ServerSocket listenSocket = new ServerSocket(RTSPport);

theServer.RTSPsocket = listenSocket.accept();
listenSocket.close();
theServer.ClientIPAddr =
theServer.RTSPsocket.getInetAddress();
state = INIT;
RTSPBufferedReader = new BufferedReader(new
InputStreamReader(theServer.RTSPsocket.getInputStream()) );
RTSPBufferedWriter = new BufferedWriter(new
OutputStreamWriter(theServer.RTSPsocket.getOutputStream()) );
int request_type;
boolean done =
false; while(!done)
{
request_type = theServer.parse_RTSP_request(); //blocking
if (request_type == SETUP)
{
done = true;
state = READY;
System.out.println("New RTSP state:
READY"); theServer.send_RTSP_response();
theServer.video = new VideoStream(VideoFileName);
theServer.RTPsocket = new DatagramSocket();
}
}
while(true)
{
request_type = theServer.parse_RTSP_request(); //blocking
if ((request_type == PLAY) && (state == READY))

{
theServer.send_RTSP_response();
theServer.timer.start();
state = PLAYING;
System.out.println("New RTSP state: PLAYING");
}
else if
((request_type == PAUSE) && (state == PLAYING))
{
theServer.timer.stop();
state = READY;
System.out.println("New RTSP state: READY");
}
else if (request_type == TEARDOWN)
{
theServer.timer.stop();
theServer.RTSPsocket.close();
theServer.RTPsocket.close(); System.exit(0);
}
}
}
public void actionPerformed(ActionEvent e)

{ if (imagenb < VIDEO_LENGTH)
{
imagenb++;
try {
int image_length = video.getnextframe(buf);
RTPpacket rtp_packet = new RTPpacket(MJPEG_TYPE,
imagenb, imagenb*FRAME_PERIOD, buf, image_length);
int packet_length = rtp_packet.getlength();
byte[] packet_bits = new byte[packet_length];

rtp_packet.getpacket(packet_bits);
senddp = new DatagramPacket(packet_bits, packet_length,
ClientIPAddr, RTP_dest_port);
RTPsocket.send(senddp);
rtp_packet.printheader();
label.setText("Send frame #" + imagenb);
}
catch(Exception ex)
{
System.out.println("Exception caught:
"+ex); System.exit(0);
}
}
else
{
timer.stop();
}
}
private int parse_RTSP_request()
{
int request_type = -1;
try
{
String RequestLine = RTSPBufferedReader.readLine();
System.out.println(RequestLine);
StringTokenizer tokens = new
StringTokenizer(RequestLine);
String request_type_string = tokens.nextToken();
if ((new String(request_type_string)).compareTo("SETUP")
== 0)
request_type = SETUP;
else if ((new String(request_type_string)).compareTo("PLAY")
== 0)
request_type = PLAY;
else if ((new
String(request_type_string)).compareTo("PAUSE") == 0)
request_type = PAUSE;
else if ((new
String(request_type_string)).compareTo("TEARDOWN") == 0)
request_type = TEARDOWN;
{
VideoFileName = tokens.nextToken();
}
String SeqNumLine = RTSPBufferedReader.readLine();

System.out.println(SeqNumLine);
tokens = new StringTokenizer(SeqNumLine);
tokens.nextToken();
RTSPSeqNb = Integer.parseInt(tokens.nextToken());
String LastLine = RTSPBufferedReader.readLine();

System.out.println(LastLine);
{
tokens = new StringTokenizer(LastLine);
for (int i=0; i<3; i++)
tokens.nextToken(); //skip unused stuff
RTP_dest_port = Integer.parseInt(tokens.nextToken());
}
}
catch(Exception ex)
{
}
return(request_type);}
private void send_RTSP_response()

{
try{
RTSPBufferedWriter.write("RTSP/1.0 200 OK"+CRLF);
RTSPBufferedWriter.write("CSeq: "+RTSPSeqNb+CRLF);
RTSPBufferedWriter.write("Session: "+RTSP_ID+CRLF);
RTSPBufferedWriter.flush();
}
catch(Exception ex)
{
}
}
}
Client.java import
java.io.*; import
java.net.*; import
java.util.*; import
java.awt.*;
import javax.swing.Timer;
public class Client{

JFrame f = new JFrame("Client");
JButton setupButton = new JButton("Setup");
JButton playButton = new JButton("Play");
JButton pauseButton = new JButton("Pause");
JButton tearButton = new JButton("Teardown");
JPanel mainPanel = new JPanel();
JPanel buttonPanel = new JPanel(); JLabel
iconLabel = new JLabel(); ImageIcon icon;
DatagramPacket rcvdp;
DatagramSocket RTPsocket;
static int RTP_RCV_PORT =
25000; Timer timer;
byte[] buf;
final static int INIT = 0;

final static int READY = 1;
final static int PLAYING = 2;
static int state;
Socket RTSPsocket;
static BufferedReader RTSPBufferedReader;

static BufferedWriter RTSPBufferedWriter;
static String VideoFileName;
int RTSPSeqNb =
0; int RTSPid = 0;
final static String CRLF = "\r\n";
static int MJPEG_TYPE = 26;
public Client() {
f.addWindowListener(new WindowAdapter()
{ public void windowClosing(WindowEvent e)
{
System.exit(0);
}
};
buttonPanel.setLayout(new GridLayout(1,0)); buttonPanel.add(setupButton);

buttonPanel.add(playButton); buttonPanel.add(pauseButton);
buttonPanel.add(tearButton); setupButton.addActionListener(new
setupButtonListener()); playButton.addActionListener(new
playButtonListener());
pauseButton.addActionListener(new pauseButtonListener());
tearButton.addActionListener(new tearButtonListener());
iconLabel.setIcon(null);
mainPanel.setLayout(null);
mainPanel.add(iconLabel);
mainPanel.add(buttonPanel);
iconLabel.setBounds(0,0,380,280);
buttonPanel.setBounds(0,280,380,50);
f.getContentPane().add(mainPanel, BorderLayout.CENTER);
f.setSize(new Dimension(390,370));
f.setVisible(true);
timer = new Timer(20, new

timerListener()); timer.setInitialDelay(0);
timer.setCoalesce(true);
buf = new byte[15000];
}
public static void main(String argv[]) throws Exception

{
Client theClient = new Client();
int RTSP_server_port = 25000;
String ServerHost = "127.0.0.1";
InetAddress ServerIPAddr =
InetAddress.getByName(ServerHost);
VideoFileName = "movie.Mjpeg";
theClient.RTSPsocket = new Socket(ServerIPAddr,
RTSP_server_port);
RTSPBufferedReader = new BufferedReader(new

InputStreamReader(theClient.RTSPsocket.getInputStream()) );
RTSPBufferedWriter = new BufferedWriter(new

OutputStreamWriter(theClient.RTSPsocket.getOutputStream()) );
state = INIT;
}
class setupButtonListener implements

ActionListener{ public void
actionPerformed(ActionEvent e){
if (state == INIT)
{
try{
RTPsocket = new DatagramSocket(RTP_RCV_PORT);
RTPsocket.setSoTimeout(5);
}
catch (SocketException se)
{
System.out.println("Socket exception: "+se);
System.exit(0);
}
RTSPSeqNb = 1;
send_RTSP_request("SETUP");
if (parse_server_response() != 200)
System.out.println("Invalid Server Response");
else
{
state = READY;
System.out.println("New RTSP state: READY");
}
}
}
}
class playButtonListener implements ActionListener { public void

actionPerformed(ActionEvent e){
if (state == READY)
{
RTSPSeqNb++;
send_RTSP_request("PLAY");
else
{
state = PLAYING;
PLAYING"); timer.start();
}
}
}
}
class pauseButtonListener implements ActionListener {

{ System.out.println("Pause Button pressed !");
if (state == PLAYING)
{
RTSPSeqNb++;
send_RTSP_request("PAUSE");
else
{
state = READY;
READY"); timer.stop();
}
}
}
}
class tearButtonListener implements ActionListener

{ public void actionPerformed(ActionEvent e){
RTSPSeqNb++;
send_RTSP_request("TEARDOWN");
else
{
state = INIT;
INIT"); timer.stop();
System.exit(0);
}
}
}
class timerListener implements ActionListener

{ public void actionPerformed(ActionEvent e) {
rcvdp = new DatagramPacket(buf, buf.length);
try{ RTPsocket.receive(rcvd
p);
RTPpacket rtp_packet = new RTPpacket(rcvdp.getData(),
rcvdp.getLength());
System.out.println("Got RTP packet with SeqNum #

"+rtp_packet.getsequencenumber()+" TimeStamp
"+rtp_packet.gettimestamp()+" ms, of type
"+rtp_packet.getpayloadtype());
rtp_packet.printheader();
int payload_length = rtp_packet.getpayload_length(); byte [] payload
= new byte[payload_length]; rtp_packet.getpayload(payload);
Toolkit toolkit = Toolkit.getDefaultToolkit();

Image image = toolkit.createImage(payload, 0,
payload_length);
icon = new ImageIcon(image);

iconLabel.setIcon(icon);
}
catch (InterruptedIOException iioe){
}
catch (IOException ioe)
{ System.out.println("Exception caught:
"+ioe);
}
}
}
private int parse_server_response()
{
int reply_code = 0;
try{
String StatusLine = RTSPBufferedReader.readLine();
System.out.println("RTSP Client - Received from Server:");
System.out.println(StatusLine);
StringTokenizer tokens = new StringTokenizer(StatusLine);

tokens.nextToken();
reply_code = Integer.parseInt(tokens.nextToken());
if (reply_code == 200)
{
String SeqNumLine = RTSPBufferedReader.readLine();
System.out.println(SeqNumLine);
String SessionLine = RTSPBufferedReader.readLine();

System.out.println(SessionLine);
tokens = new StringTokenizer(SessionLine);

tokens.nextToken(); //skip over the Session:

RTSPid = Integer.parseInt(tokens.nextToken());
}
}
catch(Exception ex)
{
System.out.println("Exception caught :
}
return(reply_code);
}
private void send_RTSP_request(String request_type)

{
try{ RTSPBufferedWriter.write(request_type
+"
"+VideoFileName+" RTSP/1.0"+CRLF);
RTSPBufferedWriter.write("CSeq: "+RTSPSeqNb+CRLF);
if ((new String(request_type)).compareTo("SETUP") == 0)
RTSPBufferedWriter.write("Transport: RTP/UDP;
client_port=
"+RTP_RCV_PORT+CRLF); else
RTSPBufferedWriter.write("Session: "+RTSPid+"\n");
RTSPBufferedWriter.flush();
}
catch(Exception ex)
{
System.out.println("Exception caught :
}
}
}
RTPpacket.java:-
public class RTPpacket{

static int HEADER_SIZE = 12;
public int Version;
public int Padding;
public int Extension;
public int CC; public
int Marker;
public int PayloadType;
public int SequenceNumber;
public int TimeStamp; public
int Ssrc;
public byte[] header; public int

payload_size; public byte[]
payload;
public RTPpacket(int PType, int Framenb, int Time, byte[] data,

int data_length){
Version = 2;
Padding = 0;
Extension = 0;
CC = 0;
Marker = 0;
Ssrc = 0;
SequenceNumber =
Framenb; TimeStamp =
Time; PayloadType = PType;
header = new byte[HEADER_SIZE];

header[0] = new Integer((Version<<6)|(Padding<<5)|
(Extension<<4)|CC).byteValu e();
header[1] = new Integer((Marker<<7)|
PayloadType).byteValue();
header[2] = new Integer(SequenceNumber>>8).byteValue();

header[3] = new Integer(SequenceNumber).byteValue();
for (int i=0; i < 4; i++)
header[7-i] = new Integer(TimeStamp>>(8*i)).byteValue();
for (int i=0; i < 4; i++)

header[11-i] = new Integer(Ssrc>>(8*i)).byteValue();
payload_size = data_length;
payload = new byte[data_length];
for (int i=0; i < data_length; i++)
payload[i] = data[i];
}
public RTPpacket(byte[] packet, int packet_size)

{
Version = 2;
Padding = 0;
Extension = 0;
CC = 0;
Marker = 0;
Ssrc = 0;
if (packet_size >= HEADER_SIZE)
{
header = new byte[HEADER_SIZE];
for (int i=0; i < HEADER_SIZE; i++)
header[i] = packet[i];
payload_size = packet_size - HEADER_SIZE;
payload = new byte[payload_size];
for (int i=HEADER_SIZE; i < packet_size; i++)
payload[i-HEADER_SIZE] = packet[i];
PayloadType = header[1] & 127;
SequenceNumber = unsigned_int(header[3]) +
256*unsigned_int(header[2]);
TimeStamp = unsigned_int(header[7]) +
256*unsigned_int(header[6]) + 65536*unsigned_int(header[5]) +
16777216*unsigned_int(header[4]);
}
}
public int getpayload(byte[] data) {
for (int i=0; i < payload_size; i+

+) data[i] = payload[i];
return(payload_size);
}
public int getpayload_length() {

return(payload_size);
}
public int getlength()

{ return(payload_size +
HEADER_SIZE);
}
public int getpacket(byte[] packet)

{
for (int i=0; i < HEADER_SIZE; i+
+) packet[i] = header[i];
for (int i=0; i < payload_size; i++)
packet[i+HEADER_SIZE] = payload[i];
return(payload_size + HEADER_SIZE);
}
public int gettimestamp() {

return(TimeStamp);
}
public int getsequencenumber()
{ return(SequenceNumber);
}
public int getpayloadtype()
{
return(PayloadType);
}
public void printheader()

{
//TO DO :
uncomment /*
for (int i=0; i < (HEADER_SIZE-4); i++)
{
for (int j = 7; j>=0 ; j--)
if (((1<<j) & header[i] ) != 0)
System.out.print("1");
else
System.out.print("0");
System.out.print(" ");
}
System.out.println();
*/
}
static int unsigned_int(int nb) {
if (nb >= 0)
return(nb);
else
return(256+nb);
}
}
VideoStream.java:-
import java.io.*;
public class VideoStream

{ FileInputStream fis;
int frame_nb;
public VideoStream(String filename) throws
Exception{ fis = new FileInputStream(filename);
frame_nb = 0;
}
public int getnextframe(byte[] frame) throws Exception

{
int length = 0; String
length_string;
byte[] frame_length = new byte[5];
fis.read(frame_length,0,5);
length_string = new String(frame_length); length =
Integer.parseInt(length_string);
return(fis.read(frame,0,length));
}
}
GUI.java:-
import java.awt.*;
import java.io.*;
import java.util.*;
import java.sql.*;
import java.net.*;
public class GUI implements ActionListener{

JFrame frame1;
JButton sign_in;
JTextField text;
JPasswordField passwd2;
static boolean valid ;
public GUI() {
valid = false ;
JPanel panel = new JPanel(); panel.setOpaque( false );
panel.setPreferredSize( new Dimension() );
frame1 = new JFrame("Welcome To Create a New

Account"); frame1.setResizable(false);
Container cp = frame1.getContentPane();
cp.add(panel);
panel.setLayout(null);
passwd2 = new JPasswordField();

passwd2.setBounds(280,375,200,30);
passwd2.setForeground(Color.BLUE);
panel.add(passwd2);
JLabel label1 = new JLabel("user name") ;

label1.setBounds(140,175,200,30);
label1.setForeground(Color.BLUE); label1.setFont(new
Font("Algerian", Font.PLAIN,22));
panel.add(label1);
JLabel label2 = new JLabel("password") ;
label2.setBounds(140,350,310,80);
label2.setForeground(Color.BLUE);
label2.setFont(new Font("Algerian",
Font.PLAIN,25)); panel.add(label2);
text = new JTextField(); // change color

panel.add(text);
//text1.setForeground(Color.BLUE);
//text1.setFont(new Font("Algerian",
Font.PLAIN,19)); text.setBounds(280,175,200,30);
sign_in = new JButton("sign_in");

sign_in.setBounds(290,500,190,35);
//button1.setForeground(Color.BLUE);
panel.add(sign_in);
sign_in.addActionListener(this);
frame1.setSize(550,600);
frame1.setVisible(true);
frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

{ try{
String firstname=””,passwrd="";
String status = "";
passwrd=passwd2.getText();
firstname=text.getText();
System.out.println(firstname);
System.out.println(passwrd);
if(firstname.equals("") ||passwrd.equals(""))
{
JOptionPane.showMessageDialog(null,"One or more fields were
left empty","Error message",JOptionPane.ERROR_MESSAGE);
frame1.dispose();
}
Statement stmt1;
Class.forName("com.mysql.jdbc.Driver");
Connection con = null;
con=DriverManager.getConnection("jdbc:mysql://localhost:3306/
AVStreaming","root","root");
stmt1=con.createStatement();
String query1,query2,name,pass1;
ResultSet rs = stmt1.executeQuery("select DesiredLoginName,
passwd FROM userinfo");
while ( rs.next()) {
//System.out.println( rs.getString("loginame") + ":" +

rs.getString("passwrd"));
name=rs.getString("DesiredLoginName");
pass1=rs.getString("passwd");
if(name.equals(firstname) && pass1.equals(passwrd)){
valid = true ;
System.out.println("invalid user name name or passwd");
break;
}
}
if(valid){
JOptionPane.showMessageDialog(null,"you are
authenticated","Error
message",JOptionPane.ERROR_MESSAGE);
new Client();
frame1.dispose();
}
else{
JOptionPane.showMessageDialog(null,”authentication
failure","Error message",JOptionPane.ERROR_MESSAGE);
}
}catch(Exception m){}
}
public static void main(String args[]){
GUI obj = new GUI();

}
}
11. FCAPS
FCAPS is the ISO Telecommunications Management Network
model and framework for network management. FCAPS is an
acronym for Fault, Configuration, Accounting, Performance,
Security, the management categories into which the ISO model
defines network management tasks. In non-billing organizations
Accounting is sometimes replaced with Administration.
The comprehensive management of an organization's

information technology (IT) infrastructure is a fundamental
requirement. Employees and customers rely on IT services where
availability and performance are mandated, and problems can be
quickly identified and resolved. Mean time to repair (MTTR)
must be as short as possible to avoid system downtimes where a
loss of revenue or lives is possible.
Fault management
A fault is an event that has a negative significance. The goal of

fault management is to recognize, isolate, correct and log faults
that occur in the network. Furthermore, it uses trend analysis to
predict errors so that the network is always available. This can be
established by monitoring different things for abnormal behavior.
When a fault or event occurs, a network component will often

send a notification to the network operator using a proprietary or
open protocol such as SNMP, or at least write a message to its
console for a console server to catch and log/page. This
notification is supposed to trigger manual or automatic activities.
For example, the gathering of more data to identify the nature and
severity of the problem or to bring backup equipment on-line.
Fault logs are one input used to compile statistics to determine the provided service
level of individual network elements, as well as sub-networks or the whole network.
They are also used to
determine apparently fragile network components that

require further attention.
Fault Isolation tools like Delphi are also available, which are
basically used to isolate the fault in any telecom network.
Configuration management
The goals of configuration management include:
 To gather and store configurations from network devices

(this can be done locally or remotely).
 to simplify the configuration of the device
 to track changes that are made to the configuration
 to configure ('provision') circuits or paths through non-
switched networks
Accounting management
Accounting is often referred to as billing management. The goal

is to gather usage statistics for users.
Using the statistics the users can be billed and usage quota can
be enforced.
Examples:
 Disk usage
 Link utilization
 CPU time
For non-billed networks, "administration" replaces "accounting".

The goals of administration are to administer the set of authorized
users by establishing users, passwords, and permissions, and to
administer the operations of the equipment such as by performing
software backup and synchronization.
Performance management
Performance management enables the manager to prepare the

network for the future, as well as to determine the efficiency of the
current network, for example, in relation to the investments done to
set it up. The network performance addresses the throughput,
percentage utilization, error rates and response time areas.
By collecting and analyzing performance data, the network health

can be monitored. Trends can indicate capacity or reliability
issues before they become service affecting.
Performance thresholds can be set in order to trigger an alarm. The

alarm would be handled by the normal fault management process
.Alarms vary depending upon the severity.
Security management
Security management is the process of controlling access to assets in the network. Data
security can be achieved mainly with authentication and encryption. Authorization to it
configured with OS and DBMS access control settings. This level of management will
help reduce the possibility of sabotage or unauthorized access into the network by illegal
users. This part involves the authentication and authorization of users as well as the
encryption of data to protect the confidentiality of user information and rights.
12. How we implemented FCAPS

Security management
in our project, a video can only be streamed by the user when he
logins. If the user is not a eligible person, then that persons
login fails and that person is not authorized to see the video.
Configuration Management
In our project we can define the port at which the socket is to be
formed. Also we can define the server address at which the
streaming is going on. We can also define the videos which are to
be made available for streaming.
Accounting
We can determine which all person are using our server to stream the video from the
list of names from database which we are maintaining.
13. SCREEN SHOTS

14. FUTURE SCOPE
 The standard media player, such as RealPlayer or Windows

Media Player, allows only three actions, namely, PLAY,
PAUSE, and STOP (roughly corresponding to TEARDOWN).
There is no SETUP-button available to the user. Given that
SETUP is mandatory in an RTSP interaction, we can implement
that in a media player in future.
 Currently the client and server only implement the minimum

necessary RTSP interactions and PAUSE. Implementation of a
method DESCRIBE can be used to pass information about the
media stream. When the server receives a DESCRIBE-request,
it sends back a session description file which tells the client
what kinds of streams are in the session and what encodings are
used.
15. CONCLUSION
Our project will make video and audio data sharing convenient and
faster due to facility of streaming instead of (actually)
downloading the video.
Live video streaming can also help monitor remote locations. At

first glance, this is similar to typical security cameras, except that
streaming technology does not need closed circuits. The video can
be monitored from virtually anywhere in the world, providing there
is an Internet connection nearby.
The advantages of using a streaming server include detecting the client's connection
speed so that video files of an appropriate bit rate are delivered. This spares the end user
the necessity of choosing between various formats.
16. REFERENCES
Books-
 Computer Networks, Andrew S Tanenbaum, Fourth
Edition PHI.
Websites-
http://java.sun.com/docs/books/tutorial/networking/ov
erview/networking.html
http://tools.ietf.org/html/rfc2326 , Real Time
Streaming Protocol (RTSP), IETF, 1998
 http://all-streaming-media.com/faq/streaming-
media/faqstreaming-media-protocols.htm
 http://java.sun.com/developer/Books/jdbc/ch07.pdf
PDF to Word

SUMIT New

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

SUMIT New

Uploaded by

Copyright:

Available Formats

Streaming Video Using RTP and RTSP 1

STREAMING VIDEO USING RTP AND RTSP

Shivangi Harit (1238)

in partial fulfillment of the requirement of the degree of M. Sc. Informatics

Dated April 8, 2011

In this project, we are developing a STREAMING

we will implement a streaming video server and

Figure 1: Our Interface…………………………...

RTP: Real-time Transfer Protocol

5.3. User Interface:

5.4. Tools and Technology Used:

Swing support to existing AWT-based programs. For

Anatomy of an Application GUI

GUI Internal Structure

writing computer programs that communicate with other

Sockets are usually implemented by an API library such as

 socket() creates a new socket of a certain socket type,

TCP/IP is generally described as having four abstraction

User Datagram Protocol is a connectionless datagram

Transport Service Requirements of Common Apps

5.5. Front End:

5.6. Back End:

We will implement the RTSP protocol and RTSP de-packetization

6.1. PROTOCOLS IMPLEMENTED

Tool Used: Swing

The Real-time Transport Protocol (RTP) defines a standardized

of service (QoS) information. When both protocols are used in

The RTP specification describes two sub-protocols:

The Real Time Control Protocol (RTCP) is used to specify

An RTP Session is established for each multimedia stream. A

The Real Time Streaming Protocol (RTSP) is a network control

The transmission of streaming data itself is not a task of the RTSP

The RTSP protocol has similarities to HTTP, but RTSP adds

An OPTIONS request returns the request types the server will

A DESCRIBE request includes an RTSP URL (rtsp://...), and

server's chosen ports. Each media stream must be configured

A PLAY request will cause one or all media streams to be

A PAUSE request temporarily halts one or all media streams, so

The RECORD request can be used to send a stream to the

Protocol stack for multimedia services

RTP de-packetization in the client, using Java (Programming

There are 4 classes in our code.

 Send PLAY request. We need to insert the Session header

• Read server's response.

 Send TEARDOWN request. We insert the Session header

It is appropriate to send TEARDOWN when user clicks on the stop-button, because

As per our designed code, the interface will resemble the

When the server receives the PLAY-request from the client, it

The server calls the first constructor of the class RTPpacket to

The diagram is in the network byte order (also known as big-

MJPEG (Motion JPEG) format files.

8. DATA FLOW DIAGRAMS

10. DESIGNING MODULES

10.1: Modules and their relations:

public class Server extends JFrame implements ActionListener {

final static int SETUP = 3;

static int state;

addWindowListener(new WindowAdapter() { public void

label = new JLabel("Send frame # ", JLabel.CENTER);

public static void main(String args[]) throws Exception

ServerSocket listenSocket = new ServerSocket(RTSPport);

if ((request_type == PLAY) && (state == READY))