org.webrtc.VideoFrame Java Examples

private void updateFrameDimensionsAndReportEvents(VideoFrame frame) {
  synchronized(this.layoutLock) {
    if (!this.isRenderingPaused) {
      if (!this.isFirstFrameRendered) {
        this.isFirstFrameRendered = true;
        Log.d(TAG, "Reporting first rendered frame.");
        if (this.rendererEvents != null) {
          this.rendererEvents.onFirstFrameRendered();
        }
      }

      if (this.rotatedFrameWidth != frame.getRotatedWidth() || this.rotatedFrameHeight != frame.getRotatedHeight() || this.frameRotation != frame.getRotation()) {
        Log.d(TAG, "Reporting frame resolution changed to " + frame.getBuffer().getWidth() + "x" + frame.getBuffer().getHeight() + " with rotation " + frame.getRotation());
        if (this.rendererEvents != null) {
          this.rendererEvents.onFrameResolutionChanged(frame.getBuffer().getWidth(), frame.getBuffer().getHeight(), frame.getRotation());
        }

        this.rotatedFrameWidth  = frame.getRotatedWidth();
        this.rotatedFrameHeight = frame.getRotatedHeight();
        this.frameRotation      = frame.getRotation();
      }
    }
  }
}
 

private void addVideoTrack(MediaStream mediaStream) {

        if (callTYpe == ProtoSignalingOffer.SignalingOffer.Type.VIDEO_CALLING) {
            videoCapturer = createCameraCapturer(new Camera1Enumerator(false));
            videoSource = peerConnectionFactoryInstance().createVideoSource(videoCapturer);
            videoCapturer.startCapture(VIDEO_RESOLUTION_WIDTH, VIDEO_RESOLUTION_HEIGHT, FPS);
            videoTrackFromCamera = peerConnectionFactoryInstance().createVideoTrack(VIDEO_TRACK_ID, videoSource);
            videoTrackFromCamera.setEnabled(true);

            videoTrackFromCamera.addSink(new VideoSink() {
                @Override
                public void onFrame(VideoFrame videoFrame) {
                    if (G.onVideoCallFrame != null) {
                        G.onVideoCallFrame.onPeerFrame(videoFrame);
                    }
                }
            });

            mediaStream.addTrack(videoTrackFromCamera);
        }
    }
 

@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);
                }
            }
        });

    }


}
 

@Override
public void onFrameCaptured(VideoFrame frame) {
  final NativeAndroidVideoTrackSource.FrameAdaptationParameters parameters =
      nativeAndroidVideoTrackSource.adaptFrame(frame);
  if (parameters == null) {
    // Drop frame.
    return;
  }

  final VideoFrame.Buffer adaptedBuffer =
      frame.getBuffer().cropAndScale(parameters.cropX, parameters.cropY, parameters.cropWidth,
          parameters.cropHeight, parameters.scaleWidth, parameters.scaleHeight);
  nativeAndroidVideoTrackSource.onFrameCaptured(
      new VideoFrame(adaptedBuffer, frame.getRotation(), parameters.timestampNs));
  adaptedBuffer.release();
}
 

@Override
synchronized public void onFrame(VideoFrame frame) {
    if (target == null) {
        Logging.d(TAG, "Dropping frame in proxy because target is null.");
        return;
    }
    target.onFrame(frame);
}
 

@Override
synchronized public void onFrame(VideoFrame frame) {
    if (mTarget == null) {
        Log.d(TAG, "Dropping frame in proxy because target is null.");
        return;
    }
    mTarget.onFrame(frame);
}
 

@Override
synchronized public void onFrame(VideoFrame frame) {
    if (target == null) {
        Logging.d(TAG, "Dropping frame in proxy because target is null.");
        return;
    }

    target.onFrame(frame);
}
 

@Override
public void onFrame(VideoFrame videoFrame) {
    synchronized (lock) {
        ++framesRendered;
        width = videoFrame.getRotatedWidth();
        height = videoFrame.getRotatedHeight();
    }
    videoFrame.release();
}
 

private void renderFrameOnRenderThread(VideoFrame frame) {
  final VideoFrame.Buffer buffer = frame.getBuffer();

  // If the frame is rotated, it will be applied after cropAndScale. Therefore, if the frame is
  // rotated by 90 degrees, swap width and height.
  final int targetWidth = frame.getRotation() % 180 == 0 ? outputFileWidth : outputFileHeight;
  final int targetHeight = frame.getRotation() % 180 == 0 ? outputFileHeight : outputFileWidth;

  final float frameAspectRatio = (float) buffer.getWidth() / (float) buffer.getHeight();
  final float fileAspectRatio = (float) targetWidth / (float) targetHeight;

  // Calculate cropping to equalize the aspect ratio.
  int cropWidth = buffer.getWidth();
  int cropHeight = buffer.getHeight();
  if (fileAspectRatio > frameAspectRatio) {
    cropHeight = (int) (cropHeight * (frameAspectRatio / fileAspectRatio));
  } else {
    cropWidth = (int) (cropWidth * (fileAspectRatio / frameAspectRatio));
  }

  final int cropX = (buffer.getWidth() - cropWidth) / 2;
  final int cropY = (buffer.getHeight() - cropHeight) / 2;

  final VideoFrame.Buffer scaledBuffer =
      buffer.cropAndScale(cropX, cropY, cropWidth, cropHeight, targetWidth, targetHeight);
  frame.release();

  final VideoFrame.I420Buffer i420 = scaledBuffer.toI420();
  scaledBuffer.release();

  fileThreadHandler.post(() -> {
    YuvHelper.I420Rotate(i420.getDataY(), i420.getStrideY(), i420.getDataU(), i420.getStrideU(),
        i420.getDataV(), i420.getStrideV(), outputFrameBuffer, i420.getWidth(), i420.getHeight(),
        frame.getRotation());
    i420.release();

    try {
      videoOutFile.write("FRAME\n".getBytes(Charset.forName("US-ASCII")));
      videoOutFile.write(
          outputFrameBuffer.array(), outputFrameBuffer.arrayOffset(), outputFrameSize);
    } catch (IOException e) {
      throw new RuntimeException("Error writing video to disk", e);
    }
    frameCount++;
  });
}
 

@Override
public void onFrame(VideoFrame frame) {
  frame.retain();
  renderThreadHandler.post(() -> renderFrameOnRenderThread(frame));
}
 

@Override
public void onFrameCaptured(final VideoFrame frame) {
}
 

@Override
public void onRemoteFrame(VideoFrame videoFrame) {
    activityCallBinding.fcrSurfaceRemote.onFrame(videoFrame);
}
 

@Override
public void onPeerFrame(VideoFrame videoFrame) {
    activityCallBinding.fcrSurfacePeer.onFrame(videoFrame);
}
 

@Override
public void onFrame(VideoFrame videoFrame) {
  eglRenderer.onFrame(videoFrame);
}
 

@Override
public void onFrame(@NonNull VideoFrame frame) {
  this.updateFrameDimensionsAndReportEvents(frame);
  super.onFrame(frame);
}
 

void onRemoteFrame(VideoFrame videoFrame); 

void onPeerFrame(VideoFrame videoFrame);