博客
关于我
强烈建议你试试无所不能的chatGPT，快点击我
基于JMF RTP的音视频传输
阅读量：5864 次
发布时间：2019-06-19

本文共 26878 字，大约阅读时间需要 89 分钟。

名流时尚服饰 dior 夏季 男装 男士t恤衬衫卫衣休闲裤牛仔裤英伦 
socool 搜酷女包◆任选两款正价包包邮◆5周年店庆◆5折疯抢 
紫紫 超人气包邮特价创意家居收纳压缩袋饰品服饰配件包包 
socool 搜酷女包◆任选两款正价包包邮◆5周年店庆◆5折疯抢 
dior 风格 CF Homme 男装 男士t恤衬衫卫衣休闲裤牛仔裤英伦 
【１９７０流行馆】（春装日韩女装瑞丽女装） 
非凡瑞丽衣衫 日韩 瑞丽 女装 韩版 2011 欧美 米娜 春夏装 女装 
芮诗凯诗国际家居馆\欧美田园家居\复古家居\韩式家居\乡村家居 
【徽商联盟】cool-百衣百顺 续写男装 冲双冠两件包邮 
美美箱包专卖店 全场19元起，满58免运费，麦包包韩版女包新款。 
import java.io.*;
import java.awt.*;
import java.net.*;
import java.awt.event.*;
import java.util.Vector;
import javax.media.*;
import javax.media.rtp.*;
import javax.media.rtp.event.*;
import javax.media.rtp.rtcp.*;
import javax.media.protocol.*;
import javax.media.protocol.DataSource;
import javax.media.format.AudioFormat;
import javax.media.format.VideoFormat;
import javax.media.Format;
import javax.media.format.FormatChangeEvent;
import javax.media.control.BufferControl;
/**
 * AVReceive3 to receive RTP transmission using the RTPConnector.
 */
public class AVReceive3 implements ReceiveStreamListener, SessionListener, 
    ControllerListener
{
    String sessions[] = null;
    RTPManager mgrs[] = null;
    Vector playerWindows = null;
    boolean dataReceived = false;
    Object dataSync = new Object();
    public AVReceive3(String sessions[]) {
    this.sessions = sessions;
    }
    protected boolean initialize() {
        try {
        mgrs = new RTPManager[sessions.length];
        playerWindows = new Vector();
        SessionLabel session;
        // Open the RTP sessions.
        for (int i = 0; i < sessions.length; i++) {
         // Parse the session addresses.
        try {
            session = new SessionLabel(sessions[i]);
        } catch (IllegalArgumentException e) {
            System.err.println("Failed to parse the session address given: " + sessions[i]);
            return false;
        }
        System.err.println("  - Open RTP session for: addr: " + session.addr + " port: " + session.port + " ttl: " + session.ttl);
        mgrs[i] = (RTPManager) RTPManager.newInstance();
        mgrs[i].addSessionListener(this);
        mgrs[i].addReceiveStreamListener(this);
        // Initialize the RTPManager with the RTPSocketAdapter
        mgrs[i].initialize(new RTPSocketAdapter(
                    InetAddress.getByName(session.addr), 
                    session.port, session.ttl));
        // You can try out some other buffer size to see
        // if you can get better smoothness.
        BufferControl bc = (BufferControl)mgrs[i].getControl("javax.media.control.BufferControl");
        if (bc != null)
            bc.setBufferLength(350);
        }
        } catch (Exception e){
            System.err.println("Cannot create the RTP Session: " + e.getMessage());
            return false;
        }
    // Wait for data to arrive before moving on.
    long then = System.currentTimeMillis();
    long waitingPeriod = 30000;  // wait for a maximum of 30 secs.
    try{
        synchronized (dataSync) {
        while (!dataReceived && 
            System.currentTimeMillis() - then < waitingPeriod) {
            if (!dataReceived)
            System.err.println("  - Waiting for RTP data to arrive");
            dataSync.wait(1000);
        }
        }
    } catch (Exception e) {}
    if (!dataReceived) {
        System.err.println("No RTP data was received.");
        close();
        return false;
    }
        return true;
    }
    public boolean isDone() {
    return playerWindows.size() == 0;
    }
    /**
     * Close the players and the session managers.
     */
    protected void close() {
    for (int i = 0; i < playerWindows.size(); i++) {
        try {
        ((PlayerWindow)playerWindows.elementAt(i)).close();
        } catch (Exception e) {}
    }
    playerWindows.removeAllElements();
    // close the RTP session.
    for (int i = 0; i < mgrs.length; i++) {
        if (mgrs[i] != null) {
                mgrs[i].removeTargets( "Closing session from AVReceive3");
                mgrs[i].dispose();
        mgrs[i] = null;
        }
    }
    }
    PlayerWindow find(Player p) {
    for (int i = 0; i < playerWindows.size(); i++) {
        PlayerWindow pw = (PlayerWindow)playerWindows.elementAt(i);
        if (pw.player == p)
        return pw;
    }
    return null;
    }
    PlayerWindow find(ReceiveStream strm) {
    for (int i = 0; i < playerWindows.size(); i++) {
        PlayerWindow pw = (PlayerWindow)playerWindows.elementAt(i);
        if (pw.stream == strm)
        return pw;
    }
    return null;
    }
    /**
     * SessionListener.
     */
    public synchronized void update(SessionEvent evt) {
    if (evt instanceof NewParticipantEvent) {
        Participant p = ((NewParticipantEvent)evt).getParticipant();
        System.err.println("  - A new participant had just joined: " + p.getCNAME());
    }
    }
    /**
     * ReceiveStreamListener
     */
    public synchronized void update( ReceiveStreamEvent evt) {
    RTPManager mgr = (RTPManager)evt.getSource();
    Participant participant = evt.getParticipant();    // could be null.
    ReceiveStream stream = evt.getReceiveStream();  // could be null.
    if (evt instanceof RemotePayloadChangeEvent) {
     
        System.err.println("  - Received an RTP PayloadChangeEvent.");
        System.err.println("Sorry, cannot handle payload change.");
        System.exit(0);
    }
    
    else if (evt instanceof NewReceiveStreamEvent) {
        try {
        stream = ((NewReceiveStreamEvent)evt).getReceiveStream();
        DataSource ds = stream.getDataSource();
        // Find out the formats.
        RTPControl ctl = (RTPControl)ds.getControl("javax.media.rtp.RTPControl");
        if (ctl != null){
            System.err.println("  - Recevied new RTP stream: " + ctl.getFormat());
        } else
            System.err.println("  - Recevied new RTP stream");
        if (participant == null)
            System.err.println("      The sender of this stream had yet to be identified.");
        else {
            System.err.println("      The stream comes from: " + participant.getCNAME()); 
        }
        // create a player by passing datasource to the Media Manager
        Player p = javax.media.Manager.createPlayer(ds);
        if (p == null)
            return;
        p.addControllerListener(this);
        p.realize();
        PlayerWindow pw = new PlayerWindow(p, stream);
        playerWindows.addElement(pw);
        // Notify intialize() that a new stream had arrived.
        synchronized (dataSync) {
            dataReceived = true;
            dataSync.notifyAll();
        }
        } catch (Exception e) {
        System.err.println("NewReceiveStreamEvent exception " + e.getMessage());
        return;
        }
        
    }
    else if (evt instanceof StreamMappedEvent) {
         if (stream != null && stream.getDataSource() != null) {
        DataSource ds = stream.getDataSource();
        // Find out the formats.
        RTPControl ctl = (RTPControl)ds.getControl("javax.media.rtp.RTPControl");
        System.err.println("  - The previously unidentified stream ");
        if (ctl != null)
            System.err.println("      " + ctl.getFormat());
        System.err.println("      had now been identified as sent by: " + participant.getCNAME());
         }
    }
    else if (evt instanceof ByeEvent) {
         System.err.println("  - Got \"bye\" from: " + participant.getCNAME());
         PlayerWindow pw = find(stream);
         if (pw != null) {
        pw.close();
        playerWindows.removeElement(pw);
         }
    }
    }
    /**
     * ControllerListener for the Players.
     */
    public synchronized void controllerUpdate(ControllerEvent ce) {
    Player p = (Player)ce.getSourceController();
    if (p == null)
        return;
    // Get this when the internal players are realized.
    if (ce instanceof RealizeCompleteEvent) {
        PlayerWindow pw = find(p);
        if (pw == null) {
        // Some strange happened.
        System.err.println("Internal error!");
        System.exit(-1);
        }
        pw.initialize();
        pw.setVisible(true);
        p.start();
    }
    if (ce instanceof ControllerErrorEvent) {
        p.removeControllerListener(this);
        PlayerWindow pw = find(p);
        if (pw != null) {
        pw.close();    
        playerWindows.removeElement(pw);
        }
        System.err.println("AVReceive3 internal error: " + ce);
    }
    }
    /**
     * A utility class to parse the session addresses.
     */
    class SessionLabel {
    public String addr = null;
    public int port;
    public int ttl = 1;
    SessionLabel(String session) throws IllegalArgumentException {
        int off;
        String portStr = null, ttlStr = null;
        if (session != null && session.length() > 0) {
        while (session.length() > 1 && session.charAt(0) == '/')
            session = session.substring(1);
        // Now see if there's a addr specified.
        off = session.indexOf('/');
        if (off == -1) {
            if (!session.equals(""))
            addr = session;
        } else {
            addr = session.substring(0, off);
            session = session.substring(off + 1);
            // Now see if there's a port specified
            off = session.indexOf('/');
            if (off == -1) {
            if (!session.equals(""))
                portStr = session;
            } else {
            portStr = session.substring(0, off);
            session = session.substring(off + 1);
            // Now see if there's a ttl specified
            off = session.indexOf('/');
            if (off == -1) {
                if (!session.equals(""))
                ttlStr = session;
            } else {
                ttlStr = session.substring(0, off);
            }
            }
        }
        }
        if (addr == null)
        throw new IllegalArgumentException();
        if (portStr != null) {
        try {
            Integer integer = Integer.valueOf(portStr);
            if (integer != null)
            port = integer.intValue();
        } catch (Throwable t) {
            throw new IllegalArgumentException();
        }
        } else
        throw new IllegalArgumentException();
        if (ttlStr != null) {
        try {
            Integer integer = Integer.valueOf(ttlStr);
            if (integer != null)
            ttl = integer.intValue();
        } catch (Throwable t) {
            throw new IllegalArgumentException();
        }
        }
    }
    }
    /**
     * GUI classes for the Player.
     */
    class PlayerWindow extends Frame {
    Player player;
    ReceiveStream stream;
    PlayerWindow(Player p, ReceiveStream strm) {
        player = p;
        stream = strm;
    }
    public void initialize() {
        add(new PlayerPanel(player));
    }
    public void close() {
        player.close();
        setVisible(false);
        dispose();
    }
    public void addNotify() {
        super.addNotify();
        pack();
    }
    }
    /**
     * GUI classes for the Player.
     */
    class PlayerPanel extends Panel {
    Component vc, cc;
    PlayerPanel(Player p) {
        setLayout(new BorderLayout());
        if ((vc = p.getVisualComponent()) != null)
        add("Center", vc);
        if ((cc = p.getControlPanelComponent()) != null)
        add("South", cc);
    }
    public Dimension getPreferredSize() {
        int w = 0, h = 0;
        if (vc != null) {
        Dimension size = vc.getPreferredSize();
        w = size.width;
        h = size.height;
        }
        if (cc != null) {
        Dimension size = cc.getPreferredSize();
        if (w == 0)
            w = size.width;
        h += size.height;
        }
        if (w < 160)
        w = 160;
        return new Dimension(w, h);
    }
    }
    public static void main(String argv[]) {
    if (argv.length == 0)
        prUsage();
    AVReceive3 avReceive = new AVReceive3(argv);
    if (!avReceive.initialize()) {
        System.err.println("Failed to initialize the sessions.");
        System.exit(-1);
    }
    // Check to see if AVReceive3 is done.
    try {
        while (!avReceive.isDone())
        Thread.sleep(1000);
    } catch (Exception e) {}
    System.err.println("Exiting AVReceive3");
    }
    static void prUsage() {
    System.err.println("Usage: AVReceive3 <session> <session> ");
    System.err.println("     <session>: <address>/<port>/<ttl>");
    System.exit(0);
    }
}// end of AVReceive3 
发送端代码：
import java.awt.*;
import java.io.*;
import java.net.InetAddress;
import javax.media.*;
import javax.media.protocol.*;
import javax.media.protocol.DataSource;
import javax.media.format.*;
import javax.media.control.TrackControl;
import javax.media.control.QualityControl;
import javax.media.rtp.*;
import javax.media.rtp.rtcp.*;
import com.sun.media.rtp.*;
public class AVTransmit3 {
    // Input MediaLocator
    // Can be a file or http or capture source
    private MediaLocator locator;
    private String ipAddress;
    private int portBase;
    private Processor processor = null;
    private RTPManager rtpMgrs[];
    private DataSource dataOutput = null;
    
    public AVTransmit3(MediaLocator locator,
             String ipAddress,
             String pb,
             Format format) {
    
    this.locator = locator;
    this.ipAddress = ipAddress;
    Integer integer = Integer.valueOf(pb);
    if (integer != null)
        this.portBase = integer.intValue();
    }
    /**
     * Starts the transmission. Returns null if transmission started ok.
     * Otherwise it returns a string with the reason why the setup failed.
     */
    public synchronized String start() {
    String result;
    // Create a processor for the specified media locator
    // and program it to output JPEG/RTP
    result = createProcessor();
    if (result != null)
        return result;
    // Create an RTP session to transmit the output of the
    // processor to the specified IP address and port no.
    result = createTransmitter();
    if (result != null) {
        processor.close();
        processor = null;
        return result;
    }
    // Start the transmission
    processor.start();
    
    return null;
    }
    /**
     * Stops the transmission if already started
     */
    public void stop() {
    synchronized (this) {
        if (processor != null) {
        processor.stop();
        processor.close();
        processor = null;
        for (int i = 0; i < rtpMgrs.length; i++) {
            rtpMgrs[i].removeTargets( "Session ended.");
            rtpMgrs[i].dispose();
        }
        }
    }
    }
    private String createProcessor() {
    if (locator == null)
        return "Locator is null";
    DataSource ds;
    DataSource clone;
    try {
        ds = javax.media.Manager.createDataSource(locator);
    } catch (Exception e) {
        return "Couldn't create DataSource";
    }
    // Try to create a processor to handle the input media locator
    try {
        processor = javax.media.Manager.createProcessor(ds);
    } catch (NoProcessorException npe) {
        return "Couldn't create processor";
    } catch (IOException ioe) {
        return "IOException creating processor";
    } 
    // Wait for it to configure
    boolean result = waitForState(processor, Processor.Configured);
    if (result == false)
        return "Couldn't configure processor";
    // Get the tracks from the processor
    TrackControl [] tracks = processor.getTrackControls();
    // Do we have atleast one track?
    if (tracks == null || tracks.length < 1)
        return "Couldn't find tracks in processor";
    // Set the output content descriptor to RAW_RTP
    // This will limit the supported formats reported from
    // Track.getSupportedFormats to only valid RTP formats.
    ContentDescriptor cd = new ContentDescriptor(ContentDescriptor.RAW_RTP);
    processor.setContentDescriptor(cd);
    Format supported[];
    Format chosen;
    boolean atLeastOneTrack = false;
    // Program the tracks.
    for (int i = 0; i < tracks.length; i++) {
        Format format = tracks[i].getFormat();
        if (tracks[i].isEnabled()) {
        supported = tracks[i].getSupportedFormats();
        // We've set the output content to the RAW_RTP.
        // So all the supported formats should work with RTP.
        // We'll just pick the first one.
        if (supported.length > 0) {
            if (supported[0] instanceof VideoFormat) {
            // For video formats, we should double check the
            // sizes since not all formats work in all sizes.
            chosen = checkForVideoSizes(tracks[i].getFormat(), 
                            supported[0]);
            } else
            chosen = supported[0];
            tracks[i].setFormat(chosen);
            System.err.println("Track " + i + " is set to transmit as:");
            System.err.println("  " + chosen);
            atLeastOneTrack = true;
        } else
            tracks[i].setEnabled(false);
        } else
        tracks[i].setEnabled(false);
    }
    if (!atLeastOneTrack)
        return "Couldn't set any of the tracks to a valid RTP format";
    // Realize the processor. This will internally create a flow
    // graph and attempt to create an output datasource for JPEG/RTP
    // audio frames.
    result = waitForState(processor, Controller.Realized);
    if (result == false)
        return "Couldn't realize processor";
    // Set the JPEG quality to .5.
    setJPEGQuality(processor, 0.5f);
    // Get the output data source of the processor
    dataOutput = processor.getDataOutput();
    return null;
    }
    /**
     * Use the RTPManager API to create sessions for each media 
     * track of the processor.
     */
    private String createTransmitter() {
    // Cheated.  Should have checked the type.
    PushBufferDataSource pbds = (PushBufferDataSource)dataOutput;
    PushBufferStream pbss[] = pbds.getStreams();
    rtpMgrs = new RTPManager[pbss.length];
    SendStream sendStream;
    int port;
    SourceDescription srcDesList[];
    for (int i = 0; i < pbss.length; i++) {
        try {
        rtpMgrs[i] = RTPManager.newInstance();        
        port = portBase + 2*i;
        
        // Initialize the RTPManager with the RTPSocketAdapter
        rtpMgrs[i].initialize(new RTPSocketAdapter(
                    InetAddress.getByName(ipAddress), 
                    port));
        System.err.println( "Created RTP session: " + ipAddress + " " + port);
        
        sendStream = rtpMgrs[i].createSendStream(dataOutput, i);        
        sendStream.start();
        } catch (Exception  e) {
        return e.getMessage();
        }
    }
    return null;
    }
    /**
     * For JPEG and H263, we know that they only work for particular
     * sizes.  So we'll perform extra checking here to make sure they
     * are of the right sizes.
     */
    Format checkForVideoSizes(Format original, Format supported) {
    int width, height;
    Dimension size = ((VideoFormat)original).getSize();
    Format jpegFmt = new Format(VideoFormat.JPEG_RTP);
    Format h263Fmt = new Format(VideoFormat.H263_RTP);
    if (supported.matches(jpegFmt)) {
        // For JPEG, make sure width and height are divisible by 8.
        width = (size.width % 8 == 0 ? size.width :
                (int)(size.width / 8) * 8);
        height = (size.height % 8 == 0 ? size.height :
                (int)(size.height / 8) * 8);
    } else if (supported.matches(h263Fmt)) {
        // For H.263, we only support some specific sizes.
        if (size.width < 128) {
        width = 128;
        height = 96;
        } else if (size.width < 176) {
        width = 176;
        height = 144;
        } else {
        width = 352;
        height = 288;
        }
    } else {
        // We don't know this particular format.  We'll just
        // leave it alone then.
        return supported;
    }
    return (new VideoFormat(null, 
                new Dimension(width, height), 
                Format.NOT_SPECIFIED,
                null,
                Format.NOT_SPECIFIED)).intersects(supported);
    }
    /**
     * Setting the encoding quality to the specified value on the JPEG encoder.
     * 0.5 is a good default.
     */
    void setJPEGQuality(Player p, float val) {
    Control cs[] = p.getControls();
    QualityControl qc = null;
    VideoFormat jpegFmt = new VideoFormat(VideoFormat.JPEG);
    // Loop through the controls to find the Quality control for
     // the JPEG encoder.
    for (int i = 0; i < cs.length; i++) {
        if (cs[i] instanceof QualityControl &&
        cs[i] instanceof Owned) {
        Object owner = ((Owned)cs[i]).getOwner();
        // Check to see if the owner is a Codec.
        // Then check for the output format.
        if (owner instanceof Codec) {
            Format fmts[] = ((Codec)owner).getSupportedOutputFormats(null);
            for (int j = 0; j < fmts.length; j++) {
            if (fmts[j].matches(jpegFmt)) {
                qc = (QualityControl)cs[i];
                    qc.setQuality(val);
                System.err.println("- Setting quality to " + 
                    val + " on " + qc);
                break;
            }
            }
        }
        if (qc != null)
            break;
        }
    }
    }
    /****************************************************************
     * Convenience methods to handle processor's state changes.
     ****************************************************************/
    
    private Integer stateLock = new Integer(0);
    private boolean failed = false;
    
    Integer getStateLock() {
    return stateLock;
    }
    void setFailed() {
    failed = true;
    }
    
    private synchronized boolean waitForState(Processor p, int state) {
    p.addControllerListener(new StateListener());
    failed = false;
    // Call the required method on the processor
    if (state == Processor.Configured) {
        p.configure();
    } else if (state == Processor.Realized) {
        p.realize();
    }
    
    // Wait until we get an event that confirms the
    // success of the method, or a failure event.
    // See StateListener inner class
    while (p.getState() < state && !failed) {
        synchronized (getStateLock()) {
        try {
            getStateLock().wait();
        } catch (InterruptedException ie) {
            return false;
        }
        }
    }
    if (failed)
        return false;
    else
        return true;
    }
    /****************************************************************
     * Inner Classes
     ****************************************************************/
    class StateListener implements ControllerListener {
    public void controllerUpdate(ControllerEvent ce) {
        // If there was an error during configure or
        // realize, the processor will be closed
        if (ce instanceof ControllerClosedEvent)
        setFailed();
        // All controller events, send a notification
        // to the waiting thread in waitForState method.
        if (ce instanceof ControllerEvent) {
        synchronized (getStateLock()) {
            getStateLock().notifyAll();
        }
        }
    }
    }
    /****************************************************************
     * Sample Usage for AVTransmit3 class
     ****************************************************************/
    
    public static void main(String [] args) {
    // We need three parameters to do the transmission
    // For example,
    //   java AVTransmit3 file:/C:/media/test.mov  129.130.131.132 42050
    
    if (args.length < 3) {
        prUsage();
    }
    Format fmt = null;
    int i = 0;
    // Create a audio transmit object with the specified params.
    AVTransmit3 at = new AVTransmit3(new MediaLocator(args[i]),
                         args[i+1], args[i+2], fmt);
    // Start the transmission
    String result = at.start();
    // result will be non-null if there was an error. The return
    // value is a String describing the possible error. Print it.
    if (result != null) {
        System.err.println("Error : " + result);
        System.exit(0);
    }
    
    System.err.println("Start transmission for 60 seconds");
    // Transmit for 60 seconds and then close the processor
    // This is a safeguard when using a capture data source
    // so that the capture device will be properly released
    // before quitting.
    // The right thing to do would be to have a GUI with a
    // "Stop" button that would call stop on AVTransmit3
    try {
        Thread.currentThread().sleep(60000);
    } catch (InterruptedException ie) {
    }
    // Stop the transmission
    at.stop();
    
    System.err.println("transmission ended.");
    System.exit(0);
    }
    static void prUsage() {
    System.err.println("Usage: AVTransmit3 <sourceURL> <destIP> <destPortBase>");
    System.err.println("     <sourceURL>: input URL or file name");
    System.err.println("     <destIP>: multicast, broadcast or unicast IP address for the transmission");
    System.err.println("     <destPortBase>: network port numbers for the transmission.");
    System.err.println("                     The first track will use the destPortBase.");
    System.err.println("                     The next track will use destPortBase + 2 and so on.\n");
    System.exit(0);
    }
}
 
底层传输部分代码：
import java.io.IOException;
import java.net.InetAddress;
import java.net.DatagramSocket;
import java.net.MulticastSocket;
import java.net.DatagramPacket;
import java.net.SocketException;
import javax.media.protocol.DataSource;
import javax.media.protocol.PushSourceStream;
import javax.media.protocol.ContentDescriptor;
import javax.media.protocol.SourceTransferHandler;
import javax.media.rtp.RTPConnector;
import javax.media.rtp.OutputDataStream;
/**
 * An implementation of RTPConnector based on UDP sockets.
 */
public class RTPSocketAdapter implements RTPConnector {
    DatagramSocket dataSock;
    DatagramSocket ctrlSock;
    InetAddress addr;
    int port;
    SockInputStream dataInStrm = null, ctrlInStrm = null;
    SockOutputStream dataOutStrm = null, ctrlOutStrm = null;
    public RTPSocketAdapter(InetAddress addr, int port) throws IOException {
    this(addr, port, 1);
    }
    public RTPSocketAdapter(InetAddress addr, int port, int ttl) throws IOException {
    try {
        if (addr.isMulticastAddress()) {
        dataSock = new MulticastSocket(port);
        ctrlSock = new MulticastSocket(port+1);
        ((MulticastSocket)dataSock).joinGroup(addr);
        ((MulticastSocket)dataSock).setTimeToLive(ttl);
        ((MulticastSocket)ctrlSock).joinGroup(addr);
        ((MulticastSocket)ctrlSock).setTimeToLive(ttl);
        } else {
        dataSock = new DatagramSocket(port, InetAddress.getLocalHost());
        ctrlSock = new DatagramSocket(port+1, InetAddress.getLocalHost());
        }
    } catch (SocketException e) {
        throw new IOException(e.getMessage());
    }
    this.addr = addr;
    this.port = port;
    }
    /**
     * Returns an input stream to receive the RTP data. 
     */
    public PushSourceStream getDataInputStream() throws IOException {
    if (dataInStrm == null) {
        dataInStrm = new SockInputStream(dataSock, addr, port);
        dataInStrm.start();
    }
    return dataInStrm;
    }
    /**
     * Returns an output stream to send the RTP data.
     */
    public OutputDataStream getDataOutputStream() throws IOException {
    if (dataOutStrm == null)
        dataOutStrm = new SockOutputStream(dataSock, addr, port);
    return dataOutStrm;
    }
    /**
     * Returns an input stream to receive the RTCP data.
     */
    public PushSourceStream getControlInputStream() throws IOException {
    if (ctrlInStrm == null) {
        ctrlInStrm = new SockInputStream(ctrlSock, addr, port+1);
        ctrlInStrm.start();
    }
    return ctrlInStrm;
    }
    /**
     * Returns an output stream to send the RTCP data.
     */
    public OutputDataStream getControlOutputStream() throws IOException {
    if (ctrlOutStrm == null)
        ctrlOutStrm = new SockOutputStream(ctrlSock, addr, port+1);
    return ctrlOutStrm;
    }
    /**
     * Close all the RTP, RTCP streams.
     */
    public void close() {
    if (dataInStrm != null)
        dataInStrm.kill();
    if (ctrlInStrm != null)
        ctrlInStrm.kill();
    dataSock.close();
    ctrlSock.close();
    }
    /**
     * 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.
     */
    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.
     */
    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.
     */
    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.
     */
    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 -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.
     */
    public double getRTCPSenderBandwidthFraction() {
    return -1;
    }
    /**
     * An inner class to implement an OutputDataStream based on UDP sockets.
     */
    class SockOutputStream implements OutputDataStream {
    DatagramSocket sock;
    InetAddress addr;
    int port;
    public SockOutputStream(DatagramSocket sock, InetAddress addr, int port) {
        this.sock = sock;
        this.addr = addr;
        this.port = port;
    }
    public int write(byte data[], int offset, int len) {
        try {
        sock.send(new DatagramPacket(data, offset, len, addr, port));
        } catch (Exception e) {
        return -1;
        }
        return len;
    }
    }
    /**
     * An inner class to implement an PushSourceStream based on UDP sockets.
     */
    class SockInputStream extends Thread implements PushSourceStream {
    DatagramSocket sock;
    InetAddress addr;
    int port;
    boolean done = false;
    boolean dataRead = false;
    SourceTransferHandler sth = null;
    public SockInputStream(DatagramSocket sock, InetAddress addr, int port) {
        this.sock = sock;
        this.addr = addr;
        this.port = port;
    }
    public int read(byte buffer[], int offset, int length) {
        DatagramPacket p = new DatagramPacket(buffer, offset, length, addr, port);
        try {
        sock.receive(p);
        } catch (IOException e) {
        return -1;
        }
        synchronized (this) {
        dataRead = true;
        notify();
        }
        return p.getLength();
    }
    public synchronized void start() {
        super.start();
        if (sth != null) {
        dataRead = true;
        notify();
        }
    }
    public synchronized void kill() {
        done = true;
        notify();
    }
    public int getMinimumTransferSize() {
        return 2 * 1024;    // twice the MTU size, just to be safe.
    }
    public synchronized void setTransferHandler(SourceTransferHandler sth) {
        this.sth = sth;
        dataRead = true;
        notify();
    }
    // Not applicable.
    public ContentDescriptor getContentDescriptor() {
        return null;
    }
    // Not applicable.
    public long getContentLength() {
        return LENGTH_UNKNOWN;
    }
    // Not applicable.
    public boolean endOfStream() {
        return false;
    }
    // Not applicable.
    public Object[] getControls() {
        return new Object[0];
    }
    // Not applicable.
    public Object getControl(String type) {
        return null;
    }
    /**
     * Loop and notify the transfer handler of new data.
     */
    public void run() {
        while (!done) {
        synchronized (this) {
            while (!dataRead && !done) {
            try {
                wait();
            } catch (InterruptedException e) { }
            }
            dataRead = false;
        }
        if (sth != null && !done) {
            sth.transferData(this);
        }
        }
    }
    }
}
本文转自Phinecos(洞庭散人)博客园博客，原文链接：http://www.cnblogs.com/phinecos/archive/2007/09/28/909970.html，如需转载请自行联系原作者
你可能感兴趣的文章
MR1和MR2的工作原理
查看>>
Eclipse中修改代码格式
查看>>
GRUB Legacy
查看>>
关于 error: LINK1123: failure during conversion to COFF: file invalid or corrupt 错误的解决方案...
查看>>
hexo博客解决不蒜子统计无法显示问题
查看>>
python实现链表
查看>>
java查找string1和string2是不是含有相同的字母种类和数量（string1是否是string2的重新组合）...
查看>>
Android TabActivity使用方法
查看>>
java ShutdownHook介绍与使用
查看>>
Eclipse的 window-->preferences里面没有Android选项
查看>>
《麦田里的守望者》--[美]杰罗姆·大卫·塞林格
查看>>
遇到的那些坑
查看>>
央行下属的上海资信网络金融征信系统（NFCS）签约机构数量突破800家
查看>>
[转] Lazy evaluation
查看>>
常用查找算法总结
查看>>
grep 零宽断言
查看>>
被神话的大数据——从大数据（big data）到深度数据（deep data）思维转变
查看>>
修改校准申请遇到的问题
查看>>
【DL-CV】浅谈GoogLeNet（咕咕net）
查看>>
python大佬养成计划----win下对数据库的操作
查看>>
喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！
当前时间: 2024-12-25 16:53:52   当前IP: 18.119.119.191   联系邮箱:javaeecc@qq.com     Copyright © 2020 - 2022 baihongyu.com 京ICP备2021015314号-2
强烈建议你试试无所不能的CHAT-GPT，快点击我
强烈建议你试试无所不能的CHAT-GPT，快点击我