Solutions for Programming Assignment 7

Below are the solutions for the RTSP/RTP lab. There are two classes: Client, RTPpacket.

Client.java 

  1. import java.io.*;
  2. import java.net.*;
  3. import java.util.*;
  4. import java.awt.*;
  5. import java.awt.event.*;
  6. import javax.swing.*;
  7. import javax.swing.Timer;
  9. public class Client{
  11.   //GUI
  12.   //----
  13.   JFrame f = new JFrame("Client");
  14.   JButton setupButton = new JButton("Setup");
  15.   JButton playButton = new JButton("Play");
  16.   JButton pauseButton = new JButton("Pause");
  17.   JButton tearButton = new JButton("Teardown");
  18.   JPanel mainPanel = new JPanel();
  19.   JPanel buttonPanel = new JPanel();
  20.   JLabel iconLabel = new JLabel();
  21.   ImageIcon icon;
  24.   //RTP variables:
  25.   //----------------
  26.   DatagramPacket rcvdp; //UDP packet received from the server
  27.   DatagramSocket RTPsocket; //socket to be used to send and receive UDP packets
  28.   static int RTP_RCV_PORT = 25000; //port where the client will receive the RTP packets
  30.   Timer timer; //timer used to receive data from the UDP socket
  31.   byte[] buf; //buffer used to store data received from the server 
  33.   //RTSP variables
  34.   //----------------
  35.   //rtsp states 
  36.   final static int INIT = 0;
  37.   final static int READY = 1;
  38.   final static int PLAYING = 2;
  39.   static int state; //RTSP state == INIT or READY or PLAYING
  40.   Socket RTSPsocket; //socket used to send/receive RTSP messages
  41.   //input and output stream filters
  42.   static BufferedReader RTSPBufferedReader;
  43.   static BufferedWriter RTSPBufferedWriter;
  44.   static String VideoFileName; //video file to request to the server
  45.   int RTSPSeqNb = 0; //Sequence number of RTSP messages within the session
  46.   int RTSPid = 0; //ID of the RTSP session (given by the RTSP Server)
  48.   final static String CRLF = "\r\n";
  50.   //Video constants:
  51.   //------------------
  52.   static int MJPEG_TYPE = 26; //RTP payload type for MJPEG video
  54.   //--------------------------
  55.   //Constructor
  56.   //--------------------------
  57.   public Client() {
  59.     //build GUI
  60.     //--------------------------
  62.     //Frame
  63.     f.addWindowListener(new WindowAdapter() {
  64.        public void windowClosing(WindowEvent e) {
  65.      System.exit(0);
  66.        }
  67.     });
  69.     //Buttons
  70.     buttonPanel.setLayout(new GridLayout(1,0));
  71.     buttonPanel.add(setupButton);
  72.     buttonPanel.add(playButton);
  73.     buttonPanel.add(pauseButton);
  74.     buttonPanel.add(tearButton);
  75.     setupButton.addActionListener(new setupButtonListener());
  76.     playButton.addActionListener(new playButtonListener());
  77.     pauseButton.addActionListener(new pauseButtonListener());
  78.     tearButton.addActionListener(new tearButtonListener());
  80.     //Image display label
  81.     iconLabel.setIcon(null);
  83.     //frame layout
  84.     mainPanel.setLayout(null);
  85.     mainPanel.add(iconLabel);
  86.     mainPanel.add(buttonPanel);
  87.     iconLabel.setBounds(0,0,380,280);
  88.     buttonPanel.setBounds(0,280,380,50);
  90.     f.getContentPane().add(mainPanel, BorderLayout.CENTER);
  91.     f.setSize(new Dimension(390,370));
  92.     f.setVisible(true);
  94.     //init timer
  95.     //--------------------------
  96.     timer = new Timer(20, new timerListener());
  97.     timer.setInitialDelay(0);
  98.     timer.setCoalesce(true);
  100.     //allocate enough memory for the buffer used to receive data from the server
  101.     buf = new byte[15000];    
  102.   }
  104.   //------------------------------------
  105.   //main
  106.   //------------------------------------
  107.   public static void main(String argv[]) throws Exception
  108.   {
  109.     //Create a Client object
  110.     Client theClient = new Client();
  112.     //get server RTSP port and IP address from the command line
  113.     //------------------
  114.     int RTSP_server_port = Integer.parseInt(argv[1]);
  115.     String ServerHost = argv[0];
  116.     InetAddress ServerIPAddr = InetAddress.getByName(ServerHost);
  118.     //get video filename to request:
  119.     VideoFileName = argv[2];
  121.     //Establish a TCP connection with the server to exchange RTSP messages
  122.     //------------------
  123.     theClient.RTSPsocket = new Socket(ServerIPAddr, RTSP_server_port);
  125.     //Set input and output stream filters:
  126.     RTSPBufferedReader = new BufferedReader(new InputStreamReader(theClient.RTSPsocket.getInputStream()) );
  127.     RTSPBufferedWriter = new BufferedWriter(new OutputStreamWriter(theClient.RTSPsocket.getOutputStream()) );
  129.     //init RTSP state:
  130.     state = INIT;
  131.   }
  134.   //------------------------------------
  135.   //Handler for buttons
  136.   //------------------------------------
  138.   //Handler for Setup button
  139.   //-----------------------
  141.   class setupButtonListener implements ActionListener{
  142.     public void actionPerformed(ActionEvent e){
  144.       //System.out.println("Setup Button pressed !");      
  146.       if (state == INIT) 
  147.     {
  148.       //Init non-blocking RTPsocket that will be used to receive data
  149.       try{
  150.         //construct a new DatagramSocket to receive RTP packets from the server, on port RTP_RCV_PORT
  151.         RTPsocket = new DatagramSocket(RTP_RCV_PORT);
  153.         //set TimeOut value of the socket to 5msec.
  154.         RTPsocket.setSoTimeout(5);
  155.       }
  156.       catch (SocketException se)
  157.         {
  158.           System.out.println("Socket exception: "+se);
  159.           System.exit(0);
  160.         }
  162.       //init RTSP sequence number
  163.       RTSPSeqNb = 1;
  165.       //Send SETUP message to the server
  166.       send_RTSP_request("SETUP");
  168.       //Wait for the response 
  169.       if (parse_server_response() != 200)
  170.         System.out.println("Invalid Server Response");
  171.       else 
  172.         {
  173.           //change RTSP state and print new state 
  174.           state = READY;
  175.           System.out.println("New RTSP state: READY");
  176.         }
  177.     }//else if state != INIT then do nothing
  178.     }
  179.   }
  181.   //Handler for Play button
  182.   //-----------------------
  183.   class playButtonListener implements ActionListener {
  184.     public void actionPerformed(ActionEvent e){
  186.       //System.out.println("Play Button pressed !"); 
  188.       if (state == READY) 
  189.     {
  190.       //increase RTSP sequence number
  191.       RTSPSeqNb++;
  193.       //Send PLAY message to the server
  194.       send_RTSP_request("PLAY");
  196.       //Wait for the response 
  197.       if (parse_server_response() != 200)
  198.           System.out.println("Invalid Server Response");
  199.       else 
  200.         {
  201.           //change RTSP state and print out new state
  202.           state = PLAYING;
  203.           System.out.println("New RTSP state: PLAYING");
  205.           //start the timer
  206.           timer.start();
  207.         }
  208.     }//else if state != READY then do nothing
  209.     }
  210.   }
  212.   //Handler for Pause button
  213.   //-----------------------
  214.   class pauseButtonListener implements ActionListener {
  215.     public void actionPerformed(ActionEvent e){
  217.       //System.out.println("Pause Button pressed !");   
  219.       if (state == PLAYING) 
  220.     {
  221.       //increase RTSP sequence number
  222.       RTSPSeqNb++;
  224.       //Send PAUSE message to the server
  225.       send_RTSP_request("PAUSE");
  227.       //Wait for the response 
  228.      if (parse_server_response() != 200)
  229.           System.out.println("Invalid Server Response");
  230.       else 
  231.         {
  232.           //change RTSP state and print out new state
  233.           state = READY;
  234.           System.out.println("New RTSP state: READY");
  236.           //stop the timer
  237.           timer.stop();
  238.         }
  239.     }
  240.       //else if state != PLAYING then do nothing
  241.     }
  242.   }
  244.   //Handler for Teardown button
  245.   //-----------------------
  246.   class tearButtonListener implements ActionListener {
  247.     public void actionPerformed(ActionEvent e){
  249.       //System.out.println("Teardown Button pressed !");  
  251.       //increase RTSP sequence number
  252.       RTSPSeqNb++;
  254.       //Send TEARDOWN message to the server
  255.       send_RTSP_request("TEARDOWN");
  257.       //Wait for the response 
  258.       if (parse_server_response() != 200)
  259.     System.out.println("Invalid Server Response");
  260.       else 
  261.     {     
  262.       //change RTSP state and print out new state
  263.       state = INIT;
  264.       System.out.println("New RTSP state: INIT");
  266.       //stop the timer
  267.       timer.stop();
  269.       //exit
  270.       System.exit(0);
  271.     }
  272.     }
  273.   }
  277.   //------------------------------------
  278.   //Handler for timer
  279.   //------------------------------------
  281.   class timerListener implements ActionListener {
  282.     public void actionPerformed(ActionEvent e) {
  284.       //Construct a DatagramPacket to receive data from the UDP socket
  285.       rcvdp = new DatagramPacket(buf, buf.length);
  287.       try{
  288.     //receive the DP from the socket :
  289.     RTPsocket.receive(rcvdp);
  291.     //create an RTPpacket object from the DP
  292.     RTPpacket rtp_packet = new RTPpacket(rcvdp.getData(), rcvdp.getLength());
  294.     //print important header fields of the RTP packet received: 
  295.     System.out.println("Got RTP packet with SeqNum # "+rtp_packet.getsequencenumber()+" TimeStamp "+rtp_packet.gettimestamp()+" ms, of type "+rtp_packet.getpayloadtype());
  297.     //print header bitstream:
  298.     rtp_packet.printheader();
  300.     //get the payload bitstream from the RTPpacket object
  301.     int payload_length = rtp_packet.getpayload_length();
  302.     byte [] payload = new byte[payload_length];
  303.     rtp_packet.getpayload(payload);
  305.     //get an Image object from the payload bitstream
  306.     Toolkit toolkit = Toolkit.getDefaultToolkit();
  307.     Image image = toolkit.createImage(payload, 0, payload_length);
  309.     //display the image as an ImageIcon object
  310.     icon = new ImageIcon(image);
  311.     iconLabel.setIcon(icon);
  312.       }
  313.       catch (InterruptedIOException iioe){
  314.     //System.out.println("Nothing to read");
  315.       }
  316.       catch (IOException ioe) {
  317.     System.out.println("Exception caught: "+ioe);
  318.       }
  319.     }
  320.   }
  322.   //------------------------------------
  323.   //Parse Server Response
  324.   //------------------------------------
  325.   private int parse_server_response() 
  326.   {
  327.     int reply_code = 0;
  329.     try{
  330.       //parse status line and extract the reply_code:
  331.       String StatusLine = RTSPBufferedReader.readLine();
  332.       //System.out.println("RTSP Client - Received from Server:");
  333.       System.out.println(StatusLine);
  335.       StringTokenizer tokens = new StringTokenizer(StatusLine);
  336.       tokens.nextToken(); //skip over the RTSP version
  337.       reply_code = Integer.parseInt(tokens.nextToken());
  339.       //if reply code is OK get and print the 2 other lines
  340.       if (reply_code == 200)
  341.     {
  342.       String SeqNumLine = RTSPBufferedReader.readLine();
  343.       System.out.println(SeqNumLine);
  345.       String SessionLine = RTSPBufferedReader.readLine();
  346.       System.out.println(SessionLine);
  348.       //if state == INIT gets the Session Id from the SessionLine
  349.       tokens = new StringTokenizer(SessionLine);
  350.       tokens.nextToken(); //skip over the Session:
  351.       RTSPid = Integer.parseInt(tokens.nextToken());
  352.     }
  353.     }
  354.     catch(Exception ex)
  355.       {
  356.     System.out.println("Exception caught : "+ex);
  357.     System.exit(0);
  358.       }
  360.     return(reply_code);
  361.   }
  363.   //------------------------------------
  364.   //Send RTSP Request
  365.   //------------------------------------
  367.   private void send_RTSP_request(String request_type)
  368.   {
  369.     try{
  370.       //Use the RTSPBufferedWriter to write to the RTSP socket
  372.       //write the request line:
  373.       RTSPBufferedWriter.write(request_type+" "+VideoFileName+" RTSP/1.0"+CRLF);
  374.       //write the CSeq line: 
  375.       RTSPBufferedWriter.write("CSeq: "+RTSPSeqNb+CRLF);
  377.       //check if request_type is equal to "SETUP" and in this case write the Transport: line advertising to the server the port used to receive the RTP packets RTP_RCV_PORT
  378.       if ((new String(request_type)).compareTo("SETUP") == 0)
  379.     RTSPBufferedWriter.write("Transport: RTP/UDP; client_port= "+RTP_RCV_PORT+CRLF);
  380.       else
  381.     RTSPBufferedWriter.write("Session: "+RTSPid+"\n");
  383.       RTSPBufferedWriter.flush();
  384.     }
  385.     catch(Exception ex)
  386.       {
  387.     System.out.println("Exception caught : "+ex);
  388.     System.exit(0);
  389.       }
  390.   }
  392. }

RTPpacket.java

Click to view as text file (will not display properly in Internet Explorer)