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