/* * RTPSocketAdapter.java * * Created on November 18, 2003, 3:08 PM */package gov.nist.applet.phone.media.protocol.transport;/** * * @author  DERUELLE Jean */import java.io.IOException;import java.net.InetAddress;import java.net.DatagramSocket;import java.net.SocketException;import javax.media.protocol.PushSourceStream;import javax.media.rtp.RTPConnector;import javax.media.rtp.OutputDataStream;/** * An implementation of RTPConnector based on UDP sockets. */public class UDPAdapter implements RTPConnector {    private DatagramSocket dataSock;    private DatagramSocket ctrlSock;    private InetAddress addr;    private int port;        //private int destinationPort;        private int rtcpPort;    //private int rtcpDestinationPort;        private UDPPushSourceStream dataInStrm = null, ctrlInStrm = null;    private UDPOutputDataStream dataOutStrm = null, ctrlOutStrm = null;    /** Creates a new instance of UDPAdapter      * @param addr - address of the remote host     * @param localPort - port of the local host     * @param destPort - port of the remote host     */    public UDPAdapter(InetAddress addr, int port) throws IOException {		this(addr, port, 1);    }    /** Creates a new instance of UDPAdapter      * @param addr - address of the remote host     * @param localPort - port of the local host     * @param destPort - port of the remote host     * @param ttl - time to live     */    public UDPAdapter(InetAddress addr, int port, int ttl) throws IOException {        rtcpPort=port++;        //rtcpDestinationPort=destPort++;		try {	    			System.out.println(addr+" port "+port+" rtcp" + rtcpPort);            dataSock = new DatagramSocket(port, addr);            ctrlSock = new DatagramSocket(rtcpPort, addr);	    		} catch(SocketException e) {					    throw new IOException(e.getMessage());		}		this.addr = addr;		this.port = port;        //this.destinationPort = destPort;    }     /**     * Returns an input stream to receive the RTP data.     * @return input stream to receive the RTP data.     */    public PushSourceStream getDataInputStream() throws IOException {		if (dataInStrm == null) {		    dataInStrm = new UDPPushSourceStream(dataSock, addr, port);		    dataInStrm.start();		}		return dataInStrm;    }     /**     * Returns an output stream to send the RTP data.     * @return output stream to send the RTP data.     */    public OutputDataStream getDataOutputStream() throws IOException {		if (dataOutStrm == null)		    dataOutStrm = new UDPOutputDataStream(dataSock, addr, port);		return dataOutStrm;    }    /**     * Returns an input stream to receive the RTCP data.     * @return input stream to receive the RTCP data.     */    public PushSourceStream getControlInputStream() throws IOException {		if (ctrlInStrm == null) {		    ctrlInStrm = new UDPPushSourceStream(ctrlSock, addr, rtcpPort);		    ctrlInStrm.start();		}		return ctrlInStrm;    }    /**     * Returns an output stream to send the RTCP data.     * @return output stream to send the RTCP data.     */    public OutputDataStream getControlOutputStream() throws IOException {		if (ctrlOutStrm == null)		    ctrlOutStrm = new UDPOutputDataStream(ctrlSock, addr, rtcpPort);		return ctrlOutStrm;    }    /**     * Close all the RTP, RTCP streams.     */    public void close() {        System.out.println("Closing the streams");		if (dataInStrm != null)		    dataInStrm.kill();		if (ctrlInStrm != null)		    ctrlInStrm.kill();        while(!dataSock.isClosed())            dataSock.close();        while(!ctrlSock.isClosed())            ctrlSock.close();        dataSock=null;        ctrlSock=null;    }    /**     * Set the receive buffer size of the RTP data channel.     * This is only a hint to the implementation.  The actual implementation     * may not be able to do anything to this.     * @param size - receive buffer size      */    public void setReceiveBufferSize( int size) throws IOException {		dataSock.setReceiveBufferSize(size);    }    /**     * Get the receive buffer size set on the RTP data channel.     * Return -1 if the receive buffer size is not applicable for     * the implementation.     * @return receive buffer size      */    public int getReceiveBufferSize() {		try {		    return dataSock.getReceiveBufferSize();		} catch (Exception e) {		    return -1;		}    }    /**     * Set the send buffer size of the RTP data channel.     * This is only a hint to the implementation.  The actual implementation     * may not be able to do anything to this.     * @param size - send buffer size.     */    public void setSendBufferSize( int size) throws IOException {		dataSock.setSendBufferSize(size);    }    /**     * Get the send buffer size set on the RTP data channel.     * Return -1 if the send buffer size is not applicable for     * the implementation.     * @return send buffer size      */    public int getSendBufferSize() {		try {		    return dataSock.getSendBufferSize();		} catch (Exception e) {		    return -1;		}    }    /**     * Return the RTCP bandwidth fraction.  This value is used to     * initialize the RTPManager.  Check RTPManager for more detauls.     * @return RTCP bandwidth fraction. -1 to use the default values.     */    public double getRTCPBandwidthFraction() {		return -1;    }    /**     * Return the RTCP sender bandwidth fraction.  This value is used to     * initialize the RTPManager.  Check RTPManager for more detauls.     * Return -1 to use the default values.     * @return RTCP sender bandwidth fraction. -1 to use the default values.     */    public double getRTCPSenderBandwidthFraction() {		return -1;    }}