/*
* @(#)RtspUtil.java 1.12 02/08/21
*
* Copyright (c) 1996-2002 Sun Microsystems, Inc. All rights reserved.
*/
package com.sun.media.content.rtsp;
import java.net.*;
import java.util.*;
import javax.media.*;
import javax.media.format.*;
import javax.media.rtp.*;
import com.sun.media.*;
import com.sun.media.sdp.*;
import com.sun.media.rtsp.*;
import com.sun.media.rtsp.protocol.*;
public class RtspUtil implements RtspListener{
// timer (in ms):
private final int TIMER_1 = 60000; // used for describe msg
private final int TIMER_2 = 30000; // used for all other messages
private RtspManager rtspManager;
private RTPManager mgrs[];
private String mediaTypes[];
private long sequenceNumber;
private int numberOfTracks;
private String userAgent;
private RtspUrl rtspUrl;
private String mediaControls[];
private int server_ports[];
private int client_ports[];
private String session_ids[];
private Message message;
private int connectionId;
private String url;
private double startPos;
private String processError;
private long duration;
private Vector listeners;
private ReceiveStreamListener parent;
public RtspUtil( ReceiveStreamListener parent) {
this.parent= parent;
listeners = new Vector();
rtspManager = new RtspManager(false);
sequenceNumber = (long)(Math.random() * 1000);
userAgent = "User-Agent: JMF RTSP Player " + BasicPlayer.VERSION;
rtspManager.addListener(this);
}
public void setUrl( String url) {
this.url = url;
}
public void setStartPos( double startPos) {
this.startPos = startPos;
}
public RTPManager getRTPManager( int i) {
return mgrs[ i];
}
public RTPManager[] getRTPManagers() {
return mgrs;
}
public String getMediaType( int i) {
return mediaTypes[ i];
}
public String[] getMediaTypes() {
return mediaTypes;
}
public long getDuration() {
return duration;
}
public void removeTrack( int trackId) {
Log.comment( "track removed: " + mediaTypes[ trackId]);
mgrs[ trackId].removeTargets( "media track not supported");
mgrs[ trackId].dispose();
numberOfTracks--;
if( trackId + 1 > mgrs.length) {
int length= mgrs.length - trackId - 1;
System.arraycopy( mgrs, trackId + 1, mgrs, trackId, length);
}
}
public boolean createConnection() {
boolean realized= true;
try {
rtspUrl = new RtspUrl(url);
} catch( MalformedURLException e) {
processError= "Invalid RTSP URL: " + url;
return false;
}
String ipAddress = getServerIpAddress();
if( ipAddress == null) {
Log.error( "Invalid server address:" + url);
processError= "Invalid Server adress: " + url;
return false;
}
connectionId = rtspManager.createConnection(ipAddress, rtspUrl.getPort());
if (connectionId < 0) {
switch (connectionId) {
case - 2:
processError = "Unknown RTSP Host!";
break;
case - 3:
processError = "Can't connect to RTSP Server!";
break;
default:
processError = "Unknown reason";
break;
}
realized = false;
}
return realized;
}
public void closeConnection() {
rtspManager.closeConnection(connectionId);
}
public boolean rtspSetup() {
String msg = "DESCRIBE rtsp://" + rtspUrl.getHost() + "/" + rtspUrl.getFile() +
" RTSP/1.0\r\n" + "CSeq: " + sequenceNumber + "\r\n" +
"Accept: application/sdp\r\n" + userAgent + "\r\n\r\n";
sendMessage(msg);
boolean timeout = waitForResponse(TIMER_1);
if (timeout) {
sendStatusMessage(StatusMessage.TIMEOUT, "Timeout received.");
return false;
}
if( !responseOk()) {
return false;
}
setDuration();
// create the RTP Managers:
numberOfTracks = getNumTracks();
client_ports = new int[ numberOfTracks];
mgrs = new RTPManager[ numberOfTracks];
// get control strings and media types:
mediaControls = new String[ numberOfTracks];
mediaTypes= new String[ numberOfTracks];
String dynamicPayloads[]= new String[ numberOfTracks];
for( int i = 0; i < numberOfTracks; i++) {
mgrs[ i] = createSessionManager( i);
mediaTypes[ i] = getCurMediaType( i);
mediaControls[ i] = getMediaAttributeValue( i, "control");
dynamicPayloads[ i] = getMediaAttributeValue( i, "rtpmap");
// Add the dynamic payloads if there's one.
if (mediaTypes[i] != null && dynamicPayloads[i] != null) {
addDynamicPayload(mgrs[i], mediaTypes[i], dynamicPayloads[i]);
}
}
// get the content base:
String contentBase = getContentBase();
session_ids = new String[ numberOfTracks];
server_ports = new int[ numberOfTracks];
// setup the individual tracks:
for( int i = 0; i < numberOfTracks; i++) {
if( i == 0) {
msg = "SETUP " + contentBase + mediaControls[ i] + " RTSP/1.0\r\n" +
"CSeq: " + sequenceNumber + "\r\n" +
"Transport: RTP/AVP;unicast;client_port=" + client_ports[ i] +
"-" + (client_ports[ i] + 1) + "\r\n" + userAgent + "\r\n\r\n";
} else {
msg = "SETUP " + contentBase + mediaControls[ i] + " RTSP/1.0\r\n" +
"CSeq: " + sequenceNumber + "\r\n" +
"Transport: RTP/AVP;unicast;client_port=" + client_ports[ i] +
"-" + (client_ports[ i] + 1) + "\r\n" + "Session: " +
session_ids[ 0] + "\r\n" + userAgent + "\r\n\r\n";
}
sendMessage(msg);
timeout = waitForResponse(TIMER_2);
if (timeout) {
Log.error("ERROR: Timeout received (1).");
processError= "Server is not responding";
return false;
}
if( !responseOk()) {
return false;
}
String sessionId= getSessionId();
if( sessionId == null) {
processError= "Invalid session ID";
return false;
}
session_ids[ i] = sessionId;
int pos = session_ids[ i].indexOf(';');
if (pos > 0) {
session_ids[ i] = session_ids[ i].substring(0, pos);
}
int serverPort= getServerDataPort();
if( serverPort == -1) {
processError= "Invalid server data port";
return false;
}
server_ports[ i] = serverPort;
}
return true;
}
private boolean responseOk() {
boolean result= false;
int statusCode= getStatusCode();
if (statusCode == com.sun.media.rtsp.protocol.StatusCode.OK) {
result= true;
} else {
processError = "Message from RTSP Server - " + getStatusText(statusCode);
}
return result;
}
private String getSessionId() {
String id= null;
try {
ResponseMessage responseMsg = (ResponseMessage) message.getParameter();
SessionHeader hdr = (SessionHeader) responseMsg.getResponse().getHeader(
Header.SESSION).parameter;
id= hdr.getSessionId();
} catch( Exception e) {
}
return id;
}
private int getServerDataPort() {
int port= -1;
try {
ResponseMessage responseMsg = (ResponseMessage) message.getParameter();
TransportHeader transport_hdr =
(TransportHeader) responseMsg.getResponse()
.getHeader( Header.TRANSPORT).parameter;
port= transport_hdr.getServerDataPort();
} catch( Exception e) {
}
return port;
}
public boolean rtspStart() {
String msg;
// start all tracks in one compound statement:
msg = "PLAY rtsp://" + rtspUrl.getHost() + "/" +
rtspUrl.getFile() + " RTSP/1.0\r\n" + "CSeq: " +
sequenceNumber + "\r\n" + "Range: npt=" +
(startPos / 1000000000) + "-\r\n" + "Session: " +
session_ids[ 0] + "\r\n" + userAgent + "\r\n\r\n";
sendMessage(msg);
boolean timeout = waitForResponse(TIMER_2);
if (timeout) {
processError= "Server is not responding";
return false;
}
int code= getStatusCode();
if( code == -1) {
processError= "Received invalid status code";
return false;
}
if (getStatusCode() == com.sun.media.rtsp.protocol.StatusCode.SESSION_NOT_FOUND) {
for( int i = 0; i < numberOfTracks; i++) {
mgrs[ i].removeTargets( "session not found");
mgrs[ i].dispose();
return false;
}
}
return true;
}
public void rtspStop() {
String msg = "PAUSE rtsp://" + rtspUrl.getHost() +
"/" + rtspUrl.getFile() +
" RTSP/1.0\r\n" + "CSeq: " + sequenceNumber + "\r\n" +
"Session: " + session_ids[ 0] + "\r\n" + userAgent +
"\r\n\r\n";
sendMessage(msg);
boolean timeout = waitForResponse(TIMER_2);
if (timeout) {
sendStatusMessage(StatusMessage.TIMEOUT, "Timeout received.");
return;
}
}
public void rtspTeardown() {
String msg = "TEARDOWN rtsp://" + rtspUrl.getHost() + "/" +
rtspUrl.getFile() + " RTSP/1.0\r\n" + "CSeq: " +
sequenceNumber + "\r\n" + "Session: " + session_ids[ 0] +
"\r\n" + userAgent + "\r\n\r\n";
sendMessage(msg);
boolean timeout= waitForResponse( TIMER_2);
if (timeout) {
sendStatusMessage( StatusMessage.TIMEOUT,
"Timeout received.");
return;
}
}
public RTPManager createSessionManager( int index) {
RTPManager rtpManager= RTPManager.newInstance();
if (rtpManager == null) {
return null;
}
rtpManager.addReceiveStreamListener((ReceiveStreamListener) parent);
try {
// create the local Session Address:
InetAddress localHost = InetAddress.getLocalHost();
// SessionAddress localAddress = new SessionAddress( localHost,
// client_port);
SessionAddress localAddress= new SessionAddress();
// initialize the RTP Manager:
rtpManager.initialize( localAddress);
client_ports[ index] = localAddress.getDataPort();
} catch (Exception e) {
e.printStackTrace();
return null;
}
return rtpManager;
}
/**
* Parse the dynamic payload string and add the payload type to the
* RTPManager.
*/
private void addDynamicPayload(RTPManager mgr, String typeStr,
String dpStr) {
// Parse the dynamic payload.
int payload;
Format fmt;
int c;
String tmpStr;
// Skip leading spaces.
c = 0;
while (dpStr.length() > 0 && dpStr.charAt(c) == ' ') c++;
if (c > 0)
dpStr = dpStr.substring(c);
// Parse the payload number.
c = 0;
while (dpStr.length() > 0 && dpStr.charAt(c) != ' ') c++;
if (c < 0)
return;
tmpStr = dpStr.substring(0, c);
dpStr = dpStr.substring(c);
Integer integer = Integer.valueOf(tmpStr);
if (integer == null)
return;
// Check the payload value.
payload = integer.intValue();
if (payload < 96 || payload > 127)
return;
// Skip leading spaces.
c = 0;
while (dpStr.length() > 0 && dpStr.charAt(c) == ' ') c++;
if (c > 0)
dpStr = dpStr.substring(c);
if (dpStr.length() == 0)
return;
// Parse the format string.
c = 0;
while (dpStr.length() > 0 && dpStr.charAt(c) != '/') c++;
if (c > 0)
tmpStr = dpStr.substring(0, c);
else
tmpStr = dpStr;
if (tmpStr.length() == 0)
return;
// Append "/rtp" to generate a JMF RTP encoding.
tmpStr = tmpStr.toLowerCase() + "/rtp";
// Add the payload type to format mapping the the manager.
if ("video".equalsIgnoreCase(typeStr)) {
mgr.addFormat(new VideoFormat(tmpStr), payload);
Log.comment("Add RTP dynamic payload for video: " + payload + " : " + tmpStr);
} if ("audio".equalsIgnoreCase(typeStr)) {
mgr.addFormat(new AudioFormat(tmpStr), payload);
Log.comment("Add RTP dynamic payload for audio: " + payload + " : " + tmpStr);
}
}
public int getStatusCode() {
int code= -1;
try {
ResponseMessage responseMsg = (ResponseMessage) message.getParameter();
code= responseMsg.getResponse().getStatusLine().getCode();
} catch( Exception e) {
}
return code;
}
private String getStatusText( int code) {
return StatusCode.getStatusText( code);
}
private void setDuration() {
duration= 0;
ResponseMessage msg = (ResponseMessage) message.getParameter();
double start_time = 0.0;
double end_time = 0.0;
SdpParser sdp = msg.getResponse().sdp;
if (sdp != null) {
MediaAttribute attribute = sdp.getSessionAttribute("range");
if (attribute != null) {
String value= attribute.getValue();
if (value.startsWith("npt")) {
int start = value.indexOf('=') + 1;
int end = value.indexOf('-');
String startTime = value.substring(start, end).trim();
String endTime = value.substring(end + 1).trim();
end_time = new Double(endTime).doubleValue();
duration = (long)(end_time * 1000000000);
}
}
}
}
private int getNumTracks() {
int numTracks = 0;
ResponseMessage msg = (ResponseMessage) message.getParameter();
SdpParser sdp = msg.getResponse().sdp;
if (sdp != null) {
numTracks = sdp.getMediaDescriptions().size();
}
return numTracks;
}
private MediaDescription getMediaDescription( String mediaName) {
MediaDescription description = null;
try {
ResponseMessage msg = (ResponseMessage) message.getParameter();
SdpParser sdp = msg.getResponse().sdp;
description = sdp.getMediaDescription(mediaName);
} catch( Exception e) {
}
return description;
}
private String getCurMediaType( int i) {
String type = null;
try {
ResponseMessage msg = (ResponseMessage) message.getParameter();
SdpParser sdp = msg.getResponse().sdp;
MediaDescription md = (MediaDescription) sdp.getMediaDescriptions().elementAt( i);
type = md.name;
} catch( Exception e) {
}
return type;
}
static public String getMediaAttribute( MediaDescription md,
String attribute) {
String mediaAttribute= "";
if( md != null) {
MediaAttribute ma = md.getMediaAttribute( "control");
if( ma != null) {
mediaAttribute= ma.getValue();
}
}
return mediaAttribute;
}
private String getMediaAttributeValue( int i, String attribute) {
String value = null;
try {
ResponseMessage msg = (ResponseMessage) message.getParameter();
SdpParser sdp = msg.getResponse().sdp;
MediaDescription md = (MediaDescription) sdp.getMediaDescriptions().elementAt( i);
MediaAttribute ma= md.getMediaAttribute( attribute);
value= ma.getValue();
} catch( Exception e) {
}
return value;
}
private String getTrackID(String mediaName) {
String trackId = null;
try {
ResponseMessage msg = (ResponseMessage) message.getParameter();
SdpParser sdp = msg.getResponse().sdp;
MediaDescription description = sdp.getMediaDescription(mediaName);
MediaAttribute attribute = description.getMediaAttribute("control");
trackId = attribute.getValue();
} catch( Exception e) {
}
return trackId;
}
private String getContentBase() {
String contentBase= "";
try {
ResponseMessage responseMsg = (ResponseMessage) message.getParameter();
Header header = responseMsg.getResponse().getHeader( Header.CONTENT_BASE);
ContentBaseHeader cbh = (ContentBaseHeader)header.parameter;
contentBase = cbh.getContentBase();
} catch( Exception e) {
}
return contentBase;
}
private void sendMessage(String message) {
responseReceived = false;
boolean success = rtspManager.sendMessage(connectionId, message);
if (!success) {
String ipAddress = getServerIpAddress();
connectionId = rtspManager.createConnection(ipAddress, rtspUrl.getPort());
rtspManager.sendMessage(connectionId, message);
}
}
boolean responseReceived;
boolean dataReceived;
Object responseSync = new Object();
private synchronized boolean waitForResponse(int time) {
boolean timeout = false;
try {
synchronized (responseSync) {
if (!responseReceived) {
responseSync.wait(time);
}
if (responseReceived) {
sequenceNumber++;
} else {
timeout = true;
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
return timeout;
}
private void processRtspRequest(int connectionId, Message message) {
if (message.getType() == MessageType.OPTIONS) {
OptionsMessage msg = (OptionsMessage) message.getParameter();
sendResponse(connectionId, msg.getRequest());
}
}
private void processRtspResponse(int connectionId, Message message) {
this.message = message;
responseReceived = true;
synchronized (responseSync) {
responseSync.notify();
}
}
private void sendResponse(int connectionId, Request msg) {
String type = null;
Header header = msg.getHeader(Header.CSEQ);
if( header != null) {
CSeqHeader cSeqHeader = (CSeqHeader) header.parameter;
String message = "RTSP/1.0 200 OK\r\n" + "CSeq: " +
cSeqHeader.getSequenceNumber() + "\r\n\r\n";
sendMessage(message);
}
}
private void sendStatusMessage(int code, String message) {
for (int i = 0; i < listeners.size(); i++) {
((RtspAppListener) listeners.elementAt(i)).postStatusMessage(code,
message);
}
}
public void addListener(RtspAppListener listener) {
listeners.addElement(listener);
}
public void removeListener(RtspAppListener listener) {
listeners.removeElement(listener);
}
public int getNumberOfTracks() {
return numberOfTracks;
}
public int[] getServerPorts() {
return server_ports;
}
public void rtspMessageIndication(int connectionId, Message message) {
if (message.getType() == MessageType.RESPONSE) {
processRtspResponse(connectionId, message);
} else {
processRtspRequest(connectionId, message);
}
}
public String getServerIpAddress() {
String ipAddress = null;
try {
if( rtspUrl == null) {
rtspUrl= new RtspUrl( url);
}
String host = rtspUrl.getHost();
if( host != null) {
ipAddress = InetAddress.getByName(host).getHostAddress();
}
} catch( MalformedURLException e) {
// System.err.println( "Malformed URL Exception: " + e);
} catch (UnknownHostException e) {
// System.err.println( "Host unknown: " + name);
}
return ipAddress;
}
public void rtspConnectionTerminated(int connectionId) {
// System.out.println( "RtspPlayer::rtspConnectionTerminated");
}
public String getProcessError() {
return processError;
}
public void setProcessError( String error) {
processError= error;
}
}
|
