| /* |
| * Copyright 2016 The WebRTC project authors. All Rights Reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| package org.webrtc; |
| |
| import android.graphics.Bitmap; |
| import android.graphics.Matrix; |
| import android.graphics.SurfaceTexture; |
| import android.opengl.GLES20; |
| import android.os.Handler; |
| import android.os.HandlerThread; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.support.annotation.Nullable; |
| import android.view.Surface; |
| import java.nio.ByteBuffer; |
| import java.text.DecimalFormat; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.concurrent.CountDownLatch; |
| import java.util.concurrent.TimeUnit; |
| |
| /** |
| * Implements VideoSink by displaying the video stream on an EGL Surface. This class is intended to |
| * be used as a helper class for rendering on SurfaceViews and TextureViews. |
| */ |
| public class EglRenderer implements VideoSink { |
| private static final String TAG = "EglRenderer"; |
| private static final long LOG_INTERVAL_SEC = 4; |
| |
| public interface FrameListener { void onFrame(Bitmap frame); } |
| |
| /** Callback for clients to be notified about errors encountered during rendering. */ |
| public static interface ErrorCallback { |
| /** Called if GLES20.GL_OUT_OF_MEMORY is encountered during rendering. */ |
| void onGlOutOfMemory(); |
| } |
| |
| private static class FrameListenerAndParams { |
| public final FrameListener listener; |
| public final float scale; |
| public final RendererCommon.GlDrawer drawer; |
| public final boolean applyFpsReduction; |
| |
| public FrameListenerAndParams(FrameListener listener, float scale, |
| RendererCommon.GlDrawer drawer, boolean applyFpsReduction) { |
| this.listener = listener; |
| this.scale = scale; |
| this.drawer = drawer; |
| this.applyFpsReduction = applyFpsReduction; |
| } |
| } |
| |
| private class EglSurfaceCreation implements Runnable { |
| private Object surface; |
| |
| // TODO(bugs.webrtc.org/8491): Remove NoSynchronizedMethodCheck suppression. |
| @SuppressWarnings("NoSynchronizedMethodCheck") |
| public synchronized void setSurface(Object surface) { |
| this.surface = surface; |
| } |
| |
| @Override |
| // TODO(bugs.webrtc.org/8491): Remove NoSynchronizedMethodCheck suppression. |
| @SuppressWarnings("NoSynchronizedMethodCheck") |
| public synchronized void run() { |
| if (surface != null && eglBase != null && !eglBase.hasSurface()) { |
| if (surface instanceof Surface) { |
| eglBase.createSurface((Surface) surface); |
| } else if (surface instanceof SurfaceTexture) { |
| eglBase.createSurface((SurfaceTexture) surface); |
| } else { |
| throw new IllegalStateException("Invalid surface: " + surface); |
| } |
| eglBase.makeCurrent(); |
| // Necessary for YUV frames with odd width. |
| GLES20.glPixelStorei(GLES20.GL_UNPACK_ALIGNMENT, 1); |
| } |
| } |
| } |
| |
| /** |
| * Handler that triggers a callback when an uncaught exception happens when handling a message. |
| */ |
| private static class HandlerWithExceptionCallback extends Handler { |
| private final Runnable exceptionCallback; |
| |
| public HandlerWithExceptionCallback(Looper looper, Runnable exceptionCallback) { |
| super(looper); |
| this.exceptionCallback = exceptionCallback; |
| } |
| |
| @Override |
| public void dispatchMessage(Message msg) { |
| try { |
| super.dispatchMessage(msg); |
| } catch (Exception e) { |
| Logging.e(TAG, "Exception on EglRenderer thread", e); |
| exceptionCallback.run(); |
| throw e; |
| } |
| } |
| } |
| |
| protected final String name; |
| |
| // `renderThreadHandler` is a handler for communicating with `renderThread`, and is synchronized |
| // on `handlerLock`. |
| private final Object handlerLock = new Object(); |
| @Nullable private Handler renderThreadHandler; |
| |
| private final ArrayList<FrameListenerAndParams> frameListeners = new ArrayList<>(); |
| |
| private volatile ErrorCallback errorCallback; |
| |
| // Variables for fps reduction. |
| private final Object fpsReductionLock = new Object(); |
| // Time for when next frame should be rendered. |
| private long nextFrameTimeNs; |
| // Minimum duration between frames when fps reduction is active, or -1 if video is completely |
| // paused. |
| private long minRenderPeriodNs; |
| |
| // EGL and GL resources for drawing YUV/OES textures. After initialization, these are only |
| // accessed from the render thread. |
| @Nullable private EglBase eglBase; |
| private final VideoFrameDrawer frameDrawer; |
| @Nullable private RendererCommon.GlDrawer drawer; |
| private boolean usePresentationTimeStamp; |
| private final Matrix drawMatrix = new Matrix(); |
| |
| // Pending frame to render. Serves as a queue with size 1. Synchronized on `frameLock`. |
| private final Object frameLock = new Object(); |
| @Nullable private VideoFrame pendingFrame; |
| |
| // These variables are synchronized on `layoutLock`. |
| private final Object layoutLock = new Object(); |
| private float layoutAspectRatio; |
| // If true, mirrors the video stream horizontally. |
| private boolean mirrorHorizontally; |
| // If true, mirrors the video stream vertically. |
| private boolean mirrorVertically; |
| |
| // These variables are synchronized on `statisticsLock`. |
| private final Object statisticsLock = new Object(); |
| // Total number of video frames received in renderFrame() call. |
| private int framesReceived; |
| // Number of video frames dropped by renderFrame() because previous frame has not been rendered |
| // yet. |
| private int framesDropped; |
| // Number of rendered video frames. |
| private int framesRendered; |
| // Start time for counting these statistics, or 0 if we haven't started measuring yet. |
| private long statisticsStartTimeNs; |
| // Time in ns spent in renderFrameOnRenderThread() function. |
| private long renderTimeNs; |
| // Time in ns spent by the render thread in the swapBuffers() function. |
| private long renderSwapBufferTimeNs; |
| |
| // Used for bitmap capturing. |
| private final GlTextureFrameBuffer bitmapTextureFramebuffer = |
| new GlTextureFrameBuffer(GLES20.GL_RGBA); |
| |
| private final Runnable logStatisticsRunnable = new Runnable() { |
| @Override |
| public void run() { |
| logStatistics(); |
| synchronized (handlerLock) { |
| if (renderThreadHandler != null) { |
| renderThreadHandler.removeCallbacks(logStatisticsRunnable); |
| renderThreadHandler.postDelayed( |
| logStatisticsRunnable, TimeUnit.SECONDS.toMillis(LOG_INTERVAL_SEC)); |
| } |
| } |
| } |
| }; |
| |
| private final EglSurfaceCreation eglSurfaceCreationRunnable = new EglSurfaceCreation(); |
| |
| /** |
| * Standard constructor. The name will be used for the render thread name and included when |
| * logging. In order to render something, you must first call init() and createEglSurface. |
| */ |
| public EglRenderer(String name) { |
| this(name, new VideoFrameDrawer()); |
| } |
| |
| public EglRenderer(String name, VideoFrameDrawer videoFrameDrawer) { |
| this.name = name; |
| this.frameDrawer = videoFrameDrawer; |
| } |
| |
| /** |
| * Initialize this class, sharing resources with `sharedContext`. The custom `drawer` will be used |
| * for drawing frames on the EGLSurface. This class is responsible for calling release() on |
| * `drawer`. It is allowed to call init() to reinitialize the renderer after a previous |
| * init()/release() cycle. If usePresentationTimeStamp is true, eglPresentationTimeANDROID will be |
| * set with the frame timestamps, which specifies desired presentation time and might be useful |
| * for e.g. syncing audio and video. |
| */ |
| public void init(@Nullable final EglBase.Context sharedContext, final int[] configAttributes, |
| RendererCommon.GlDrawer drawer, boolean usePresentationTimeStamp) { |
| synchronized (handlerLock) { |
| if (renderThreadHandler != null) { |
| throw new IllegalStateException(name + "Already initialized"); |
| } |
| logD("Initializing EglRenderer"); |
| this.drawer = drawer; |
| this.usePresentationTimeStamp = usePresentationTimeStamp; |
| |
| final HandlerThread renderThread = new HandlerThread(name + "EglRenderer"); |
| renderThread.start(); |
| renderThreadHandler = |
| new HandlerWithExceptionCallback(renderThread.getLooper(), new Runnable() { |
| @Override |
| public void run() { |
| synchronized (handlerLock) { |
| renderThreadHandler = null; |
| } |
| } |
| }); |
| // Create EGL context on the newly created render thread. It should be possibly to create the |
| // context on this thread and make it current on the render thread, but this causes failure on |
| // some Marvel based JB devices. https://bugs.chromium.org/p/webrtc/issues/detail?id=6350. |
| ThreadUtils.invokeAtFrontUninterruptibly(renderThreadHandler, () -> { |
| // If sharedContext is null, then texture frames are disabled. This is typically for old |
| // devices that might not be fully spec compliant, so force EGL 1.0 since EGL 1.4 has |
| // caused trouble on some weird devices. |
| if (sharedContext == null) { |
| logD("EglBase10.create context"); |
| eglBase = EglBase.createEgl10(configAttributes); |
| } else { |
| logD("EglBase.create shared context"); |
| eglBase = EglBase.create(sharedContext, configAttributes); |
| } |
| }); |
| renderThreadHandler.post(eglSurfaceCreationRunnable); |
| final long currentTimeNs = System.nanoTime(); |
| resetStatistics(currentTimeNs); |
| renderThreadHandler.postDelayed( |
| logStatisticsRunnable, TimeUnit.SECONDS.toMillis(LOG_INTERVAL_SEC)); |
| } |
| } |
| |
| /** |
| * Same as above with usePresentationTimeStamp set to false. |
| * |
| * @see #init(EglBase.Context, int[], RendererCommon.GlDrawer, boolean) |
| */ |
| public void init(@Nullable final EglBase.Context sharedContext, final int[] configAttributes, |
| RendererCommon.GlDrawer drawer) { |
| init(sharedContext, configAttributes, drawer, /* usePresentationTimeStamp= */ false); |
| } |
| |
| public void createEglSurface(Surface surface) { |
| createEglSurfaceInternal(surface); |
| } |
| |
| public void createEglSurface(SurfaceTexture surfaceTexture) { |
| createEglSurfaceInternal(surfaceTexture); |
| } |
| |
| private void createEglSurfaceInternal(Object surface) { |
| eglSurfaceCreationRunnable.setSurface(surface); |
| postToRenderThread(eglSurfaceCreationRunnable); |
| } |
| |
| /** |
| * Block until any pending frame is returned and all GL resources released, even if an interrupt |
| * occurs. If an interrupt occurs during release(), the interrupt flag will be set. This function |
| * should be called before the Activity is destroyed and the EGLContext is still valid. If you |
| * don't call this function, the GL resources might leak. |
| */ |
| public void release() { |
| logD("Releasing."); |
| final CountDownLatch eglCleanupBarrier = new CountDownLatch(1); |
| synchronized (handlerLock) { |
| if (renderThreadHandler == null) { |
| logD("Already released"); |
| return; |
| } |
| renderThreadHandler.removeCallbacks(logStatisticsRunnable); |
| // Release EGL and GL resources on render thread. |
| renderThreadHandler.postAtFrontOfQueue(() -> { |
| // Detach current shader program. |
| synchronized (EglBase.lock) { |
| GLES20.glUseProgram(/* program= */ 0); |
| } |
| if (drawer != null) { |
| drawer.release(); |
| drawer = null; |
| } |
| frameDrawer.release(); |
| bitmapTextureFramebuffer.release(); |
| if (eglBase != null) { |
| logD("eglBase detach and release."); |
| eglBase.detachCurrent(); |
| eglBase.release(); |
| eglBase = null; |
| } |
| frameListeners.clear(); |
| eglCleanupBarrier.countDown(); |
| }); |
| final Looper renderLooper = renderThreadHandler.getLooper(); |
| // TODO(magjed): Replace this post() with renderLooper.quitSafely() when API support >= 18. |
| renderThreadHandler.post(() -> { |
| logD("Quitting render thread."); |
| renderLooper.quit(); |
| }); |
| // Don't accept any more frames or messages to the render thread. |
| renderThreadHandler = null; |
| } |
| // Make sure the EGL/GL cleanup posted above is executed. |
| ThreadUtils.awaitUninterruptibly(eglCleanupBarrier); |
| synchronized (frameLock) { |
| if (pendingFrame != null) { |
| pendingFrame.release(); |
| pendingFrame = null; |
| } |
| } |
| logD("Releasing done."); |
| } |
| |
| /** |
| * Reset the statistics logged in logStatistics(). |
| */ |
| private void resetStatistics(long currentTimeNs) { |
| synchronized (statisticsLock) { |
| statisticsStartTimeNs = currentTimeNs; |
| framesReceived = 0; |
| framesDropped = 0; |
| framesRendered = 0; |
| renderTimeNs = 0; |
| renderSwapBufferTimeNs = 0; |
| } |
| } |
| |
| public void printStackTrace() { |
| synchronized (handlerLock) { |
| final Thread renderThread = |
| (renderThreadHandler == null) ? null : renderThreadHandler.getLooper().getThread(); |
| if (renderThread != null) { |
| final StackTraceElement[] renderStackTrace = renderThread.getStackTrace(); |
| if (renderStackTrace.length > 0) { |
| logW("EglRenderer stack trace:"); |
| for (StackTraceElement traceElem : renderStackTrace) { |
| logW(traceElem.toString()); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Set if the video stream should be mirrored horizontally or not. |
| */ |
| public void setMirror(final boolean mirror) { |
| logD("setMirrorHorizontally: " + mirror); |
| synchronized (layoutLock) { |
| this.mirrorHorizontally = mirror; |
| } |
| } |
| |
| /** |
| * Set if the video stream should be mirrored vertically or not. |
| */ |
| public void setMirrorVertically(final boolean mirrorVertically) { |
| logD("setMirrorVertically: " + mirrorVertically); |
| synchronized (layoutLock) { |
| this.mirrorVertically = mirrorVertically; |
| } |
| } |
| |
| /** |
| * Set layout aspect ratio. This is used to crop frames when rendering to avoid stretched video. |
| * Set this to 0 to disable cropping. |
| */ |
| public void setLayoutAspectRatio(float layoutAspectRatio) { |
| logD("setLayoutAspectRatio: " + layoutAspectRatio); |
| synchronized (layoutLock) { |
| this.layoutAspectRatio = layoutAspectRatio; |
| } |
| } |
| |
| /** |
| * Limit render framerate. |
| * |
| * @param fps Limit render framerate to this value, or use Float.POSITIVE_INFINITY to disable fps |
| * reduction. |
| */ |
| public void setFpsReduction(float fps) { |
| logD("setFpsReduction: " + fps); |
| synchronized (fpsReductionLock) { |
| final long previousRenderPeriodNs = minRenderPeriodNs; |
| if (fps <= 0) { |
| minRenderPeriodNs = Long.MAX_VALUE; |
| } else { |
| minRenderPeriodNs = (long) (TimeUnit.SECONDS.toNanos(1) / fps); |
| } |
| if (minRenderPeriodNs != previousRenderPeriodNs) { |
| // Fps reduction changed - reset frame time. |
| nextFrameTimeNs = System.nanoTime(); |
| } |
| } |
| } |
| |
| public void disableFpsReduction() { |
| setFpsReduction(Float.POSITIVE_INFINITY /* fps */); |
| } |
| |
| public void pauseVideo() { |
| setFpsReduction(0 /* fps */); |
| } |
| |
| /** |
| * Register a callback to be invoked when a new video frame has been received. This version uses |
| * the drawer of the EglRenderer that was passed in init. |
| * |
| * @param listener The callback to be invoked. The callback will be invoked on the render thread. |
| * It should be lightweight and must not call removeFrameListener. |
| * @param scale The scale of the Bitmap passed to the callback, or 0 if no Bitmap is |
| * required. |
| */ |
| public void addFrameListener(final FrameListener listener, final float scale) { |
| addFrameListener(listener, scale, null, false /* applyFpsReduction */); |
| } |
| |
| /** |
| * Register a callback to be invoked when a new video frame has been received. |
| * |
| * @param listener The callback to be invoked. The callback will be invoked on the render thread. |
| * It should be lightweight and must not call removeFrameListener. |
| * @param scale The scale of the Bitmap passed to the callback, or 0 if no Bitmap is |
| * required. |
| * @param drawer Custom drawer to use for this frame listener or null to use the default one. |
| */ |
| public void addFrameListener( |
| final FrameListener listener, final float scale, final RendererCommon.GlDrawer drawerParam) { |
| addFrameListener(listener, scale, drawerParam, false /* applyFpsReduction */); |
| } |
| |
| /** |
| * Register a callback to be invoked when a new video frame has been received. |
| * |
| * @param listener The callback to be invoked. The callback will be invoked on the render thread. |
| * It should be lightweight and must not call removeFrameListener. |
| * @param scale The scale of the Bitmap passed to the callback, or 0 if no Bitmap is |
| * required. |
| * @param drawer Custom drawer to use for this frame listener or null to use the default one. |
| * @param applyFpsReduction This callback will not be called for frames that have been dropped by |
| * FPS reduction. |
| */ |
| public void addFrameListener(final FrameListener listener, final float scale, |
| @Nullable final RendererCommon.GlDrawer drawerParam, final boolean applyFpsReduction) { |
| postToRenderThread(() -> { |
| final RendererCommon.GlDrawer listenerDrawer = drawerParam == null ? drawer : drawerParam; |
| frameListeners.add( |
| new FrameListenerAndParams(listener, scale, listenerDrawer, applyFpsReduction)); |
| }); |
| } |
| |
| /** |
| * Remove any pending callback that was added with addFrameListener. If the callback is not in |
| * the queue, nothing happens. It is ensured that callback won't be called after this method |
| * returns. |
| * |
| * @param runnable The callback to remove. |
| */ |
| public void removeFrameListener(final FrameListener listener) { |
| final CountDownLatch latch = new CountDownLatch(1); |
| synchronized (handlerLock) { |
| if (renderThreadHandler == null) { |
| return; |
| } |
| if (Thread.currentThread() == renderThreadHandler.getLooper().getThread()) { |
| throw new RuntimeException("removeFrameListener must not be called on the render thread."); |
| } |
| postToRenderThread(() -> { |
| latch.countDown(); |
| final Iterator<FrameListenerAndParams> iter = frameListeners.iterator(); |
| while (iter.hasNext()) { |
| if (iter.next().listener == listener) { |
| iter.remove(); |
| } |
| } |
| }); |
| } |
| ThreadUtils.awaitUninterruptibly(latch); |
| } |
| |
| /** Can be set in order to be notified about errors encountered during rendering. */ |
| public void setErrorCallback(ErrorCallback errorCallback) { |
| this.errorCallback = errorCallback; |
| } |
| |
| // VideoSink interface. |
| @Override |
| public void onFrame(VideoFrame frame) { |
| synchronized (statisticsLock) { |
| ++framesReceived; |
| } |
| final boolean dropOldFrame; |
| synchronized (handlerLock) { |
| if (renderThreadHandler == null) { |
| logD("Dropping frame - Not initialized or already released."); |
| return; |
| } |
| synchronized (frameLock) { |
| dropOldFrame = (pendingFrame != null); |
| if (dropOldFrame) { |
| pendingFrame.release(); |
| } |
| pendingFrame = frame; |
| pendingFrame.retain(); |
| renderThreadHandler.post(this ::renderFrameOnRenderThread); |
| } |
| } |
| if (dropOldFrame) { |
| synchronized (statisticsLock) { |
| ++framesDropped; |
| } |
| } |
| } |
| |
| /** |
| * Release EGL surface. This function will block until the EGL surface is released. |
| */ |
| public void releaseEglSurface(final Runnable completionCallback) { |
| // Ensure that the render thread is no longer touching the Surface before returning from this |
| // function. |
| eglSurfaceCreationRunnable.setSurface(null /* surface */); |
| synchronized (handlerLock) { |
| if (renderThreadHandler != null) { |
| renderThreadHandler.removeCallbacks(eglSurfaceCreationRunnable); |
| renderThreadHandler.postAtFrontOfQueue(() -> { |
| if (eglBase != null) { |
| eglBase.detachCurrent(); |
| eglBase.releaseSurface(); |
| } |
| completionCallback.run(); |
| }); |
| return; |
| } |
| } |
| completionCallback.run(); |
| } |
| |
| /** |
| * Private helper function to post tasks safely. |
| */ |
| private void postToRenderThread(Runnable runnable) { |
| synchronized (handlerLock) { |
| if (renderThreadHandler != null) { |
| renderThreadHandler.post(runnable); |
| } |
| } |
| } |
| |
| private void clearSurfaceOnRenderThread(float r, float g, float b, float a) { |
| if (eglBase != null && eglBase.hasSurface()) { |
| logD("clearSurface"); |
| GLES20.glClearColor(r, g, b, a); |
| GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT); |
| eglBase.swapBuffers(); |
| } |
| } |
| |
| /** |
| * Post a task to clear the surface to a transparent uniform color. |
| */ |
| public void clearImage() { |
| clearImage(0 /* red */, 0 /* green */, 0 /* blue */, 0 /* alpha */); |
| } |
| |
| /** |
| * Post a task to clear the surface to a specific color. |
| */ |
| public void clearImage(final float r, final float g, final float b, final float a) { |
| synchronized (handlerLock) { |
| if (renderThreadHandler == null) { |
| return; |
| } |
| renderThreadHandler.postAtFrontOfQueue(() -> clearSurfaceOnRenderThread(r, g, b, a)); |
| } |
| } |
| |
| /** |
| * Renders and releases `pendingFrame`. |
| */ |
| private void renderFrameOnRenderThread() { |
| // Fetch and render `pendingFrame`. |
| final VideoFrame frame; |
| synchronized (frameLock) { |
| if (pendingFrame == null) { |
| return; |
| } |
| frame = pendingFrame; |
| pendingFrame = null; |
| } |
| if (eglBase == null || !eglBase.hasSurface()) { |
| logD("Dropping frame - No surface"); |
| frame.release(); |
| return; |
| } |
| // Check if fps reduction is active. |
| final boolean shouldRenderFrame; |
| synchronized (fpsReductionLock) { |
| if (minRenderPeriodNs == Long.MAX_VALUE) { |
| // Rendering is paused. |
| shouldRenderFrame = false; |
| } else if (minRenderPeriodNs <= 0) { |
| // FPS reduction is disabled. |
| shouldRenderFrame = true; |
| } else { |
| final long currentTimeNs = System.nanoTime(); |
| if (currentTimeNs < nextFrameTimeNs) { |
| logD("Skipping frame rendering - fps reduction is active."); |
| shouldRenderFrame = false; |
| } else { |
| nextFrameTimeNs += minRenderPeriodNs; |
| // The time for the next frame should always be in the future. |
| nextFrameTimeNs = Math.max(nextFrameTimeNs, currentTimeNs); |
| shouldRenderFrame = true; |
| } |
| } |
| } |
| |
| final long startTimeNs = System.nanoTime(); |
| |
| final float frameAspectRatio = frame.getRotatedWidth() / (float) frame.getRotatedHeight(); |
| final float drawnAspectRatio; |
| synchronized (layoutLock) { |
| drawnAspectRatio = layoutAspectRatio != 0f ? layoutAspectRatio : frameAspectRatio; |
| } |
| |
| final float scaleX; |
| final float scaleY; |
| |
| if (frameAspectRatio > drawnAspectRatio) { |
| scaleX = drawnAspectRatio / frameAspectRatio; |
| scaleY = 1f; |
| } else { |
| scaleX = 1f; |
| scaleY = frameAspectRatio / drawnAspectRatio; |
| } |
| |
| drawMatrix.reset(); |
| drawMatrix.preTranslate(0.5f, 0.5f); |
| drawMatrix.preScale(mirrorHorizontally ? -1f : 1f, mirrorVertically ? -1f : 1f); |
| drawMatrix.preScale(scaleX, scaleY); |
| drawMatrix.preTranslate(-0.5f, -0.5f); |
| |
| try { |
| if (shouldRenderFrame) { |
| GLES20.glClearColor(0 /* red */, 0 /* green */, 0 /* blue */, 0 /* alpha */); |
| GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT); |
| frameDrawer.drawFrame(frame, drawer, drawMatrix, 0 /* viewportX */, 0 /* viewportY */, |
| eglBase.surfaceWidth(), eglBase.surfaceHeight()); |
| |
| final long swapBuffersStartTimeNs = System.nanoTime(); |
| if (usePresentationTimeStamp) { |
| eglBase.swapBuffers(frame.getTimestampNs()); |
| } else { |
| eglBase.swapBuffers(); |
| } |
| |
| final long currentTimeNs = System.nanoTime(); |
| synchronized (statisticsLock) { |
| ++framesRendered; |
| renderTimeNs += (currentTimeNs - startTimeNs); |
| renderSwapBufferTimeNs += (currentTimeNs - swapBuffersStartTimeNs); |
| } |
| } |
| |
| notifyCallbacks(frame, shouldRenderFrame); |
| } catch (GlUtil.GlOutOfMemoryException e) { |
| logE("Error while drawing frame", e); |
| final ErrorCallback errorCallback = this.errorCallback; |
| if (errorCallback != null) { |
| errorCallback.onGlOutOfMemory(); |
| } |
| // Attempt to free up some resources. |
| drawer.release(); |
| frameDrawer.release(); |
| bitmapTextureFramebuffer.release(); |
| // Continue here on purpose and retry again for next frame. In worst case, this is a continous |
| // problem and no more frames will be drawn. |
| } finally { |
| frame.release(); |
| } |
| } |
| |
| private void notifyCallbacks(VideoFrame frame, boolean wasRendered) { |
| if (frameListeners.isEmpty()) |
| return; |
| |
| drawMatrix.reset(); |
| drawMatrix.preTranslate(0.5f, 0.5f); |
| drawMatrix.preScale(mirrorHorizontally ? -1f : 1f, mirrorVertically ? -1f : 1f); |
| drawMatrix.preScale(1f, -1f); // We want the output to be upside down for Bitmap. |
| drawMatrix.preTranslate(-0.5f, -0.5f); |
| |
| Iterator<FrameListenerAndParams> it = frameListeners.iterator(); |
| while (it.hasNext()) { |
| FrameListenerAndParams listenerAndParams = it.next(); |
| if (!wasRendered && listenerAndParams.applyFpsReduction) { |
| continue; |
| } |
| it.remove(); |
| |
| final int scaledWidth = (int) (listenerAndParams.scale * frame.getRotatedWidth()); |
| final int scaledHeight = (int) (listenerAndParams.scale * frame.getRotatedHeight()); |
| |
| if (scaledWidth == 0 || scaledHeight == 0) { |
| listenerAndParams.listener.onFrame(null); |
| continue; |
| } |
| |
| bitmapTextureFramebuffer.setSize(scaledWidth, scaledHeight); |
| |
| GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, bitmapTextureFramebuffer.getFrameBufferId()); |
| GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER, GLES20.GL_COLOR_ATTACHMENT0, |
| GLES20.GL_TEXTURE_2D, bitmapTextureFramebuffer.getTextureId(), 0); |
| |
| GLES20.glClearColor(0 /* red */, 0 /* green */, 0 /* blue */, 0 /* alpha */); |
| GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT); |
| frameDrawer.drawFrame(frame, listenerAndParams.drawer, drawMatrix, 0 /* viewportX */, |
| 0 /* viewportY */, scaledWidth, scaledHeight); |
| |
| final ByteBuffer bitmapBuffer = ByteBuffer.allocateDirect(scaledWidth * scaledHeight * 4); |
| GLES20.glViewport(0, 0, scaledWidth, scaledHeight); |
| GLES20.glReadPixels( |
| 0, 0, scaledWidth, scaledHeight, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, bitmapBuffer); |
| |
| GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0); |
| GlUtil.checkNoGLES2Error("EglRenderer.notifyCallbacks"); |
| |
| final Bitmap bitmap = Bitmap.createBitmap(scaledWidth, scaledHeight, Bitmap.Config.ARGB_8888); |
| bitmap.copyPixelsFromBuffer(bitmapBuffer); |
| listenerAndParams.listener.onFrame(bitmap); |
| } |
| } |
| |
| private String averageTimeAsString(long sumTimeNs, int count) { |
| return (count <= 0) ? "NA" : TimeUnit.NANOSECONDS.toMicros(sumTimeNs / count) + " us"; |
| } |
| |
| private void logStatistics() { |
| final DecimalFormat fpsFormat = new DecimalFormat("#.0"); |
| final long currentTimeNs = System.nanoTime(); |
| synchronized (statisticsLock) { |
| final long elapsedTimeNs = currentTimeNs - statisticsStartTimeNs; |
| if (elapsedTimeNs <= 0 || (minRenderPeriodNs == Long.MAX_VALUE && framesReceived == 0)) { |
| return; |
| } |
| final float renderFps = framesRendered * TimeUnit.SECONDS.toNanos(1) / (float) elapsedTimeNs; |
| logD("Duration: " + TimeUnit.NANOSECONDS.toMillis(elapsedTimeNs) + " ms." |
| + " Frames received: " + framesReceived + "." |
| + " Dropped: " + framesDropped + "." |
| + " Rendered: " + framesRendered + "." |
| + " Render fps: " + fpsFormat.format(renderFps) + "." |
| + " Average render time: " + averageTimeAsString(renderTimeNs, framesRendered) + "." |
| + " Average swapBuffer time: " |
| + averageTimeAsString(renderSwapBufferTimeNs, framesRendered) + "."); |
| resetStatistics(currentTimeNs); |
| } |
| } |
| |
| private void logE(String string, Throwable e) { |
| Logging.e(TAG, name + string, e); |
| } |
| |
| private void logD(String string) { |
| Logging.d(TAG, name + string); |
| } |
| |
| private void logW(String string) { |
| Logging.w(TAG, name + string); |
| } |
| } |
