| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 |
| 11 | package org.webrtc; |
| 12 |
| 13 | import android.os.Build.VERSION; |
| 14 | import android.os.Build.VERSION_CODES; |
| 15 | import android.os.Handler; |
| 16 | import android.os.Looper; |
| 17 | import android.os.Trace; |
| 18 | import android.view.Choreographer; |
| 19 | import androidx.annotation.GuardedBy; |
| 20 | import java.util.List; |
| 21 | import java.util.concurrent.CopyOnWriteArrayList; |
| 22 | import java.util.concurrent.TimeUnit; |
| 23 |
| 24 | /** |
| 25 | * Class to synchronize rendering updates with display refresh cycles and save power by blocking |
| 26 | * updates that exceeds the target frame rate. |
| 27 | */ |
| 28 | public final class RenderSynchronizer { |
| 29 |
| 30 | /** Interface for listening to render window updates. */ |
| 31 | public interface Listener { |
| 32 | void onRenderWindowOpen(); |
| 33 |
| 34 | void onRenderWindowClose(); |
| 35 | } |
| 36 |
| 37 | private static final String TAG = "RenderSynchronizer"; |
| 38 | private static final float DEFAULT_TARGET_FPS = 30f; |
| 39 | private final Object lock = new Object(); |
| 40 | private final List<Listener> listeners = new CopyOnWriteArrayList<>(); |
| 41 | private final long targetFrameIntervalNanos; |
| 42 | private final Handler mainThreadHandler; |
| 43 | private Choreographer choreographer; |
| 44 |
| 45 | @GuardedBy("lock") |
| 46 | private boolean isListening; |
| 47 |
| 48 | private boolean renderWindowOpen; |
| 49 | private long lastRefreshTimeNanos; |
| 50 | private long lastOpenedTimeNanos; |
| 51 |
| 52 | public RenderSynchronizer(float targetFrameRateFps) { |
| 53 | this.targetFrameIntervalNanos = Math.round(TimeUnit.SECONDS.toNanos(1) / targetFrameRateFps); |
| 54 | this.mainThreadHandler = new Handler(Looper.getMainLooper()); |
| 55 | mainThreadHandler.post(() -> this.choreographer = Choreographer.getInstance()); |
| 56 | Logging.d(TAG, "Created"); |
| 57 | } |
| 58 |
| 59 | public RenderSynchronizer() { |
| 60 | this(DEFAULT_TARGET_FPS); |
| 61 | } |
| 62 |
| 63 | public void registerListener(Listener listener) { |
| 64 | listeners.add(listener); |
| 65 |
| 66 | synchronized (lock) { |
| 67 | if (!isListening) { |
| 68 | Logging.d(TAG, "First listener, subscribing to frame callbacks"); |
| 69 | isListening = true; |
| 70 | mainThreadHandler.post( |
| 71 | () -> choreographer.postFrameCallback(this::onDisplayRefreshCycleBegin)); |
| 72 | } |
| 73 | } |
| 74 | } |
| 75 |
| 76 | public void removeListener(Listener listener) { |
| 77 | listeners.remove(listener); |
| 78 | } |
| 79 |
| 80 | private void onDisplayRefreshCycleBegin(long refreshTimeNanos) { |
| 81 | synchronized (lock) { |
| 82 | if (listeners.isEmpty()) { |
| 83 | Logging.d(TAG, "No listeners, unsubscribing to frame callbacks"); |
| 84 | isListening = false; |
| 85 | return; |
| 86 | } |
| 87 | } |
| 88 | choreographer.postFrameCallback(this::onDisplayRefreshCycleBegin); |
| 89 |
| 90 | long lastOpenDeltaNanos = refreshTimeNanos - lastOpenedTimeNanos; |
| 91 | long refreshDeltaNanos = refreshTimeNanos - lastRefreshTimeNanos; |
| 92 | lastRefreshTimeNanos = refreshTimeNanos; |
| 93 |
| 94 | // Make a greedy choice whether to open (or keep open) the render window. If the current time |
| 95 | // since the render window was last opened is closer to the target than what we predict it would |
| 96 | // be in the next refresh cycle then we open the window. |
| 97 | if (Math.abs(lastOpenDeltaNanos - targetFrameIntervalNanos) |
| 98 | < Math.abs(lastOpenDeltaNanos - targetFrameIntervalNanos + refreshDeltaNanos)) { |
| 99 | lastOpenedTimeNanos = refreshTimeNanos; |
| 100 | openRenderWindow(); |
| 101 | } else if (renderWindowOpen) { |
| 102 | closeRenderWindow(); |
| 103 | } |
| 104 | } |
| 105 |
| 106 | private void traceRenderWindowChange() { |
| 107 | if (VERSION.SDK_INT >= VERSION_CODES.Q) { |
| 108 | Trace.setCounter("RenderWindow", renderWindowOpen ? 1 : 0); |
| 109 | } |
| 110 | } |
| 111 |
| 112 | private void openRenderWindow() { |
| 113 | renderWindowOpen = true; |
| 114 | traceRenderWindowChange(); |
| 115 | for (Listener listener : listeners) { |
| 116 | listener.onRenderWindowOpen(); |
| 117 | } |
| 118 | } |
| 119 |
| 120 | private void closeRenderWindow() { |
| 121 | renderWindowOpen = false; |
| 122 | traceRenderWindowChange(); |
| 123 | for (Listener listener : listeners) { |
| 124 | listener.onRenderWindowClose(); |
| 125 | } |
| 126 | } |
| 127 | } |
| 128 |