jmf实现视频通话

最新推荐文章于 2018-06-19 22:13:18 发布
最新推荐文章于 2018-06-19 22:13:18 发布
阅读量1.7k 收藏 5
点赞数
分类专栏： java 文章标签： null integer import session stream string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ycb1689/article/details/8073063
版权

MediaTransmit

package test.video;

import java.awt.Dimension;
import java.io.IOException;
import java.net.InetAddress;
import java.util.Vector;

import javax.media.CaptureDeviceInfo;
import javax.media.Codec;
import javax.media.Control;
import javax.media.Controller;
import javax.media.ControllerClosedEvent;
import javax.media.ControllerEvent;
import javax.media.ControllerListener;
import javax.media.Format;
import javax.media.IncompatibleSourceException;
import javax.media.Manager;
import javax.media.MediaLocator;
import javax.media.NoProcessorException;
import javax.media.Owned;
import javax.media.Player;
import javax.media.Processor;
import javax.media.cdm.CaptureDeviceManager;
import javax.media.control.QualityControl;
import javax.media.control.TrackControl;
import javax.media.format.AudioFormat;
import javax.media.format.VideoFormat;
import javax.media.protocol.ContentDescriptor;
import javax.media.protocol.DataSource;
import javax.media.protocol.PushBufferDataSource;
import javax.media.protocol.PushBufferStream;
import javax.media.protocol.SourceCloneable;
import javax.media.rtp.RTPManager;
import javax.media.rtp.SendStream;
import javax.media.rtp.SessionAddress;
import javax.swing.JFrame;
   
public class MediaTransmit {    
   
    private String ipAddress;    
    private int portBase;    
    private MediaLocator audioLocator = null, vedioLocator = null;    
    private Processor audioProcessor = null;    
    private Processor videoProcessor = null;    
    private DataSource audioDataLocal = null, videoDataLocal = null;    
    private DataSource audioDataOutput = null, videoDataOutput = null;    
    private RTPManager rtpMgrs[];    
    private DataSource mediaData = null;    
    private DataSource dataLocalClone = null;    
   
    private PlayPane playFrame;    
   
    public MediaTransmit(String ipAddress, String pb) {    
        this.ipAddress = ipAddress;    
        Integer integer = Integer.valueOf(pb);    
        if (integer != null) {    
            this.portBase = integer.intValue();    
        }    
        // /    
        playFrame = new PlayPane();    
        JFrame jf = new JFrame("视频实例");    
   
        jf.add(playFrame);    
        jf.pack();    
        jf.setLocationRelativeTo(null);    
        jf.setDefaultCloseOperation(3);    
        jf.setVisible(true);    
        //     
        Vector<CaptureDeviceInfo> video = CaptureDeviceManager    
                .getDeviceList(new VideoFormat(null));    
        Vector<CaptureDeviceInfo> audio = CaptureDeviceManager    
                .getDeviceList(new AudioFormat(AudioFormat.LINEAR, 44100, 16, 2));    
        // MediaLocator mediaLocator = new    
        // MediaLocator("file:/C:/纯音乐 - 忧伤还是快乐.mp3");    
        if (audio != null && audio.size() > 0) {    
            audioLocator = ((CaptureDeviceInfo) audio.get(0)).getLocator();    
            if ((audioProcessor = createProcessor(audioLocator)) != null) {    
                audioDataLocal = mediaData;    
                audioDataOutput = audioProcessor.getDataOutput();    
            }    
        } else {    
            System.out.println("******错误：没有检测到您的音频采集设备！！！");    
        }    
        // /    
        if (video != null && video.size() > 0) {    
            vedioLocator = ((CaptureDeviceInfo) video.get(0)).getLocator();    
            if ((videoProcessor = createProcessor(vedioLocator)) != null) {    
                videoDataLocal = mediaData;    
                videoDataOutput = videoProcessor.getDataOutput();    
            }    
        } else {    
            System.out.println("******错误：没有检测到您的视频设备！！！");    
        }    
        // /    
        final DataSource[] dataSources = new DataSource[2];    
        dataSources[0] = audioDataLocal;    
        dataSources[1] = videoDataLocal;    
        try {    
            DataSource dsLocal = Manager.createMergingDataSource(dataSources);    
            if (dsLocal != null) {
				playFrame.localPlay(dsLocal);  
			}
              
        } catch (IncompatibleSourceException e) {    
            e.printStackTrace();    
            return;    
        }    
        // 远程传输    
        dataSources[1] = audioDataOutput;    
        dataSources[0] = videoDataOutput;    
   
        try {    
            DataSource dsoutput = Manager.createMergingDataSource(dataSources);    
            createTransmitter(dsoutput);    
        } catch (IncompatibleSourceException e) {    
            e.printStackTrace();    
            return;    
        }    
        if (audioProcessor != null) {
			audioProcessor.start(); 
		} 
        if (videoProcessor != null) {
        	videoProcessor.start(); 
		}
               
    }    
   
    private Processor createProcessor(MediaLocator locator) {    
        Processor processor = null;    
        if (locator == null)    
            return null;    
        // 通过设备定位器得到数据源，    
        try {    
            mediaData = Manager.createDataSource(locator);    
            // 创建可克隆数据源    
            mediaData = Manager.createCloneableDataSource(mediaData);    
            // 克隆数据源，用于传输到远程    
            dataLocalClone = ((SourceCloneable) mediaData).createClone();    
        } catch (Exception e) {    
            e.printStackTrace();    
            return null;    
        }    
        try {    
            processor = javax.media.Manager.createProcessor(dataLocalClone);    
   
        } catch (NoProcessorException npe) {    
            npe.printStackTrace();    
            return null;    
        } catch (IOException ioe) {    
            return null;    
        }    
        boolean result = waitForState(processor, Processor.Configured);    
        if (result == false)    
            return null;    
   
        TrackControl[] tracks = processor.getTrackControls();    
        if (tracks == null || tracks.length < 1)    
            return null;    
        ContentDescriptor cd = new ContentDescriptor(ContentDescriptor.RAW_RTP);    
        processor.setContentDescriptor(cd);    
        Format supportedFormats[];    
        Format chosen;    
        boolean atLeastOneTrack = false;    
        for (int i = 0; i < tracks.length; i++) {    
            if (tracks[i].isEnabled()) {    
                supportedFormats = tracks[i].getSupportedFormats();    
                if (supportedFormats.length > 0) {    
                    if (supportedFormats[0] instanceof VideoFormat) {    
                        chosen = checkForVideoSizes(tracks[i].getFormat(),    
                                supportedFormats[0]);    
                    } else   
                        chosen = supportedFormats[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 null;    
        result = waitForState(processor, Controller.Realized);    
        if (result == false)    
            return null;    
        setJPEGQuality(processor, 0.5f);    
   
        return processor;    
    }    
   
    private String createTransmitter(DataSource dataOutput) {    
        PushBufferDataSource pbds = (PushBufferDataSource) dataOutput;  
        if (pbds != null) {

            PushBufferStream pbss[] = pbds.getStreams();    
            System.out.println("pbss.length:" + pbss.length);    
            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;    
                    SessionAddress localAddr = new SessionAddress(    
                            InetAddress.getLocalHost(), port);    
                    SessionAddress destAddr = new SessionAddress(    
                            InetAddress.getByName(ipAddress), port);    
                    rtpMgrs[i].initialize(localAddr);    
                    rtpMgrs[i].addTarget(destAddr);    
                    System.out.println("Created RTP session: "   
                            + InetAddress.getLocalHost() + " " + port);    
                    sendStream = rtpMgrs[i].createSendStream(dataOutput, i);    
                    sendStream.start();    
                } catch (Exception e) {    
                    e.printStackTrace();    
                    return e.getMessage();    
                }    
            }   
		}
        return null;    
    }    
    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)) {    
            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)) {    
            if (size.width < 128) {    
                width = 128;    
                height = 96;    
            } else if (size.width < 176) {    
                width = 176;    
                height = 144;    
            } else {    
                width = 352;    
                height = 288;    
            }    
        } else {    
            return supported;    
        }    
   
        return (new VideoFormat(null, new Dimension(width, height),    
                Format.NOT_SPECIFIED, null, Format.NOT_SPECIFIED))    
                .intersects(supported);    
    }    
    void setJPEGQuality(Player p, float val) {    
   
        Control cs[] = p.getControls();    
        QualityControl qc = null;    
        VideoFormat jpegFmt = new VideoFormat(VideoFormat.JPEG);    
        for (int i = 0; i < cs.length; i++) {    
   
            if (cs[i] instanceof QualityControl && cs[i] instanceof Owned) {    
                Object owner = ((Owned) cs[i]).getOwner();    
                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;    
            }    
        }    
    }    
    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;    
        if (state == Processor.Configured) {    
            p.configure();    
        } else if (state == Processor.Realized) {    
            p.realize();    
        }    
        while (p.getState() < state && !failed) {    
            synchronized (getStateLock()) {    
                try {    
                    getStateLock().wait();    
                } catch (InterruptedException ie) {    
                    return false;    
                }    
            }    
        }    
   
        if (failed)    
            return false;    
        else   
            return true;    
    }    
    class StateListener implements ControllerListener {    
   
        public void controllerUpdate(ControllerEvent ce) {    
   
            if (ce instanceof ControllerClosedEvent)    
                setFailed();    
   
            if (ce instanceof ControllerEvent) {    
                synchronized (getStateLock()) {    
                    getStateLock().notifyAll();    
                }    
            }    
        }    
    }    
    public static void main(String[] args) {    
        String[] strs = { "localhost", "9994" };    
        new MediaTransmit(strs[0], strs[1]);    
    }    
}


 

package test.video;

import java.net.InetAddress;

import javax.media.ControllerEvent;
import javax.media.ControllerListener;
import javax.media.Player;
import javax.media.control.BufferControl;
import javax.media.protocol.DataSource;
import javax.media.rtp.Participant;
import javax.media.rtp.RTPControl;
import javax.media.rtp.RTPManager;
import javax.media.rtp.ReceiveStream;
import javax.media.rtp.ReceiveStreamListener;
import javax.media.rtp.SessionListener;
import javax.media.rtp.event.ByeEvent;
import javax.media.rtp.event.NewParticipantEvent;
import javax.media.rtp.event.NewReceiveStreamEvent;
import javax.media.rtp.event.ReceiveStreamEvent;
import javax.media.rtp.event.RemotePayloadChangeEvent;
import javax.media.rtp.event.SessionEvent;
import javax.media.rtp.event.StreamMappedEvent;
import javax.swing.JFrame;

import net.sf.fmj.media.rtp.RTPSocketAdapter;
   
   
public class MediaReceive implements ReceiveStreamListener, SessionListener,    
        ControllerListener {    
    String sessions[] = null;    
    RTPManager mgrs[] = null;    
   
    boolean dataReceived = false;    
    Object dataSync = new Object();    
    private PlayPane playFrame;    
   
    public MediaReceive(String sessions[]) {    
        this.sessions = sessions;    
    }    
   
    protected void initialize() {    
        playFrame = new PlayPane();    
        JFrame jf = new JFrame("视频实例");    
   
        jf.add(playFrame);    
        jf.pack();    
        jf.setLocationRelativeTo(null);    
        jf.setDefaultCloseOperation(3);    
        jf.setVisible(true);    
        try {    
            // 每一个session对应一个RTPManager    
            mgrs = new RTPManager[sessions.length];    
            // 创建播放窗口的向量vector    
   
            SessionLabel session = null;    
   
            // Open the RTP sessions.    
            // 针对每一个会话对象进行ip、port和ttl的解析    
            for (int i = 0; i < sessions.length; i++) {    
   
                // Parse the session addresses.    
                // 进行会话对象的解析，得到ip、port和ttl    
                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);    
                // 这对本条会话对象创建RTPManager    
                mgrs[i] = (RTPManager) RTPManager.newInstance();    
                mgrs[i].addSessionListener(this);    
                mgrs[i].addReceiveStreamListener(this);    
   
                // Initialize the RTPManager with the RTPSocketAdapter    
                // 将本机ip和端口号加入RTP会话管理    
                System.out.println("session.addr:" + session.addr);    
                mgrs[i].initialize(new RTPSocketAdapter(InetAddress    
                        .getByName(session.addr), session.port, session.ttl));    
                BufferControl bc = (BufferControl) mgrs[i]    
                        .getControl("javax.media.control.BufferControl");    
                if (bc != null)    
                    bc.setBufferLength(350);    
            }    
   
        } catch (Exception e) {    
            e.printStackTrace();    
        }    
    }    
   
       
    protected void close() {    
   
        // 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;    
            }    
        }    
    }    
   
       
    @SuppressWarnings("deprecation")    
    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);    
        }    
    }    
   
       
    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) {    
            System.out.println("evt instanceof NewReceiveStreamEvent");    
            try {    
                stream = ((NewReceiveStreamEvent) evt).getReceiveStream();    
                final DataSource data = stream.getDataSource();    
   
                // Find out the formats.    
                RTPControl ctl = (RTPControl) data    
                        .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    
                new Thread() {    
                    public void run() {    
                        playFrame.remotePlay(data);    
                    }    
                }.start();    
                // Player p = javax.media.Manager.createPlayer(data);    
                // 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) {    
            System.out.println("evt instanceof StreamMappedEvent");    
            stream = ((StreamMappedEvent) evt).getReceiveStream();    
            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());    
                System.out.println("ds == null" + (ds == null));    
            }    
        }    
   
        else if (evt instanceof ByeEvent) {    
   
            System.err.println("  - Got bye from: "   
                    + participant.getCNAME());    
   
        }    
   
    }    
   
       
    public synchronized void controllerUpdate(ControllerEvent ce) {    
   
        Player p = (Player) ce.getSourceController();    
   
        if (p == null)    
            return;    
   
    }    
   
       
    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);    
                }    
                off = session.indexOf('/');    
                if (off == -1) {    
                    if (!session.equals(""))    
                        addr = session;    
                } else {    
                    addr = session.substring(0, off);    
                    session = session.substring(off + 1);    
                    off = session.indexOf('/');    
                    if (off == -1) {    
                        if (!session.equals(""))    
                            portStr = session;    
                    } else {    
                        portStr = session.substring(0, off);    
                        session = session.substring(off + 1);    
                        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();    
                }    
            }    
        }    
    }    
        
   
    public static void main(String argv[]) {    
        String[] strs = { "125.221.165.126/9994", "125.221.165.126/9996" };    
        MediaReceive avReceive = new MediaReceive(strs);    
        avReceive.initialize();    
   
    }    
}


 

package test.video;
import java.awt.BorderLayout;    
import java.awt.Color;    
import java.awt.Component;    
import java.awt.Dimension;    
import java.awt.FlowLayout;    
import java.awt.Graphics;    
import java.awt.Rectangle;    
import java.awt.event.ActionEvent;    
import java.awt.event.ActionListener;    
import java.io.IOException;    
   
import javax.media.ControllerEvent;    
import javax.media.ControllerListener;    
import javax.media.DataSink;    
import javax.media.NoPlayerException;    
import javax.media.Player;    
import javax.media.Processor;    
import javax.media.protocol.DataSource;    
import javax.swing.ImageIcon;    
import javax.swing.JButton;    
import javax.swing.JPanel;    
   
public class PlayPane extends JPanel {    
    private ImageIcon videoReqIcon = new ImageIcon("videoReq.jpg");    
    private ImageIcon VideolocalIcon = new ImageIcon("localVideo.jpg");    
    private boolean isViewBigPlaying = false;    
    private boolean isViewSmallPlaying = false;    
    private JPanel viewBigPane;    
    private JPanel viewSmallPane;    
    private JPanel controlPane;    
   
    private JButton closeButton;    
   
    private boolean localPlay = false;    
    private boolean remotePlay = false;    
   
    private DataSource localData;    
    private DataSource remoteData;    
   
    private boolean isViewRun = true;    
    private boolean isShow = true;    
    //    
    private Player localPlayer = null;    
    private Player remotePlayer = null;    
    //    
    private Processor videotapeProcessor = null;    
    private Player videotapePlayer = null;    
    private DataSink videotapeFileWriter;    
   
    public PlayPane() {    
        this.setLayout(new BorderLayout());    
        // 视图面板    
        viewBigPane = new JPanel() {    
            public void paintComponent(Graphics g) {    
                super.paintComponent(g);    
                if (!isViewBigPlaying) {    
                    g.drawImage(videoReqIcon.getImage(), 1, 1,    
                            videoReqIcon.getIconWidth(),    
                            videoReqIcon.getIconHeight(), null);    
   
                    g.drawRect(getSmallPlayRec().x - 1,    
                            getSmallPlayRec().y - 1,    
                            getSmallPlayRec().width + 1,    
                            getSmallPlayRec().height + 1);    
                } else {    
   
                }    
            }    
        };    
        viewBigPane.setBackground(Color.black);    
        this.add(viewBigPane, BorderLayout.CENTER);    
        viewBigPane.setLayout(null);    
        // ///    
        viewSmallPane = new JPanel() {    
            public void paintComponent(Graphics g) {    
                super.paintComponent(g);    
                if (!isViewSmallPlaying) {    
                    g.drawImage(VideolocalIcon.getImage(), 0, 0, null);    
                } else {    
   
                }    
            }    
        };    
        viewSmallPane.setBounds(getSmallPlayRec());    
        viewBigPane.add(viewSmallPane);    
        viewSmallPane.setLayout(null);    
   
        // 控制面板组件    
        closeButton = new JButton("挂断");    
        controlPane = new JPanel();    
        controlPane.setLayout(new FlowLayout(FlowLayout.RIGHT, 0, 0));    
        controlPane.add(closeButton);    
        this.add(controlPane, BorderLayout.SOUTH);    
        closeButton.addActionListener(new ActionListener() {    
            public void actionPerformed(ActionEvent e) {    
                if (localPlayer != null) {    
                    localPlayer.stop();    
                }    
                if (remotePlayer != null) {    
                    remotePlayer.stop();    
                }    
                if (videotapePlayer != null) {    
                    videotapePlayer.stop();    
                }    
                if (videotapeProcessor != null) {    
                    videotapeProcessor.stop();    
                }    
                if (videotapeFileWriter != null) {    
                    try {    
                        videotapeFileWriter.stop();    
                        videotapeFileWriter.close();    
                    } catch (IOException e1) {    
                    }    
                }    
            }    
   
        });    
        // this.setMinimumSize(new Dimension(videoReqIcon.getIconWidth()+2,    
        // 241));    
        // this.setPreferredSize(new Dimension(videoReqIcon.getIconWidth()+2,    
        // 241));    
   
    }    
   
    public Dimension getMinimumSize() {    
        System.out    
                .println("controlPane.getHeight():" + controlPane.getHeight());    
        return new Dimension(videoReqIcon.getIconWidth() + 2,    
                videoReqIcon.getIconHeight() + controlPane.getHeight());    
    }    
   
    public Dimension getPreferredSize() {    
        System.out    
                .println("controlPane.getHeight():" + controlPane.getHeight());    
        return new Dimension(videoReqIcon.getIconWidth() + 2,    
                videoReqIcon.getIconHeight()    
                        + controlPane.getPreferredSize().height);    
    }    
   
    public void localPlay(DataSource dataSource) {    
        this.setLocalData(dataSource);    
        try {    
            localPlayer = javax.media.Manager.createPlayer(dataSource);    
   
            localPlayer.addControllerListener(new ControllerListener() {    
                public void controllerUpdate(ControllerEvent e) {    
   
                    if (e instanceof javax.media.RealizeCompleteEvent) {    
                        Component comp = null;    
                        comp = localPlayer.getVisualComponent();    
                        if (comp != null) {    
                            // 将可视容器加到窗体上    
                            comp.setBounds(0, 0, VideolocalIcon.getIconWidth(),    
                                    VideolocalIcon.getIconHeight());    
                            viewSmallPane.add(comp);    
                        }    
                        viewBigPane.validate();    
                    }    
                }    
            });    
            localPlayer.start();    
            localPlay = true;    
        } catch (NoPlayerException e1) {    
            e1.printStackTrace();    
        } catch (IOException e1) {    
            e1.printStackTrace();    
        }    
    }    
   
    private Rectangle getSmallPlayRec() {    
        int bigShowWidth = videoReqIcon.getIconWidth();    
        int bigShowHeight = videoReqIcon.getIconHeight();    
        int smallShowWidth = VideolocalIcon.getIconWidth();    
        int smallShowHeight = VideolocalIcon.getIconHeight();    
        return new Rectangle(bigShowWidth - smallShowWidth - 2, bigShowHeight    
                - smallShowHeight - 2, smallShowWidth, smallShowHeight);    
    }    
   
    public void remotePlay(DataSource dataSource) {    
        this.setLocalData(dataSource);    
        remotePlay = true;    
        try {    
            remotePlayer = javax.media.Manager.createPlayer(dataSource);    
   
            remotePlayer.addControllerListener(new ControllerListener() {    
                public void controllerUpdate(ControllerEvent e) {    
   
                    if (e instanceof javax.media.RealizeCompleteEvent) {    
                        Component comp;    
                        if ((comp = remotePlayer.getVisualComponent()) != null) {    
                            // 将可视容器加到窗体上    
                            comp.setBounds(1, 1, videoReqIcon.getIconWidth(),    
                                    videoReqIcon.getIconHeight());    
                            viewBigPane.add(comp);    
                        }    
                        viewBigPane.validate();    
                    }    
                }    
            });    
            remotePlayer.start();    
            remotePlay = true;    
        } catch (NoPlayerException e1) {    
            e1.printStackTrace();    
        } catch (IOException e1) {    
            e1.printStackTrace();    
        }    
    }    
   
    public void closeViewUI() {    
        isShow = false;    
    }    
   
    public boolean isViewRunning() {    
        return isViewRun;    
    }    
   
    public boolean isShowing() {    
        return isShow;    
    }    
   
    public void localReady() {    
        localPlay = true;    
    }    
   
    public void remoteReady() {    
        remotePlay = true;    
    }    
   
    public boolean isRemotePlay() {    
        return remotePlay;    
    }    
   
    public void setRemotePlay(boolean remotePlay) {    
        this.remotePlay = remotePlay;    
    }    
   
    public DataSource getRemoteData() {    
        return remoteData;    
    }    
   
    public void setRemoteData(DataSource remoteData) {    
        this.remoteData = remoteData;    
    }    
   
    public boolean isLocalPlay() {    
        return localPlay;    
    }    
   
    public void setLocalPlay(boolean localPlay) {    
        this.localPlay = localPlay;    
    }    
   
    public DataSource getLocalData() {    
        return localData;    
    }    
   
    public void setLocalData(DataSource localData) {    
        this.localData = localData;    
    }    
   
}


 

运行的时候先运行MediaTransmit类，后运行MediaReceive类

 

ycb1689
关注
专栏目录
jmf的视频聊天
12-11
java开发的聊天软件，包括基于jmf的视频聊天模块，帮转，方便大家一起学习进步。
论文研究-基于JMF的Internet可视通话软件的设计与实现.pdf
07-22
随着计算机网络和多媒体技术的飞速发展，实时的视频通话软件已经成为人们日常工作和生活中不可或缺的一部分。本文重点研究了基于Java媒体框架（Java Media Framework，简称JMF）开发的Internet可视通话软件的设计与...
JMF视频音频通信( 图+源码 ）
梅竹寒香
06-20 306
 最近由于做山寨QQ视频聊天的需要，做了一个视频通信窗口组件。现在分享一下供大家学习……   原创文章，转载请标明出处！谢谢！ 工程文件下载地址：http://download.csdn.net/source/3378150  本文地址： http://mzhx-com.iteye.com/blog/1098698   效果图如下：       三个类 源代码如下：   p...
使用JMF进行视频、音频的采集与实时传送
hangke的专栏
01-24 3436
许多朋友在找关于网络视频会议的资料，希望对这方面感兴趣的朋友有所帮助。也真诚希望大家多多交流。 　　一.简介 　　1.1JMF 体系结构简介 　　在开发JMF 应用程序之前要完全理解JMF 的体系架构、接口和类。就拿我们的家用摄像机系统作个例子。首先用摄像机拍摄内容，拍摄下来的内容录制在DV带中。DV带可以放在放像机里播放、放像机提供视频信号给电视机，提供音频信号给音箱，这样我们就可以在电视机上看
利用JMF播放视频
weixin_34122810的博客
04-30 121
本文主要使用JMF来实现在一个Applet中播放本地MPEG格式视频文件。并给出一个实例。 author: ZJ 06-11-15 Blog: [url]http://zhangjunhd.blog.51cto.com/[/url] 实现具体步骤： 1． 确定视频文件的位置 MediaLocator mrl=new MediaLocator(new ja...
JMF 的音视频聊天实现
weixin_34217773的博客
12-02 676
java media framework （JMF ）为java 在多媒体领域的开发提供了便利的平台。本文基于JMF 遵从RTP 协议对音/视频聊天进行了实现，解决了会话的管理和流媒体的发送、接收、播放等关键问题。 1.引言 如今VoIP 已经成为一种经济高效的通讯方式。不过只有语音方面的交互已经不能满足人们的需求。只闻其声不见其人显得过于单调。音/视频聊天在这种需求...
基于JMF 的Internet 可视通话软件的设计与实现 (2005年)
05-18
在软件开发中，需要特别关注实时通信中的数据传输效率和延迟问题，以及保证视频通话的清晰度和流畅度。JMF的跨平台特性让可视通话软件能够在不同的操作系统上运行，大大降低了用户的使用门槛。 总之，基于JMF的...
JMF的音视频实时交互及存储的具体实现
06-20
3. 视频聊天应用：如Skype、QQ等即时通讯软件的早期版本可能基于JMF实现了音视频通话功能。 六、JMF的局限性和替代方案 虽然JMF提供了一套全面的多媒体处理能力，但其更新较慢，不支持新的媒体格式和编码标准。因此...
JMF-RTP.rar_jmf_rtp java_rtp 语音视频_视频传输_视频语音
09-14
通过集成JMF和RTP，开发者可以构建能够进行音视频通话、直播或者点对点传输的应用。JMF提供了API来封装RTP的使用，使得开发者可以更方便地处理RTP的数据包发送和接收。 **基于JMF RTP的音视频传输过程** 1. **初始...
基于android的视频通话系统的设计与实现毕业设计论文.doc
最新发布
07-11
系统使用 RTP/RTCP 协议来实现视频通话，并使用 H.264 编解码器来编解码视频流。系统的实现通过需求分析、详细设计、编码实现、单元测试以及集成测试等过程。本系统的实现为人们提供了一种跨平台的视频通话解决方案...
Jmf实现的视频聊天系统
01-16
java实现的视频聊天系统，需要32位JDK，32位系统
jmf播放视频视频，录制视频
02-25
jmf播放视频视频，录制视频
java利用JMF框架实现视频传输的完整代码
04-05
JMF是java的多媒体框架，该资源内含对jmf的完整的应用代码。实现了视频的完整传输。
基于JMF的语音聊天系统
12-21
本系统采用客户机/服务器架构模式通过Java提供的Soket类来连接客户机和服务器并使客户机和服务器之间相互通信，由于聊天是多点对多点的而Java提供的多线程功能用多线程可完成多点对多点的聊天。
JMF实现实时视频语音的发布和接收
05-21
JMF实现实时视频语音的发布和接收,视频质量清晰，语音流畅。
JMF--视频通话篇
白林的专栏
04-09 3012
　　Java媒体框架（JMF）：该核心框架支持不同媒体（如：音频输出和视频输出）间的时钟同步。它是一个标准的扩展框架，允许用户制作纯音频流和视频流。　　这里只是说模拟视频通话的过程，而关于JMF的学习介绍请另见其他文章。　　2.JMF在处理对媒体数据方面体现了很强的功能，MyQQ的制作在这学期的前段时间已经完成了视频通话功能的模拟。语音聊天不太直观，无法截图，但其原理也和视频通话一样，
JMF(视频传输)
xu的blog
11-05 2003
导读： 　　//转自：陈开源的专栏 　　 　　 　　 　　 　　/**//*在coogo上面看到有人在做项目，是多人视频聊天系统。要我做的感觉是很麻烦的一块。视频传输。我是还没有接触过jmf啊。一开始的时候就是只能捕获摄像头，怎么都不能传输，网络上面这方面的资料也比较上，找了很就都没有找到。没有办法，只有到sun公司去看JMF 2.1.1 Solutions。看了半天的例子，终于算是拼凑出
基于JMF视频聊天
qq_38619449的博客
06-19 477
java media framework  （JMF ）为java 在多媒体领域的开发提供了便利的平台。本文基于JMF 遵从RTP 协议对音/视频聊天进行了实现，解决了会话的管理和流媒体的发送、接收、播放等关键问题。1.引言如今VoIP  已经成为一种经济高效的通讯方式。不过只有语音方面的交互已经不能满足人们的需求。只闻其声不见其人显得过于单调。音/视频聊天在这种需求下应运而生。音/视频聊天的关键...
使用JMF实现音视频同步播放的研究
"基于JMF的音视频同步播放技术，主要介绍了如何利用Java Media Framework (JMF) 实现音视频的同步播放。JMF是由Sun、IBM、Intel等公司共同开发的多媒体框架，支持多种媒体协议和压缩标准，提供播放、转码、捕获和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值