org.webrtc.VideoTrack Java Examples

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // create PeerConnectionFactory
    PeerConnectionFactory.InitializationOptions initializationOptions =
            PeerConnectionFactory.InitializationOptions.builder(this).createInitializationOptions();
    PeerConnectionFactory.initialize(initializationOptions);
    PeerConnectionFactory peerConnectionFactory = PeerConnectionFactory.builder().createPeerConnectionFactory();

    // create AudioSource
    AudioSource audioSource = peerConnectionFactory.createAudioSource(new MediaConstraints());
    AudioTrack audioTrack = peerConnectionFactory.createAudioTrack("101", audioSource);

    EglBase.Context eglBaseContext = EglBase.create().getEglBaseContext();

    SurfaceTextureHelper surfaceTextureHelper = SurfaceTextureHelper.create("CaptureThread", eglBaseContext);
    // create VideoCapturer
    VideoCapturer videoCapturer = createCameraCapturer();
    VideoSource videoSource = peerConnectionFactory.createVideoSource(videoCapturer.isScreencast());
    videoCapturer.initialize(surfaceTextureHelper, getApplicationContext(), videoSource.getCapturerObserver());
    videoCapturer.startCapture(480, 640, 30);

    SurfaceViewRenderer localView = findViewById(R.id.localView);
    localView.setMirror(true);
    localView.init(eglBaseContext, null);

    // create VideoTrack
    VideoTrack videoTrack = peerConnectionFactory.createVideoTrack("100", videoSource);
    // display in localView
    videoTrack.addSink(localView);
}
 

private void addLocalStreams(Context context) {
    AudioManager audioManager = ((AudioManager) context.getSystemService(Context.AUDIO_SERVICE));
    // TODO(fischman): figure out how to do this Right(tm) and remove the suppression.
    @SuppressWarnings("deprecation")
    boolean isWiredHeadsetOn = audioManager.isWiredHeadsetOn();
    audioManager.setMode(isWiredHeadsetOn ? AudioManager.MODE_IN_CALL : AudioManager.MODE_IN_COMMUNICATION);
    audioManager.setSpeakerphoneOn(!isWiredHeadsetOn);

    localStream = peerConnectionFactory.createLocalMediaStream("ARDAMS");

    if (!audioOnly) {
        VideoCapturer capturer = getVideoCapturer();
        MediaConstraints videoConstraints = new MediaConstraints();
        videoSource = peerConnectionFactory.createVideoSource(capturer, videoConstraints);
        VideoTrack videoTrack = peerConnectionFactory.createVideoTrack("ARDAMSv0", videoSource);
        videoTrack.addRenderer(new VideoRenderer(localRender));
        localStream.addTrack(videoTrack);
    }

    localStream.addTrack(peerConnectionFactory.createAudioTrack("ARDAMSa0", peerConnectionFactory.createAudioSource(new MediaConstraints())));

    peerConnection.addStream(localStream);
}
 

@Override
public void onAddStream(MediaStream stream) {
    for (AudioTrack audioTrack : stream.audioTracks) {
        audioTrack.setEnabled(true);
    }

    if (stream.videoTracks != null && stream.videoTracks.size() == 1) {
        VideoTrack videoTrack = stream.videoTracks.get(0);
        videoTrack.setEnabled(true);

        videoTrack.addSink(new VideoSink() {
            @Override
            public void onFrame(VideoFrame videoFrame) {

                if (G.onVideoCallFrame != null) {
                    G.onVideoCallFrame.onRemoteFrame(videoFrame);
                }
            }
        });

    }


}
 

protected void addStream(final MediaStream mediaStream) {
    DCHECK(mediaStream);
    DCHECK(pcExecutor);
    pcExecutor.execute(() -> {
        if (disposed()) {
            return;
        }
        ArrayList<String> streamIds = new ArrayList<>();
        streamIds.add(mediaStream.getId());
        for (AudioTrack audioTrack : mediaStream.audioTracks) {
            RtpSender audioSender = peerConnection.addTrack(audioTrack, streamIds);
            audioRtpSenders.put(mediaStream.getId(), audioSender);
        }
        for (VideoTrack videoTrack : mediaStream.videoTracks) {
            RtpSender videoSender = peerConnection.addTrack(videoTrack, streamIds);
            videoRtpSenders.put(mediaStream.getId(), videoSender);
        }
    });
}
 

public void gotRemoteStream(MediaStream stream, final RemoteParticipant remoteParticipant) {
    final VideoTrack videoTrack = stream.videoTracks.getFirst();
    runOnUiThread(new Runnable() {
        @Override
        public void run() {
            remoteRenderer = new VideoRenderer(remoteParticipant.getVideoView());
            remoteParticipant.getVideoView().setVisibility(View.VISIBLE);
            videoTrack.addRenderer(remoteRenderer);
            MediaStream mediaStream = peersManager.getPeerConnectionFactory().createLocalMediaStream("105");
            remoteParticipant.setMediaStream(mediaStream);
            mediaStream.addTrack(peersManager.getLocalAudioTrack());
            mediaStream.addTrack(peersManager.getLocalVideoTrack());
            remoteParticipant.getPeerConnection().removeStream(mediaStream);
            remoteParticipant.getPeerConnection().addStream(mediaStream);
        }
    });
}
 

/**
 * 创建本地流
 */
public void createLocalStream() {
    _localStream = _factory.createLocalMediaStream("ARDAMS");
    // 音频
    audioSource = _factory.createAudioSource(createAudioConstraints());
    _localAudioTrack = _factory.createAudioTrack(AUDIO_TRACK_ID, audioSource);
    _localStream.addTrack(_localAudioTrack);

    // 视频
    if (!mIsAudioOnly) {
        captureAndroid = createVideoCapture();
        surfaceTextureHelper = SurfaceTextureHelper.create("CaptureThread", mRootEglBase.getEglBaseContext());
        videoSource = _factory.createVideoSource(captureAndroid.isScreencast());

        captureAndroid.initialize(surfaceTextureHelper, mContext, videoSource.getCapturerObserver());
        captureAndroid.startCapture(VIDEO_RESOLUTION_WIDTH, VIDEO_RESOLUTION_HEIGHT, FPS);


        VideoTrack _localVideoTrack = _factory.createVideoTrack(VIDEO_TRACK_ID, videoSource);
        _localStream.addTrack(_localVideoTrack);
    }

}
 

private synchronized PeerConnection getOrCreatePeerConnection(String socketId) {
    PeerConnection peerConnection = peerConnectionMap.get(socketId);
    if(peerConnection != null) {
        return peerConnection;
    }
    peerConnection = peerConnectionFactory.createPeerConnection(iceServers, new PeerConnectionAdapter("PC:" + socketId) {
        @Override
        public void onIceCandidate(IceCandidate iceCandidate) {
            super.onIceCandidate(iceCandidate);
            SignalingClient.get().sendIceCandidate(iceCandidate, socketId);
        }

        @Override
        public void onAddStream(MediaStream mediaStream) {
            super.onAddStream(mediaStream);
            VideoTrack remoteVideoTrack = mediaStream.videoTracks.get(0);
            runOnUiThread(() -> {
                remoteVideoTrack.addSink(remoteViews[remoteViewsIndex++]);
            });
        }
    });
    peerConnection.addStream(mediaStream);
    peerConnectionMap.put(socketId, peerConnection);
    return peerConnection;
}
 

private void call() {
    List<PeerConnection.IceServer> iceServers = new ArrayList<>();
    iceServers.add(PeerConnection.IceServer.builder("stun:stun.l.google.com:19302").createIceServer());
    peerConnection = peerConnectionFactory.createPeerConnection(iceServers, new PeerConnectionAdapter("localconnection") {
        @Override
        public void onIceCandidate(IceCandidate iceCandidate) {
            super.onIceCandidate(iceCandidate);
            SignalingClient.get().sendIceCandidate(iceCandidate);
        }

        @Override
        public void onAddStream(MediaStream mediaStream) {
            super.onAddStream(mediaStream);
            VideoTrack remoteVideoTrack = mediaStream.videoTracks.get(0);
            runOnUiThread(() -> {
                remoteVideoTrack.addSink(remoteView);
            });
        }
    });

    peerConnection.addStream(mediaStream);
}
 

@Override
public void onAddStream(MediaStream stream) {
    ALog.logForSecret(TAG, "onAddStream:" + stream);

    for (AudioTrack audioTrack : stream.audioTracks) {
        audioTrack.setEnabled(true);
    }

    if (stream.videoTracks != null && stream.videoTracks.size() == 1) {
        VideoTrack videoTrack = stream.videoTracks.get(0);
        videoTrack.setEnabled(true);
        videoTrack.addSink(remoteRenderer);
    }
}
 

@Nullable
private VideoTrack createVideoTrack(VideoCapturer capturer) {
    surfaceTextureHelper =
            SurfaceTextureHelper.create("CaptureThread", rootEglBase.getEglBaseContext());
    videoSource = factory.createVideoSource(capturer.isScreencast());
    capturer.initialize(surfaceTextureHelper, appContext, videoSource.getCapturerObserver());
    capturer.startCapture(videoWidth, videoHeight, videoFps);

    localVideoTrack = factory.createVideoTrack(VIDEO_TRACK_ID, videoSource);
    localVideoTrack.setEnabled(renderVideo);
    localVideoTrack.addSink(localRender);
    return localVideoTrack;
}
 

private VideoTrack createVideoTrack(VideoCapturer capturer) {
  videoSource = factory.createVideoSource(capturer);
  capturer.startCapture(videoWidth, videoHeight, videoFps);

  localVideoTrack = factory.createVideoTrack(VIDEO_TRACK_ID, videoSource);
  localVideoTrack.setEnabled(renderLocalVideo);
  localVideoTrack.addSink(localRender);
  return localVideoTrack;
}
 

private static void addSink(final VideoTrack videoTrack, final SurfaceViewRenderer surfaceViewRenderer) {
    try {
        videoTrack.addSink(surfaceViewRenderer);
    } catch (final IllegalStateException e) {
        Log.e(Config.LOGTAG, "possible race condition on trying to display video track. ignoring", e);
    }
}
 

private void releaseVideoTracks(final JingleRtpConnection jingleRtpConnection) {
    final Optional<VideoTrack> remoteVideo = jingleRtpConnection.getRemoteVideoTrack();
    if (remoteVideo.isPresent()) {
        remoteVideo.get().removeSink(binding.remoteVideo);
    }
    final Optional<VideoTrack> localVideo = jingleRtpConnection.getLocalVideoTrack();
    if (localVideo.isPresent()) {
        localVideo.get().removeSink(binding.localVideo);
    }
}
 

void setVideoEnabled(final boolean enabled) {
    final VideoTrack videoTrack = this.localVideoTrack;
    if (videoTrack == null) {
        throw new IllegalStateException("Local video track does not exist");
    }
    videoTrack.setEnabled(enabled);
}
 

boolean isVideoEnabled() {
    final VideoTrack videoTrack = this.localVideoTrack;
    if (videoTrack == null) {
        throw new IllegalStateException("Local video track does not exist");
    }
    return videoTrack.enabled();
}
 

private Optional<VideoTrack> getRemoteVideoTrack() {
    final JingleRtpConnection connection = this.rtpConnectionReference != null ? this.rtpConnectionReference.get() : null;
    if (connection == null) {
        return Optional.absent();
    }
    return connection.getRemoteVideoTrack();
}
 

private Optional<VideoTrack> getLocalVideoTrack() {
    final JingleRtpConnection connection = this.rtpConnectionReference != null ? this.rtpConnectionReference.get() : null;
    if (connection == null) {
        return Optional.absent();
    }
    return connection.getLocalVideoTrack();
}
 

private void releaseVideoTracks(final JingleRtpConnection jingleRtpConnection) {
    final Optional<VideoTrack> remoteVideo = jingleRtpConnection.getRemoteVideoTrack();
    if (remoteVideo.isPresent()) {
        remoteVideo.get().removeSink(binding.remoteVideo);
    }
    final Optional<VideoTrack> localVideo = jingleRtpConnection.getLocalVideoTrack();
    if (localVideo.isPresent()) {
        localVideo.get().removeSink(binding.localVideo);
    }
}
 

private static void addSink(final VideoTrack videoTrack, final SurfaceViewRenderer surfaceViewRenderer) {
    try {
        videoTrack.addSink(surfaceViewRenderer);
    } catch (final IllegalStateException e) {
        Log.e(Config.LOGTAG, "possible race condition on trying to display video track. ignoring", e);
    }
}
 

void setVideoEnabled(final boolean enable) {
    executor.execute(new Runnable() {
        @Override
        public void run() {
            renderVideo = enable;
            if (localVideoTrack != null) {
                localVideoTrack.setEnabled(renderVideo);
            }
            for (VideoTrack tv : remoteVideoTracks.values()) {
                tv.setEnabled(renderVideo);
            }
        }
    });
}
 

public void run() {
    Log.d(TAG, "Attaching VideoRenderer to remote stream (" + remoteStream + ")");

    // Check if the remote stream has a video track
    if (remoteStream.videoTracks.size() == 1) {
        // Get the video track
        VideoTrack remoteVideoTrack = remoteStream.videoTracks.get(0);
        // Set video track enabled if we have enabled video rendering
        remoteVideoTrack.setEnabled(renderVideo);

        VideoRenderer videoRenderer = remoteVideoRenderers.get(remoteRender);
        if (videoRenderer != null) {
            MediaStream mediaStream = remoteVideoMediaStreams.get(videoRenderer);
            if (mediaStream != null) {
                VideoTrack videoTrack = remoteVideoTracks.get(mediaStream);
                if (videoTrack != null) {
                    videoTrack.removeRenderer(videoRenderer);
                }
            }
        }

        VideoRenderer newVideoRenderer = new VideoRenderer(remoteRender);
        remoteVideoTrack.addRenderer(newVideoRenderer);
        remoteVideoRenderers.put(remoteRender, newVideoRenderer);
        remoteVideoMediaStreams.put(newVideoRenderer, remoteStream);
        remoteVideoTracks.put(remoteStream, remoteVideoTrack);
        Log.d(TAG, "Attached.");
    }
}
 

private VideoTrack createCapturerVideoTrack(VideoCapturerAndroid capturer) {
    videoSource = factory.createVideoSource(capturer, videoConstraints);
    localVideoTrack = factory.createVideoTrack(VIDEO_TRACK_ID, videoSource);
    localVideoTrack.setEnabled(renderVideo);
    localVideoTrack.addRenderer(new VideoRenderer(localRender));
    return localVideoTrack;
}
 

private Optional<VideoTrack> getRemoteVideoTrack() {
    final JingleRtpConnection connection = this.rtpConnectionReference != null ? this.rtpConnectionReference.get() : null;
    if (connection == null) {
        return Optional.absent();
    }
    return connection.getRemoteVideoTrack();
}
 

@Override
public void onAddTrack(RtpReceiver rtpReceiver, MediaStream[] mediaStreams) {
    MediaStreamTrack track = rtpReceiver.track();
    if (track instanceof VideoTrack) {
        Log.i(TAG, "onAddVideoTrack");
        VideoTrack remoteVideoTrack = (VideoTrack) track;
        remoteVideoTrack.setEnabled(true);
        ProxyVideoSink videoSink = new ProxyVideoSink();
        videoSink.setTarget(mRemoteSurfaceView);
        remoteVideoTrack.addSink(videoSink);
    }
}
 

void setVideoEnabled(final boolean enabled) {
    final VideoTrack videoTrack = this.localVideoTrack;
    if (videoTrack == null) {
        throw new IllegalStateException("Local video track does not exist");
    }
    videoTrack.setEnabled(enabled);
}
 

private VideoTrack createVideoTrack(VideoCapturer capturer) {
  videoSource = factory.createVideoSource(capturer);
  capturer.startCapture(videoWidth, videoHeight, videoFps);

  localVideoTrack = factory.createVideoTrack(VIDEO_TRACK_ID, videoSource);
  localVideoTrack.setEnabled(renderVideo);
  localVideoTrack.addSink(localRender);
  return localVideoTrack;
}
 

MediaStream createMediaStream(VideoCapturer videoCapturer,
        AudioTrackConstraints audioMediaConstraints) {
    RCHECK(videoCapturer != null || audioMediaConstraints != null);

    String label = UUID.randomUUID().toString();
    MediaStream mediaStream = PCFactoryProxy.instance().createLocalMediaStream(label);

    if (videoCapturer != null) {
        VideoSource videoSource = PCFactoryProxy.instance().createVideoSource(
                videoCapturer.isScreencast());
        SurfaceTextureHelper helper = SurfaceTextureHelper.create("CT", localContext);
        videoCapturer.initialize(helper, ContextInitialization.context,
                videoSource.getCapturerObserver());
        videoCapturer.startCapture(videoCapturer.getWidth(),
                videoCapturer.getHeight(),
                videoCapturer.getFps());
        VideoTrack videoTrack = PCFactoryProxy.instance().createVideoTrack(label + "v0",
                videoSource);
        videoTrack.setEnabled(true);
        mediaStream.addTrack(videoTrack);
        unsharedVideoSources.put(label, videoSource);
    }

    if (audioMediaConstraints != null) {
        if (sharedAudioSource == null) {
            sharedAudioSource = PCFactoryProxy.instance().createAudioSource(
                    audioMediaConstraints.convertToWebRTCConstraints());
        }
        audioSourceRef++;
        mediaStream.addTrack(
                PCFactoryProxy.instance().createAudioTrack(label + "a0", sharedAudioSource));
    }

    return mediaStream;
}
 

boolean isVideoEnabled() {
    final VideoTrack videoTrack = this.localVideoTrack;
    if (videoTrack == null) {
        throw new IllegalStateException("Local video track does not exist");
    }
    return videoTrack.enabled();
}
 

private VideoTrack createVideoTrack(VideoCapturer capturer) {
  videoSource = factory.createVideoSource(capturer);
  capturer.startCapture(videoWidth, videoHeight, videoFps);

  localVideoTrack = factory.createVideoTrack(VIDEO_TRACK_ID, videoSource);
  localVideoTrack.setEnabled(renderVideo);
  localVideoTrack.addRenderer(new VideoRenderer(localRender));
  return localVideoTrack;
}
 

private VideoTrack createVideoTrack(VideoCapturerAndroid capturer) {
    videoSource = factory.createVideoSource(capturer, videoConstraints);

    localVideoTrack = factory.createVideoTrack(VIDEO_TRACK_ID, videoSource);
    localVideoTrack.setEnabled(renderVideo);
    localVideoTrack.addRenderer(new VideoRenderer(localRender));
    return localVideoTrack;
}