1 /*
2 * Copyright 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <algorithm>
18
19 #include "BackgroundExecutor.h"
20 #include "Client.h"
21 #include "Layer.h"
22 #include "RefreshRateOverlay.h"
23
24 #pragma clang diagnostic push
25 #pragma clang diagnostic ignored "-Wconversion"
26 #include <SkCanvas.h>
27 #include <SkPaint.h>
28 #pragma clang diagnostic pop
29 #include <SkBlendMode.h>
30 #include <SkRect.h>
31 #include <SkSurface.h>
32 #include <gui/SurfaceControl.h>
33
34 #undef LOG_TAG
35 #define LOG_TAG "RefreshRateOverlay"
36
37 namespace android {
38 namespace {
39
40 constexpr int kDigitWidth = 64;
41 constexpr int kDigitHeight = 100;
42 constexpr int kDigitSpace = 16;
43
44 constexpr int kMaxDigits = /*displayFps*/ 3 + /*renderFps*/ 3 + /*spinner*/ 1;
45 constexpr int kBufferWidth = kMaxDigits * kDigitWidth + (kMaxDigits - 1) * kDigitSpace;
46 constexpr int kBufferHeight = kDigitHeight;
47
48 } // namespace
49
~SurfaceControlHolder()50 SurfaceControlHolder::~SurfaceControlHolder() {
51 // Hand the sp<SurfaceControl> to the helper thread to release the last
52 // reference. This makes sure that the SurfaceControl is destructed without
53 // SurfaceFlinger::mStateLock held.
54 BackgroundExecutor::getInstance().sendCallbacks(
55 {[sc = std::move(mSurfaceControl)]() mutable { sc.clear(); }});
56 }
57
drawSegment(Segment segment,int left,SkColor color,SkCanvas & canvas)58 void RefreshRateOverlay::SevenSegmentDrawer::drawSegment(Segment segment, int left, SkColor color,
59 SkCanvas& canvas) {
60 const SkRect rect = [&]() {
61 switch (segment) {
62 case Segment::Upper:
63 return SkRect::MakeLTRB(left, 0, left + kDigitWidth, kDigitSpace);
64 case Segment::UpperLeft:
65 return SkRect::MakeLTRB(left, 0, left + kDigitSpace, kDigitHeight / 2);
66 case Segment::UpperRight:
67 return SkRect::MakeLTRB(left + kDigitWidth - kDigitSpace, 0, left + kDigitWidth,
68 kDigitHeight / 2);
69 case Segment::Middle:
70 return SkRect::MakeLTRB(left, kDigitHeight / 2 - kDigitSpace / 2,
71 left + kDigitWidth, kDigitHeight / 2 + kDigitSpace / 2);
72 case Segment::LowerLeft:
73 return SkRect::MakeLTRB(left, kDigitHeight / 2, left + kDigitSpace, kDigitHeight);
74 case Segment::LowerRight:
75 return SkRect::MakeLTRB(left + kDigitWidth - kDigitSpace, kDigitHeight / 2,
76 left + kDigitWidth, kDigitHeight);
77 case Segment::Bottom:
78 return SkRect::MakeLTRB(left, kDigitHeight - kDigitSpace, left + kDigitWidth,
79 kDigitHeight);
80 }
81 }();
82
83 SkPaint paint;
84 paint.setColor(color);
85 paint.setBlendMode(SkBlendMode::kSrc);
86 canvas.drawRect(rect, paint);
87 }
88
drawDigit(int digit,int left,SkColor color,SkCanvas & canvas)89 void RefreshRateOverlay::SevenSegmentDrawer::drawDigit(int digit, int left, SkColor color,
90 SkCanvas& canvas) {
91 if (digit < 0 || digit > 9) return;
92
93 if (digit == 0 || digit == 2 || digit == 3 || digit == 5 || digit == 6 || digit == 7 ||
94 digit == 8 || digit == 9)
95 drawSegment(Segment::Upper, left, color, canvas);
96 if (digit == 0 || digit == 4 || digit == 5 || digit == 6 || digit == 8 || digit == 9)
97 drawSegment(Segment::UpperLeft, left, color, canvas);
98 if (digit == 0 || digit == 1 || digit == 2 || digit == 3 || digit == 4 || digit == 7 ||
99 digit == 8 || digit == 9)
100 drawSegment(Segment::UpperRight, left, color, canvas);
101 if (digit == 2 || digit == 3 || digit == 4 || digit == 5 || digit == 6 || digit == 8 ||
102 digit == 9)
103 drawSegment(Segment::Middle, left, color, canvas);
104 if (digit == 0 || digit == 2 || digit == 6 || digit == 8)
105 drawSegment(Segment::LowerLeft, left, color, canvas);
106 if (digit == 0 || digit == 1 || digit == 3 || digit == 4 || digit == 5 || digit == 6 ||
107 digit == 7 || digit == 8 || digit == 9)
108 drawSegment(Segment::LowerRight, left, color, canvas);
109 if (digit == 0 || digit == 2 || digit == 3 || digit == 5 || digit == 6 || digit == 8 ||
110 digit == 9)
111 drawSegment(Segment::Bottom, left, color, canvas);
112 }
113
draw(int displayFps,int renderFps,SkColor color,ui::Transform::RotationFlags rotation,ftl::Flags<Features> features)114 auto RefreshRateOverlay::SevenSegmentDrawer::draw(int displayFps, int renderFps, SkColor color,
115 ui::Transform::RotationFlags rotation,
116 ftl::Flags<Features> features) -> Buffers {
117 const size_t loopCount = features.test(Features::Spinner) ? 6 : 1;
118
119 Buffers buffers;
120 buffers.reserve(loopCount);
121
122 for (size_t i = 0; i < loopCount; i++) {
123 // Pre-rotate the buffer before it reaches SurfaceFlinger.
124 SkMatrix canvasTransform = SkMatrix();
125 const auto [bufferWidth, bufferHeight] = [&]() -> std::pair<int, int> {
126 switch (rotation) {
127 case ui::Transform::ROT_90:
128 canvasTransform.setTranslate(kBufferHeight, 0);
129 canvasTransform.preRotate(90.f);
130 return {kBufferHeight, kBufferWidth};
131 case ui::Transform::ROT_270:
132 canvasTransform.setRotate(270.f, kBufferWidth / 2.f, kBufferWidth / 2.f);
133 return {kBufferHeight, kBufferWidth};
134 default:
135 return {kBufferWidth, kBufferHeight};
136 }
137 }();
138
139 const auto kUsageFlags =
140 static_cast<uint64_t>(GRALLOC_USAGE_SW_WRITE_RARELY | GRALLOC_USAGE_HW_COMPOSER |
141 GRALLOC_USAGE_HW_TEXTURE);
142 sp<GraphicBuffer> buffer = sp<GraphicBuffer>::make(static_cast<uint32_t>(bufferWidth),
143 static_cast<uint32_t>(bufferHeight),
144 HAL_PIXEL_FORMAT_RGBA_8888, 1u,
145 kUsageFlags, "RefreshRateOverlayBuffer");
146
147 const status_t bufferStatus = buffer->initCheck();
148 LOG_ALWAYS_FATAL_IF(bufferStatus != OK, "RefreshRateOverlay: Buffer failed to allocate: %d",
149 bufferStatus);
150
151 sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(bufferWidth, bufferHeight);
152 SkCanvas* canvas = surface->getCanvas();
153 canvas->setMatrix(canvasTransform);
154
155 int left = 0;
156 drawNumber(displayFps, left, color, *canvas);
157 left += 3 * (kDigitWidth + kDigitSpace);
158 if (features.test(Features::Spinner)) {
159 switch (i) {
160 case 0:
161 drawSegment(Segment::Upper, left, color, *canvas);
162 break;
163 case 1:
164 drawSegment(Segment::UpperRight, left, color, *canvas);
165 break;
166 case 2:
167 drawSegment(Segment::LowerRight, left, color, *canvas);
168 break;
169 case 3:
170 drawSegment(Segment::Bottom, left, color, *canvas);
171 break;
172 case 4:
173 drawSegment(Segment::LowerLeft, left, color, *canvas);
174 break;
175 case 5:
176 drawSegment(Segment::UpperLeft, left, color, *canvas);
177 break;
178 }
179 }
180
181 left += kDigitWidth + kDigitSpace;
182
183 if (features.test(Features::RenderRate)) {
184 drawNumber(renderFps, left, color, *canvas);
185 }
186 left += 3 * (kDigitWidth + kDigitSpace);
187
188 void* pixels = nullptr;
189 buffer->lock(GRALLOC_USAGE_SW_WRITE_RARELY, reinterpret_cast<void**>(&pixels));
190
191 const SkImageInfo& imageInfo = surface->imageInfo();
192 const size_t dstRowBytes =
193 buffer->getStride() * static_cast<size_t>(imageInfo.bytesPerPixel());
194
195 canvas->readPixels(imageInfo, pixels, dstRowBytes, 0, 0);
196 buffer->unlock();
197 buffers.push_back(std::move(buffer));
198 }
199 return buffers;
200 }
201
drawNumber(int number,int left,SkColor color,SkCanvas & canvas)202 void RefreshRateOverlay::SevenSegmentDrawer::drawNumber(int number, int left, SkColor color,
203 SkCanvas& canvas) {
204 if (number < 0 || number >= 1000) return;
205
206 if (number >= 100) {
207 drawDigit(number / 100, left, color, canvas);
208 }
209 left += kDigitWidth + kDigitSpace;
210
211 if (number >= 10) {
212 drawDigit((number / 10) % 10, left, color, canvas);
213 }
214 left += kDigitWidth + kDigitSpace;
215
216 drawDigit(number % 10, left, color, canvas);
217 }
218
createSurfaceControlHolder()219 std::unique_ptr<SurfaceControlHolder> createSurfaceControlHolder() {
220 sp<SurfaceControl> surfaceControl =
221 SurfaceComposerClient::getDefault()
222 ->createSurface(String8("RefreshRateOverlay"), kBufferWidth, kBufferHeight,
223 PIXEL_FORMAT_RGBA_8888,
224 ISurfaceComposerClient::eFXSurfaceBufferState);
225 return std::make_unique<SurfaceControlHolder>(std::move(surfaceControl));
226 }
227
RefreshRateOverlay(FpsRange fpsRange,ftl::Flags<Features> features)228 RefreshRateOverlay::RefreshRateOverlay(FpsRange fpsRange, ftl::Flags<Features> features)
229 : mFpsRange(fpsRange), mFeatures(features), mSurfaceControl(createSurfaceControlHolder()) {
230 if (!mSurfaceControl) {
231 ALOGE("%s: Failed to create buffer state layer", __func__);
232 return;
233 }
234
235 createTransaction()
236 .setLayer(mSurfaceControl->get(), INT32_MAX - 2)
237 .setTrustedOverlay(mSurfaceControl->get(), true)
238 .apply();
239 }
240
getOrCreateBuffers(Fps displayFps,Fps renderFps)241 auto RefreshRateOverlay::getOrCreateBuffers(Fps displayFps, Fps renderFps) -> const Buffers& {
242 static const Buffers kNoBuffers;
243 if (!mSurfaceControl) return kNoBuffers;
244
245 // avoid caching different render rates if RenderRate is anyway not visible
246 if (!mFeatures.test(Features::RenderRate)) {
247 renderFps = 0_Hz;
248 }
249
250 const auto transformHint =
251 static_cast<ui::Transform::RotationFlags>(mSurfaceControl->get()->getTransformHint());
252
253 // Tell SurfaceFlinger about the pre-rotation on the buffer.
254 const auto transform = [&] {
255 switch (transformHint) {
256 case ui::Transform::ROT_90:
257 return ui::Transform::ROT_270;
258 case ui::Transform::ROT_270:
259 return ui::Transform::ROT_90;
260 default:
261 return ui::Transform::ROT_0;
262 }
263 }();
264
265 createTransaction().setTransform(mSurfaceControl->get(), transform).apply();
266
267 BufferCache::const_iterator it =
268 mBufferCache.find({displayFps.getIntValue(), renderFps.getIntValue(), transformHint});
269 if (it == mBufferCache.end()) {
270 // HWC minFps is not known by the framework in order
271 // to consider lower rates we set minFps to 0.
272 const int minFps = isSetByHwc() ? 0 : mFpsRange.min.getIntValue();
273 const int maxFps = mFpsRange.max.getIntValue();
274
275 // Clamp to the range. The current displayFps may be outside of this range if the display
276 // has changed its set of supported refresh rates.
277 const int displayIntFps = std::clamp(displayFps.getIntValue(), minFps, maxFps);
278 const int renderIntFps = renderFps.getIntValue();
279
280 // Ensure non-zero range to avoid division by zero.
281 const float fpsScale =
282 static_cast<float>(displayIntFps - minFps) / std::max(1, maxFps - minFps);
283
284 constexpr SkColor kMinFpsColor = SK_ColorRED;
285 constexpr SkColor kMaxFpsColor = SK_ColorGREEN;
286 constexpr float kAlpha = 0.8f;
287
288 SkColor4f colorBase = SkColor4f::FromColor(kMaxFpsColor) * fpsScale;
289 const SkColor4f minFpsColor = SkColor4f::FromColor(kMinFpsColor) * (1 - fpsScale);
290
291 colorBase.fR = colorBase.fR + minFpsColor.fR;
292 colorBase.fG = colorBase.fG + minFpsColor.fG;
293 colorBase.fB = colorBase.fB + minFpsColor.fB;
294 colorBase.fA = kAlpha;
295
296 const SkColor color = colorBase.toSkColor();
297
298 auto buffers = SevenSegmentDrawer::draw(displayIntFps, renderIntFps, color, transformHint,
299 mFeatures);
300 it = mBufferCache
301 .try_emplace({displayIntFps, renderIntFps, transformHint}, std::move(buffers))
302 .first;
303 }
304
305 return it->second;
306 }
307
setViewport(ui::Size viewport)308 void RefreshRateOverlay::setViewport(ui::Size viewport) {
309 constexpr int32_t kMaxWidth = 1000;
310 const auto width = std::min({kMaxWidth, viewport.width, viewport.height});
311 const auto height = 2 * width;
312 Rect frame((5 * width) >> 4, height >> 5);
313
314 if (!mFeatures.test(Features::ShowInMiddle)) {
315 frame.offsetBy(width >> 5, height >> 4);
316 } else {
317 frame.offsetBy(width >> 1, height >> 4);
318 }
319
320 createTransaction()
321 .setMatrix(mSurfaceControl->get(), frame.getWidth() / static_cast<float>(kBufferWidth),
322 0, 0, frame.getHeight() / static_cast<float>(kBufferHeight))
323 .setPosition(mSurfaceControl->get(), frame.left, frame.top)
324 .apply();
325 }
326
setLayerStack(ui::LayerStack stack)327 void RefreshRateOverlay::setLayerStack(ui::LayerStack stack) {
328 createTransaction().setLayerStack(mSurfaceControl->get(), stack).apply();
329 }
330
changeRefreshRate(Fps displayFps,Fps renderFps)331 void RefreshRateOverlay::changeRefreshRate(Fps displayFps, Fps renderFps) {
332 mDisplayFps = displayFps;
333 mRenderFps = renderFps;
334 const auto buffer = getOrCreateBuffers(displayFps, renderFps)[mFrame];
335 createTransaction().setBuffer(mSurfaceControl->get(), buffer).apply();
336 }
337
animate()338 void RefreshRateOverlay::animate() {
339 if (!mFeatures.test(Features::Spinner) || !mDisplayFps) return;
340
341 const auto& buffers = getOrCreateBuffers(*mDisplayFps, *mRenderFps);
342 mFrame = (mFrame + 1) % buffers.size();
343 const auto buffer = buffers[mFrame];
344 createTransaction().setBuffer(mSurfaceControl->get(), buffer).apply();
345 }
346
createTransaction() const347 SurfaceComposerClient::Transaction RefreshRateOverlay::createTransaction() const {
348 constexpr float kFrameRate = 0.f;
349 constexpr int8_t kCompatibility = ANATIVEWINDOW_FRAME_RATE_NO_VOTE;
350 constexpr int8_t kSeamlessness = ANATIVEWINDOW_CHANGE_FRAME_RATE_ONLY_IF_SEAMLESS;
351
352 const sp<SurfaceControl>& surface = mSurfaceControl->get();
353
354 SurfaceComposerClient::Transaction transaction;
355 if (isSetByHwc()) {
356 transaction.setFlags(surface, layer_state_t::eLayerIsRefreshRateIndicator,
357 layer_state_t::eLayerIsRefreshRateIndicator);
358 // Disable overlay layer caching when refresh rate is updated by the HWC.
359 transaction.setCachingHint(surface, gui::CachingHint::Disabled);
360 }
361 transaction.setFrameRate(surface, kFrameRate, kCompatibility, kSeamlessness);
362 return transaction;
363 }
364
365 } // namespace android
366